Merge branch 'tuoyun'

Author: FGadvancer

Makefile

@@ -1,6 +1,6 @@
 .PHONY: ios build install
 
-BINARY_NAME=open_im_sdk/ws_wrapper/open_im_sdk_server
+BINARY_NAME=ws_wrapper/cmd/open_im_sdk_server
 BIN_DIR=../../bin/
 LAN_FILE=.go
 GO_FILE:=${BINARY_NAME}${LAN_FILE}
@@ -20,7 +20,8 @@ reset_remote_branch:
 	git reset --hard $(remote_branch)
 	git pull $(remote_branch)
 
-ios: reset_remote_branch
+ios:
 	go get golang.org/x/mobile
-	rm -rf build/ open_im_sdk/t_friend_sdk.go
-	GOARCH=arm64 gomobile bind -v -trimpath -ldflags "-s -w" -o build/OpenIMCore.xcframework -target=ios ./open_im_sdk/
+	rm -rf build/ open_im_sdk/t_friend_sdk.go open_im_sdk/t_group_sdk.go  open_im_sdk/ws_wrapper/
+	go mod download golang.org/x/exp
+	GOARCH=arm64 gomobile bind -v -trimpath -ldflags "-s -w" -o build/OpenIMCore.xcframework -target=ios ./open_im_sdk/ ./open_im_sdk_callback/	

go.mod

@@ -3,17 +3,34 @@ module open_im_sdk
 go 1.15
 
 require (
+	github.com/antonfisher/nested-logrus-formatter v1.3.1
+	github.com/fatih/structs v1.1.0 // indirect
+	github.com/go-ini/ini v1.66.4 // indirect
+	github.com/go-playground/validator/v10 v10.10.0
 	github.com/golang/protobuf v1.5.2
-	github.com/google/uuid v1.1.2 // indirect
+	github.com/google/go-cmp v0.5.5
 	github.com/gorilla/websocket v1.4.2
-	github.com/mattn/go-sqlite3 v1.14.7
-	github.com/minio/minio-go/v6 v6.0.57
+	github.com/jinzhu/copier v0.3.4
+	github.com/jonboulle/clockwork v0.2.2 // indirect
+	github.com/konsorten/go-windows-terminal-sequences v1.0.1 // indirect
+	github.com/lestrrat-go/file-rotatelogs v2.4.0+incompatible
+	github.com/lestrrat-go/strftime v1.0.5 // indirect
+	github.com/minio/minio-go v6.0.14+incompatible // indirect
+	github.com/minio/minio-go/v7 v7.0.22 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/mapstructure v1.4.3
+	github.com/pkg/errors v0.9.1
+	github.com/rifflock/lfshook v0.0.0-20180920164130-b9218ef580f5
 	github.com/shamsher31/goimgext v1.0.0 // indirect
 	github.com/shamsher31/goimgtype v1.0.0
-	github.com/stretchr/testify v1.7.0 // indirect
-	github.com/tencentyun/cos-go-sdk-v5 v0.7.25
-	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 // indirect
-	golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4 // indirect
-	golang.org/x/sys v0.0.0-20210510120138-977fb7262007 // indirect
+	github.com/sirupsen/logrus v1.8.1
+	github.com/tencentyun/cos-go-sdk-v5 v0.7.33
+	github.com/tencentyun/qcloud-cos-sts-sdk v0.0.0-20220106031843-2efeb10ca2f6
+	golang.org/x/crypto v0.0.0-20220214200702-86341886e292 // indirect
+	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd // indirect
+	golang.org/x/sys v0.0.0-20220209214540-3681064d5158 // indirect
+	golang.org/x/text v0.3.7 // indirect
 	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	gorm.io/driver/sqlite v1.2.6
+	gorm.io/gorm v1.22.4
 )

go.sum

@@ -0,0 +1,18 @@
+package common
+
+import (
+	"github.com/golang/protobuf/proto"
+	api "open_im_sdk/pkg/server_api_params"
+	"open_im_sdk/pkg/utils"
+)
+
+func UnmarshalTips(msg *api.MsgData, detail proto.Message) error {
+	var tips api.TipsComm
+	if err := proto.Unmarshal(msg.Content, &tips); err != nil {
+		return utils.Wrap(err, "")
+	}
+	if err := proto.Unmarshal(tips.Detail, detail); err != nil {
+		return utils.Wrap(err, "")
+	}
+	return nil
+}

internal/common/common.go

