复制项目

internal/push/offlinepush/dummy/push.go

@@ -0,0 +1,38 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 dummy
+
+import (
+	"context"
+	"sync/atomic"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"github.com/openimsdk/tools/log"
+)
+
+func NewClient() *Dummy {
+	return &Dummy{}
+}
+
+type Dummy struct {
+	v atomic.Bool
+}
+
+func (d *Dummy) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
+	if d.v.CompareAndSwap(false, true) {
+		log.ZWarn(ctx, "dummy push", nil, "ps", "the offline push is not configured. to configure it, please go to config/openim-push.yml")
+	}
+	return nil
+}

internal/push/offlinepush/fcm/push.go

@@ -0,0 +1,172 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 fcm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"github.com/openimsdk/tools/utils/httputil"
+
+	firebase "firebase.google.com/go/v4"
+	"firebase.google.com/go/v4/messaging"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache"
+	"git.imall.cloud/openim/protocol/constant"
+	"github.com/openimsdk/tools/errs"
+	"github.com/redis/go-redis/v9"
+	"google.golang.org/api/option"
+)
+
+const SinglePushCountLimit = 400
+
+var Terminal = []int{constant.IOSPlatformID, constant.AndroidPlatformID, constant.WebPlatformID}
+
+type Fcm struct {
+	fcmMsgCli *messaging.Client
+	cache     cache.ThirdCache
+}
+
+// NewClient initializes a new FCM client using the Firebase Admin SDK.
+// It requires the FCM service account credentials file located within the project's configuration directory.
+func NewClient(pushConf *config.Push, cache cache.ThirdCache, fcmConfigPath string) (*Fcm, error) {
+	var opt option.ClientOption
+	switch {
+	case len(pushConf.FCM.FilePath) != 0:
+		// with file path
+		credentialsFilePath := filepath.Join(fcmConfigPath, pushConf.FCM.FilePath)
+		opt = option.WithCredentialsFile(credentialsFilePath)
+	case len(pushConf.FCM.AuthURL) != 0:
+		// with authentication URL
+		client := httputil.NewHTTPClient(httputil.NewClientConfig())
+		resp, err := client.Get(pushConf.FCM.AuthURL)
+		if err != nil {
+			return nil, err
+		}
+		opt = option.WithCredentialsJSON(resp)
+	default:
+		return nil, errs.New("no FCM config").Wrap()
+	}
+
+	fcmApp, err := firebase.NewApp(context.Background(), nil, opt)
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	ctx := context.Background()
+	fcmMsgClient, err := fcmApp.Messaging(ctx)
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	return &Fcm{fcmMsgCli: fcmMsgClient, cache: cache}, nil
+}
+
+func (f *Fcm) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
+	// accounts->registrationToken
+	allTokens := make(map[string][]string, 0)
+	for _, account := range userIDs {
+		var personTokens []string
+		for _, v := range Terminal {
+			Token, err := f.cache.GetFcmToken(ctx, account, v)
+			if err == nil {
+				personTokens = append(personTokens, Token)
+			}
+		}
+		allTokens[account] = personTokens
+	}
+	Success := 0
+	Fail := 0
+	notification := &messaging.Notification{}
+	notification.Body = content
+	notification.Title = title
+	var messages []*messaging.Message
+	var sendErrBuilder strings.Builder
+	var msgErrBuilder strings.Builder
+	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.SendEach(ctx, messages)
+			if err != nil {
+				Fail = Fail + messageCount
+				// Record push error
+				sendErrBuilder.WriteString(err.Error())
+				sendErrBuilder.WriteByte('.')
+			} else {
+				Success = Success + response.SuccessCount
+				Fail = Fail + response.FailureCount
+				if response.FailureCount != 0 {
+					// Record message error
+					for i := range response.Responses {
+						if !response.Responses[i].Success {
+							msgErrBuilder.WriteString(response.Responses[i].Error.Error())
+							msgErrBuilder.WriteByte('.')
+						}
+					}
+				}
+			}
+			messages = messages[0:0]
+		}
+		if opts.IOSBadgeCount {
+			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)
+				Fail++
+				continue
+			}
+		} else {
+			unreadCountSum, err := f.cache.GetUserBadgeUnreadCountSum(ctx, userID)
+			if err == nil && unreadCountSum != 0 {
+				apns.Payload.Aps.Badge = &unreadCountSum
+			} else if errors.Is(err, redis.Nil) || unreadCountSum == 0 {
+				zero := 1
+				apns.Payload.Aps.Badge = &zero
+			} else {
+				// log.Error(operationID, "GetUserBadgeUnreadCountSum redis err", err.Error(), uid)
+				Fail++
+				continue
+			}
+		}
+		for _, token := range personTokens {
+			temp := &messaging.Message{
+				Data:         map[string]string{"ex": opts.Ex},
+				Token:        token,
+				Notification: notification,
+				APNS:         apns,
+			}
+			messages = append(messages, temp)
+		}
+	}
+	messageCount := len(messages)
+	if messageCount > 0 {
+		response, err := f.fcmMsgCli.SendEach(ctx, messages)
+		if err != nil {
+			Fail = Fail + messageCount
+		} else {
+			Success = Success + response.SuccessCount
+			Fail = Fail + response.FailureCount
+		}
+	}
+	if Fail != 0 {
+		return errs.New(fmt.Sprintf("%d message send failed;send err:%s;message err:%s",
+			Fail, sendErrBuilder.String(), msgErrBuilder.String())).Wrap()
+	}
+	return nil
+}

