xonecas.io
8058
Ir

irvc / files

irvc / channels.go

17.1 KB
1package main
2
3import (
4	"database/sql"
5	"fmt"
6	"net/http"
7	"strconv"
8	"strings"
9	"time"
10	"unicode/utf8"
11
12	"github.com/gin-gonic/gin"
13)
14
15func dmName(u1, u2 int64) string {
16	if u1 > u2 {
17		u1, u2 = u2, u1
18	}
19	return fmt.Sprintf("u:%d:%d", u1, u2)
20}
21
22func parseDM(name string) (int64, int64, bool) {
23	var u1, u2 int64
24	if _, err := fmt.Sscanf(name, "u:%d:%d", &u1, &u2); err != nil {
25		return 0, 0, false
26	}
27	return u1, u2, true
28}
29
30// dmPeer returns the other participant of a DM named name, if userID is one.
31func dmPeer(name string, userID int64) (int64, bool) {
32	u1, u2, ok := parseDM(name)
33	if !ok || (u1 != userID && u2 != userID) {
34		return 0, false
35	}
36	if u1 == userID {
37		return u2, true
38	}
39	return u1, true
40}
41
42func (s *Server) notifyChannel(channelType, channelName string, ev event) {
43	if channelType == "dm" {
44		if u1, u2, ok := parseDM(channelName); ok {
45			s.hub.sendTo(ev, u1, u2)
46		}
47		return
48	}
49	s.hub.broadcast(ev)
50}
51
52func validChannelName(name string) bool {
53	if len(name) < 1 || len(name) > 32 {
54		return false
55	}
56	for _, r := range name {
57		ok := r == '_' || r == '-' || (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')
58		if !ok {
59			return false
60		}
61	}
62	return true
63}
64
65func (s *Server) handleChannels(c *gin.Context) {
66	user := c.MustGet("user").(User)
67	users := map[int64]string{}
68	for _, u := range s.hub.roster() {
69		users[u.ID] = u.Username
70	}
71	rows, err := s.db.Query(
72		`SELECT c.id, c.type, c.name, c.position, c.permanent,
73		        (SELECT COUNT(*) FROM messages m
74		         WHERE m.channel_id = c.id AND m.user_id != ?
75		           AND m.id > COALESCE((SELECT r.last_read_message_id FROM read_state r
76		                                WHERE r.user_id = ? AND r.channel_id = c.id), 0))
77		 FROM channels c ORDER BY c.position, c.id`,
78		user.ID, user.ID,
79	)
80	if err != nil {
81		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
82		return
83	}
84	defer rows.Close()
85	channels := []Channel{}
86	for rows.Next() {
87		var ch Channel
88		if err := rows.Scan(&ch.ID, &ch.Type, &ch.Name, &ch.Position, &ch.Permanent, &ch.Unread); err != nil {
89			c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
90			return
91		}
92		if ch.Type == "dm" {
93			u1, u2, ok := parseDM(ch.Name)
94			if !ok || (u1 != user.ID && u2 != user.ID) {
95				continue
96			}
97			peerID := u1
98			if u1 == user.ID {
99				peerID = u2
100			}
101			ch.Name = users[peerID]
102			if ch.Name == "" {
103				continue
104			}
105		}
106		channels = append(channels, ch)
107	}
108	c.JSON(http.StatusOK, channels)
109}
110
111// handleMarkRead advances the caller's read cursor for a channel to the latest
112// message, clearing its unread count for every device they use.
113func (s *Server) handleMarkRead(c *gin.Context) {
114	channelID, err := strconv.ParseInt(c.Param("id"), 10, 64)
115	if err != nil {
116		c.JSON(http.StatusBadRequest, gin.H{"error": "bad channel"})
117		return
118	}
119	user := c.MustGet("user").(User)
120	if _, _, ok := s.checkTextOrDM(c, channelID, user.ID); !ok {
121		return
122	}
123	var lastID int64
124	if err := s.db.QueryRow(
125		`SELECT COALESCE(MAX(id), 0) FROM messages WHERE channel_id = ?`, channelID,
126	).Scan(&lastID); err != nil {
127		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
128		return
129	}
130	if _, err := s.db.Exec(
131		`INSERT INTO read_state (user_id, channel_id, last_read_message_id, updated_at)
132		 VALUES (?, ?, ?, ?)
133		 ON CONFLICT(user_id, channel_id) DO UPDATE SET
134		   last_read_message_id = MAX(last_read_message_id, excluded.last_read_message_id),
135		   updated_at = excluded.updated_at`,
136		user.ID, channelID, lastID, time.Now().Unix(),
137	); err != nil {
138		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
139		return
140	}
141	c.Status(http.StatusNoContent)
142}
143
144type createChannelRequest struct {
145	Type string `json:"type"`
146	Name string `json:"name"`
147}
148
149func (s *Server) handleCreateChannel(c *gin.Context) {
150	var req createChannelRequest
151	if err := c.ShouldBindJSON(&req); err != nil {
152		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
153		return
154	}
155	if req.Type != "text" && req.Type != "voice" {
156		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid channel type"})
157		return
158	}
159	name := strings.TrimSpace(req.Name)
160	if !validChannelName(name) {
161		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid channel name"})
162		return
163	}
164	var pos int
165	if err := s.db.QueryRow(
166		`SELECT COALESCE(MAX(position), 0) + 1 FROM channels WHERE type = ?`, req.Type,
167	).Scan(&pos); err != nil {
168		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
169		return
170	}
171	res, err := s.db.Exec(
172		`INSERT INTO channels (type, name, position, created_at) VALUES (?, ?, ?, ?)`,
173		req.Type, name, pos, time.Now().Unix(),
174	)
175	if err != nil {
176		c.JSON(http.StatusConflict, gin.H{"error": "channel already exists"})
177		return
178	}
179	id, _ := res.LastInsertId()
180	ch := Channel{ID: id, Type: req.Type, Name: name, Position: pos}
181	s.hub.broadcast(event{Type: "channel", Channel: &ch})
182	c.JSON(http.StatusOK, ch)
183}
184
185func (s *Server) handleDeleteChannel(c *gin.Context) {
186	channelID, err := strconv.ParseInt(c.Param("id"), 10, 64)
187	if err != nil {
188		c.JSON(http.StatusBadRequest, gin.H{"error": "bad channel"})
189		return
190	}
191	var ch Channel
192	err = s.db.QueryRow(
193		`SELECT id, type, name, position, permanent FROM channels WHERE id = ?`, channelID,
194	).Scan(&ch.ID, &ch.Type, &ch.Name, &ch.Position, &ch.Permanent)
195	if err != nil {
196		if err == sql.ErrNoRows {
197			c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
198			return
199		}
200		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
201		return
202	}
203	if ch.Type == "dm" {
204		c.JSON(http.StatusBadRequest, gin.H{"error": "not a channel"})
205		return
206	}
207	if ch.Permanent {
208		c.JSON(http.StatusForbidden, gin.H{"error": "channel is permanent"})
209		return
210	}
211	if ch.Type == "voice" && s.hub.voiceOccupied(channelID) {
212		c.JSON(http.StatusConflict, gin.H{"error": "channel is not empty"})
213		return
214	}
215	if _, err := s.db.Exec(`DELETE FROM messages WHERE channel_id = ?`, channelID); err != nil {
216		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
217		return
218	}
219	if _, err := s.db.Exec(`DELETE FROM channels WHERE id = ?`, channelID); err != nil {
220		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
221		return
222	}
223	s.hub.broadcast(event{Type: "channel_delete", ChannelID: channelID})
224	c.Status(http.StatusNoContent)
225}
226
227func (s *Server) handleOpenDM(c *gin.Context) {
228	peerID, err := strconv.ParseInt(c.Param("userId"), 10, 64)
229	if err != nil {
230		c.JSON(http.StatusBadRequest, gin.H{"error": "bad user"})
231		return
232	}
233	user := c.MustGet("user").(User)
234	var peerName string
235	if err := s.db.QueryRow(`SELECT username FROM users WHERE id = ?`, peerID).Scan(&peerName); err != nil {
236		if err == sql.ErrNoRows {
237			c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
238			return
239		}
240		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
241		return
242	}
243	name := dmName(user.ID, peerID)
244	s.db.Exec(
245		`INSERT OR IGNORE INTO channels (type, name, position, created_at) VALUES ('dm', ?, 0, ?)`,
246		name, time.Now().Unix(),
247	)
248	var ch Channel
249	if err := s.db.QueryRow(`SELECT id, type, position FROM channels WHERE type = 'dm' AND name = ?`, name).Scan(&ch.ID, &ch.Type, &ch.Position); err != nil {
250		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
251		return
252	}
253	ch.Name = peerName
254	c.JSON(http.StatusOK, ch)
255}
256
257// handleRing propagates a DM call ring, or its end, to the other participant
258// so their client can sound the incoming-call tone.
259func (s *Server) handleRing(ringing bool) gin.HandlerFunc {
260	return func(c *gin.Context) {
261		channelID, err := strconv.ParseInt(c.Param("id"), 10, 64)
262		if err != nil {
263			c.JSON(http.StatusBadRequest, gin.H{"error": "bad channel"})
264			return
265		}
266		user := c.MustGet("user").(User)
267		var chType, chName string
268		if err := s.db.QueryRow(`SELECT type, name FROM channels WHERE id = ?`, channelID).Scan(&chType, &chName); err != nil {
269			c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
270			return
271		}
272		if chType != "dm" {
273			c.JSON(http.StatusBadRequest, gin.H{"error": "not a dm"})
274			return
275		}
276		peerID, ok := dmPeer(chName, user.ID)
277		if !ok {
278			c.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
279			return
280		}
281		if ringing {
282			s.hub.sendTo(event{Type: "ring", ChannelID: channelID}, peerID)
283		} else {
284			s.hub.sendTo(event{Type: "ring_end", ChannelID: channelID}, peerID)
285		}
286		c.Status(http.StatusNoContent)
287	}
288}
289
290func (s *Server) checkTextOrDM(c *gin.Context, channelID, userID int64) (string, string, bool) {
291	var chType, chName string
292	if err := s.db.QueryRow(`SELECT type, name FROM channels WHERE id = ?`, channelID).Scan(&chType, &chName); err != nil {
293		if err == sql.ErrNoRows {
294			c.JSON(http.StatusNotFound, gin.H{"error": "channel not found"})
295			return "", "", false
296		}
297		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
298		return "", "", false
299	}
300	if chType == "dm" {
301		u1, u2, ok := parseDM(chName)
302		if !ok || (u1 != userID && u2 != userID) {
303			c.JSON(http.StatusForbidden, gin.H{"error": "forbidden"})
304			return "", "", false
305		}
306		return chType, chName, true
307	}
308	if chType != "text" {
309		c.JSON(http.StatusBadRequest, gin.H{"error": "not a text channel"})
310		return "", "", false
311	}
312	return chType, chName, true
313}
314
315func (s *Server) handleMessages(c *gin.Context) {
316	channelID, err := strconv.ParseInt(c.Param("id"), 10, 64)
317	if err != nil {
318		c.JSON(http.StatusBadRequest, gin.H{"error": "bad channel"})
319		return
320	}
321	user := c.MustGet("user").(User)
322	if _, _, ok := s.checkTextOrDM(c, channelID, user.ID); !ok {
323		return
324	}
325	rows, err := s.db.Query(
326		`SELECT m.id, m.channel_id, m.user_id, u.username, m.body, m.created_at, COALESCE(m.edited_at, 0), m.preview
327		 FROM messages m JOIN users u ON u.id = m.user_id
328		 WHERE m.channel_id = ? ORDER BY m.id DESC LIMIT 200`,
329		channelID,
330	)
331	if err != nil {
332		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
333		return
334	}
335	defer rows.Close()
336	messages := []Message{}
337	for rows.Next() {
338		var m Message
339		var preview sql.NullString
340		if err := rows.Scan(&m.ID, &m.ChannelID, &m.UserID, &m.Username, &m.Body, &m.CreatedAt, &m.EditedAt, &preview); err != nil {
341			c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
342			return
343		}
344		m.Preview = decodePreview(preview.String)
345		messages = append(messages, m)
346	}
347	// reverse to chronological order
348	for i, j := 0, len(messages)-1; i < j; i, j = i+1, j-1 {
349		messages[i], messages[j] = messages[j], messages[i]
350	}
351	if len(messages) > 0 {
352		byID := make(map[int64]*Message, len(messages))
353		for i := range messages {
354			byID[messages[i].ID] = &messages[i]
355		}
356		rRows, err := s.db.Query(
357			`SELECT r.message_id, r.reaction, u.username
358			 FROM reactions r JOIN users u ON u.id = r.user_id
359			 WHERE r.message_id >= ? AND r.message_id <= ?
360			 ORDER BY r.rowid`,
361			messages[0].ID, messages[len(messages)-1].ID,
362		)
363		if err == nil {
364			defer rRows.Close()
365			for rRows.Next() {
366				var mid int64
367				var react, uname string
368				if rRows.Scan(&mid, &react, &uname) == nil {
369					if m := byID[mid]; m != nil {
370						if m.Reactions == nil {
371							m.Reactions = map[string][]string{}
372						}
373						m.Reactions[react] = append(m.Reactions[react], uname)
374					}
375				}
376			}
377		}
378	}
379	c.JSON(http.StatusOK, messages)
380}
381
382func (s *Server) messageReactions(msgID int64) map[string][]string {
383	rows, err := s.db.Query(
384		`SELECT r.reaction, u.username FROM reactions r JOIN users u ON u.id = r.user_id WHERE r.message_id = ? ORDER BY r.rowid`,
385		msgID,
386	)
387	if err != nil {
388		return nil
389	}
390	defer rows.Close()
391	var out map[string][]string
392	for rows.Next() {
393		var react, uname string
394		if rows.Scan(&react, &uname) == nil {
395			if out == nil {
396				out = map[string][]string{}
397			}
398			out[react] = append(out[react], uname)
399		}
400	}
401	return out
402}
403
404type sendMessageRequest struct {
405	Body string `json:"body"`
406}
407
408// checkBody rejects empty bodies and ones over the size cap, replying with the
409// reason. The composer has no copy of the cap, so the toast shows this message.
410func checkBody(c *gin.Context, body string) bool {
411	if body == "" {
412		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid message"})
413		return false
414	}
415	if n := utf8.RuneCountInString(body); n > maxMessageLen {
416		c.JSON(http.StatusRequestEntityTooLarge, gin.H{
417			"error": fmt.Sprintf("message is too long: %d of %d characters", n, maxMessageLen),
418		})
419		return false
420	}
421	return true
422}
423
424func (s *Server) handleSendMessage(c *gin.Context) {
425	channelID, err := strconv.ParseInt(c.Param("id"), 10, 64)
426	if err != nil {
427		c.JSON(http.StatusBadRequest, gin.H{"error": "bad channel"})
428		return
429	}
430	var req sendMessageRequest
431	if err := c.ShouldBindJSON(&req); err != nil {
432		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
433		return
434	}
435	body := strings.TrimSpace(req.Body)
436	if !checkBody(c, body) {
437		return
438	}
439	user := c.MustGet("user").(User)
440	chType, chName, ok := s.checkTextOrDM(c, channelID, user.ID)
441	if !ok {
442		return
443	}
444	now := time.Now().Unix()
445	res, err := s.db.Exec(
446		`INSERT INTO messages (channel_id, user_id, body, created_at) VALUES (?, ?, ?, ?)`,
447		channelID, user.ID, body, now,
448	)
449	if err != nil {
450		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
451		return
452	}
453	id, _ := res.LastInsertId()
454	msg := Message{ID: id, ChannelID: channelID, UserID: user.ID, Username: user.Username, Body: body, CreatedAt: now}
455	s.notifyChannel(chType, chName, event{Type: "message", Message: &msg})
456	go s.refreshPreview(id)
457	c.JSON(http.StatusOK, msg)
458}
459
460func (s *Server) handleEditMessage(c *gin.Context) {
461	msgID, err := strconv.ParseInt(c.Param("id"), 10, 64)
462	if err != nil {
463		c.JSON(http.StatusBadRequest, gin.H{"error": "bad message"})
464		return
465	}
466	var req sendMessageRequest
467	if err := c.ShouldBindJSON(&req); err != nil {
468		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
469		return
470	}
471	body := strings.TrimSpace(req.Body)
472	if !checkBody(c, body) {
473		return
474	}
475	user := c.MustGet("user").(User)
476	now := time.Now().Unix()
477	var m Message
478	err = s.db.QueryRow(
479		`UPDATE messages SET body = ?, edited_at = ?
480		 WHERE id = ? AND user_id = ?
481		 RETURNING id, channel_id, user_id, body, created_at, edited_at`,
482		body, now, msgID, user.ID,
483	).Scan(&m.ID, &m.ChannelID, &m.UserID, &m.Body, &m.CreatedAt, &m.EditedAt)
484	if err != nil {
485		if err == sql.ErrNoRows {
486			c.JSON(http.StatusNotFound, gin.H{"error": "message not found"})
487			return
488		}
489		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
490		return
491	}
492	m.Username = user.Username
493	m.Reactions = s.messageReactions(m.ID)
494	m.Preview = s.messagePreview(m.ID)
495	var chType, chName string
496	s.db.QueryRow(`SELECT type, name FROM channels WHERE id = ?`, m.ChannelID).Scan(&chType, &chName)
497	s.notifyChannel(chType, chName, event{Type: "message_edit", Message: &m})
498	go s.refreshPreview(m.ID)
499	c.JSON(http.StatusOK, m)
500}
501
502var validReactions = map[string]bool{
503	"+1":    true,
504	"-1":    true,
505	"heart": true,
506	"laugh": true,
507}
508
509type reactionRequest struct {
510	Reaction string `json:"reaction"`
511}
512
513func (s *Server) handleToggleReaction(c *gin.Context) {
514	msgID, err := strconv.ParseInt(c.Param("id"), 10, 64)
515	if err != nil {
516		c.JSON(http.StatusBadRequest, gin.H{"error": "bad message"})
517		return
518	}
519	var req reactionRequest
520	if err := c.ShouldBindJSON(&req); err != nil || !validReactions[req.Reaction] {
521		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid reaction"})
522		return
523	}
524	var m Message
525	err = s.db.QueryRow(
526		`SELECT m.id, m.channel_id, m.user_id, u.username, m.body, m.created_at, COALESCE(m.edited_at, 0)
527		 FROM messages m JOIN users u ON u.id = m.user_id WHERE m.id = ?`,
528		msgID,
529	).Scan(&m.ID, &m.ChannelID, &m.UserID, &m.Username, &m.Body, &m.CreatedAt, &m.EditedAt)
530	if err != nil {
531		if err == sql.ErrNoRows {
532			c.JSON(http.StatusNotFound, gin.H{"error": "message not found"})
533			return
534		}
535		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
536		return
537	}
538	user := c.MustGet("user").(User)
539	chType, chName, ok := s.checkTextOrDM(c, m.ChannelID, user.ID)
540	if !ok {
541		return
542	}
543	res, err := s.db.Exec(
544		`DELETE FROM reactions WHERE message_id = ? AND user_id = ? AND reaction = ?`,
545		msgID, user.ID, req.Reaction,
546	)
547	if err != nil {
548		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
549		return
550	}
551	if n, _ := res.RowsAffected(); n == 0 {
552		if _, err := s.db.Exec(
553			`INSERT INTO reactions (message_id, user_id, reaction) VALUES (?, ?, ?)`,
554			msgID, user.ID, req.Reaction,
555		); err != nil {
556			c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
557			return
558		}
559	}
560	m.Reactions = s.messageReactions(m.ID)
561	m.Preview = s.messagePreview(m.ID)
562	s.notifyChannel(chType, chName, event{Type: "message_edit", Message: &m})
563	c.JSON(http.StatusOK, m)
564}
565
566func (s *Server) handleDeleteMessage(c *gin.Context) {
567	msgID, err := strconv.ParseInt(c.Param("id"), 10, 64)
568	if err != nil {
569		c.JSON(http.StatusBadRequest, gin.H{"error": "bad message"})
570		return
571	}
572	user := c.MustGet("user").(User)
573	var m Message
574	err = s.db.QueryRow(
575		`DELETE FROM messages WHERE id = ? AND user_id = ? RETURNING id, channel_id`,
576		msgID, user.ID,
577	).Scan(&m.ID, &m.ChannelID)
578	if err != nil {
579		if err == sql.ErrNoRows {
580			c.JSON(http.StatusNotFound, gin.H{"error": "message not found"})
581			return
582		}
583		c.JSON(http.StatusInternalServerError, gin.H{"error": "db"})
584		return
585	}
586	var chType, chName string
587	s.db.QueryRow(`SELECT type, name FROM channels WHERE id = ?`, m.ChannelID).Scan(&chType, &chName)
588	s.notifyChannel(chType, chName, event{Type: "message_delete", Message: &m})
589	c.Status(http.StatusNoContent)
590}