@@ -0,0 +1,137 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"open_im_sdk/pkg/log"
+
+	"open_im_sdk/pkg/constant"
+
+	"github.com/tencentyun/cos-go-sdk-v5"
+	"math/rand"
+	"net/http"
+	"net/url"
+	ws "open_im_sdk/internal/interaction"
+	//	"open_im_sdk/pkg/constant"
+	"open_im_sdk/pkg/server_api_params"
+	"open_im_sdk/pkg/utils"
+	"path"
+	"time"
+)
+
+type COS struct {
+	p *ws.PostApi
+}
+
+func NewCOS(p *ws.PostApi) *COS {
+	return &COS{p: p}
+}
+
+func (c *COS) tencentCOSCredentials() (*server_api_params.TencentCloudStorageCredentialRespData, error) {
+	req := server_api_params.TencentCloudStorageCredentialReq{OperationID: utils.OperationIDGenerator()}
+	var resp server_api_params.TencentCloudStorageCredentialResp
+	err := c.p.PostReturn(constant.TencentCloudStorageCredentialRouter, req, &resp.CosData)
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	return &resp.CosData, nil
+}
+
+func (c *COS) UploadImage(filePath string, onProgressFun func(int)) (string, string, error) {
+	return c.uploadObj(filePath, "img", onProgressFun)
+
+}
+
+func (c *COS) UploadSound(filePath string, onProgressFun func(int)) (string, string, error) {
+	return c.uploadObj(filePath, "", onProgressFun)
+}
+
+func (c *COS) UploadFile(filePath string, onProgressFun func(int)) (string, string, error) {
+	return c.uploadObj(filePath, "", onProgressFun)
+}
+
+func (c *COS) UploadVideo(videoPath, snapshotPath string, onProgressFun func(int)) (string, string, string, string, error) {
+	videoURL, videoUUID, err := c.uploadObj(videoPath, "", onProgressFun)
+	if err != nil {
+		return "", "", "", "", utils.Wrap(err, "")
+	}
+	snapshotURL, snapshotUUID, err := c.uploadObj(snapshotPath, "img", onProgressFun)
+	if err != nil {
+		return "", "", "", "", utils.Wrap(err, "")
+	}
+	return snapshotURL, snapshotUUID, videoURL, videoUUID, nil
+}
+
+func (c *COS) getNewFileNameAndContentType(filePath string, fileType string) (string, string, error) {
+	suffix := path.Ext(filePath)
+	if len(suffix) == 0 {
+		return "", "", utils.Wrap(errors.New("no suffix "), filePath)
+	}
+	newName := fmt.Sprintf("%d-%d%s", time.Now().UnixNano(), rand.Int(), suffix)
+	contentType := ""
+	if fileType == "img" {
+		contentType = "image/" + suffix[1:]
+	}
+	return newName, contentType, nil
+}
+
+func (c *COS) uploadObj(filePath string, fileType string, onProgressFun func(int)) (string, string, error) {
+	COSResp, err := c.tencentCOSCredentials()
+	log.Info("upload ", COSResp.Credentials.SessionToken, "bucket ", COSResp.Credentials.TmpSecretID)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	dir := fmt.Sprintf("https://%s.cos.%s.myqcloud.com", COSResp.Bucket, COSResp.Region)
+	u, _ := url.Parse(dir)
+	b := &cos.BaseURL{BucketURL: u}
+
+	client := cos.NewClient(b, &http.Client{
+		Transport: &cos.AuthorizationTransport{
+			SecretID:     COSResp.Credentials.TmpSecretID,
+			SecretKey:    COSResp.Credentials.TmpSecretKey,
+			SessionToken: COSResp.Credentials.SessionToken,
+		},
+	})
+	if client == nil {
+		err := errors.New("client == nil")
+		return "", "", utils.Wrap(err, "")
+	}
+
+	newName, contentType, err := c.getNewFileNameAndContentType(filePath, fileType)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	var lis = &selfListener{}
+	lis.onProgressFun = onProgressFun
+	opt := &cos.ObjectPutOptions{ObjectPutHeaderOptions: &cos.ObjectPutHeaderOptions{Listener: lis}}
+	if fileType == "img" {
+		opt.ContentType = contentType
+	}
+	_, err = client.Object.PutFromFile(context.Background(), newName, filePath, opt)
+	if err != nil {
+		return "", "", utils.Wrap(err, "")
+	}
+	return dir + "/" + newName, newName, nil
+}
+
+type selfListener struct {
+	onProgressFun func(int)
+}
+
+func (l *selfListener) ProgressChangedCallback(event *cos.ProgressEvent) {
+	switch event.EventType {
+	case cos.ProgressDataEvent:
+		if event.ConsumedBytes == event.TotalBytes {
+			if l.onProgressFun != nil {
+				l.onProgressFun(int((event.ConsumedBytes - 1) * 100 / event.TotalBytes))
+			}
+
+		} else {
+			if l.onProgressFun != nil {
+				l.onProgressFun(int(event.ConsumedBytes * 100 / event.TotalBytes))
+			}
+		}
+	case cos.ProgressFailedEvent:
+	}
+}