internal/push/offlinepush/getui/body.go

@@ -0,0 +1,219 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 getui
+
+import (
+	"fmt"
+
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"github.com/openimsdk/tools/utils/datautil"
+)
+
+var (
+	incOne          = datautil.ToPtr("+1")
+	addNum          = "1"
+	defaultStrategy = strategy{
+		Default: 1,
+	}
+	msgCategory = "CATEGORY_MESSAGE"
+)
+
+type Resp struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+	Data any    `json:"data"`
+}
+
+func (r *Resp) parseError() (err error) {
+	switch r.Code {
+	case tokenExpireCode:
+		err = ErrTokenExpire
+	case 0:
+		err = nil
+	default:
+		err = fmt.Errorf("code %d, msg %s", r.Code, r.Msg)
+	}
+	return err
+}
+
+type RespI interface {
+	parseError() error
+}
+
+type AuthReq struct {
+	Sign      string `json:"sign"`
+	Timestamp string `json:"timestamp"`
+	AppKey    string `json:"appkey"`
+}
+
+type AuthResp struct {
+	ExpireTime string `json:"expire_time"`
+	Token      string `json:"token"`
+}
+
+type TaskResp struct {
+	TaskID string `json:"taskID"`
+}
+
+type Settings struct {
+	TTL      *int64   `json:"ttl"`
+	Strategy strategy `json:"strategy"`
+}
+
+type strategy struct {
+	Default int64 `json:"default"`
+	//IOS     int64 `json:"ios"`
+	//St      int64 `json:"st"`
+	//Hw      int64 `json:"hw"`
+	//Ho      int64 `json:"ho"`
+	//XM      int64 `json:"xm"`
+	//XMG     int64 `json:"xmg"`
+	//VV      int64 `json:"vv"`
+	//Op      int64 `json:"op"`
+	//OpG     int64 `json:"opg"`
+	//MZ      int64 `json:"mz"`
+	//HosHw   int64 `json:"hoshw"`
+	//WX      int64 `json:"wx"`
+}
+
+type Audience struct {
+	Alias []string `json:"alias"`
+}
+
+type PushMessage struct {
+	Notification *Notification `json:"notification,omitempty"`
+	Transmission *string       `json:"transmission,omitempty"`
+}
+
+type PushChannel struct {
+	Ios     *Ios     `json:"ios"`
+	Android *Android `json:"android"`
+}
+
+type PushReq struct {
+	RequestID   *string      `json:"request_id"`
+	Settings    *Settings    `json:"settings"`
+	Audience    *Audience    `json:"audience"`
+	PushMessage *PushMessage `json:"push_message"`
+	PushChannel *PushChannel `json:"push_channel"`
+	IsAsync     *bool        `json:"is_async"`
+	TaskID      *string      `json:"taskid"`
+}
+
+type Ios struct {
+	NotificationType *string `json:"type"`
+	AutoBadge        *string `json:"auto_badge"`
+	Aps              struct {
+		Sound string `json:"sound"`
+		Alert Alert  `json:"alert"`
+	} `json:"aps"`
+}
+
+type Alert struct {
+	Title string `json:"title"`
+	Body  string `json:"body"`
+}
+
+type Android struct {
+	Ups struct {
+		Notification Notification `json:"notification"`
+		Options      Options      `json:"options"`
+	} `json:"ups"`
+}
+
+type Notification struct {
+	Title       string `json:"title"`
+	Body        string `json:"body"`
+	ChannelID   string `json:"channelID"`
+	ChannelName string `json:"ChannelName"`
+	ClickType   string `json:"click_type"`
+	BadgeAddNum string `json:"badge_add_num"`
+	Category    string `json:"category"`
+}
+
+type Options struct {
+	HW struct {
+		DefaultSound bool   `json:"/message/android/notification/default_sound"`
+		ChannelID    string `json:"/message/android/notification/channel_id"`
+		Sound        string `json:"/message/android/notification/sound"`
+		Importance   string `json:"/message/android/notification/importance"`
+		Category     string `json:"/message/android/category"`
+	} `json:"HW"`
+	XM struct {
+		ChannelID string `json:"/extra.channel_id"`
+	} `json:"XM"`
+	VV struct {
+		Classification int `json:"/classification"`
+	} `json:"VV"`
+}
+
+type Payload struct {
+	IsSignal bool `json:"isSignal"`
+}
+
+func newPushReq(pushConf *config.Push, title, content string) PushReq {
+	pushReq := PushReq{PushMessage: &PushMessage{Notification: &Notification{
+		Title:       title,
+		Body:        content,
+		ClickType:   "startapp",
+		ChannelID:   pushConf.GeTui.ChannelID,
+		ChannelName: pushConf.GeTui.ChannelName,
+		BadgeAddNum: addNum,
+		Category:    msgCategory,
+	}}}
+	return pushReq
+}
+
+func newBatchPushReq(userIDs []string, taskID string) PushReq {
+	IsAsync := true
+	return PushReq{Audience: &Audience{Alias: userIDs}, IsAsync: &IsAsync, TaskID: &taskID}
+}
+
+func (pushReq *PushReq) setPushChannel(title string, body string) {
+	pushReq.PushChannel = &PushChannel{}
+	// autoBadge := "+1"
+	pushReq.PushChannel.Ios = &Ios{}
+	notify := "notify"
+	pushReq.PushChannel.Ios.NotificationType = &notify
+	pushReq.PushChannel.Ios.Aps.Sound = "default"
+	pushReq.PushChannel.Ios.AutoBadge = incOne
+	pushReq.PushChannel.Ios.Aps.Alert = Alert{
+		Title: title,
+		Body:  body,
+	}
+	pushReq.PushChannel.Android = &Android{}
+	pushReq.PushChannel.Android.Ups.Notification = Notification{
+		Title:     title,
+		Body:      body,
+		ClickType: "startapp",
+	}
+	pushReq.PushChannel.Android.Ups.Options = Options{
+		HW: struct {
+			DefaultSound bool   `json:"/message/android/notification/default_sound"`
+			ChannelID    string `json:"/message/android/notification/channel_id"`
+			Sound        string `json:"/message/android/notification/sound"`
+			Importance   string `json:"/message/android/notification/importance"`
+			Category     string `json:"/message/android/category"`
+		}{ChannelID: "RingRing4", Sound: "/raw/ring001", Importance: "NORMAL", Category: "IM"},
+		XM: struct {
+			ChannelID string `json:"/extra.channel_id"`
+		}{ChannelID: "high_system"},
+		VV: struct {
+			Classification int "json:\"/classification\""
+		}{
+			Classification: 1,
+		},
+	}
+}

