func MyActiveOrg(orgIdHex string) (activeOrg *ws.ActiveOrg, err error) {
mu.Lock()
defer mu.Unlock()
// Validation: The org id should be valid
orgId, err := utils.ToObjectId(orgIdHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Already running in the map
activeOrg, exist := activeOrgMap[orgIdHex]
if exist {
return
}
// Should init the org and put into map for further use
org, err := organizations.FindById(orgId)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Find and maintain all dbs for handling shared groups
allDBs := []*mgodb.Database{org.Database}
embedOrgs, err := organizations.FindByIds(org.EmbededOrgIds)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, embedOrg := range embedOrgs {
allDBs = append(allDBs, embedOrg.Database)
}
// Init the activeOrg and put it into the map
activeOrg = &ws.ActiveOrg{
OrgId: orgIdHex,
Organization: org,
OnlineUsers: make(map[bson.ObjectId]*ws.OnlineUser),
Broadcast: make(chan ws.GenericPushingMessage),
CloseSign: make(chan bool),
AllDBs: allDBs,
}
go runActiveOrg(activeOrg)
activeOrgMap[orgIdHex] = activeOrg
return
}
func SendEntryNotification(entryTopicData *nsqproducers.EntryTopicData) (err error) {
serv, err := MakeWsService(entryTopicData.OrgId, entryTopicData.UserId)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiEntry := entryTopicData.ApiEntry
currentOrg := serv.CurrentOrg
currentUser := serv.LoggedInUser
// TODO: the db should be group db, not current org db
db := currentOrg.Database
entry, err := entries.FindById(db, bson.ObjectIdHex(apiEntry.Id))
if err != nil {
utils.PrintStackAndError(err)
return
}
var entity notifications.Entity
switch entryTopicData.Status {
case nsqproducers.TOPIC_STATUS_CREATE, nsqproducers.TOPIC_STATUS_DELETE, nsqproducers.TOPIC_STATUS_UPDATE:
entity = notifications.MakeEntryEntity(db, currentOrg, currentUser, entry)
case nsqproducers.TOPIC_STATUS_LIKE, nsqproducers.TOPIC_STATUS_REMOVE_LIKE:
hasLiked := (entryTopicData.Status == nsqproducers.TOPIC_STATUS_LIKE)
entity = notifications.NewLikeEntity(currentOrg, currentUser, entry, hasLiked)
}
// currentTime := time.Now()
causedEntry := entity.CausedEntry()
causedEntries := entity.CausedEntries()
eventMap := entity.Events(db)
// Save or delete notification items
if err := entity.HandleNotificationItems(db, eventMap); err != nil {
utils.PrintStackAndError(err) // dont' return
}
orgIds := entity.GetToNotifyOrgIds()
// Build organization map for shared group user
orgMap := make(map[string]*organizations.Organization)
orgs, err := organizations.FindByIds(utils.TurnPlainIdsToObjectIds(orgIds))
if err == nil {
for _, org := range orgs {
orgMap[org.Id.Hex()] = org
}
}
onlineUsers := GetOnlineUsersByOrgIds(orgIds)
emailToUserMap := make(map[string]bool)
// Handle event for each user
for toUserId, event := range eventMap {
// If it is Qortex Support, then the key of the eventMap is "userId-organizationId",
// which is used to differentiate same user in different organizations
toUserId = strings.Split(toUserId, "-")[0]
toUserObjectId := bson.ObjectIdHex(toUserId)
orgId := bson.ObjectIdHex(event.ToUser.OriginalOrgId)
// don't notify anything to sender
if currentUser.Id == toUserObjectId && entity.NotNotifySelf() {
continue
}
if entity.NeedResetUserCount() {
if causedEntries != nil {
for _, causedEntry := range causedEntries {
notifications.ResetCount(db, toUserObjectId, causedEntry.GroupId, orgId)
}
} else {
// Reset user mycount for event user
notifications.ResetCount(db, toUserObjectId, causedEntry.GroupId, orgId)
}
}
onlineUser := pickOnlineUser(toUserObjectId, onlineUsers)
if onlineUser == nil {
// Don't send mail multi times to the same member when posting a Qortex Support
_, exist := emailToUserMap[toUserId]
if !exist && event.NeedToSendNotificationMail() {
// Send Mail if user offline, only work in Dev and Production
// serv.SendNotificationMail(event, apiEntry, currentTime, orgMap)
}
} else if entity.NeetToSendRealtimeNotification(onlineUser.User) {
makeAndPushEventReply(currentUser, event, entity, onlineUser)
}
emailToUserMap[toUserId] = true
}
return
}