errcode

internal/push/fcm/push.go

@@ -3,57 +3,52 @@ package fcm
 import (
 	"Open_IM/internal/push"
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/cache"
 	"context"
-	go_redis "github.com/go-redis/redis/v8"
-	"path/filepath"
-	"strconv"
-
 	firebase "firebase.google.com/go"
 	"firebase.google.com/go/messaging"
+	"github.com/go-redis/redis/v8"
 	"google.golang.org/api/option"
+	"path/filepath"
 )
 
 const SinglePushCountLimit = 400
 
+var Terminal = []int{constant.IOSPlatformID, constant.AndroidPlatformID, constant.WebPlatformID}
+
 type Fcm struct {
-	FcmMsgCli *messaging.Client
+	fcmMsgCli *messaging.Client
+	cache     cache.Cache
 }
 
-func NewFcm() *Fcm {
-	return newFcmClient()
-}
-func newFcmClient() *Fcm {
+func newFcmClient(cache cache.Cache) *Fcm {
 	opt := option.WithCredentialsFile(filepath.Join(config.Root, "config", config.Config.Push.Fcm.ServiceAccount))
 	fcmApp, err := firebase.NewApp(context.Background(), nil, opt)
 	if err != nil {
-		log.Debug("", "error initializing app: ", err.Error())
 		return nil
 	}
-	//授权
+	// auth
 	// fcmClient, err := fcmApp.Auth(context.Background())
 	// if err != nil {
-	// 	log.Println("error getting Auth client: %v\n", err)
 	// 	return
 	// }
-	// log.Printf("%#v\r\n", fcmClient)
 	ctx := context.Background()
 	fcmMsgClient, err := fcmApp.Messaging(ctx)
 	if err != nil {
 		panic(err.Error())
 		return nil
 	}
-	return &Fcm{FcmMsgCli: fcmMsgClient}
+	return &Fcm{fcmMsgCli: fcmMsgClient}
 }
 
-func (f *Fcm) Push(accounts []string, title, detailContent, operationID string, opts push.PushOpts) (string, error) {
+func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string, opts push.Opts) error {
 	// accounts->registrationToken
 	allTokens := make(map[string][]string, 0)
-	for _, account := range accounts {
+	for _, account := range userIDs {
 		var personTokens []string
-		for _, v := range push.PushTerminal {
-			Token, err := db.DB.GetFcmToken(account, v)
+		for _, v := range Terminal {
+			Token, err := f.cache.GetFcmToken(ctx, account, v)
 			if err == nil {
 				personTokens = append(personTokens, Token)
 			}
@@ -63,18 +58,16 @@ func (f *Fcm) Push(accounts []string, title, detailContent, operationID string,
 	Success := 0
 	Fail := 0
 	notification := &messaging.Notification{}
-	notification.Body = detailContent
+	notification.Body = content
 	notification.Title = title
 	var messages []*messaging.Message
-	ctx := context.Background()
-	for uid, personTokens := range allTokens {
+	for userID, personTokens := range allTokens {
 		apns := &messaging.APNSConfig{Payload: &messaging.APNSPayload{Aps: &messaging.Aps{Sound: opts.IOSPushSound}}}
 		messageCount := len(messages)
 		if messageCount >= SinglePushCountLimit {
-			response, err := f.FcmMsgCli.SendAll(ctx, messages)
+			response, err := f.fcmMsgCli.SendAll(ctx, messages)
 			if err != nil {
 				Fail = Fail + messageCount
-				log.Info(operationID, "some token push err", err.Error(), messageCount)
 			} else {
 				Success = Success + response.SuccessCount
 				Fail = Fail + response.FailureCount
@@ -82,30 +75,30 @@ func (f *Fcm) Push(accounts []string, title, detailContent, operationID string,
 			messages = messages[0:0]
 		}
 		if opts.IOSBadgeCount {
-			unreadCountSum, err := db.DB.IncrUserBadgeUnreadCountSum(uid)
+			unreadCountSum, err := f.cache.IncrUserBadgeUnreadCountSum(ctx, userID)
 			if err == nil {
 				apns.Payload.Aps.Badge = &unreadCountSum
 			} else {
-				log.Error(operationID, "IncrUserBadgeUnreadCountSum redis err", err.Error(), uid)
+				//log.Error(operationID, "IncrUserBadgeUnreadCountSum redis err", err.Error(), uid)
 				Fail++
 				continue
 			}
 		} else {
-			unreadCountSum, err := db.DB.GetUserBadgeUnreadCountSum(uid)
+			unreadCountSum, err := f.cache.GetUserBadgeUnreadCountSum(ctx, userID)
 			if err == nil && unreadCountSum != 0 {
 				apns.Payload.Aps.Badge = &unreadCountSum
-			} else if err == go_redis.Nil || unreadCountSum == 0 {
+			} else if err == redis.Nil || unreadCountSum == 0 {
 				zero := 1
 				apns.Payload.Aps.Badge = &zero
 			} else {
-				log.Error(operationID, "GetUserBadgeUnreadCountSum redis err", err.Error(), uid)
+				//log.Error(operationID, "GetUserBadgeUnreadCountSum redis err", err.Error(), uid)
 				Fail++
 				continue
 			}
 		}
 		for _, token := range personTokens {
 			temp := &messaging.Message{
-				Data:         map[string]string{"ex": opts.Data},
+				Data:         map[string]string{"ex": opts.Ex},
 				Token:        token,
 				Notification: notification,
 				APNS:         apns,
@@ -116,14 +109,14 @@ func (f *Fcm) Push(accounts []string, title, detailContent, operationID string,
 	}
 	messageCount := len(messages)
 	if messageCount > 0 {
-		response, err := f.FcmMsgCli.SendAll(ctx, messages)
+		response, err := f.fcmMsgCli.SendAll(ctx, messages)
 		if err != nil {
 			Fail = Fail + messageCount
-			log.Info(operationID, "some token push err", err.Error(), messageCount)
+			//log.Info(operationID, "some token push err", err.Error(), messageCount)
 		} else {
 			Success = Success + response.SuccessCount
 			Fail = Fail + response.FailureCount
 		}
 	}
-	return strconv.Itoa(Success) + " Success," + strconv.Itoa(Fail) + " Fail", nil
+	return nil
 }