internal/push/offlinepush/getui/push.go

@@ -0,0 +1,219 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 getui
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"strconv"
+	"sync"
+	"time"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache"
+	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
+	"github.com/openimsdk/tools/mcontext"
+	"github.com/openimsdk/tools/utils/httputil"
+	"github.com/openimsdk/tools/utils/splitter"
+	"github.com/redis/go-redis/v9"
+)
+
+var (
+	ErrTokenExpire = errs.New("token expire")
+	ErrUserIDEmpty = errs.New("userIDs is empty")
+)
+
+const (
+	pushURL      = "/push/single/alias"
+	authURL      = "/auth"
+	taskURL      = "/push/list/message"
+	batchPushURL = "/push/list/alias"
+
+	// Codes.
+	tokenExpireCode = 10001
+	tokenExpireTime = 60 * 60 * 23
+	taskIDTTL       = 1000 * 60 * 60 * 24
+)
+
+type Client struct {
+	cache           cache.ThirdCache
+	tokenExpireTime int64
+	taskIDTTL       int64
+	pushConf        *config.Push
+	httpClient      *httputil.HTTPClient
+}
+
+func NewClient(pushConf *config.Push, cache cache.ThirdCache) *Client {
+	return &Client{cache: cache,
+		tokenExpireTime: tokenExpireTime,
+		taskIDTTL:       taskIDTTL,
+		pushConf:        pushConf,
+		httpClient:      httputil.NewHTTPClient(httputil.NewClientConfig()),
+	}
+}
+
+func (g *Client) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
+	token, err := g.cache.GetGetuiToken(ctx)
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			log.ZDebug(ctx, "getui token not exist in redis")
+			token, err = g.getTokenAndSave2Redis(ctx)
+			if err != nil {
+				return err
+			}
+		} else {
+			return err
+		}
+	}
+	pushReq := newPushReq(g.pushConf, title, content)
+	pushReq.setPushChannel(title, content)
+	if len(userIDs) > 1 {
+		maxNum := 999
+		if len(userIDs) > maxNum {
+			s := splitter.NewSplitter(maxNum, userIDs)
+			wg := sync.WaitGroup{}
+			wg.Add(len(s.GetSplitResult()))
+			for i, v := range s.GetSplitResult() {
+				go func(index int, userIDs []string) {
+					defer wg.Done()
+					for i := 0; i < len(userIDs); i += maxNum {
+						end := i + maxNum
+						if end > len(userIDs) {
+							end = len(userIDs)
+						}
+						if err = g.batchPush(ctx, token, userIDs[i:end], pushReq); err != nil {
+							log.ZError(ctx, "batchPush failed", err, "index", index, "token", token, "req", pushReq)
+						}
+					}
+					if err = g.batchPush(ctx, token, userIDs, pushReq); err != nil {
+						log.ZError(ctx, "batchPush failed", err, "index", index, "token", token, "req", pushReq)
+					}
+				}(i, v.Item)
+			}
+			wg.Wait()
+		} else {
+			err = g.batchPush(ctx, token, userIDs, pushReq)
+		}
+	} else if len(userIDs) == 1 {
+		err = g.singlePush(ctx, token, userIDs[0], pushReq)
+	} else {
+		return ErrUserIDEmpty
+	}
+	switch err {
+	case ErrTokenExpire:
+		token, err = g.getTokenAndSave2Redis(ctx)
+	}
+	return err
+}
+
+func (g *Client) Auth(ctx context.Context, timeStamp int64) (token string, expireTime int64, err error) {
+	h := sha256.New()
+	h.Write(
+		[]byte(g.pushConf.GeTui.AppKey + strconv.Itoa(int(timeStamp)) + g.pushConf.GeTui.MasterSecret),
+	)
+	sign := hex.EncodeToString(h.Sum(nil))
+	reqAuth := AuthReq{
+		Sign:      sign,
+		Timestamp: strconv.Itoa(int(timeStamp)),
+		AppKey:    g.pushConf.GeTui.AppKey,
+	}
+	respAuth := AuthResp{}
+	err = g.request(ctx, authURL, reqAuth, "", &respAuth)
+	if err != nil {
+		return "", 0, err
+	}
+	expire, err := strconv.Atoi(respAuth.ExpireTime)
+	return respAuth.Token, int64(expire), err
+}
+
+func (g *Client) GetTaskID(ctx context.Context, token string, pushReq PushReq) (string, error) {
+	respTask := TaskResp{}
+	ttl := int64(1000 * 60 * 5)
+	pushReq.Settings = &Settings{TTL: &ttl, Strategy: defaultStrategy}
+	err := g.request(ctx, taskURL, pushReq, token, &respTask)
+	if err != nil {
+		return "", errs.Wrap(err)
+	}
+	return respTask.TaskID, nil
+}
+
+// max num is 999.
+func (g *Client) batchPush(ctx context.Context, token string, userIDs []string, pushReq PushReq) error {
+	taskID, err := g.GetTaskID(ctx, token, pushReq)
+	if err != nil {
+		return err
+	}
+	pushReq = newBatchPushReq(userIDs, taskID)
+	return g.request(ctx, batchPushURL, pushReq, token, nil)
+}
+
+func (g *Client) singlePush(ctx context.Context, token, userID string, pushReq PushReq) error {
+	operationID := mcontext.GetOperationID(ctx)
+	pushReq.RequestID = &operationID
+	pushReq.Audience = &Audience{Alias: []string{userID}}
+	return g.request(ctx, pushURL, pushReq, token, nil)
+}
+
+func (g *Client) request(ctx context.Context, url string, input any, token string, output any) error {
+	header := map[string]string{"token": token}
+	resp := &Resp{}
+	resp.Data = output
+	return g.postReturn(ctx, g.pushConf.GeTui.PushUrl+url, header, input, resp, 3)
+}
+
+func (g *Client) postReturn(
+	ctx context.Context,
+	url string,
+	header map[string]string,
+	input any,
+	output RespI,
+	timeout int,
+) error {
+	err := g.httpClient.PostReturn(ctx, url, header, input, output, timeout)
+	if err != nil {
+		return err
+	}
+	log.ZDebug(ctx, "postReturn", "url", url, "header", header, "input", input, "timeout", timeout, "output", output)
+	return output.parseError()
+}
+
+func (g *Client) getTokenAndSave2Redis(ctx context.Context) (token string, err error) {
+	token, _, err = g.Auth(ctx, time.Now().UnixNano()/1e6)
+	if err != nil {
+		return
+	}
+	err = g.cache.SetGetuiToken(ctx, token, 60*60*23)
+	if err != nil {
+		return
+	}
+	return token, nil
+}
+
+func (g *Client) GetTaskIDAndSave2Redis(ctx context.Context, token string, pushReq PushReq) (taskID string, err error) {
+	pushReq.Settings = &Settings{TTL: &g.taskIDTTL, Strategy: defaultStrategy}
+	taskID, err = g.GetTaskID(ctx, token, pushReq)
+	if err != nil {
+		return
+	}
+	err = g.cache.SetGetuiTaskID(ctx, taskID, g.tokenExpireTime)
+	if err != nil {
+		return
+	}
+	return token, nil
+}