internal/common/cos.go

@@ -0,0 +1,112 @@
+package common
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	minio "github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"math/rand"
+	"net/url"
+	_"net/url"
+	ws "open_im_sdk/internal/interaction"
+	"open_im_sdk/pkg/constant"
+	"open_im_sdk/pkg/log"
+	"open_im_sdk/pkg/server_api_params"
+	"open_im_sdk/pkg/utils"
+	"path"
+	"time"
+)
+
+
+
+type Minio struct {
+	p *ws.PostApi
+}
+
+func NewMinio(p *ws.PostApi) *Minio {
+	return &Minio{p:p}
+}
+
+
+func (m *Minio) getMinioCredentials() (*server_api_params.MinioStorageCredentialResp, error){
+	req := server_api_params.MinioStorageCredentialReq{OperationID: utils.OperationIDGenerator()}
+	var resp server_api_params.MinioStorageCredentialResp
+	err := m.p.PostReturn(constant.MinioStorageCredentialRouter, req, &resp)
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		return &resp, utils.Wrap(err, "")
+	}
+	return &resp, nil
+}
+
+func (m *Minio) upload(filePath, fileType string, onProgressFun func(int)) (string, string, error){
+	minioResp, err := m.getMinioCredentials()
+	endPoint, err  := url.Parse(minioResp.StsEndpointURL)
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "url parse failed", err.Error())
+		return "", "", err
+	}
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "new minio client failed", err.Error())
+	}
+	newName, newType, err := m.getNewFileNameAndContentType(filePath, fileType)
+	client, err := minio.New(endPoint.Host,  &minio.Options{
+		Creds:        credentials.NewStaticV4(minioResp.AccessKeyID, minioResp.SecretAccessKey, minioResp.SessionToken),
+		Secure:       false,
+	})
+	if err != nil {
+		log.NewError("", utils.GetSelfFuncName(), "generate filename and filetype failed", err.Error())
+		return "", "", utils.Wrap(err, "")
+	}
+	_, err = client.FPutObject(context.Background(), minioResp.BucketName, newName, filePath, minio.PutObjectOptions{ContentType:newType})
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "FPutObject failed", err.Error())
+		return "", "", utils.Wrap(err, "")
+	}
+	// fake callback
+	onProgressFun(100)
+	reqParams := make(url.Values)
+	log.NewInfo("", reqParams)
+
+	presignedURL := endPoint.String() + "/" + minioResp.BucketName + "/" + newName
+	log.NewInfo("", presignedURL)
+	return presignedURL, newName, nil
+}
+
+
+func (m *Minio) getNewFileNameAndContentType(filePath string, fileType string) (string, string, error) {
+	suffix := path.Ext(filePath)
+	if len(suffix) == 0 {
+		return "", "", utils.Wrap(errors.New("no suffix "), filePath)
+	}
+	newName := fmt.Sprintf("%d-%d%s", time.Now().UnixNano(), rand.Int(), suffix)
+	contentType := ""
+	if fileType == "img" {
+		contentType = "image/" + suffix[1:]
+	}
+	return newName, contentType, nil
+}
+
+func (m *Minio) UploadImage(filePath string, onProgressFun func(int)) (string, string, error) {
+	return m.upload(filePath, "img	", onProgressFun)
+}
+
+
+func (m *Minio) UploadSound(filePath string, onProgressFun func(int)) (string, string, error) {
+	return m.upload(filePath, "", onProgressFun)
+}
+
+func (m *Minio) UploadFile(filePath string, onProgressFun func(int)) (string, string, error) {
+	return m.upload(filePath, "", onProgressFun)
+}
+
+func (m *Minio) UploadVideo(videoPath, snapshotPath string, onProgressFun func(int)) (string, string, string, string, error) {
+	videoURL, videoName, err := m.upload(videoPath, "", onProgressFun)
+	snapshotURL, snapshotUUID, err :=  m.upload(snapshotPath, "img", onProgressFun)
+	if err != nil {
+		return snapshotURL, snapshotUUID, videoURL, videoName, utils.Wrap(err, "")
+	}
+	return snapshotURL, snapshotUUID, videoURL, videoName, nil
+}
+

internal/common/minio.go

@@ -0,0 +1,14 @@
+package common
+
+import (
+	_ "image/gif"
+	_ "image/jpeg"
+	_ "image/png"
+)
+
+type ObjectStorage interface {
+	UploadImage(filePath string, onProgressFun func(int)) (string, string, error)
+	UploadSound(filePath string, onProgressFun func(int)) (string, string, error)
+	UploadFile(filePath string, onProgressFun func(int)) (string, string, error)
+	UploadVideo(videoPath, snapshotPath string, onProgressFun func(int)) (string, string, string, string, error)
+}