add notifications and chat tracking

config.go

@@ -17,6 +17,7 @@ import (
 )
 
 var NodeToken string
+var NodeID string
 
 type LocalServerConfig struct {
 	configFilePath string
@@ -114,6 +115,7 @@ func (l *LocalServerConfig) startup() (err error) {
 		return
 	}
 	logger.Println(config)
+	NodeID = l.NodeId
 	l.NodeId = config["nodeId"]
 	l.PrivateKeyPath = config["privKeyPath"]
 	l.Token = config["token"]
@@ -160,6 +162,7 @@ func (l *LocalServerConfig) authenticate() (err error) {
 		return
 	}
 	err = l.handleLoginResponse(payload)
+	NodeID = l.NodeId
 	return
 }
 

zoneChatTracking.go

@@ -10,6 +10,7 @@ import (
 )
 
 type ZoneChatTrackingDB struct {
+	ZoneID string
 	db     func(cb func(*badger.DB) (err error)) (err error)
 	lock   *sync.RWMutex
 }
@@ -34,7 +35,7 @@ func NewZoneChatTracking(zoneId,chatId string,members ...string) (*ZoneChatTrack
 			binary.BigEndian.PutUint64(b, 0)
 			for _, member := range members {
 				if _, rerr := txn.Get([]byte(member)); rerr == badger.ErrKeyNotFound {
-					txn.Set([]byte(member),b)
+					_ = txn.Set([]byte(member), b)
 				} else if rerr != nil {
 					return rerr
 				}
@@ -48,7 +49,7 @@ func NewZoneChatTracking(zoneId,chatId string,members ...string) (*ZoneChatTrack
 	}); err != nil {
 		return nil, err
 	}
-	return &ZoneChatTrackingDB{db,lock},nil
+	return &ZoneChatTrackingDB{zoneId, db, lock}, nil
 }
 
 func (zctdb *ZoneChatTrackingDB) Initialize(lastIndex uint64, users ...string) (err error) {
@@ -60,6 +61,19 @@ func (zctdb *ZoneChatTrackingDB) Initialize(lastIndex uint64,users ...string) (e
 	return
 }
 
+func (zctdb *ZoneChatTrackingDB) updateDBCallbackFolder(newChatId string) {
+	db := func(f func(*badger.DB) (err error)) (err error) {
+		db, err := badger.Open(badger.DefaultOptions(filepath.Join("data", "zones", zctdb.ZoneID, "chats", newChatId, "__tracking__")).WithLogger(dbLogger))
+		if err != nil {
+			return
+		}
+		defer db.Close()
+		err = f(db)
+		return
+	}
+	zctdb.db = db
+}
+
 func (zctdb *ZoneChatTrackingDB) RevertTrackingLastIndex(lastIndex uint64) (err error) {
 	zctdb.lock.Lock()
 	defer zctdb.lock.Unlock()
@@ -125,7 +139,7 @@ func (zctdb *ZoneChatTrackingDB) GetUserLastIndex(userId string) (index uint,err
 			if rerr != nil {
 				return rerr
 			}
-			item.Value(func(val []byte) error {
+			_ = item.Value(func(val []byte) error {
 				index = uint(binary.BigEndian.Uint64(val))
 				return nil
 			})

zoneChatsDBHandler.go

@@ -94,17 +94,14 @@ func (zcdbh *ZoneChatDBHandler) calculateNewChatCount(previousId uint64) ( count
 			count = 0
 			b := make([]byte, bufferSize)
 			binary.BigEndian.PutUint64(b, previousId)
-			for it.Seek(b); it.Valid(); it.Next() {
+			if previousId == 0 || previousId == 1 {
-				item := it.Item()
+				count++
-				if err = item.Value(func(val []byte) (err error) {
+				for it.Rewind(); it.Valid(); it.Next() {
-					var chatMessage *ChatMessage
+					count++
-					if err = json.Unmarshal(val, &chatMessage); err != nil {
+				}
-						return err
+			} else {
-					}
+				for it.Seek(b); it.Valid(); it.Next() {
 					count++
-					return
-				}); err != nil {
-					return err
 				}
 			}
 			if count > 0 {
@@ -118,8 +115,6 @@ func (zcdbh *ZoneChatDBHandler) calculateNewChatCount(previousId uint64) ( count
 }
 
 func (zcdbh *ZoneChatDBHandler) revertPreviousId() (err error) {
-	zcdbh.lock.Lock()
-	defer zcdbh.lock.Unlock()
 	err = zcdbh.db(func(d *badger.DB) (err error) {
 		err = d.View(func(txn *badger.Txn) error {
 			opt := badger.DefaultIteratorOptions
@@ -162,8 +157,6 @@ func (zcdbh *ZoneChatDBHandler) updateDbCallbackFolder(newChatId string) {
 }
 
 func (zcdbh *ZoneChatDBHandler) AddNewChatMessage(chatMessage *ChatMessage) (err error) {
-	zcdbh.lock.Lock()
-	defer zcdbh.lock.Unlock()
 	b := make([]byte, bufferSize)
 	zcdbh.PreviousId++
 	binary.BigEndian.PutUint64(b, zcdbh.PreviousId)
@@ -188,8 +181,6 @@ func (zcdbh *ZoneChatDBHandler) AddNewChatMessage(chatMessage *ChatMessage) (err
 
 func (zcdbh *ZoneChatDBHandler) DeleteChatMessage(key uint64) (err error) {
 	if err = zcdbh.db(func(d *badger.DB) (err error) {
-		zcdbh.lock.Lock()
-		defer zcdbh.lock.Unlock()
 		err = d.Update(func(txn *badger.Txn) (err error) {
 			b := make([]byte, bufferSize)
 			binary.BigEndian.PutUint64(b, key)
@@ -207,8 +198,6 @@ func (zcdbh *ZoneChatDBHandler) DeleteChatMessage(key uint64) (err error) {
 }
 
 func (zcdbh *ZoneChatDBHandler) DeleteChatFile(filename string, key uint64) (err error) {
-	zcdbh.lock.Lock()
-	defer zcdbh.lock.Unlock()
 	if err = zcdbh.DeleteChatMessage(key); err != nil {
 		return
 	}
@@ -217,8 +206,6 @@ func (zcdbh *ZoneChatDBHandler) DeleteChatFile(filename string, key uint64) (err
 }
 
 func (zcdbh *ZoneChatDBHandler) ListChatMessages(lastIndex int, limit int) (chatMessages []*ChatMessage, l int, done bool, err error) {
-	zcdbh.lock.RLock()
-	defer zcdbh.lock.RUnlock()
 	err = zcdbh.db(func(d *badger.DB) (err error) {
 		err = d.View(func(txn *badger.Txn) (err error) {
 			opt := badger.DefaultIteratorOptions
@@ -264,8 +251,6 @@ func (zcdbh *ZoneChatDBHandler) ListChatMessages(lastIndex int, limit int) (chat
 }
 
 func (zcdbh *ZoneChatDBHandler) ListChatFiles(lastIndex int, limit int) (chatMessages []*ChatFile, l int, err error) {
-	zcdbh.lock.RLock()
-	defer zcdbh.lock.RUnlock()
 	err = zcdbh.db(func(d *badger.DB) (err error) {
 		err = d.View(func(txn *badger.Txn) (err error) {
 			opt := badger.DefaultIteratorOptions
@@ -326,8 +311,6 @@ func (zcdbh *ZoneChatDBHandler) ListChatFiles(lastIndex int, limit int) (chatMes
 }
 
 func (zcdbh *ZoneChatDBHandler) GetChatMessage(index uint64) (chatMessage *ChatMessage, err error) {
-	zcdbh.lock.RLock()
-	defer zcdbh.lock.RUnlock()
 	err = zcdbh.db(func(d *badger.DB) (err error) {
 		err = d.View(func(txn *badger.Txn) (err error) {
 			b := make([]byte, bufferSize)
@@ -347,8 +330,6 @@ func (zcdbh *ZoneChatDBHandler) GetChatMessage(index uint64) (chatMessage *ChatM
 }
 
 func (zcdbh *ZoneChatDBHandler) ModifyChatMessage(key uint64, newContent string) (err error) {
-	zcdbh.lock.Lock()
-	defer zcdbh.lock.Unlock()
 	b := make([]byte, bufferSize)
 	binary.BigEndian.PutUint64(b, key)
 	chatMessage, err := zcdbh.GetChatMessage(key)

zoneChatsHandler.go

@@ -79,6 +79,7 @@ type Chat struct {
 }
 
 type ZoneChatsHandler struct {
+	ZoneName           string
 	ZoneId             string
 	HostId             string
 	ChatFSInstance     *ChatFSInstance
@@ -92,17 +93,17 @@ type ZoneChatsHandler struct {
 	init               bool
 }
 
-func NewZoneChatsHandler(hostId, zoneId, owner string, authorizedMembers []string, dataChannels map[string]*DataChannel, flag *uint32) (zoneChatsHandler *ZoneChatsHandler, err error) {
+func NewZoneChatsHandler(hostId, zoneId, zoneName, owner string, authorizedMembers []string, dataChannels map[string]*DataChannel, flag *uint32) (zoneChatsHandler *ZoneChatsHandler, err error) {
 	var dirs []fs.DirEntry
 	dirs, err = os.ReadDir(filepath.Join("data", "zones", zoneId, "chats"))
 	if err != nil {
 		if os.IsNotExist(err) {
 			logger.Printf("creating chat directory for zone %s...\n", zoneId)
-			mkdirErr := os.MkdirAll(filepath.Join("data", "zones", zoneId, "chats", "general"), 0700)
+			mkdirErr := os.MkdirAll(filepath.Join("data", "zones", zoneId, "chats", GENERAL), 0700)
 			if mkdirErr != nil {
 				return nil, mkdirErr
 			}
-			file, ferr := os.Create(filepath.Join("data", "zones", zoneId, "chats", "general", "chatConfig.json"))
+			file, ferr := os.Create(filepath.Join("data", "zones", zoneId, "chats", GENERAL, "chatConfig.json"))
 			if ferr != nil {
 				return nil, ferr
 			}
@@ -110,7 +111,7 @@ func NewZoneChatsHandler(hostId, zoneId, owner string, authorizedMembers []strin
 				ChatId:   GENERAL,
 				Owner:    owner,
 				ChatType: "public",
-				Members:  authorizedMembers,
+				Members:  []string{},
 			}
 			bs, jsonErr := json.Marshal(baseConfig)
 			if jsonErr != nil {
@@ -134,10 +135,6 @@ func NewZoneChatsHandler(hostId, zoneId, owner string, authorizedMembers []strin
 		if err != nil {
 			return nil, err
 		}
-		zoneChatTracking,err := NewZoneChatTracking(zoneId, chat.Name())
-		if err != nil {
-			return nil, err
-		}
 		var bs []byte
 		bs, err = os.ReadFile(filepath.Join("data", "zones", zoneId, "chats", chat.Name(), "chatConfig.json"))
 		if err != nil {
@@ -148,7 +145,8 @@ func NewZoneChatsHandler(hostId, zoneId, owner string, authorizedMembers []strin
 		if err = json.Unmarshal(bs, &c); err != nil {
 			return nil, err
 		}
-		if err = zoneChatTracking.Initialize(0,c.Members...); err != nil {
+		zoneChatTracking, err := NewZoneChatTracking(zoneId, c.ChatId, c.Members...)
+		if err != nil {
 			return nil, err
 		}
 		logger.Println("chats data :", c.ChatId, c.ChatType, c.Owner, c.Members)
@@ -160,6 +158,7 @@ func NewZoneChatsHandler(hostId, zoneId, owner string, authorizedMembers []strin
 	chatFSFlag := uint32(0)
 	zoneChatsHandler = &ZoneChatsHandler{
 		HostId:             hostId,
+		ZoneName:           zoneName,
 		ChatFSInstance:     NewChatFSInstance(zoneId, owner, authorizedMembers),
 		ChatFSInstanceFlag: &chatFSFlag,
 		ZoneId:             zoneId,
@@ -200,6 +199,8 @@ func (zch *ZoneChatsHandler) sendDataChannelMessage(reqType string, from string,
 					return jsonErr
 				}
 				err = zch.DataChannels[to].DataChannel.SendText(string(bs))
+			} else {
+				err = fmt.Errorf("no corresponding dataChannel")
 			}
 			return
 		}); err != nil {
@@ -250,7 +251,7 @@ func (zch *ZoneChatsHandler) signalCandidate(from string, to string, candidate *
 	})
 	select {
 	case <-d:
-	case err = <-e:
+	case <-e:
 	}
 	return
 }
@@ -262,7 +263,6 @@ func (zch *ZoneChatsHandler) GetChats(userId string, chatsId ...interface{}) (er
 			err = fmt.Errorf("id of wrong type")
 			return
 		}
-		fmt.Println("chat from get chats", id.(string))
 		_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
 			if _, ok := zch.Chats[id.(string)]; ok {
 				logger.Println(zch.Chats[id.(string)])
@@ -271,35 +271,24 @@ func (zch *ZoneChatsHandler) GetChats(userId string, chatsId ...interface{}) (er
 			return
 		})
 	}
-	fmt.Println("first  loop done")
 	for _, chat := range chats {
-		fmt.Println(chat.ChatId)
 		index, err := chat.Tracking.GetUserLastIndex(userId)
 		if err != nil {
-			fmt.Println("there")
-			fmt.Println(err)
 			return err
 		}
-		chat.DB.lock.RLock()
-		defer chat.DB.lock.RUnlock()
 		unread, err := chat.DB.calculateNewChatCount(uint64(index))
 		if err != nil {
-			fmt.Println("over there")
-			fmt.Println(err)
 			return err
 		}
 		chat.LastReadIndex = index
 		chat.Unread = unread
 	}
-	fmt.Println(chats)
 	done, e := zch.sendDataChannelMessage(GET_CHATS_RESPONSE, "node", userId, map[string]interface{}{
 		"chats": chats,
 	})
 	select {
 	case <-done:
-			fmt.Println("done")
+	case err = <-e:
-		case terr :=<-e:
-			fmt.Println(terr)
 	}
 	return
 }
@@ -333,16 +322,21 @@ func (zch *ZoneChatsHandler) AddNewChat(chatName string, owner string, chatType
 		return ferr
 	}
 	m := make([]string, 0, len(members))
+	if chatType == PRIVATE {
 		for _, member := range members {
 			if mbr, ok := member.(string); ok && mbr != owner {
 				m = append(m, mbr)
 			}
 		}
+		m = append(m, owner)
+	} else {
+		m = zch.ZoneMembersId
+	}
 	baseConfig := &ChatConfig{
 		ChatId:   chatName,
 		Owner:    owner,
 		ChatType: chatType,
-		Members:  append(m,owner),
+		Members:  m,
 	}
 	bs, jsonErr := json.Marshal(baseConfig)
 	if jsonErr != nil {
@@ -387,10 +381,24 @@ func (zch *ZoneChatsHandler) AddNewChat(chatName string, owner string, chatType
 			})
 			select {
 			case <-done:
-			case err = <-e:
+			case <-e:
-				return
 			}
 		}
+		bs, err := json.Marshal(map[string]any{
+			"zoneId": zch.ZoneId,
+			"chatId": chatName,
+		})
+		if err != nil {
+			return err
+		}
+		zch.sendZoneRequest(CREATE_NOTIFICATION, "node", map[string]interface{}{
+			"type":       "added_in_chat",
+			"title":      "Added in zone text channel 💬",
+			"body":       fmt.Sprintf("Added in channel %s in zone %s", c.ChatId, zch.ZoneName),
+			"isPushed":   true,
+			"payload":    string(bs),
+			"recipients": members,
+		})
 		return
 	}
 	switch c.ChatType {
@@ -402,7 +410,10 @@ func (zch *ZoneChatsHandler) AddNewChat(chatName string, owner string, chatType
 			return
 		})
 	case PRIVATE:
+		err = atomicallyExecute(zch.ChatFlag, func() (err error) {
 			err = newChatForMembers(c.Members)
+			return
+		})
 	}
 	return
 }
@@ -426,11 +437,24 @@ func (zch *ZoneChatsHandler) DeleteChat(chatId string) (err error) {
 				})
 				select {
 				case <-done:
-					continue
+				case <-e:
-				case err = <-e:
-					return
 				}
 			}
+			bs, err := json.Marshal(map[string]any{
+				"zoneId": zch.ZoneId,
+				"chatId": chatId,
+			})
+			if err != nil {
+				return err
+			}
+			zch.sendZoneRequest(CREATE_NOTIFICATION, "node", map[string]any{
+				"type":       "removed_from_chat",
+				"title":      "Removed from zone text channel ⛔️",
+				"body":       fmt.Sprintf("You have no longer access to the channel %s in zone %s", chatId, zch.ZoneName),
+				"isPushed":   true,
+				"payload":    string(bs),
+				"recipients": members,
+			})
 			return
 		}
 		switch zch.Chats[chatId].ChatType {
@@ -488,6 +512,7 @@ func (zch *ZoneChatsHandler) EditChatName(chatId string, newChatId string) (err
 		Tracking: zch.Chats[chatId].Tracking,
 	}
 	chat.DB.updateDbCallbackFolder(newChatId)
+	chat.Tracking.updateDBCallbackFolder(newChatId)
 	_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
 		defer delete(zch.Chats, chatId)
 		zch.Chats[newChatId] = chat
@@ -540,6 +565,9 @@ func (zch *ZoneChatsHandler) EditChatType(chatId string, chatType string) (err e
 		return
 	}
 	chatConfig.ChatType = chatType
+	if chatType == PUBLIC {
+		chatConfig.Members = zch.ZoneMembersId
+	}
 	bs, err = json.Marshal(&chatConfig)
 	f, err := os.OpenFile(filepath.Join("data", "zones", zch.ZoneId, "chats", chatId, "chatConfig.json"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
 	defer func() {
@@ -563,13 +591,8 @@ func (zch *ZoneChatsHandler) EditChatType(chatId string, chatType string) (err e
 	case BROADCAST:
 		fallthrough
 	case PUBLIC:
-		var members = []string{}
-		_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
-			members = append(members, zch.ZoneMembersId...)
-			return
-		})
 		for _, member := range zch.ZoneMembersId {
-			if pubErr := zch.SetChatPublicForUser(chatId, member); pubErr != nil {
+			if pubErr := zch.AddChatMembers(chatId, []any{member}); pubErr != nil {
 				logger.Println(pubErr)
 			}
 			zch.sendDataChannelMessage(CHAT_TYPE_EDITED, "node", member, map[string]interface{}{
@@ -578,11 +601,6 @@ func (zch *ZoneChatsHandler) EditChatType(chatId string, chatType string) (err e
 			})
 		}
 	case PRIVATE:
-		var members = []string{}
-		_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
-			members = append(members, zch.ZoneMembersId...)
-			return
-		})
 		for _, member := range zch.ZoneMembersId {
 			if pubErr := zch.SetChatPrivateForUser(chatId, member); pubErr != nil {
 				logger.Println(pubErr)
@@ -636,6 +654,21 @@ memberLoop:
 			"chatId": chatId,
 		})
 	}
+	bs, err = json.Marshal(map[string]any{
+		"zoneId": zch.ZoneId,
+		"chatId": chatId,
+	})
+	if err != nil {
+		return err
+	}
+	zch.sendZoneRequest(CREATE_NOTIFICATION, "node", map[string]interface{}{
+		"type":       "added_in_chat",
+		"title":      "Added in zone text channel 💬",
+		"body":       fmt.Sprintf("Added in channel %s in zone %s", chatId, zch.ZoneName),
+		"isPushed":   true,
+		"payload":    string(bs),
+		"recipients": chatMembers,
+	})
 	bs, err = json.Marshal(&chatConfig)
 	f, err := os.OpenFile(filepath.Join("data", "zones", zch.ZoneId, "chats", chatId, "chatConfig.json"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
 	defer func() {
@@ -655,13 +688,10 @@ memberLoop:
 		DB:       zch.Chats[chatId].DB,
 		Tracking: zch.Chats[chatId].Tracking,
 	}
-	chat.DB.lock.Lock()
-	lastIndex := chat.DB.PreviousId
-	chat.DB.lock.Unlock()
 	_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
+		lastIndex := chat.DB.PreviousId
 		zch.Chats[chatId] = chat
-		return
+
-	})
 		var chmb []string
 		if chat.ChatType == PRIVATE {
 			chmb = chat.Members
@@ -699,6 +729,8 @@ broadcastLoop:
 			}
 		}
 		return
+	})
+	return
 }
 
 func (zch *ZoneChatsHandler) RemoveChatMember(chatId string, chatMember string) (err error) {
@@ -770,6 +802,21 @@ func (zch *ZoneChatsHandler) RemoveChatMember(chatId string, chatMember string)
 		"userId": chatMember,
 		"chatId": chatId,
 	})
+	bs, err = json.Marshal(map[string]any{
+		"zoneId": zch.ZoneId,
+		"chatId": chatId,
+	})
+	if err != nil {
+		return
+	}
+	zch.sendZoneRequest(CREATE_NOTIFICATION, "node", map[string]interface{}{
+		"type":       "removed_from_chat",
+		"title":      "Removed from zone text channel ⛔️",
+		"body":       fmt.Sprintf("You have no longer access to the channel %s in zone %s", chatId, zch.ZoneName),
+		"isPushed":   true,
+		"payload":    string(bs),
+		"recipients": []string{chatMember},
+	})
 	done, e := zch.sendDataChannelMessage(REMOVED_FROM_CHAT, "node", chatMember, map[string]interface{}{
 		"chatId": chatId,
 		"userId": chatMember,
@@ -876,9 +923,12 @@ func (zch *ZoneChatsHandler) AddChatMessage(userId, chatId, content string, isRe
 		Tags:       make([]string, 0),
 		Date:       time.Now().Format("Mon, 02 Jan 2006 15:04:05 MST"),
 	}
-	
+	var chatType string
+	var chatMembers []string
 	if err = atomicallyExecute(zch.ChatFlag, func() (err error) {
 		if chat, ok := zch.Chats[chatId]; ok {
+			chatType = chat.ChatType
+			chatMembers = chat.Members
 			if isResponse {
 				parentMessage, getErr := chat.DB.GetChatMessage(chatResponseId)
 				if err != nil {
@@ -900,10 +950,44 @@ func (zch *ZoneChatsHandler) AddChatMessage(userId, chatId, content string, isRe
 	}); err != nil {
 		return
 	}
+
+	notifyActivity := func(done <-chan struct{}, e <-chan error, member string) {
+		select {
+		case <-done:
+		case <-e:
 			_ = atomicallyExecute(zch.ChatFlag, func() (err error) {
-		chat := zch.Chats[chatId]
+				if chat, ok := zch.Chats[chatId]; ok {
-		logger.Println(chat.ChatType)
+					li, err := chat.Tracking.GetUserLastIndex(member)
-		switch chat.ChatType {
+					if err != nil {
+						return err
+					}
+					count, err := chat.DB.calculateNewChatCount(uint64(li))
+					if err != nil {
+						return err
+					}
+					if count == 1 {
+						bs, err := json.Marshal(map[string]any{
+							"zoneId": zch.ZoneId,
+							"chatId": chatId,
+						})
+						if err != nil {
+							return err
+						}
+						zch.sendZoneRequest(CREATE_NOTIFICATION, "node", map[string]interface{}{
+							"type":       "new_chat_activity",
+							"title":      "Unread messages 👀",
+							"body":       fmt.Sprintf("New messages in channel %s of %s", chatId, zch.ZoneName),
+							"isPushed":   true,
+							"payload":    string(bs),
+							"recipients": []string{member},
+						})
+					}
+				}
+				return
+			})
+		}
+	}
+	switch chatType {
 	case BROADCAST:
 		fallthrough
 	case PUBLIC:
@@ -912,25 +996,17 @@ func (zch *ZoneChatsHandler) AddChatMessage(userId, chatId, content string, isRe
 				"chatMessage": chatMessage,
 				"chatId":      chatId,
 			})
-				select {
+			go notifyActivity(done, e, v)
-				case <-done:
-				case err = <-e:
-				}
 		}
 	case PRIVATE:
-			for _, v := range chat.Members {
+		for _, v := range chatMembers {
 			done, e := zch.sendDataChannelMessage(NEW_CHAT_MESSAGE, "node", v, map[string]interface{}{
 				"chatMessage": chatMessage,
 				"chatId":      chatId,
 			})
-				select {
+			go notifyActivity(done, e, v)
-				case <-done:
-				case err = <-e:
 		}
 	}
-		}
-		return
-	})
 	return
 }
 
@@ -955,7 +1031,7 @@ func (zch *ZoneChatsHandler) SetChatPrivateForUser(chatId string, member string)
 				})
 				select {
 				case <-done:
-				case err = <-e:
+				case <-e:
 				}
 			}
 		}
@@ -984,7 +1060,7 @@ func (zch *ZoneChatsHandler) SetChatPublicForUser(chatId string, member string)
 				})
 				select {
 				case <-done:
-				case err = <-e:
+				case <-e:
 				}
 			}
 		}
@@ -997,15 +1073,22 @@ func (zch *ZoneChatsHandler) SetAllPublicChatForUser(userId string) (err error)
 	for _, chat := range zch.Chats {
 		logger.Println("--------------- public chat for all : ", chat)
 		if chat.ChatType == PUBLIC || chat.ChatType == BROADCAST {
-			if chat.ChatId == GENERAL {
+			var contains bool
-				if err = zch.AddChatMembers(chat.ChatId, []interface{}{userId}); err != nil {
+			for _, m := range chat.Members {
-					logger.Println(err)
+				if m == userId {
+					contains = true
+					break
+				}
+			}
+			if !contains {
+				if addErr := zch.AddChatMembers(chat.ChatId, []any{userId}); addErr != nil {
+					logger.Println(addErr)
 				}
 				continue
 			}
-			if err = zch.SetChatPublicForUser(chat.ChatId, userId); err != nil {
+			// if addErr := zch.SetChatPublicForUser(chat.ChatId, userId); addErr != nil {
-				continue
+			// 	continue
-			}
+			// }
 		}
 	}
 	return
@@ -1048,7 +1131,7 @@ func (zch *ZoneChatsHandler) ConnectToChatFSInstance(channelId string, userId st
 		d, e := zch.ChatFSInstance.HandleOffer(context.Background(), channelId, userId, sdp, zch.HostId, zch.sendDataChannelMessage, zch.signalCandidate)
 		select {
 		case <-d:
-		case err = <-e:
+		case <-e:
 		}
 		return
 	})
@@ -1116,7 +1199,7 @@ func (zch *ZoneChatsHandler) DeleteChatMessage(key uint64, chatId string) (err e
 func (zch *ZoneChatsHandler) UpdateChatMessage(key uint64, chatId, newContent string) (err error) {
 	err = atomicallyExecute(zch.ChatFlag, func() (err error) {
 		if _, ok := zch.Chats[chatId]; !ok {
-			err = fmt.Errorf("no file corresponding to id %s", chatId)
+			err = fmt.Errorf("no chat corresponding to id %s", chatId)
 			return
 		}
 		if err = zch.Chats[chatId].DB.ModifyChatMessage(key, newContent); err != nil {
@@ -1279,13 +1362,10 @@ func (zch *ZoneChatsHandler) handleZoneRequest(ctx context.Context, req *ZoneReq
 		}
 		err = zch.AddNewChat(req.Payload["chatId"].(string), req.Payload["owner"].(string), req.Payload["chatType"].(string), req.Payload["members"].([]interface{}))
 	case GET_CHATS:
-		fmt.Println("got a get chat req")
 		if err = verifyFieldsSliceInterface(req.Payload, "chatsId"); err != nil {
 			return
 		}
-		fmt.Println("calling  get chat")
 		err = zch.GetChats(req.From, req.Payload["chatsId"].([]interface{})...)
-		fmt.Println("get chat done")
 	case LIST_LATEST_CHATS:
 		if err = verifyFieldsString(req.Payload, "chatId"); err != nil {
 			return

zoneManager.go

@@ -52,7 +52,7 @@ type Zone struct {
 
 func NewZone(hostId string, zoneId string, zoneName string, imageUrl string, owner string, creationDate string, initialized bool, authorizedMembers []string) (zone *Zone, err error) {
 	dataChannels, dataChannelFlag := make(map[string]*DataChannel), uint32(0)
-	zoneChatHandler, err := NewZoneChatsHandler(hostId, zoneId, owner, authorizedMembers, dataChannels, &dataChannelFlag)
+	zoneChatHandler, err := NewZoneChatsHandler(hostId, zoneId, zoneName, owner, authorizedMembers, dataChannels, &dataChannelFlag)
 	if err != nil {
 		return nil, err
 	}
@@ -68,11 +68,15 @@ func NewZone(hostId string, zoneId string, zoneName string, imageUrl string, own
 	if err != nil {
 		return
 	}
+	zoneNotificationsHandler, err := NewZoneNotificationsHandler(hostId, zoneId, owner, authorizedMembers, dataChannels, &dataChannelFlag)
+	if err != nil {
+		return
+	}
 	zoneFileHandler, err := NewZoneFileHandler(hostId, zoneId, owner, authorizedMembers, dataChannels, &dataChannelFlag)
 	if err != nil {
 		return
 	}
-	zoneScheduler, e := NewZoneRequestScheduler(authorizedMembers, zoneUsersHandler, zoneAudioChannelsHandler, zoneVideoChannelsHandler, zoneFileHandler, zoneChatHandler)
+	zoneScheduler, e := NewZoneRequestScheduler(authorizedMembers, zoneUsersHandler, zoneAudioChannelsHandler, zoneVideoChannelsHandler, zoneFileHandler, zoneChatHandler, zoneNotificationsHandler)
 	go func() {
 		for schedErr := range e {
 			logger.Println("from scheduler :", schedErr)

zoneNotificationsDBHandler.go

@@ -0,0 +1,41 @@
+package localserver
+
+import (
+	"path/filepath"
+	sync "sync"
+
+	"github.com/dgraph-io/badger/v3"
+)
+
+type ZoneNotification struct {
+	ID          string
+	Type        string
+	Description string
+	Recipients  []string
+}
+
+type ZoneNotificationDBHandler struct {
+	ZoneID string
+	db     func(func(*badger.DB) (err error)) (err error)
+	lock   *sync.RWMutex
+}
+
+func NewZoneNotificationDBHandler(zoneId string) (zoneFilesDBHandler *ZoneNotificationDBHandler, err error) {
+	zoneFilesDBHandler = &ZoneNotificationDBHandler{
+		db: func(f func(*badger.DB) (err error)) (err error) {
+			path := filepath.Join("data", "zones", zoneId, "notifications")
+			db, err := badger.Open(badger.DefaultOptions(path).WithLogger(dbLogger))
+			if err != nil {
+				return
+			}
+			defer db.Close()
+			err = f(db)
+			return
+		},
+		ZoneID: zoneId,
+		lock:   new(sync.RWMutex),
+	}
+	return
+}
+
+//Todo: implement pull notification module for beta only push notification are enabled for simplicity

zoneNotificationsHandler.go

@@ -1,10 +1,179 @@
 package localserver
 
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+const (
+	CREATE_NOTIFICATION = "create_notification"
+)
+
+const (
+	NOTIFY = "notify"
+)
+
 type ZoneNotificationsHandler struct {
 	ZoneId        string
 	ZoneMembersId []string
 	DataChannels  map[string]*DataChannel
 	Flag          *uint32
+	DB            *ZoneNotificationDBHandler
 	Publishers    []<-chan *ZoneRequest
 	reqChans      []chan<- *ZoneRequest
 }
+
+func NewZoneNotificationsHandler(_ string, zoneId string, owner string, authorizedMembers []string, dataChannels map[string]*DataChannel, flag *uint32) (zoneNotificationsHandler *ZoneNotificationsHandler, err error) {
+	db, err := NewZoneNotificationDBHandler(zoneId)
+	if err != nil {
+		return
+	}
+	if _, dirErr := os.ReadDir(filepath.Join("data", "zones", zoneId, "notifications")); os.IsNotExist(dirErr) {
+		dirErr := os.MkdirAll(filepath.Join("data", "zones", zoneId, "notifications"), 0700)
+		if dirErr != nil {
+			return
+		}
+	}
+	zoneNotificationsHandler = &ZoneNotificationsHandler{
+		ZoneId:        zoneId,
+		ZoneMembersId: authorizedMembers,
+		DataChannels:  dataChannels,
+		DB:            db,
+		Flag:          flag,
+	}
+	return
+}
+
+func (znh *ZoneNotificationsHandler) sendZoneRequest(reqType string, from string, payload map[string]interface{}) {
+	go func() {
+		for _, rc := range znh.reqChans {
+			rc <- &ZoneRequest{
+				ReqType: reqType,
+				From:    from,
+				Payload: payload,
+			}
+		}
+	}()
+}
+
+func (znh *ZoneNotificationsHandler) sendDataChannelMessage(reqType string, from string, to string, payload map[string]interface{}) (<-chan struct{}, <-chan error) {
+	done, errCh := make(chan struct{}), make(chan error)
+	go func() {
+		if err := atomicallyExecute(znh.Flag, func() (err error) {
+			if _, ok := znh.DataChannels[to]; ok {
+				bs, jsonErr := json.Marshal(&ZoneResponse{
+					Type:    reqType,
+					From:    from,
+					To:      to,
+					Payload: payload,
+				})
+				if jsonErr != nil {
+					return jsonErr
+				}
+				err = znh.DataChannels[to].DataChannel.SendText(string(bs))
+			}
+			return
+		}); err != nil {
+			errCh <- err
+			return
+		}
+		done <- struct{}{}
+	}()
+	return done, errCh
+}
+
+func (znh *ZoneNotificationsHandler) Init(ctx context.Context, authorizedMembers []string) (err error) {
+	//? initialization code here
+	return
+}
+
+func (znh *ZoneNotificationsHandler) Subscribe(ctx context.Context, publisher <-chan *ZoneRequest) (reqChan chan *ZoneRequest, done chan struct{}, errCh chan error) {
+	reqChan, done, errCh = make(chan *ZoneRequest), make(chan struct{}), make(chan error)
+	znh.reqChans = append(znh.reqChans, reqChan)
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				done <- struct{}{}
+				return
+			case req := <-publisher:
+				if err := znh.handleZoneRequest(ctx, req); err != nil {
+					errCh <- err
+				}
+			}
+		}
+	}()
+	return
+}
+
+func (zng *ZoneNotificationsHandler) ListNotifications(userId string) {}
+
+func (zng *ZoneNotificationsHandler) CreateNotification(notificationType, title, body, payload string, isPushed bool, recipients ...string) (err error) {
+	if isPushed {
+		err = zng.PushNotification(notificationType, title, body, payload, recipients...)
+	}
+	return
+}
+
+func (zng *ZoneNotificationsHandler) DeleteNotification() {}
+
+func (zng *ZoneNotificationsHandler) PushNotification(notificationType, title, body ,payload string, recipients ...string) (err error) {
+	em := NewEncryptionManager()
+	sig := em.SignRequestHMAC(NodeID)
+	b, err := json.Marshal(map[string]interface{}{
+		"type":     NOTIFY,
+		"mac":      sig,
+		"from":     NodeID,
+		"peerType": "node",
+		"payload": map[string]interface{}{
+			"type":       notificationType,
+			"title":      title,
+			"body":       body,
+			"recipients": recipients,
+			"payload":    payload,
+		},
+	})
+	if err != nil {
+		return
+	}
+	_, err = http.Post("https://app.zippytal.com/req", "application/json", bytes.NewBuffer(b))
+	if err != nil {
+		logger.Println("error come from there in zone manager")
+		return
+	}
+	return
+}
+
+func (zng *ZoneNotificationsHandler) handleZoneRequest(ctx context.Context, req *ZoneRequest) (err error) {
+	switch req.ReqType {
+	case CREATE_NOTIFICATION:
+		if err = verifyFieldsString(req.Payload, "type", "title", "body","payload"); err != nil {
+			return
+		}
+		if err = verifyFieldsBool(req.Payload, "isPushed"); err != nil {
+			return
+		}
+		if _, ok := req.Payload["recipients"]; !ok {
+			err = fmt.Errorf("no field recipient in payload")
+			return
+		}
+		if _, ok := req.Payload["recipients"].([]string); !ok {
+			err = fmt.Errorf(" field recipient in payload is wrong type")
+			return
+		}
+		// recipients := []string{}
+		// for _, recipient := range req.Payload["recipients"].([]any) {
+		// 	if r, ok := recipient.(string); ok {
+		// 		recipients = append(recipients, r)
+		// 	}
+		// }
+
+		err = zng.CreateNotification(req.Payload["type"].(string), req.Payload["title"].(string), req.Payload["body"].(string), req.Payload["payload"].(string),req.Payload["isPushed"].(bool),req.Payload["recipients"].([]string)...)
+	}
+	return
+}

zoneRequestScheduler.go

@@ -72,7 +72,7 @@ func verifyFieldsSliceInterface(payload map[string]interface{}, fields ...string
 		if _, ok := payload[field]; !ok {
 			err = fmt.Errorf("no field %s in payload", field)
 			return
-		} else if _, ok := payload[field].([]interface{}); !ok {
+		} else if _, ok := payload[field].([]any); !ok {
 			err = fmt.Errorf("field %s in payload is not a []interface{}", field)
 			return
 		}