internal/push/offlinepush/jpush/body/audience.go

@@ -0,0 +1,64 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+const (
+	TAG            = "tag"
+	TAGAND         = "tag_and"
+	TAGNOT         = "tag_not"
+	ALIAS          = "alias"
+	REGISTRATIONID = "registration_id"
+)
+
+type Audience struct {
+	Object   any
+	audience map[string][]string
+}
+
+func (a *Audience) set(key string, v []string) {
+	if a.audience == nil {
+		a.audience = make(map[string][]string)
+		a.Object = a.audience
+	}
+	// v, ok = this.audience[key]
+	// if ok {
+	//	return
+	//}
+	a.audience[key] = v
+}
+
+func (a *Audience) SetTag(tags []string) {
+	a.set(TAG, tags)
+}
+
+func (a *Audience) SetTagAnd(tags []string) {
+	a.set(TAGAND, tags)
+}
+
+func (a *Audience) SetTagNot(tags []string) {
+	a.set(TAGNOT, tags)
+}
+
+func (a *Audience) SetAlias(alias []string) {
+	a.set(ALIAS, alias)
+}
+
+func (a *Audience) SetRegistrationId(ids []string) {
+	a.set(REGISTRATIONID, ids)
+}
+
+func (a *Audience) SetAll() {
+	a.Object = "all"
+}

