wehub-resource-sync
446 lines
16 KiB
Go
446 lines
16 KiB
Go
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
package notificationcommon
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/apache/answer/internal/base/translator"
|
|
"github.com/apache/answer/internal/service/siteinfo_common"
|
|
"github.com/apache/answer/internal/service/user_external_login"
|
|
"github.com/apache/answer/pkg/display"
|
|
|
|
"github.com/apache/answer/internal/base/constant"
|
|
"github.com/apache/answer/internal/base/data"
|
|
"github.com/apache/answer/internal/base/reason"
|
|
"github.com/apache/answer/internal/entity"
|
|
"github.com/apache/answer/internal/schema"
|
|
"github.com/apache/answer/internal/service/activity_common"
|
|
"github.com/apache/answer/internal/service/noticequeue"
|
|
"github.com/apache/answer/internal/service/object_info"
|
|
usercommon "github.com/apache/answer/internal/service/user_common"
|
|
"github.com/apache/answer/pkg/uid"
|
|
"github.com/apache/answer/plugin"
|
|
"github.com/goccy/go-json"
|
|
"github.com/jinzhu/copier"
|
|
"github.com/segmentfault/pacman/errors"
|
|
"github.com/segmentfault/pacman/log"
|
|
)
|
|
|
|
type NotificationRepo interface {
|
|
AddNotification(ctx context.Context, notification *entity.Notification) (err error)
|
|
GetNotificationPage(ctx context.Context, search *schema.NotificationSearch) ([]*entity.Notification, int64, error)
|
|
ClearUnRead(ctx context.Context, userID string, notificationType int) (err error)
|
|
ClearIDUnRead(ctx context.Context, userID string, id string) (err error)
|
|
GetByUserIdObjectIdTypeId(ctx context.Context, userID, objectID string, notificationType int) (*entity.Notification, bool, error)
|
|
UpdateNotificationContent(ctx context.Context, notification *entity.Notification) (err error)
|
|
GetById(ctx context.Context, id string) (*entity.Notification, bool, error)
|
|
CountNotificationByUser(ctx context.Context, cond *entity.Notification) (int64, error)
|
|
DeleteNotification(ctx context.Context, userID string) (err error)
|
|
DeleteUserNotificationConfig(ctx context.Context, userID string) (err error)
|
|
}
|
|
|
|
type NotificationCommon struct {
|
|
data *data.Data
|
|
notificationRepo NotificationRepo
|
|
activityRepo activity_common.ActivityRepo
|
|
followRepo activity_common.FollowRepo
|
|
userCommon *usercommon.UserCommon
|
|
objectInfoService *object_info.ObjService
|
|
notificationQueueService noticequeue.Service
|
|
userExternalLoginRepo user_external_login.UserExternalLoginRepo
|
|
siteInfoService siteinfo_common.SiteInfoCommonService
|
|
}
|
|
|
|
func NewNotificationCommon(
|
|
data *data.Data,
|
|
notificationRepo NotificationRepo,
|
|
userCommon *usercommon.UserCommon,
|
|
activityRepo activity_common.ActivityRepo,
|
|
followRepo activity_common.FollowRepo,
|
|
objectInfoService *object_info.ObjService,
|
|
notificationQueueService noticequeue.Service,
|
|
userExternalLoginRepo user_external_login.UserExternalLoginRepo,
|
|
siteInfoService siteinfo_common.SiteInfoCommonService,
|
|
) *NotificationCommon {
|
|
notification := &NotificationCommon{
|
|
data: data,
|
|
notificationRepo: notificationRepo,
|
|
activityRepo: activityRepo,
|
|
followRepo: followRepo,
|
|
userCommon: userCommon,
|
|
objectInfoService: objectInfoService,
|
|
notificationQueueService: notificationQueueService,
|
|
userExternalLoginRepo: userExternalLoginRepo,
|
|
siteInfoService: siteInfoService,
|
|
}
|
|
notificationQueueService.RegisterHandler(notification.AddNotification)
|
|
return notification
|
|
}
|
|
|
|
// AddNotification
|
|
// need set
|
|
// LoginUserID
|
|
// Type 1 inbox 2 achievement
|
|
// [inbox] Activity
|
|
// [achievement] Rank
|
|
// ObjectInfo.Title
|
|
// ObjectInfo.ObjectID
|
|
// ObjectInfo.ObjectType
|
|
func (ns *NotificationCommon) AddNotification(ctx context.Context, msg *schema.NotificationMsg) (err error) {
|
|
if msg.Type == schema.NotificationTypeAchievement && plugin.RankAgentEnabled() {
|
|
return nil
|
|
}
|
|
req := &schema.NotificationContent{
|
|
TriggerUserID: msg.TriggerUserID,
|
|
ReceiverUserID: msg.ReceiverUserID,
|
|
ObjectInfo: schema.ObjectInfo{
|
|
Title: msg.Title,
|
|
ObjectID: uid.DeShortID(msg.ObjectID),
|
|
ObjectType: msg.ObjectType,
|
|
},
|
|
NotificationAction: msg.NotificationAction,
|
|
Type: msg.Type,
|
|
}
|
|
var questionID string // just for notify all followers
|
|
var objInfo *schema.SimpleObjectInfo
|
|
if msg.ObjectType == constant.BadgeAwardObjectType {
|
|
req.ObjectInfo.Title = msg.Title
|
|
objectMap := make(map[string]string)
|
|
objectMap["badge_id"] = msg.ExtraInfo["badge_id"]
|
|
req.ObjectInfo.ObjectMap = objectMap
|
|
} else {
|
|
objInfo, err = ns.objectInfoService.GetInfo(ctx, req.ObjectInfo.ObjectID)
|
|
if err != nil {
|
|
log.Error(err)
|
|
return err
|
|
} else {
|
|
req.ObjectInfo.Title = objInfo.Title
|
|
questionID = objInfo.QuestionID
|
|
objectMap := make(map[string]string)
|
|
objectMap["question"] = uid.DeShortID(objInfo.QuestionID)
|
|
objectMap["answer"] = uid.DeShortID(objInfo.AnswerID)
|
|
objectMap["comment"] = objInfo.CommentID
|
|
req.ObjectInfo.ObjectMap = objectMap
|
|
}
|
|
}
|
|
|
|
if msg.Type == schema.NotificationTypeAchievement {
|
|
notificationInfo, exist, err := ns.notificationRepo.GetByUserIdObjectIdTypeId(ctx, req.ReceiverUserID, req.ObjectInfo.ObjectID, req.Type)
|
|
if err != nil {
|
|
return fmt.Errorf("get by user id object id type id error: %w", err)
|
|
}
|
|
rank, err := ns.activityRepo.GetUserIDObjectIDActivitySum(ctx, req.ReceiverUserID, req.ObjectInfo.ObjectID)
|
|
if err != nil {
|
|
return fmt.Errorf("get user id object id activity sum error: %w", err)
|
|
}
|
|
req.Rank = rank
|
|
if exist {
|
|
// modify notification
|
|
updateContent := &schema.NotificationContent{}
|
|
err := json.Unmarshal([]byte(notificationInfo.Content), updateContent)
|
|
if err != nil {
|
|
return fmt.Errorf("unmarshal notification content error: %w", err)
|
|
}
|
|
updateContent.Rank = rank
|
|
content, _ := json.Marshal(updateContent)
|
|
notificationInfo.Content = string(content)
|
|
err = ns.notificationRepo.UpdateNotificationContent(ctx, notificationInfo)
|
|
if err != nil {
|
|
return fmt.Errorf("update notification content error: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
info := &entity.Notification{}
|
|
now := time.Now()
|
|
info.UserID = req.ReceiverUserID
|
|
info.Type = req.Type
|
|
info.IsRead = schema.NotificationNotRead
|
|
info.Status = schema.NotificationStatusNormal
|
|
info.CreatedAt = now
|
|
info.UpdatedAt = now
|
|
info.ObjectID = req.ObjectInfo.ObjectID
|
|
|
|
userBasicInfo, exist, err := ns.userCommon.GetUserBasicInfoByID(ctx, req.TriggerUserID)
|
|
if err != nil {
|
|
return fmt.Errorf("get user basic info error: %w", err)
|
|
}
|
|
if !exist {
|
|
return fmt.Errorf("user not exist: %s", req.TriggerUserID)
|
|
}
|
|
req.UserInfo = userBasicInfo
|
|
content, _ := json.Marshal(req)
|
|
_, ok := constant.NotificationMsgTypeMapping[req.NotificationAction]
|
|
if ok {
|
|
info.MsgType = constant.NotificationMsgTypeMapping[req.NotificationAction]
|
|
}
|
|
info.Content = string(content)
|
|
err = ns.notificationRepo.AddNotification(ctx, info)
|
|
if err != nil {
|
|
return fmt.Errorf("add notification error: %w", err)
|
|
}
|
|
err = ns.addRedDot(ctx, info.UserID, msg.Type)
|
|
if err != nil {
|
|
log.Error("addRedDot Error", err.Error())
|
|
}
|
|
if req.ObjectInfo.ObjectType == constant.BadgeAwardObjectType {
|
|
err = ns.AddBadgeAwardAlertCache(ctx, info.UserID, info.ID, req.ObjectInfo.ObjectMap["badge_id"])
|
|
if err != nil {
|
|
log.Error("AddBadgeAwardAlertCache Error", err.Error())
|
|
}
|
|
}
|
|
|
|
go ns.SendNotificationToAllFollower(ctx, msg, questionID)
|
|
|
|
if msg.Type == schema.NotificationTypeInbox {
|
|
ns.syncNotificationToPlugin(ctx, objInfo, msg)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ns *NotificationCommon) addRedDot(ctx context.Context, userID string, noticeType int) error {
|
|
var key string
|
|
if noticeType == schema.NotificationTypeInbox {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeInbox, userID)
|
|
} else {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeAchievement, userID)
|
|
}
|
|
_, exist, err := ns.data.Cache.GetInt64(ctx, key)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
if exist {
|
|
if _, err := ns.data.Cache.Increase(ctx, key, 1); err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
return nil
|
|
}
|
|
err = ns.data.Cache.SetInt64(ctx, key, 1, constant.RedDotCacheTime)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ns *NotificationCommon) DecreaseRedDot(ctx context.Context, userID string, notificationType int) error {
|
|
var key string
|
|
if notificationType == schema.NotificationTypeInbox {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeInbox, userID)
|
|
} else {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeAchievement, userID)
|
|
}
|
|
_, exist, err := ns.data.Cache.GetInt64(ctx, key)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
if !exist {
|
|
return nil
|
|
}
|
|
res, err := ns.data.Cache.Decrease(ctx, key, 1)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
if res <= 0 {
|
|
return ns.DeleteRedDot(ctx, userID, notificationType)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ns *NotificationCommon) DeleteRedDot(ctx context.Context, userID string, notificationType int) error {
|
|
var key string
|
|
if notificationType == schema.NotificationTypeInbox {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeInbox, userID)
|
|
} else {
|
|
key = fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeAchievement, userID)
|
|
}
|
|
err := ns.data.Cache.Del(ctx, key)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// AddBadgeAwardAlertCache add badge award alert cache
|
|
func (ns *NotificationCommon) AddBadgeAwardAlertCache(ctx context.Context, userID, notificationID, badgeID string) (err error) {
|
|
key := fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeBadgeAchievement, userID)
|
|
cacheData, exist, err := ns.data.Cache.GetString(ctx, key)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
if !exist {
|
|
c := schema.NewRedDotBadgeAwardCache()
|
|
c.AddBadgeAward(&schema.RedDotBadgeAward{
|
|
NotificationID: notificationID,
|
|
BadgeID: badgeID,
|
|
})
|
|
return ns.data.Cache.SetString(ctx, key, c.ToJSON(), constant.RedDotCacheTime)
|
|
}
|
|
c := schema.NewRedDotBadgeAwardCache()
|
|
c.FromJSON(cacheData)
|
|
c.AddBadgeAward(&schema.RedDotBadgeAward{
|
|
NotificationID: notificationID,
|
|
BadgeID: badgeID,
|
|
})
|
|
return ns.data.Cache.SetString(ctx, key, c.ToJSON(), constant.RedDotCacheTime)
|
|
}
|
|
|
|
// RemoveBadgeAwardAlertCache remove badge award alert cache
|
|
func (ns *NotificationCommon) RemoveBadgeAwardAlertCache(ctx context.Context, userID, notificationID string) (err error) {
|
|
key := fmt.Sprintf(constant.RedDotCacheKey, constant.NotificationTypeBadgeAchievement, userID)
|
|
cacheData, exist, err := ns.data.Cache.GetString(ctx, key)
|
|
if err != nil {
|
|
return errors.InternalServer(reason.UnknownError).WithError(err).WithStack()
|
|
}
|
|
if !exist {
|
|
return nil
|
|
}
|
|
c := schema.NewRedDotBadgeAwardCache()
|
|
c.FromJSON(cacheData)
|
|
c.RemoveBadgeAward(notificationID)
|
|
if len(c.BadgeAwardList) == 0 {
|
|
return ns.data.Cache.Del(ctx, key)
|
|
}
|
|
return ns.data.Cache.SetString(ctx, key, c.ToJSON(), constant.RedDotCacheTime)
|
|
}
|
|
|
|
// SendNotificationToAllFollower send notification to all followers
|
|
func (ns *NotificationCommon) SendNotificationToAllFollower(ctx context.Context, msg *schema.NotificationMsg,
|
|
questionID string) {
|
|
if msg.NoNeedPushAllFollow || len(questionID) == 0 {
|
|
return
|
|
}
|
|
if msg.NotificationAction != constant.NotificationUpdateQuestion &&
|
|
msg.NotificationAction != constant.NotificationAnswerTheQuestion &&
|
|
msg.NotificationAction != constant.NotificationUpdateAnswer &&
|
|
msg.NotificationAction != constant.NotificationAcceptAnswer {
|
|
return
|
|
}
|
|
condObjectID := msg.ObjectID
|
|
if len(questionID) > 0 {
|
|
condObjectID = uid.DeShortID(questionID)
|
|
}
|
|
userIDs, err := ns.followRepo.GetFollowUserIDs(ctx, condObjectID)
|
|
if err != nil {
|
|
log.Error(err)
|
|
return
|
|
}
|
|
log.Infof("send notification to all followers: %s %d", condObjectID, len(userIDs))
|
|
for _, userID := range userIDs {
|
|
t := &schema.NotificationMsg{}
|
|
_ = copier.Copy(t, msg)
|
|
t.ReceiverUserID = userID
|
|
t.TriggerUserID = msg.TriggerUserID
|
|
t.NoNeedPushAllFollow = true
|
|
ns.notificationQueueService.Send(ctx, t)
|
|
}
|
|
}
|
|
|
|
func (ns *NotificationCommon) syncNotificationToPlugin(ctx context.Context, objInfo *schema.SimpleObjectInfo,
|
|
msg *schema.NotificationMsg) {
|
|
if objInfo == nil {
|
|
return
|
|
}
|
|
siteInfo, err := ns.siteInfoService.GetSiteGeneral(ctx)
|
|
if err != nil {
|
|
log.Errorf("get site general info failed: %v", err)
|
|
return
|
|
}
|
|
seoInfo, err := ns.siteInfoService.GetSiteSeo(ctx)
|
|
if err != nil {
|
|
log.Errorf("get site seo info failed: %v", err)
|
|
return
|
|
}
|
|
interfaceInfo, err := ns.siteInfoService.GetSiteInterface(ctx)
|
|
if err != nil {
|
|
log.Errorf("get site interface info failed: %v", err)
|
|
return
|
|
}
|
|
|
|
objInfo.QuestionID = uid.DeShortID(objInfo.QuestionID)
|
|
objInfo.AnswerID = uid.DeShortID(objInfo.AnswerID)
|
|
pluginNotificationMsg := plugin.NotificationMessage{
|
|
Type: plugin.NotificationType(msg.NotificationAction),
|
|
ReceiverUserID: msg.ReceiverUserID,
|
|
TriggerUserID: msg.TriggerUserID,
|
|
QuestionTitle: objInfo.Title,
|
|
}
|
|
|
|
if len(objInfo.QuestionID) > 0 {
|
|
pluginNotificationMsg.QuestionUrl =
|
|
display.QuestionURL(seoInfo.Permalink, siteInfo.SiteUrl, objInfo.QuestionID, objInfo.Title)
|
|
}
|
|
if len(objInfo.AnswerID) > 0 {
|
|
pluginNotificationMsg.AnswerUrl =
|
|
display.AnswerURL(seoInfo.Permalink, siteInfo.SiteUrl, objInfo.QuestionID, objInfo.Title, objInfo.AnswerID)
|
|
}
|
|
if len(objInfo.CommentID) > 0 {
|
|
pluginNotificationMsg.CommentUrl =
|
|
display.CommentURL(seoInfo.Permalink, siteInfo.SiteUrl, objInfo.QuestionID, objInfo.Title, objInfo.AnswerID, objInfo.CommentID)
|
|
}
|
|
|
|
if len(msg.TriggerUserID) > 0 {
|
|
triggerUser, exist, err := ns.userCommon.GetUserBasicInfoByID(ctx, msg.TriggerUserID)
|
|
if err != nil {
|
|
log.Errorf("get trigger user basic info failed: %v", err)
|
|
return
|
|
}
|
|
if exist {
|
|
pluginNotificationMsg.TriggerUserID = triggerUser.ID
|
|
pluginNotificationMsg.TriggerUserDisplayName = triggerUser.DisplayName
|
|
pluginNotificationMsg.TriggerUserUrl = display.UserURL(siteInfo.SiteUrl, triggerUser.Username)
|
|
}
|
|
}
|
|
|
|
if len(pluginNotificationMsg.ReceiverLang) == 0 && len(msg.ReceiverUserID) > 0 {
|
|
userInfo, _, _ := ns.userCommon.GetUserBasicInfoByID(ctx, msg.ReceiverUserID)
|
|
if userInfo != nil {
|
|
pluginNotificationMsg.ReceiverLang = userInfo.Language
|
|
}
|
|
// If receiver not set language, use site default language.
|
|
if len(pluginNotificationMsg.ReceiverLang) == 0 || pluginNotificationMsg.ReceiverLang == translator.DefaultLangOption {
|
|
pluginNotificationMsg.ReceiverLang = interfaceInfo.Language
|
|
}
|
|
}
|
|
|
|
externalLogins, err := ns.userExternalLoginRepo.GetUserExternalLoginList(ctx, msg.ReceiverUserID)
|
|
if err != nil {
|
|
log.Errorf("get user external login list failed for user %s: %v", msg.ReceiverUserID, err)
|
|
} else if len(externalLogins) > 0 {
|
|
pluginNotificationMsg.ReceiverExternalID = externalLogins[0].ExternalID
|
|
}
|
|
|
|
_ = plugin.CallNotification(func(fn plugin.Notification) error {
|
|
userInfo, exist, err := ns.userExternalLoginRepo.GetByUserID(ctx, fn.Info().SlugName, msg.ReceiverUserID)
|
|
if err != nil {
|
|
log.Errorf("get user external login info failed: %v", err)
|
|
return nil
|
|
}
|
|
if exist {
|
|
pluginNotificationMsg.ReceiverExternalID = userInfo.ExternalID
|
|
}
|
|
fn.Notify(pluginNotificationMsg)
|
|
return nil
|
|
})
|
|
}
|