1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
"""Notification endpoints — /v1/notifications/*"""
from fastapi import APIRouter, Depends, HTTPException
from datetime import datetime, timezone
from sqlalchemy import delete, func, select, update
from sqlalchemy.ext.asyncio import AsyncSession
from meshbay_hub.api.deps import get_current_user
from meshbay_hub.db.engine import get_db
from meshbay_hub.db.models import GroupMember, Notification, User
router = APIRouter(prefix="/v1/notifications", tags=["notifications"])
@router.get("")
async def list_notifications(
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
limit: int = 50,
offset: int = 0,
unread_only: bool = False,
):
query = select(Notification).where(Notification.user_id == current_user.id)
if unread_only:
query = query.where(Notification.read == False) # noqa: E712
result = await db.execute(
query.order_by(Notification.created_at.desc()).limit(limit).offset(offset)
)
notifs = result.scalars().all()
count_q = select(func.count()).select_from(Notification).where(
Notification.user_id == current_user.id, Notification.read == False # noqa: E712
)
unread = (await db.execute(count_q)).scalar() or 0
return {
"notifications": [
{
"id": n.id,
"kind": n.kind,
"title": n.title,
"detail": n.detail,
"link": n.link,
"group_id": n.group_id,
"read": n.read,
"created_at": n.created_at.isoformat(),
}
for n in notifs
],
"unread_count": unread,
}
@router.post("/{notification_id}/read")
async def mark_read(
notification_id: int,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
notif = await db.get(Notification, notification_id)
if not notif or notif.user_id != current_user.id:
raise HTTPException(status_code=404, detail="Notification not found")
notif.read = True
await db.commit()
return {"status": "ok"}
@router.delete("")
async def purge_notifications(
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
"""
Throw them all away.
These are signals, not a record: the group is still there, the message is
still in the chat, the invitation is still an invitation. Nothing is lost by
clearing the list, so it clears rather than marking a hundred rows read.
"""
result = await db.execute(
delete(Notification).where(Notification.user_id == current_user.id))
await db.commit()
return {"status": "ok", "removed": result.rowcount}
@router.post("/read-all")
async def mark_all_read(
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
await db.execute(
update(Notification)
.where(Notification.user_id == current_user.id, Notification.read == False) # noqa: E712
.values(read=True)
)
await db.commit()
return {"status": "ok"}
async def create_notification(
db: AsyncSession,
user_id: str,
kind: str,
title: str,
detail: str | None = None,
link: str | None = None,
group_id: str | None = None,
aggregate: bool = False,
) -> Notification | None:
"""
Create a notification, or refresh the one already standing for this group.
`aggregate` is for anything that repeats — chat, above all. One row per
(person, kind, group) whose date moves and whose read flag clears, so a busy
conversation is a single line saying when it last spoke rather than forty
saying that it spoke.
Returns None when the person muted this group: the point of muting is that
nothing is created, not that something is created and hidden.
"""
if group_id is not None:
muted = await db.execute(
select(GroupMember.muted).where(
GroupMember.group_id == group_id,
GroupMember.user_id == user_id,
)
)
if muted.scalar() is True:
return None
if aggregate and group_id is not None:
existing = (await db.execute(
select(Notification).where(
Notification.user_id == user_id,
Notification.kind == kind,
Notification.group_id == group_id,
).order_by(Notification.created_at.desc()).limit(1)
)).scalar_one_or_none()
if existing is not None:
existing.title = title
existing.detail = detail
existing.link = link
existing.read = False
existing.created_at = datetime.now(timezone.utc)
await db.flush()
return existing
notif = Notification(
user_id=user_id, kind=kind, title=title, detail=detail, link=link,
group_id=group_id,
)
db.add(notif)
await db.flush()
return notif
|