internal/push/offlinepush/jpush/body/message.go

@@ -0,0 +1,41 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+type Message struct {
+	MsgContent  string         `json:"msg_content"`
+	Title       string         `json:"title,omitempty"`
+	ContentType string         `json:"content_type,omitempty"`
+	Extras      map[string]any `json:"extras,omitempty"`
+}
+
+func (m *Message) SetMsgContent(c string) {
+	m.MsgContent = c
+}
+
+func (m *Message) SetTitle(t string) {
+	m.Title = t
+}
+
+func (m *Message) SetContentType(c string) {
+	m.ContentType = c
+}
+
+func (m *Message) SetExtras(key string, value any) {
+	if m.Extras == nil {
+		m.Extras = make(map[string]any)
+	}
+	m.Extras[key] = value
+}

internal/push/offlinepush/jpush/body/notification.go

@@ -0,0 +1,72 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+import (
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+)
+
+type Notification struct {
+	Alert   string  `json:"alert,omitempty"`
+	Android Android `json:"android,omitempty"`
+	IOS     Ios     `json:"ios,omitempty"`
+}
+
+type Android struct {
+	Alert  string `json:"alert,omitempty"`
+	Title  string `json:"title,omitempty"`
+	Intent struct {
+		URL string `json:"url,omitempty"`
+	} `json:"intent,omitempty"`
+	Extras map[string]string `json:"extras,omitempty"`
+}
+type Ios struct {
+	Alert          IosAlert          `json:"alert,omitempty"`
+	Sound          string            `json:"sound,omitempty"`
+	Badge          string            `json:"badge,omitempty"`
+	Extras         map[string]string `json:"extras,omitempty"`
+	MutableContent bool              `json:"mutable-content"`
+}
+
+type IosAlert struct {
+	Title string `json:"title,omitempty"`
+	Body  string `json:"body,omitempty"`
+}
+
+func (n *Notification) SetAlert(alert string, title string, opts *options.Opts) {
+	n.Alert = alert
+	n.Android.Alert = alert
+	n.Android.Title = title
+	n.IOS.Alert.Body = alert
+	n.IOS.Alert.Title = title
+	n.IOS.Sound = opts.IOSPushSound
+	if opts.IOSBadgeCount {
+		n.IOS.Badge = "+1"
+	}
+}
+
+func (n *Notification) SetExtras(extras map[string]string) {
+	n.IOS.Extras = extras
+	n.Android.Extras = extras
+}
+
+func (n *Notification) SetAndroidIntent(pushConf *config.Push) {
+	n.Android.Intent.URL = pushConf.JPush.PushIntent
+}
+
+func (n *Notification) IOSEnableMutableContent() {
+	n.IOS.MutableContent = true
+}

