349 lines
12 KiB
Go
349 lines
12 KiB
Go
package database
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"github.com/google/uuid"
|
|
"relay-server/helpers"
|
|
"relay-server/model"
|
|
"strings"
|
|
)
|
|
|
|
func DeleteContact(db *sql.DB, userID uuid.UUID, conversationID uuid.UUID) error {
|
|
var conversationType string
|
|
err := db.QueryRow(
|
|
"SELECT conversation_type FROM Conversations WHERE conversation_id = $1",
|
|
conversationID,
|
|
).Scan(&conversationType)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return helpers.NewError(helpers.ErrNotFound, "no contacts found for this id", fmt.Errorf("no conversation found with id: %s", conversationID))
|
|
}
|
|
return helpers.NewError(helpers.ErrInternal, "Failed to check conversation", err)
|
|
}
|
|
|
|
if conversationType == "group" {
|
|
// Delete from Contacts
|
|
res, err := db.Exec(
|
|
"DELETE FROM Contacts WHERE conversation_id = $1 AND user_id = $2",
|
|
conversationID, userID,
|
|
)
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "Failed to delete contact", err)
|
|
}
|
|
|
|
rowsAffected, err := res.RowsAffected()
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to verify contact deletion: %w", err))
|
|
}
|
|
if rowsAffected == 0 {
|
|
return helpers.NewError(helpers.ErrNotFound, fmt.Sprintf("no matching contact found with conversation id: %s, user id: %s", conversationID, userID), nil)
|
|
}
|
|
|
|
// Delete from Memberships
|
|
res, err = db.Exec(
|
|
"DELETE FROM Memberships WHERE conversation_id = $1 AND user_id = $2",
|
|
conversationID, userID,
|
|
)
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to delete membership: %w", err))
|
|
}
|
|
|
|
rowsAffected, err = res.RowsAffected()
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to verify membership deletion: %w", err))
|
|
}
|
|
if rowsAffected == 0 {
|
|
return helpers.NewError(helpers.ErrNotFound, "No membership found", err)
|
|
}
|
|
} else {
|
|
res, err := db.Exec(
|
|
"DELETE FROM Contacts WHERE user_id = $1 AND conversation_id = $2",
|
|
userID, conversationID,
|
|
)
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "Failed to delete contact", err)
|
|
}
|
|
|
|
rowsAffected, err := res.RowsAffected()
|
|
if err != nil {
|
|
return helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to verify contact deletion: %w", err))
|
|
}
|
|
if rowsAffected == 0 {
|
|
return helpers.NewError(helpers.ErrNotFound, fmt.Sprintf("no matching contact found with user id: %s, conversation id: %s", userID, conversationID), nil)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func InsertContact(db *sql.DB, userID uuid.UUID, contactID uuid.UUID, contactUsername string) (*model.Contact, error) {
|
|
isSelfContact := userID == contactID
|
|
var conversationID uuid.UUID
|
|
|
|
if isSelfContact {
|
|
err := db.QueryRow(`
|
|
SELECT c.conversation_id
|
|
FROM Conversations c
|
|
JOIN Memberships m ON c.conversation_id = m.conversation_id
|
|
WHERE c.conversation_type = 'direct'
|
|
AND m.user_id = $1
|
|
AND (SELECT COUNT(*) FROM Memberships WHERE conversation_id = c.conversation_id) = 1
|
|
LIMIT 1;
|
|
`, userID).Scan(&conversationID)
|
|
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to check existing conversation: %w", err))
|
|
}
|
|
|
|
if conversationID == uuid.Nil {
|
|
err := db.QueryRow(`
|
|
INSERT INTO Conversations (conversation_type)
|
|
VALUES ('direct')
|
|
RETURNING conversation_id;
|
|
`).Scan(&conversationID)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to create conversation: %w", err))
|
|
}
|
|
|
|
_, err = db.Exec(`
|
|
INSERT INTO Memberships (conversation_id, user_id)
|
|
VALUES ($1, $2)
|
|
ON CONFLICT (conversation_id, user_id) DO NOTHING;
|
|
`, conversationID, userID)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to create membership: %w", err))
|
|
}
|
|
}
|
|
} else {
|
|
err := db.QueryRow(`
|
|
SELECT c.conversation_id
|
|
FROM Conversations c
|
|
JOIN Memberships m1 ON c.conversation_id = m1.conversation_id
|
|
JOIN Memberships m2 ON c.conversation_id = m2.conversation_id
|
|
WHERE c.conversation_type = 'direct'
|
|
AND ((m1.user_id = $1 AND m2.user_id = $2) OR (m1.user_id = $2 AND m2.user_id = $1))
|
|
LIMIT 1;
|
|
`, userID, contactID).Scan(&conversationID)
|
|
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to check existing conversation %w", err))
|
|
}
|
|
|
|
if conversationID == uuid.Nil {
|
|
err := db.QueryRow(`
|
|
INSERT INTO Conversations (conversation_type)
|
|
VALUES ('direct')
|
|
RETURNING conversation_id;
|
|
`).Scan(&conversationID)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to create conversation: %w", err))
|
|
}
|
|
|
|
_, err = db.Exec(`
|
|
INSERT INTO Memberships (conversation_id, user_id)
|
|
VALUES ($1, $2), ($1, $3)
|
|
ON CONFLICT (conversation_id, user_id) DO NOTHING;
|
|
`, conversationID, userID, contactID)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to create memberships: %w", err))
|
|
}
|
|
}
|
|
}
|
|
|
|
insertedContact, err := InsertContactByID(db, contactID, conversationID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
latestMessage, err := GetLatestMessage(db, conversationID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
contact := model.Contact{
|
|
ID: insertedContact.ID,
|
|
ConversationID: insertedContact.ConversationID,
|
|
UserID: insertedContact.UserID,
|
|
Username: contactUsername,
|
|
Type: "direct",
|
|
LastMessageID: latestMessage.LastMessageID,
|
|
LastMessage: latestMessage.LastMessage,
|
|
LastMessageTime: latestMessage.LastMessageTime,
|
|
LastMessageSender: latestMessage.LastMessageSender,
|
|
}
|
|
return &contact, nil
|
|
}
|
|
|
|
func InsertContactByID(db *sql.DB, userID uuid.UUID, conversationID uuid.UUID) (*model.Contact, error) {
|
|
// First check if contact already exists
|
|
var contact model.Contact
|
|
err := db.QueryRow(`
|
|
SELECT contact_id, conversation_id, user_id
|
|
FROM Contacts
|
|
WHERE user_id = $1 AND conversation_id = $2
|
|
`, userID, conversationID).Scan(&contact.ID, &contact.ConversationID, &contact.UserID)
|
|
|
|
if err == nil {
|
|
return nil, helpers.NewError(helpers.ErrInvalidInput, "Contact already exists", nil)
|
|
} else if !errors.Is(err, sql.ErrNoRows) {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", fmt.Errorf("failed to check contact existence: %w", err))
|
|
}
|
|
|
|
// Insert new contact
|
|
err = db.QueryRow(`
|
|
INSERT INTO Contacts (user_id, conversation_id)
|
|
VALUES($1, $2)
|
|
RETURNING contact_id, conversation_id, user_id
|
|
`, userID, conversationID).Scan(&contact.ID, &contact.ConversationID, &contact.UserID)
|
|
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Failed to create contact", err)
|
|
}
|
|
|
|
return &contact, nil
|
|
}
|
|
|
|
func GetLatestMessage(db *sql.DB, conversationId uuid.UUID) (*model.Contact, error) {
|
|
var latestMessage model.Contact
|
|
|
|
err := db.QueryRow(`
|
|
SELECT DISTINCT ON (m.conversation_id)
|
|
m.message_id AS last_message_id,
|
|
m.content AS last_message,
|
|
m.sent_at AS last_message_time,
|
|
a.username AS last_message_sender
|
|
FROM Messages m
|
|
JOIN Accounts a ON m.user_id = a.user_id
|
|
WHERE m.conversation_id = $1
|
|
ORDER BY m.conversation_id, m.sent_at DESC
|
|
LIMIT 1;
|
|
`, conversationId).Scan(
|
|
&latestMessage.LastMessageID,
|
|
&latestMessage.LastMessage,
|
|
&latestMessage.LastMessageTime,
|
|
&latestMessage.LastMessageSender,
|
|
)
|
|
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return &model.Contact{}, nil // Return empty contact if no messages
|
|
}
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Failed to get latest message", err)
|
|
}
|
|
|
|
return &latestMessage, nil
|
|
}
|
|
|
|
func GetContacts(db *sql.DB, userID uuid.UUID) ([]*model.Contact, error) {
|
|
contactsQuery := `
|
|
WITH DirectContacts AS (
|
|
SELECT DISTINCT ON (c.conversation_id)
|
|
c.contact_id AS id,
|
|
a.user_id AS user_id,
|
|
a.username AS username,
|
|
conv.last_active,
|
|
c.conversation_id,
|
|
conv.conversation_type AS type,
|
|
requesting_member.last_read_message_id
|
|
FROM Contacts c
|
|
JOIN Conversations conv ON c.conversation_id = conv.conversation_id
|
|
JOIN Memberships requesting_member
|
|
ON requesting_member.conversation_id = conv.conversation_id
|
|
AND requesting_member.user_id = $1
|
|
JOIN Memberships other_member
|
|
ON other_member.conversation_id = conv.conversation_id
|
|
JOIN Accounts a ON a.user_id = other_member.user_id
|
|
WHERE c.user_id = $1
|
|
AND conv.conversation_type = 'direct'
|
|
AND (
|
|
a.user_id != $1
|
|
OR (SELECT COUNT(*) FROM Memberships WHERE conversation_id = c.conversation_id) = 1
|
|
)
|
|
),
|
|
GroupContacts AS (
|
|
SELECT DISTINCT ON (c.conversation_id)
|
|
c.contact_id AS id,
|
|
NULL::uuid AS user_id,
|
|
conv.name AS username,
|
|
conv.last_active,
|
|
c.conversation_id,
|
|
conv.conversation_type AS type,
|
|
m.last_read_message_id
|
|
FROM Contacts c
|
|
JOIN Conversations conv ON c.conversation_id = conv.conversation_id
|
|
JOIN Memberships m
|
|
ON m.conversation_id = conv.conversation_id
|
|
AND m.user_id = $1
|
|
WHERE c.user_id = $1
|
|
AND conv.conversation_type = 'group'
|
|
)
|
|
SELECT * FROM DirectContacts
|
|
UNION ALL
|
|
SELECT * FROM GroupContacts
|
|
ORDER BY last_active DESC NULLS LAST;
|
|
`
|
|
|
|
rows, err := db.Query(contactsQuery, userID)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Failed to get contacts", err)
|
|
}
|
|
|
|
var contacts []*model.Contact
|
|
for rows.Next() {
|
|
contact := &model.Contact{}
|
|
err := rows.Scan(&contact.ID, &contact.UserID, &contact.Username,
|
|
&contact.ConversationID, &contact.Type)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", err)
|
|
}
|
|
|
|
latestMessage, err := GetLatestMessage(db, contact.ConversationID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
contact.LastMessageID = latestMessage.LastMessageID
|
|
contact.LastMessage = latestMessage.LastMessage
|
|
contact.LastMessageTime = latestMessage.LastMessageTime
|
|
contact.LastMessageSender = latestMessage.LastMessageSender
|
|
|
|
contacts = append(contacts, contact)
|
|
}
|
|
|
|
if err = rows.Err(); err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Failed to process contacts", err)
|
|
}
|
|
|
|
return contacts, nil
|
|
}
|
|
|
|
func ContactSuggestion(db *sql.DB, contactUsername string) ([]string, error) {
|
|
query := `
|
|
SELECT username FROM accounts
|
|
WHERE LOWER(username) LIKE $1
|
|
LIMIT 5;
|
|
`
|
|
|
|
rows, err := db.Query(query, "%"+strings.ToLower(contactUsername)+"%")
|
|
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Failed to get contact suggestions", err)
|
|
}
|
|
|
|
var suggestions []string
|
|
for rows.Next() {
|
|
var suggestion string
|
|
err := rows.Scan(&suggestion)
|
|
if err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "internal server error", err)
|
|
}
|
|
suggestions = append(suggestions, suggestion)
|
|
}
|
|
if err = rows.Err(); err != nil {
|
|
return nil, helpers.NewError(helpers.ErrInternal, "Error processing suggestions", err)
|
|
}
|
|
return suggestions, nil
|
|
}
|