slawk0/relay-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

finished rewriting socket but it isn't working 😊

Browse Source
This commit is contained in:
slawk0
2025-02-11 23:03:31 +01:00
parent 248966d63f
commit e6817cb4c6
6 changed files with 214 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
socket/socket.go
View File

@@ -10,6 +10,11 @@ import (
socketio "github.com/googollee/go-socket.io"
)
type JoinRoomResponse struct {
Status string `json:"status"`
Message string `json:"message"`
}
// Message represents the chat message structure
type Message struct {
Content string `json:"message"`
@@ -43,11 +48,10 @@ type SocketResponse struct {
}
// InitializeSocket sets up and configures the Socket.IO server
func InitializeSocket() (*socketio.Server, error) {
server := socketio.NewServer(nil)
func InitializeSocket(server *socketio.Server) error {
// Middleware for authentication
server.OnConnect("/", func(s socketio.Conn) error {
s.SetContext("")
token := s.RemoteHeader().Get("Authorization")
if token == "" {
log.Println("(socket) Not logged in")
@@ -90,12 +94,12 @@ func InitializeSocket() (*socketio.Server, error) {
log.Printf("(socket) Failed to get user conversations: %v\n", err)
return
}
log.Println("CONVERSATIONS", conversations)
// Join all conversations
for _, conv := range conversations {
s.Join(conv)
}
s.Join(userID) // Join user's personal room
s.Join(userID)
log.Printf("User: %s joined to: %v\n", username, conversations)
})
@@ -178,21 +182,30 @@ func InitializeSocket() (*socketio.Server, error) {
return SocketResponse{Status: "error", Message: "No user id provided"}
}
err := removeUserFromGroupById(data.GroupID, data.UserID)
msg, err := database.RemoveUserFromGroup(database.DB, data.GroupID, data.UserID)
if msg != "" {
return SocketResponse{Status: "error", Message: msg}
}
if err != nil {
return SocketResponse{Status: "error", Message: err.Error()}
}
// Remove user from room
sockets := server.Sockets(data.GroupID)
for _, socket := range sockets {
if socket.Context().(map[string]interface{})["user_id"] == data.UserID {
socket.Leave(data.GroupID)
server.ForEach("/", data.GroupID.String(), func(c socketio.Conn) {
// Get the context and check user ID
if ctxData, ok := c.Context().(map[string]interface{}); ok {
if userIDFromCtx, ok := ctxData["user_id"].(string); ok {
if userIDFromCtx == data.UserID.String() {
c.Leave(data.GroupID.String())
}
}
}
}
})
groupIDstr := data.GroupID.String()
userIDstr := data.UserID.String()
server.BroadcastToRoom("", data.GroupID, "left group", data)
server.BroadcastToRoom("", data.UserID, "left group", data)
server.BroadcastToRoom("", groupIDstr, "left group", data)
server.BroadcastToRoom("", userIDstr, "left group", data)
return SocketResponse{Status: "ok", Message: "Successfully removed user from group"}
})
@@ -200,59 +213,118 @@ func InitializeSocket() (*socketio.Server, error) {
// Handle administrator operations
server.OnEvent("/", "added administrator", func(s socketio.Conn, data GroupUserData) SocketResponse {
ctx := s.Context().(map[string]interface{})
userID := ctx["user_id"].(string)
userIDstr := ctx["user_id"].(string)
if data.GroupID == "" {
userID, err := uuid.Parse(userIDstr)
if err != nil {
return SocketResponse{Status: "error", Message: "Invalid user id"}
}
if data.GroupID == uuid.Nil {
return SocketResponse{Status: "error", Message: "No conversation id provided"}
}
if data.UserID == "" {
if data.UserID == uuid.Nil {
return SocketResponse{Status: "error", Message: "No user id provided"}
}
isAdmin, err := isAdmin(userID, data.GroupID)
isAdmin, err := database.IsAdmin(database.DB, data.UserID, data.GroupID)
if err != nil || !isAdmin {
return SocketResponse{Status: "error", Message: "You are not an administrator"}
}
err = addAdministrator(data.GroupID, data.UserID, userID)
msg, err := database.AddAdministrator(database.DB, data.GroupID, data.UserID, userID)
if err != nil {
return SocketResponse{Status: "error", Message: err.Error()}
}
if msg != "" {
return SocketResponse{Status: "error", Message: msg}
}
server.BroadcastToRoom("", data.GroupID, "added administrator", data)
groupIDstr := data.GroupID.String()
server.BroadcastToRoom("", groupIDstr, "added administrator", data)
return SocketResponse{Status: "ok", Message: "Successfully added administrator"}
})
// Handle message read status
server.OnEvent("/", "message read", func(s socketio.Conn, data MessageReadData) {
server.OnEvent("/", "message read", func(s socketio.Conn, data MessageReadData) SocketResponse {
ctx := s.Context().(map[string]interface{})
userID := ctx["user_id"].(string)
userIDstr := ctx["user_id"].(string)
if data.ConversationID == "" || data.MessageID == "" {
return
userID, err := uuid.Parse(userIDstr)
if err != nil {
return SocketResponse{Status: "error", Message: "Invalid user id"}
}
err := updateContactStatus(userID, data.ConversationID, data.MessageID)
if data.ConversationID == uuid.Nil || data.MessageID == 0 {
return SocketResponse{Status: "error", Message: "Invalid conversation or message id"}
}
err = database.UpdateContactStatus(database.DB, userID, data.ConversationID, data.MessageID)
if err != nil {
log.Printf("Failed to update message read status: %v\n", err)
}
return SocketResponse{Status: "ok", Message: "Successfully updated message read status"}
})
server.OnEvent("/", "join room", func(s socketio.Conn, conversationIDstr string, callback func(JoinRoomResponse)) {
// Get user data from context
ctx := s.Context().(map[string]interface{})
userIDstr := ctx["user_id"].(string)
username := ctx["username"].(string)
log.Printf("JOIN ROOM SDJKLSDFJKLSDFJKLSDFJKLSDFSDFJKLSLDFJKJLSDFKSDFJKLSDFJKLSDFJKLSDFJLKSFDLJKSDFJKLSDFJLKSDFJLKSDFJLKSDFJLSDFKSDFJKLSDFJKLJKL")
userID, err := uuid.Parse(userIDstr)
if err != nil {
callback(JoinRoomResponse{
Status: "error",
Message: "Invalid user id",
})
return
}
conversationID, err := uuid.Parse(conversationIDstr)
if err != nil {
callback(JoinRoomResponse{
Status: "error",
Message: "Invalid conversation id",
})
return
}
// Check if user is member of the conversation
isMember, err := database.IsMember(database.DB, userID, conversationID)
if err != nil {
callback(JoinRoomResponse{
Status: "error",
Message: "Failed to check conversation membership",
})
return
}
if isMember {
log.Printf("Join room for: %s, room: %s", username, conversationID)
s.Join(conversationIDstr)
callback(JoinRoomResponse{
Status: "ok",
Message: "Successfully joined to conversation",
})
} else {
callback(JoinRoomResponse{
Status: "error",
Message: "You are not member of this group",
})
}
})
server.OnEvent("/", "*", func(s socketio.Conn, event string, data interface{}) {
log.Printf("Received event: %s, data: %v\n", event, data)
})
server.OnError("/", func(s socketio.Conn, e error) {
log.Printf("Error: %v\n", e)
})
// Handle disconnection
server.OnDisconnect("/", func(s socketio.Conn, reason string) {
log.Printf("(socket) %s disconnected due to: %s\n", s.ID(), reason)
})
return server, nil
return nil
}
// The following functions would need to be implemented according to your specific needs:
// - verifyJwtToken
// - isValidUsername
// - getConversationsForUser
// - insertMessage
// - deleteMessage
// - removeUserFromGroupById
// - isAdmin
// - addAdministrator
// - updateContactStatus