internal/push/offlinepush/jpush/body/options.go

@@ -0,0 +1,23 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+type Options struct {
+	ApnsProduction bool `json:"apns_production"`
+}
+
+func (o *Options) SetApnsProduction(c bool) {
+	o.ApnsProduction = c
+}

internal/push/offlinepush/jpush/body/platform.go

@@ -0,0 +1,99 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+import (
+	"github.com/openimsdk/tools/errs"
+
+	"git.imall.cloud/openim/protocol/constant"
+)
+
+const (
+	ANDROID      = "android"
+	IOS          = "ios"
+	QUICKAPP     = "quickapp"
+	WINDOWSPHONE = "winphone"
+	ALL          = "all"
+)
+
+type Platform struct {
+	Os     any
+	osArry []string
+}
+
+func (p *Platform) Set(os string) error {
+	if p.Os == nil {
+		p.osArry = make([]string, 0, 4)
+	} else {
+		switch p.Os.(type) {
+		case string:
+			return errs.New("platform is all")
+		default:
+		}
+	}
+
+	for _, value := range p.osArry {
+		if os == value {
+			return nil
+		}
+	}
+
+	switch os {
+	case IOS:
+		fallthrough
+	case ANDROID:
+		fallthrough
+	case QUICKAPP:
+		fallthrough
+	case WINDOWSPHONE:
+		p.osArry = append(p.osArry, os)
+		p.Os = p.osArry
+	default:
+		return errs.New("unknow platform")
+	}
+
+	return nil
+}
+
+func (p *Platform) SetPlatform(platform string) error {
+	switch platform {
+	case constant.AndroidPlatformStr:
+		return p.SetAndroid()
+	case constant.IOSPlatformStr:
+		return p.SetIOS()
+	default:
+		return errs.New("platform err")
+	}
+}
+
+func (p *Platform) SetIOS() error {
+	return p.Set(IOS)
+}
+
+func (p *Platform) SetAndroid() error {
+	return p.Set(ANDROID)
+}
+
+func (p *Platform) SetQuickApp() error {
+	return p.Set(QUICKAPP)
+}
+
+func (p *Platform) SetWindowsPhone() error {
+	return p.Set(WINDOWSPHONE)
+}
+
+func (p *Platform) SetAll() {
+	p.Os = ALL
+}

internal/push/offlinepush/jpush/body/pushobj.go

@@ -0,0 +1,43 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 body
+
+type PushObj struct {
+	Platform     any `json:"platform"`
+	Audience     any `json:"audience"`
+	Notification any `json:"notification,omitempty"`
+	Message      any `json:"message,omitempty"`
+	Options      any `json:"options,omitempty"`
+}
+
+func (p *PushObj) SetPlatform(pf *Platform) {
+	p.Platform = pf.Os
+}
+
+func (p *PushObj) SetAudience(ad *Audience) {
+	p.Audience = ad.Object
+}
+
+func (p *PushObj) SetNotification(no *Notification) {
+	p.Notification = no
+}
+
+func (p *PushObj) SetMessage(m *Message) {
+	p.Message = m
+}
+
+func (p *PushObj) SetOptions(o *Options) {
+	p.Options = o
+}

internal/push/offlinepush/jpush/push.go

@@ -0,0 +1,107 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 jpush
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/jpush/body"
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"github.com/openimsdk/tools/utils/httputil"
+)
+
+type JPush struct {
+	pushConf   *config.Push
+	httpClient *httputil.HTTPClient
+}
+
+func NewClient(pushConf *config.Push) *JPush {
+	return &JPush{pushConf: pushConf,
+		httpClient: httputil.NewHTTPClient(httputil.NewClientConfig()),
+	}
+}
+
+func (j *JPush) Auth(apiKey, secretKey string, timeStamp int64) (token string, err error) {
+	return token, nil
+}
+
+func (j *JPush) SetAlias(cid, alias string) (resp string, err error) {
+	return resp, nil
+}
+
+func (j *JPush) getAuthorization(appKey string, masterSecret string) string {
+	str := fmt.Sprintf("%s:%s", appKey, masterSecret)
+	buf := []byte(str)
+	Authorization := fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString(buf))
+	return Authorization
+}
+
+func (j *JPush) Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error {
+	var pf body.Platform
+	pf.SetAll()
+	var au body.Audience
+	au.SetAlias(userIDs)
+	var no body.Notification
+	extras := make(map[string]string)
+	extras["ex"] = opts.Ex
+	if opts.Signal.ClientMsgID != "" {
+		extras["ClientMsgID"] = opts.Signal.ClientMsgID
+	}
+	no.IOSEnableMutableContent()
+	no.SetExtras(extras)
+	no.SetAlert(content, title, opts)
+	no.SetAndroidIntent(j.pushConf)
+
+	var msg body.Message
+	msg.SetMsgContent(content)
+	msg.SetTitle(title)
+	if opts.Signal.ClientMsgID != "" {
+		msg.SetExtras("ClientMsgID", opts.Signal.ClientMsgID)
+	}
+	msg.SetExtras("ex", opts.Ex)
+	var opt body.Options
+	opt.SetApnsProduction(j.pushConf.IOSPush.Production)
+	var pushObj body.PushObj
+	pushObj.SetPlatform(&pf)
+	pushObj.SetAudience(&au)
+	pushObj.SetNotification(&no)
+	pushObj.SetMessage(&msg)
+	pushObj.SetOptions(&opt)
+	var resp map[string]any
+	return j.request(ctx, pushObj, &resp, 5)
+}
+
+func (j *JPush) request(ctx context.Context, po body.PushObj, resp *map[string]any, timeout int) error {
+	err := j.httpClient.PostReturn(
+		ctx,
+		j.pushConf.JPush.PushURL,
+		map[string]string{
+			"Authorization": j.getAuthorization(j.pushConf.JPush.AppKey, j.pushConf.JPush.MasterSecret),
+		},
+		po,
+		resp,
+		timeout,
+	)
+	if err != nil {
+		return err
+	}
+	if (*resp)["sendno"] != "0" {
+		return fmt.Errorf("jpush push failed %v", resp)
+	}
+	return nil
+}

internal/push/offlinepush/offlinepusher.go

@@ -0,0 +1,55 @@
+// Copyright © 2023 OpenIM. All rights reserved.
+//
+// Licensed 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 offlinepush
+
+import (
+	"context"
+	"strings"
+
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/dummy"
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/fcm"
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/getui"
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/jpush"
+	"git.imall.cloud/openim/open-im-server-deploy/internal/push/offlinepush/options"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/config"
+	"git.imall.cloud/openim/open-im-server-deploy/pkg/common/storage/cache"
+)
+
+const (
+	geTUI    = "getui"
+	firebase = "fcm"
+	jPush    = "jpush"
+)
+
+// OfflinePusher Offline Pusher.
+type OfflinePusher interface {
+	Push(ctx context.Context, userIDs []string, title, content string, opts *options.Opts) error
+}
+
+func NewOfflinePusher(pushConf *config.Push, cache cache.ThirdCache, fcmConfigPath string) (OfflinePusher, error) {
+	var offlinePusher OfflinePusher
+	pushConf.Enable = strings.ToLower(pushConf.Enable)
+	switch pushConf.Enable {
+	case geTUI:
+		offlinePusher = getui.NewClient(pushConf, cache)
+	case firebase:
+		return fcm.NewClient(pushConf, cache, fcmConfigPath)
+	case jPush:
+		offlinePusher = jpush.NewClient(pushConf)
+	default:
+		offlinePusher = dummy.NewClient()
+	}
+	return offlinePusher, nil
+}

internal/push/offlinepush/options/options.go

@@ -0,0 +1,14 @@
+package options
+
+// Opts opts.
+type Opts struct {
+	Signal        *Signal
+	IOSPushSound  string
+	IOSBadgeCount bool
+	Ex            string
+}
+
+// Signal message id.
+type Signal struct {
+	ClientMsgID string
+}