package service
import (
"archive/zip"
"context"
"encoding/json"
"errors"
"finclip-app-manager/domain/entity"
"finclip-app-manager/domain/entity/proto"
"finclip-app-manager/domain/entity/proto/apiproto"
"finclip-app-manager/domain/repository"
"finclip-app-manager/infrastructure/client/httpcall"
"finclip-app-manager/infrastructure/config"
impl "finclip-app-manager/infrastructure/db/repo"
"finclip-app-manager/infrastructure/kafka"
pb "finclip-app-manager/infrastructure/protobuf/golang"
"finclip-app-manager/infrastructure/utility"
"finclip-app-manager/infrastructure/utils"
"fmt"
"io"
"os"
"path"
"path/filepath"
"strings"
ezip "github.com/alexmullins/zip"
"github.com/gin-gonic/gin"
"gopkg.in/mgo.v2/bson"
"net/http"
"time"
)
const (
/**
* 开发中: InDevelopment
* 审核中: Publishing
* 撤销审核: PublishWithdraw
* 审核通过:PublishApproved
* 审核被拒:PublishRejected
* 已上架:Published
* 高本版上架致下架:UnpublishedByNewSeq
* 开发者下架: UnpublishedByDev
* 运营端下架:UnpublishedByAdmin
**/
AppExternalStatusInDevelopment = "InDevelopment"
AppExternalStatusPublishing = "Publishing"
AppExternalStatusPublishWithdrawed = "PublishWithdrawed"
AppExternalStatusPublishApproved = "PublishApproved"
AppExternalStatusPublishRejected = "PublishRejected"
AppExternalStatusPublished = "Published"
AppExternalStatusUnpublishedByNewSeq = "UnpublishedByNewSeq"
AppExternalStatusUnpublishedByDev = "UnpublishedByDev"
AppExternalStatusUnpublishedByAdmin = "UnpublishedByAdmin"
)
type AppService struct {
appRepo repository.AppRepository
buildRepo repository.IAppBuildInfoRepo
bindingRepo repository.IBindingRepo
tempAppRepo repository.IAppTempInfoRepo
//qrcodeRepo repository.IQrCodeInfoRepo
prviacySettingRepo repository.IPrivacySettingRepo
tool *BoxTool
}
func NewAppService() *AppService {
return &AppService{
appRepo: impl.InitAppRepo(),
buildRepo: impl.InitBuildInfoRepo(),
bindingRepo: impl.InitBindingRepo(),
tempAppRepo: impl.InitAppTempInfoRepo(),
//qrcodeRepo: impl.InitQrCodeInfoRepo(),
prviacySettingRepo: impl.InitPrivacySettingRepo(),
tool: NewBoxTool(),
}
}
func (as *AppService) CreateApp(ctx context.Context, c *gin.Context, req proto.CreateAppReq, accountId string) (*entity.App, *utility.SvrRsp) {
log.Infof("createApp get req:%+v", req)
rsp := utility.DefaultSvrRsp()
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, accountId)
if err != nil {
log.Errorf("createApp GetGroupID err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
accountInfo, err := hCaller.GetAccountInfo(ctx, accountId)
if err != nil {
log.Errorf("createApp GetAccountInfo err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_ACCOUNTINFO_ERROR)
}
if req.ProjectType < 0 || req.ProjectType > 2 {
log.Errorf("createApp param err")
return nil, rsp.SetLoc(http.StatusBadRequest, utility.FS_PARAM_ERR)
}
info := entity.App{}
info.AppClass = req.AppClass
info.AppTag = req.AppTag
info.AppType = req.AppType
info.CoreDescription = req.CoreDescription
info.Logo = req.Logo
info.Name = req.Name
info.GroupID = groupInfo.GroupID
info.CreatedBy = accountInfo.Account
info.DeveloperID = accountId
info.AppID = bson.NewObjectId().Hex()
info.ProjectType = req.ProjectType
timestamp := time.Now().UnixNano() / 1e6
info.Status = entity.Status{
Value: entity.StInDevelopment,
LastUpdated: timestamp,
ModifiedBy: info.DeveloperID,
}
info.Created = timestamp
info.IsForbidden = 0
licenseInfo, err := hCaller.GetLicense(ctx)
if err != nil {
log.Errorf("createApp get license info error:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
log.Infof("createApp get license info:%+v", licenseInfo)
appCount, err := as.appRepo.AppCount(ctx, "")
if err != nil {
log.Errorf("createApp get app count error:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if appCount >= licenseInfo.AppCount {
log.Errorf("createApp app count has over license limit app count:%d", appCount)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FC_PRI_LIMIT_APPID_OVER_ERROR)
}
//调用支付权限模块增加小程序数量
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
applyReq := httpcall.PayAddLimitReq{}
applyReq.Type = httpcall.PAY_ADD_TYPE_APP
applyReq.AccountId = accountId
applyReq.BusinessId = info.AppID
applyReq.BusinessName = info.Name
payAddRsp, httpCode, err := hCaller.PayAddLimit(ctx, &applyReq)
if err != nil {
log.Errorf("PayAddLimit err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if httpCode != http.StatusOK {
return nil, rsp.SetLoc(httpCode, utility.FC_OPERA_LIMIT_APPID_OVER_ERROR)
}
if payAddRsp.Data.EndTime == 0 {
payAddRsp.Data.EndTime = MAX_EXPIRE_DATA
}
info.Expire = payAddRsp.Data.EndTime
} else { //调用运营端增加企业appid数量，会做校验
n := httpcall.AddLimitInfoReq{
Type: "appId",
OrganId: info.GroupID,
AddNum: 1,
}
httpCode, _, err := hCaller.AddLimitInfo(ctx, &n)
if err != nil {
log.Errorf("createApp AddLimitInfo err:%s", err.Error())
return nil, rsp.SetLoc(httpCode, utility.FC_OPERA_LIMIT_APPID_OVER_ERROR)
}
}
if err = as.appRepo.InsertApp(ctx, info); err != nil {
log.Errorf("createApp insert appVer info err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_DB_ERR)
}
//生成操作日志
logExp := make(map[string]interface{})
go hCaller.AddOperateLog(c, groupInfo.GroupID, kafka.GenContent(kafka.APP_ADD_LOG, info.Name, info.AppID), logExp, accountInfo.Account)
info.Expire = getExpire(info.Expire, licenseInfo.ExpireTime)
return &info, rsp.SetLoc(http.StatusCreated, utility.OK)
}
func (as *AppService) WithdrawPublishRequest(ctx context.Context, c *gin.Context, appId string, seq int, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appVer, err := as.appRepo.GetAppVerInfo(ctx, appId, seq)
if err != nil {
log.Errorf("withdrawPublishRequest get app ver err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("withdrawPublishRequest GetGroupID err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
err = as.appRepo.WithdrawPubApp(ctx, appId, seq, accountInfo.Account)
if err != nil {
log.Errorf("withdrawPublishRequest db err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
logExp := make(map[string]interface{})
go hCaller.AddOperateLog(c, accountInfo.OrganId, kafka.GenContent(kafka.APP_CANCEL_REVIEW_LOG, appVer.Name, appVer.AppID), logExp, accountInfo.Account)
//model.NewAsyncMessageRepo().GenAppStatusChangeInfo(traceCtx, model.AppStatusChangeInfo{Event: model.AppWithdrawPubReq, Info: map[string]interface{}{"appId": appVer.AppID}})
return rsp
}
func (as *AppService) UpdateApp(ctx context.Context, c *gin.Context, req proto.AppUpdateReq, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appInfo, err := as.appRepo.GetAppInfo(ctx, req.AppId)
if err != nil {
log.Errorf("UpdateApp app info not found,req:%+v", req)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
oldName := appInfo.Name
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, userId)
if err != nil {
log.Errorf("updateApp GetGroupID err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
if groupInfo.GroupID != appInfo.GroupID {
log.Errorf("updateApp group id not equal,req groupId:%+v,get groupId:%s", groupInfo, appInfo.GroupID)
return rsp.SetLoc(http.StatusForbidden, utility.FS_FORBIDDEN)
}
//err = as.appRepo.UpdateApp(ctx, appInfo)
//if err != nil {
// log.Errorf("updateApp app err:%s", err.Error())
// return rsp.SetLoc(http.StatusForbidden, utility.FS_DB_ERR)
//}
appInfo.Name = req.Name
appInfo.Logo = req.Logo
appInfo.AppClass = req.AppClass
appInfo.AppTag = req.AppTag
appInfo.CoreDescription = req.CoreDescription
appInfo.CustomData.DetailDescription = req.CustomData.DetailDescription
err = as.appRepo.UpdateApp(ctx, appInfo)
if err != nil {
log.Errorf("UpdateApp repo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if oldName != req.Name {
if err = as.appRepo.UpdateAppVerAppName(ctx, req.AppId, req.Name); err != nil {
log.Errorf("UpdateAppVerAppName repo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
//操作日志
logExp := make(map[string]interface{})
logReq := httpcall.GenOperateDataV2Req{
OrganId: appInfo.GroupID,
Content: kafka.GenContent(kafka.APP_EDIT_INFO_LOG, appInfo.Name, appInfo.AppID),
Extra: logExp,
Oper: "",
AccountId: userId,
IsDev: true,
}
hCaller.AddOperateLogV2(c, logReq)
return rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) UpdateAppIsForbidden(ctx context.Context, req proto.AppIsForbiddenUpdateReq, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appInfo, err := as.appRepo.GetAppInfo(ctx, req.AppId)
if err != nil {
log.Errorf("UpdateAppIsForbidden app info not found,req:%+v", req)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, userId)
if err != nil {
log.Errorf("updateAppIsForbidden GetGroupID err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
if groupInfo.GroupID != appInfo.GroupID {
log.Errorf("updateAppIsForbidden group id not equal,req groupId:%+v,get groupId:%s", groupInfo, appInfo.GroupID)
return rsp.SetLoc(http.StatusForbidden, utility.FS_FORBIDDEN)
}
if req.IsForbidden == 0 {
licenseInfo, err := hCaller.GetLicense(ctx)
if err != nil {
log.Errorf("createApp get license info error:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
log.Infof("createApp get license info:%+v", licenseInfo)
appCount, err := as.appRepo.AppCount(ctx, "")
if err != nil {
log.Errorf("createApp get app count error:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if appCount >= licenseInfo.AppCount {
log.Errorf("createApp app count has over license limit app count:%d", appCount)
return rsp.SetLoc(http.StatusOK, utility.FC_PRI_LIMIT_APPID_OVER_ERROR)
}
}
appInfo.IsForbidden = req.IsForbidden
//调用支付权限模块增加小程序数量
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
applyReq := httpcall.PayAddLimitReq{}
applyReq.Type = httpcall.PAY_ADD_TYPE_APP
applyReq.AccountId = userId
applyReq.BusinessId = req.AppId
applyReq.BusinessName = appInfo.Name
if req.IsForbidden == 0 {
payAddRsp, httpCode, err := hCaller.PayAddLimit(ctx, &applyReq)
if err != nil {
log.Errorf("PayAddLimit err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if httpCode != http.StatusOK {
return rsp.SetLoc(httpCode, utility.FC_OPERA_LIMIT_APPID_OVER_ERROR)
}
if payAddRsp.Data.EndTime == 0 {
payAddRsp.Data.EndTime = MAX_EXPIRE_DATA
}
appInfo.Expire = payAddRsp.Data.EndTime
} else {
_, httpCode, err := hCaller.PayUpdateLimit(ctx, &applyReq)
if err != nil {
log.Errorf("PayAddLimit err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if httpCode != http.StatusOK {
return rsp.SetLoc(httpCode, utility.FC_OPERA_LIMIT_APPID_OVER_ERROR)
}
}
} else { //调用运营端增加企业appid数量，会做校验
addNum := 1
if req.IsForbidden == 1 {
addNum = -1
}
n := httpcall.AddLimitInfoReq{
Type: "appId",
OrganId: appInfo.GroupID,
AddNum: addNum,
}
httpCode, _, err := hCaller.AddLimitInfo(ctx, &n)
if err != nil {
log.Errorf("createApp AddLimitInfo err:%s", err.Error())
return rsp.SetLoc(httpCode, utility.FC_OPERA_LIMIT_APPID_OVER_ERROR)
}
}
err = as.appRepo.UpdateApp(ctx, appInfo)
if err != nil {
log.Errorf("UpdateAppIsForbidden repo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
/*//操作日志
logExp := make(map[string]interface{})
logReq := kafka.GenOperateDataV2Req{
OrganId: appInfo.GroupID,
Content: kafka.GenContent(kafka.APP_EDIT_INFO_LOG, appInfo.Name, appInfo.AppID),
Extra: logExp,
Oper: "",
AccountId: userId,
IsDev: true,
}
kafka.GenOperateDataV2(ctx, c, logReq)*/
return rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) PubApp(ctx context.Context, appId string, seq int, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appVerInfo, err := as.appRepo.GetAppVerInfo(ctx, appId, seq)
if err != nil {
log.Errorf("as.appRepo.GetAppVerInfo err:%s", err.Error())
if repository.NotFound(err) {
log.Errorf("DevPublishApp get appVer not found!")
return rsp.SetLoc(http.StatusNotFound, utility.FS_APP_SEQUENCE_NOT_FOUND)
}
}
log.Debugf("as.appRepo.GetAppVerInfo err:%s", utility.InterfaceToJsonString(appVerInfo))
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, userId)
if err != nil {
log.Errorf("DevPublishApp GetGroupID err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
if groupInfo.GroupID != appVerInfo.GroupID {
log.Errorf("DevPublishApp group id no equal,app ver group Id:%s,get group info:%+v", appVerInfo.GroupID, groupInfo)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_APP_SEQUENCE_NOT_FOUND)
}
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("DevPublishApp GetAccountInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_ACCOUNTINFO_ERROR)
}
_, onlineAppErr := as.appRepo.GetOnlineAppVer(ctx, appId)
if onlineAppErr != nil {
if !repository.NotFound(onlineAppErr) {
log.Errorf("GetOnlineAppVer err:%s", onlineAppErr.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
lastPubVerInfo, err := as.appRepo.GetLatestPubAppVer(ctx, appId)
if err != nil && !repository.NotFound(err) {
log.Errorf("DevPublishApp GetLatestPubAppVer err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
var isRollback = false
if !repository.NotFound(err) && lastPubVerInfo.Sequence > seq { //代表回退版本
if repository.NotFound(onlineAppErr) { //如果当前小程序未上架，不允许回退
log.Errorf("no pub app,appId:[%s]", appId)
return rsp.SetLoc(http.StatusBadRequest, utility.FS_ROLLBACK_FORBID)
}
isRollback = true
//如果当前上架的小程序版本已经是回退版本，那不可再次回退
if lastPubVerInfo.Status.Value == entity.StPublished && lastPubVerInfo.IsRollback {
log.Errorf("roll back app ver has rollback,info:%+v", lastPubVerInfo)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_MULTI_ROLLBACK_FORBID)
}
//校验是否可以回退----不是最近下架的5个版本
rollbackList, err := as.appRepo.GetRollbackAbleList(ctx, groupInfo.GroupID, appId, lastPubVerInfo.Sequence)
if err != nil {
log.Errorf("GetRollbackAbleList err:%s,info:%+v", err.Error(), lastPubVerInfo)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
isValidRollbackSeq := false
for _, v := range rollbackList {
if v.Sequence == seq {
isValidRollbackSeq = true
}
}
if !isValidRollbackSeq {
log.Errorf("roll back app not valid,req appId:%s,seq:%d", appId, seq)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_ROLLBACK_FORBID)
}
log.Infof("PubApp appId:[%s],seq:[%d] is rollback!", appId, seq)
} else {
if appVerInfo.Status.Value != entity.StPublishApproved {
log.Errorf("PubApp status not valid,appId:[%s],seq:[%d]", appId, seq)
return rsp.SetLoc(http.StatusBadRequest, utility.FS_INVALID_STATE)
}
}
err = as.pubAppHelp(ctx, appId, seq, accountInfo.Account, true, isRollback, userId, appVerInfo.ActionStatus.ModifiedBy)
if err != nil {
log.Errorf("pubAppHelp err:%s", err.Error())
return rsp.SetLoc(http.StatusBadRequest, utility.FS_SYSTEM_CALL)
}
//service.NewWechatInfoService().TouchWechatInfo(traceCtx, appVer.AppID)
//if isDev {
// logExp := make(map[string]interface{})
// go model.GenOperateData(traceCtx, c, groupID, GenContent(APP_PUB_LOG, appVer.Name, appVer.AppID, appVer.Sequence), logExp, accountInfo.Account)
//}
//notifySpiderPushApp(traceCtx, req.AppID, client.UP_STATE)
//sendSwanReport(ctx, "userId", userId)
//c.JSON(http.StatusOK, gin.H{})
sendDelaySms(ctx, appVerInfo.DeveloperID, true, true, true, appId, appVerInfo.Name, seq)
//上架通过后，更新小程序隐私中的updateTime与effectiveTime
total, err := as.prviacySettingRepo.Count(ctx, appId)
if total > 0 {
item, err := as.prviacySettingRepo.GetInfoByAppId(ctx, appId)
if err != nil {
log.Errorf("PrviacySettingRepo insert err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
/*if item.EffectiveTime == 0 {
item.EffectiveTime = time.Now().UnixNano() / 1e6
}*/
item.UpdateTime = time.Now().UnixNano() / 1e6
err = as.prviacySettingRepo.UpdateInfo(ctx, *item)
if err != nil {
log.Errorf("PrviacySettingRepo UpdateInfo time err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
return rsp.SetLoc(http.StatusOK, utility.OK)
}
//下架小程序
func (as *AppService) UnpubApp(ctx context.Context, c *gin.Context, appId string, seq int, userId string, isDev bool, reason string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appVerInfo, err := as.appRepo.GetAppVerInfo(ctx, appId, seq)
if err != nil {
log.Errorf("UnpubApp GetAppVerInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
log.Debugf("UnpubApp appVerInfo:%+v", appVerInfo)
if appVerInfo.Status.Value != entity.StPublished {
log.Errorf("UnpubApp status err,need approved,appId:%s,seq:%d", appId, seq)
return rsp.SetLoc(http.StatusBadRequest, utility.FS_INVALID_STATE)
}
var account string
if isDev {
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, userId)
if err != nil {
log.Errorf("UnpubApp get group info err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if groupInfo.GroupID != appVerInfo.GroupID {
log.Errorf("unpublishAppHelp group id not equal appVer group id:%s,get group id:%+v", appVerInfo.GroupID, groupInfo)
return rsp.SetLoc(http.StatusForbidden, utility.FS_FORBIDDEN)
}
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("UnpubApp GetAccountInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
account = accountInfo.Account
} else {
adminInfo, err := hCaller.GetAdminAccountInfo(ctx, userId)
if err != nil {
log.Errorf("UnpubApp GetAdminAccountInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
account = adminInfo.Account
}
err = as.appRepo.UnpubApp(ctx, appId, seq, account, reason, isDev)
if err != nil {
log.Errorf("UnpubApp db err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if isDev {
logExp := make(map[string]interface{})
go hCaller.AddOperateLog(c, appVerInfo.GroupID, kafka.GenContent(kafka.APP_DOWN_LOG, appVerInfo.Name, appVerInfo.AppID, appVerInfo.Sequence), logExp, account)
} else {
notifyContent := kafka.NotifyContent{}
notifyContent.Title = fmt.Sprintf("小程序“%s”被下架", appVerInfo.Name)
notifyContent.Result = "fail"
notifyContent.Msg = fmt.Sprintf("小程序 %s（App ID：%s）被进行下架操作。用户暂无法使用小程序的所有服务（关联应用也无法使用）。下架理由为：%s", appVerInfo.Name, appVerInfo.AppID, reason)
notifyContent.Reason = reason
go kafka.GenNotifyData(ctx, appVerInfo.GroupID, 1000, notifyContent)
}
notifySpiderPushApp(ctx, appId, httpcall.DOWN_STATE)
return rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) RollbackAppList(ctx context.Context, appId, userId string) ([]entity.AppVersion, error) {
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("RollbackAppList GetAccountInfo err:%s", err.Error())
return nil, err
}
latestPubAppVer, err := as.appRepo.GetLatestPubAppVer(ctx, appId)
if err != nil {
if repository.NotFound(err) {
log.Errorf("RollbackAppList not found,appId:%s", appId)
return make([]entity.AppVersion, 0), nil
}
return nil, err
}
if latestPubAppVer.Status.Value != entity.StPublished {
log.Errorf("RollbackAppList latestPubAppVer no pub,appId:[%s]", appId)
return make([]entity.AppVersion, 0), nil
}
if latestPubAppVer.IsRollback {
log.Errorf("RollbackAppList latestPubAppVer has rollback,appId:[%s]", appId)
return make([]entity.AppVersion, 0), nil
}
rollbackList, err := as.appRepo.GetRollbackAbleList(ctx, accountInfo.OrganId, appId, latestPubAppVer.Sequence)
if err != nil {
log.Errorf("GetRollbackAbleList db err:%s", err.Error())
return nil, err
}
return rollbackList, nil
}
func (as *AppService) SubmitApp(ctx context.Context, c *gin.Context, req apiproto.SubmitPublishReqest, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
buildInfo, err := as.buildRepo.GetInfoById(ctx, req.Id)
if as.buildRepo.NotFound(err) || buildInfo == nil {
buildInfo, err = as.buildRepo.GetInfoByBuildId(ctx, req.Id)
if err != nil || buildInfo == nil {
if err != nil {
log.Errorf("SubmitApp get build info err:%s", err.Error())
} else {
log.Errorf("SubmitApp get build info nil")
}
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
if buildInfo.AppID != req.AppID {
log.Errorf("buildID err")
return rsp.SetLoc(http.StatusBadRequest, utility.FS_PARAM_ERR)
}
if config.GetConfig().IsOpenAuditSecurity {
auditInfo, err := hCaller.GetAuditDataInfoByBuildInfoId(ctx, buildInfo.BuildInfoId)
log.Debugln("GetAuditDataInfoByBuildInfoId:%v", utility.InterfaceToJsonString(auditInfo))
if err != nil {
log.Errorf("GetAuditDataInfoByBuildInfoId err:%s", err.Error())
return rsp.SetLoc(http.StatusBadRequest, utility.FS_PARAM_ERR)
}
//0无，1审核中，2通过，3不通过
if auditInfo.Data.Status != 2 && auditInfo.Data.OperOpinion != 1 {
log.Errorf("auditInfo.Data.Status not pass:%v", auditInfo.Data.Status)
return rsp.SetLoc(http.StatusBadRequest, utility.FS_PARAM_ERR)
}
}
appInfo, err := as.appRepo.GetAppInfo(ctx, req.AppID)
if err != nil {
log.Errorf("SubmitApp GetAppInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("SubmitApp GetAccountInfo err:%s,user id:%s", err.Error(), userId)
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if appInfo.GroupID != accountInfo.OrganId {
log.Errorf("SubmitApp group id not match!")
return rsp.SetLoc(http.StatusBadRequest, utility.FS_BAD_JSON)
}
maxSeqAppVerInfo, err := as.appRepo.GetMaxSeqAppVer(ctx, req.AppID)
if err != nil {
if !repository.NotFound(err) {
log.Errorf("SubmitApp GetMaxSeqAppVer err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
} else {
if maxSeqAppVerInfo.Status.Value == entity.StPublishing {
log.Errorf("submitPublishRequest max version Publishing!!!")
return rsp.SetLoc(http.StatusBadRequest, utility.FS_PUBLISHING_OR_UNPUBLISHING)
}
}
oper := c.GetHeader("C-Open-Api")
if oper == "" {
oper = accountInfo.Account
}
SubmitAppReq := entity.SubmitAppReq{
AppId: req.AppID,
BuildId: req.Id,
Account: oper,
NeedAutoPub: req.NeedAutoPub,
TestInfo: req.TestInfo,
UserId: userId,
}
err = as.appRepo.SubmitApp(ctx, SubmitAppReq, 0, userId)
if err != nil {
log.Errorf("SubmitApp app err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
logExp := make(map[string]interface{})
go hCaller.AddOperateLog(c, appInfo.GroupID, kafka.GenContent(kafka.APP_SUB_REVIEW_LOG, appInfo.Name, appInfo.AppID), logExp, oper)
if config.Cfg.PublishEnv == config.ENV_UAT {
// 通知中心发送消息
notifyContent := kafka.NotifyContent{}
notifyContent.Title = fmt.Sprintf("%s提交了”%s”小程序审核", accountInfo.Account, appInfo.Name)
notifyContent.Result = "success"
notifyContent.Msg = fmt.Sprintf("%s提交了小程序“%s”（APPID: %s）的上架审核申请", oper, appInfo.Name, appInfo.AppID)
go kafka.GenNotifyData(ctx, accountInfo.OrganId, 1000, notifyContent)
}
return rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) ApproveApp(ctx context.Context, req apiproto.ApproveAppReq, isAdmin bool, userId string) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
appVerInfo, err := as.appRepo.GetAppVerInfo(ctx, req.AppID, req.Sequence)
if err != nil {
log.Errorf("ApproveApp get app version info err:%s", err.Error())
return rsp.SetLoc(http.StatusBadRequest, utility.FS_APP_SEQUENCE_NOT_FOUND)
}
var account string
if isAdmin {
adminInfo, err := hCaller.GetAdminAccountInfo(ctx, userId)
if err != nil {
log.Errorf("approveApp GetAdminAccountInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusBadRequest, utility.FS_GET_ACCOUNTINFO_ERROR)
}
account = adminInfo.Account
} else {
devAccountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("approveApp GetAdminAccountInfo err:%s", err.Error())
return rsp.SetLoc(http.StatusBadRequest, utility.FS_GET_ACCOUNTINFO_ERROR)
}
if devAccountInfo.OrganId != appVerInfo.GroupID {
log.Errorf("ApproveApp organ id not match,req organ id:%s,app ver:%+v", devAccountInfo.OrganId, appVerInfo)
return rsp.SetLoc(http.StatusNotFound, utility.FS_FORBIDDEN)
}
account = devAccountInfo.Account
}
if req.RequestFrom != "" {
account = req.RequestFrom
}
var isPass = false
if req.Status == entity.StPublishApproved {
isPass = true
}
var isPubImmediately = false
if appVerInfo.NeedAutoPub && isPass {
isPubImmediately = true
}
log.Infof("isPass:%t isPubImmediately:%t", isPass, isPubImmediately)
err = as.appRepo.ApproveApp(ctx, req.AppID, req.Sequence, account, req.Reason, isPass)
if err != nil {
log.Errorf("ApproveApp db err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
{
//给通知中心发消息
st := time.Unix(appVerInfo.PublishingStatus.LastUpdated/1000, 0).Format("2006-01-02 15:04")
at := time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04")
notifyContent := kafka.NotifyContent{}
if isPass {
notifyContent.Title = fmt.Sprintf("小程序“%s”上架审核成功", appVerInfo.Name)
notifyContent.Result = "success"
//notifyContent.Msg = fmt.Sprintf("小程序 %s（APP ID: %s）已经通过审核，可进行后续操作。
申请时间：%s，审核时间：%s",
// appVerInfo.Name, appVerInfo.AppID, st, at)
notifyContent.Msg = fmt.Sprintf("小程序 %s（APP ID: %s）您提交的小程序已经通过审核，请在小程序详情中进行版本上架操作。
申请时间：%s，审核时间：%s",
appVerInfo.Name, appVerInfo.AppID, st, at)
notifyContent.Reason = req.Reason
} else {
notifyContent.Title = fmt.Sprintf("小程序“%s”上架审核失败", appVerInfo.Name)
notifyContent.Result = "fail"
notifyContent.Msg = fmt.Sprintf("小程序 %s（APP ID: %s）未通过审核，可进行后续操作。
申请时间：%s，审核时间：%s", appVerInfo.Name, appVerInfo.AppID, st, at)
notifyContent.Reason = req.Reason
}
go kafka.GenNotifyData(ctx, appVerInfo.GroupID, 1000, notifyContent)
sendDelaySms(ctx, appVerInfo.DeveloperID, isPass, isPubImmediately, false, req.AppID, appVerInfo.Name, req.Sequence)
}
if isPubImmediately {
err = as.pubAppHelp(ctx, req.AppID, req.Sequence, "自动上架", false, false, "[auto]", appVerInfo.ActionStatus.ModifiedBy)
//err = as.appRepo.PubApp(ctx, req.AppID, req.Sequence, "自动上架", true, false)
if err != nil {
log.Errorf("ApproveApp auto pub app err:%s", err.Error())
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
} else {
appTagStr := ""
if len(appVerInfo.AppTag) > 0 {
for _, v := range appVerInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagStr += tag.Name + ","
log.Debugln("appTagStr", appTagStr)
}
}
}
if len(appTagStr) > 0 {
appTagStr = appTagStr[0 : len(appTagStr)-1]
}
}
}
//sendSwanReport(ctx, "account", appVerInfo.RequestStatus.ModifiedBy)
}
return rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) pubAppHelp(ctx context.Context, appId string, seq int, account string, isDev, isRollback bool, userId, requestAccount string) error {
//通知灰度发布并更新状态
var err error
if isDev { //运营端审核通过自动上架，做一个特殊处理
err = hCaller.PubNotifyRuleEngine(ctx, appId, seq, userId, isDev)
} else {
err = hCaller.PubNotifyRuleEngine(ctx, appId, seq, "", isDev)
}
if err != nil {
log.Errorf("pubAppHelp PubNotifyRuleEngine err:%s", err.Error())
return err
}
err = as.appRepo.PubApp(ctx, appId, seq, account, isDev, isRollback)
if err != nil {
log.Errorf("PubAppVer err:%s,appId:%s,seq:%d", err.Error(), appId, seq)
return err
}
appVersion, err := as.appRepo.GetAppVerInfo(ctx, appId, seq)
if err != nil {
log.Errorf("pubAppHelp GetAppVerInfo err:%s", err.Error())
return nil
}
//service.NewWechatInfoService().TouchWechatInfo(traceCtx, appVer.AppID)
//if isDev {
// logExp := make(map[string]interface{})
// go model.GenOperateData(traceCtx, c, groupID, GenContent(APP_PUB_LOG, appVer.Name, appVer.AppID, appVer.Sequence), logExp, accountInfo.Account)
//}
//notifySpiderPushApp(traceCtx, req.AppID, client.UP_STATE)
err = hCaller.TouchWechatInfo(ctx, appId)
if err != nil {
log.Errorf("TouchWechatInfo err:%s", err.Error())
return nil
}
/*appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return err
}
log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
if len(appVersion.AppTag) > 0 {
log.Debugln("AppTag:", appVersion.AppTag)
for _, v := range appVersion.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagStr += tag.Name + ","
log.Debugln("appTagStr", appTagStr)
}
}
}
if len(appTagStr) > 0 {
appTagStr = appTagStr[0 : len(appTagStr)-1]
}
}*/
/*
if len(appVersion.AppTag) > 0 {
for _, v := range appTagInfo.Data.AppClass {
if v.Key == appVersion.AppClass {
appClassStr = v.Name
}
}
}*/
/*if len(appVersion.CustomData.SourceFile) > 0 {
notifySpiderPubApp(ctx, appVersion.AppID, appVersion.Name, appVersion.CoreDescription, "", appVersion.CustomData.SourceFile[0].SourceFileUrl, appTagStr, appClassStr)
}*/
go hCaller.PubAppNotifyToMiniprogram(ctx, &appVersion)
sendSwanReport(ctx, "account", requestAccount)
return nil
}
type GetStatisticsResponse struct {
Created int `json:"created"`
Submited int `json:"submited"`
Approved int `json:"approved"`
Published int `json:"published"`
}
func (as *AppService) AppStatistics(ctx context.Context, startTime, endTime int64, groupId string, distinct bool, isForbidden int) (GetStatisticsResponse, error) {
var (
result = GetStatisticsResponse{}
err error
)
result.Created, err = as.appRepo.GetCreatedStatistics(ctx, startTime, endTime, groupId, isForbidden)
if err != nil {
return GetStatisticsResponse{}, err
}
result.Submited, err = as.appRepo.GetSubmittedStatistics(ctx, startTime, endTime, groupId, distinct)
if err != nil {
return GetStatisticsResponse{}, err
}
result.Approved, err = as.appRepo.GetApprovedStatistics(ctx, startTime, endTime, groupId, distinct)
if err != nil {
return GetStatisticsResponse{}, err
}
result.Published, err = as.appRepo.GetPublishedStatistics(ctx, startTime, endTime, groupId)
if err != nil {
return GetStatisticsResponse{}, err
}
return result, nil
}
func (as *AppService) GetAppInfoByAppId(ctx context.Context, appId string) (entity.App, error) {
return as.appRepo.GetAppInfo(ctx, appId)
}
func (as *AppService) GetAppVerInfo(ctx context.Context, appId string, seq int) (entity.AppVersion, error) {
return as.appRepo.GetAppVerInfo(ctx, appId, seq)
}
func (as *AppService) GetLatestPubAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
return as.appRepo.GetLatestPubAppVer(ctx, appId)
}
func (as *AppService) GetOnlineAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
return as.appRepo.GetOnlineAppVer(ctx, appId)
}
func (as *AppService) GetLatestReviewAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
return as.appRepo.GetLatestReviewAppVer(ctx, appId)
}
func (as *AppService) GetMaxSeqAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
return as.appRepo.GetMaxSeqAppVer(ctx, appId)
}
func (as *AppService) GetPubAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
return as.appRepo.GetLatestPubAppVer(ctx, appId)
}
func (as *AppService) GetAllPublishedVerList(ctx context.Context, appId string) ([]entity.AppVersion, int, error) {
return as.appRepo.GetAllPublishedVerList(ctx, appId)
}
func (as *AppService) GetBuildInfo(ctx context.Context, req apiproto.GetBuildAppInfoReq, sdkKey string) (*pb.BuildAppInfo, *utility.SvrRsp) {
switch req.Type {
case entity.BuildInfoTypeTrial: //获取体验版小程序详情
return as.GetTrialInfo(ctx, req.CodeId, sdkKey)
case entity.BuildInfoTypeTemporary, entity.BuildInfoTypeRomoteDebug: //获取ide临时小程序详情
return as.getTempAppBuildInfo(ctx, req.CodeId)
case entity.BuildInfoTypeDevelopment:
return as.GetDevInfo(ctx, req.CodeId, sdkKey)
default:
return nil, utility.DefaultSvrRsp().SetLoc(http.StatusBadRequest, utility.FS_PARAM_ERR)
}
}
func (as *AppService) GetTrialInfo(ctx context.Context, codeId, sdkKey string) (*pb.BuildAppInfo, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
buildInfo := new(pb.BuildAppInfo)
info, err := as.buildRepo.GetInfoById(ctx, codeId)
if err != nil {
log.Errorf("GetTrialInfo get info err:%s", err.Error())
if repository.NotFound(err) {
return nil, rsp.SetLoc(http.StatusNotFound, utility.FS_NOT_FOUND)
}
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if info.Source != entity.APP_BUILD_SOURCE_TRIAL {
log.Errorf("GetTrialInfo id is not a trial info:[%s]", codeId)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_NOT_TRIAL_INFO)
}
appInfo, err := as.appRepo.GetAppInfo(ctx, info.AppID)
if err != nil {
log.Errorf("GetTrialInfo GetAppVerInfo err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if appInfo.IsForbidden == 1 {
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_IS_FORBIDDEN)
}
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appInfo.GroupID)
if err != nil {
log.Errorf("GetTrialInfo GetGroupInfoByUserId err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
// 获取开发者信息
//developerInfo, err := client.GetDeveloperInfo(ctx, appVerInfo.DeveloperID)
//if err != nil {
// log.Errorf("GetDeveloperInfo err:%s", err.Error())
// return nil, rsp.SetLoc(gin.H{}, http.StatusInternalServerError, common.FS_SERVER_ERR)
//}
//status := avs.account.getAccountStatus(groupInfo, developerInfo)
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("GetTrialInfo get info organ info invalid,code id:%s", codeId)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("GetTrialInfo get info organ info invalid,code id:%s", codeId)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
}
domainInfo, err := hCaller.GetAppDomainByOrganId(ctx, groupInfo.GroupID)
if err != nil {
log.Errorf("GetTrialInfo ger domain info err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//支付信息过期校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
appStatus, err := as.CheckIdStatus(ctx, appInfo.AppID)
if err != nil {
log.Errorf("CheckIdStatus err:%s,appId:%s", err.Error(), appInfo.AppID)
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if appStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("check appid purch status no ok ")
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_PAY_EXPIRE)
}
}
log.Debugf("get group id:%s,sdkKey:%s", appInfo.GroupID, sdkKey)
inWhiteList := utility.InArry(sdkKey, config.WhiteSDKArry)
if !inWhiteList {
bindingInfo, err := as.bindingRepo.GetInfoBySdkKeyOrganId(ctx, appInfo.GroupID, sdkKey)
if err != nil {
log.Errorf("GetInfoBySdkKeyOrganId err:%s", err.Error())
if repository.NotFound(err) {
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_BIND_NOT_FOUND)
}
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if bindingInfo.CooperateStatus.Value != entity.StBindValid {
log.Errorf("GetTrialInfo binding bind invalid,binding info:%+v", bindingInfo)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_COOPERATION_TERMINATED)
}
//支付信息校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
bindStatus, err := as.CheckIdStatus(ctx, bindingInfo.BindingID)
if err != nil {
log.Errorf("CheckIdStatus err:%s,bindingId:%s", err.Error(), bindingInfo.BindingID)
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if bindStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("binding id pay check no ok ")
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_BIND_PAY_EXPIRE)
}
}
appAssBind := false
for _, v := range bindingInfo.AppInfos {
if v.AppID == appInfo.AppID {
appAssBind = true
}
}
if !appAssBind {
log.Errorf("GetTrialInfo sdk key not ass binding,appId:[%s]", appInfo.AppID)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appInfo.AppTag) > 0 {
for _, v := range appInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
buildInfo.CodeId = info.Id
buildInfo.CoreDescription = appInfo.CoreDescription
buildInfo.Created = info.Created
buildInfo.CreatedBy = info.CreatedBy
err, errCode, customData := ConvertModelCustomDataToPb(ctx, info.GroupID, info.CustomData, domainInfo, "cache")
if err != nil {
log.Errorf("ConvertModelCustomDataToPb err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, errCode)
}
buildInfo.CustomData = customData
buildInfo.CustomData.DetailDescription = appInfo.CustomData.DetailDescription
buildInfo.GroupId = info.GroupID
buildInfo.GroupName = groupInfo.GroupName
buildInfo.Logo = appInfo.Logo
buildInfo.Name = appInfo.Name
buildInfo.Version = info.Version
buildInfo.IsTemp = false
buildInfo.NeedCrt = domainInfo.NeedCrt
buildInfo.AppId = info.AppID
buildInfo.AppTag = appTagArr
buildInfo.PrivacySettingType = int32(appInfo.PrivacySettingType)
buildInfo.ProjectType = int32(appInfo.ProjectType)
buildInfo.DeveloperStatus = int32(getAccountStatus(groupInfo))
//buildInfoCacheByte, _ = json.Marshal(buildInfo)
//avs.rc.Set(ctx, avs.getTrialInfoCacheKey(codeId), string(buildInfoCacheByte), config.Cfg.RedisTrialExpireTime)
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, info.AppID)
if err == nil {
buildInfo.WechatLoginInfo = ConvertWechatLoginInfoToPb(wechatLoginInfo)
//return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
return buildInfo, rsp
}
func (as *AppService) GetDevInfo(ctx context.Context, codeId, sdkKey string) (*pb.BuildAppInfo, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
buildInfo := new(pb.BuildAppInfo)
//buildInfoCacheByte, err := avs.rc.GetBytes(ctx, avs.getDevInfoCacheKey(codeId))
//if err == nil {
// if err = json.Unmarshal(buildInfoCacheByte, buildInfo); err == nil {
// log.Infof("GetDevInfo from cache ...")
// return buildInfo, rsp.SetLoc(gin.H{}, http.StatusOK, common.OK)
// }
//}
info, err := as.buildRepo.GetInfoById(ctx, codeId)
if err != nil {
log.Errorf("GetDevInfo get info err:%s", err.Error())
if repository.NotFound(err) {
return nil, rsp.SetLoc(http.StatusNotFound, utility.FS_NOT_FOUND)
}
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
appInfo, err := as.appRepo.GetAppInfo(ctx, info.AppID)
if err != nil {
log.Errorf("GetDevInfo GetAppVerInfo err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if appInfo.IsForbidden == 1 {
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_IS_FORBIDDEN)
}
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appInfo.GroupID)
if err != nil {
log.Errorf("GetDevInfo GetGroupInfoByUserId err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//// 获取开发者信息
//developerInfo, err := client.GetDeveloperInfo(ctx, appVerInfo.DeveloperID)
//if err != nil {
// log.Errorf("GetDeveloperInfo err:%s", err.Error())
// return nil, rsp.SetLoc(gin.H{}, http.StatusInternalServerError, common.FS_SERVER_ERR)
//}
//status := avs.account.getAccountStatus(groupInfo, developerInfo)
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("GetDevInfo get info organ info invalid,code id:%s", codeId)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("GetDevInfo get info organ info invalid,code id:%s", codeId)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
}
//if !client.OrganStatusIsValid(groupInfo.ReviewStatus) {
// log.Errorf("GetDevInfo get info organ info invalid,code id:%s", codeId)
// return nil, rsp.SetLoc(gin.H{}, http.StatusForbidden, common.FS_ORGAN_STATUS_INVALID)
//}
//支付信息过期校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
appStatus, err := as.CheckIdStatus(ctx, appInfo.AppID)
if err != nil {
log.Errorf("CheckIdStatus err:%s,appId:%s", err.Error(), appInfo.AppID)
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if appStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("check appid purch status no ok ")
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_PAY_EXPIRE)
}
}
domainInfo, err := hCaller.GetAppDomainByOrganId(ctx, appInfo.GroupID)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger domain info err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
log.Debugf("get group id:%s,sdkKey:%s", appInfo.GroupID, sdkKey)
inWhiteList := utility.InArry(sdkKey, config.WhiteSDKArry)
if !inWhiteList {
bindingInfo, err := as.bindingRepo.GetInfoBySdkKeyOrganId(ctx, appInfo.GroupID, sdkKey)
if err != nil {
log.Errorf("GetInfoBySdkKeyOrganId err:%s", err.Error())
if repository.NotFound(err) {
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_BIND_NOT_FOUND)
}
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if bindingInfo.CooperateStatus.Value != entity.StBindValid {
log.Errorf("GetDevInfo binding bind invalid,binding info:%+v", bindingInfo)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_COOPERATION_TERMINATED)
}
//支付信息校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
bindStatus, err := as.CheckIdStatus(ctx, bindingInfo.BindingID)
if err != nil {
log.Errorf("CheckIdStatus err:%s,bindingId:%s", err.Error(), bindingInfo.BindingID)
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
if bindStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("binding id pay check no ok ")
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_BIND_PAY_EXPIRE)
}
}
appAssBind := false
for _, v := range bindingInfo.AppInfos {
if v.AppID == appInfo.AppID {
appAssBind = true
}
}
if !appAssBind {
log.Errorf("GetDevInfo sdk key not ass binding,appId:[%s]", appInfo.AppID)
return nil, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appInfo.AppTag) > 0 {
for _, v := range appInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
buildInfo.CodeId = info.Id
buildInfo.CoreDescription = appInfo.CoreDescription
buildInfo.Created = info.Created
buildInfo.CreatedBy = info.CreatedBy
err, errCode, customData := ConvertModelCustomDataToPb(ctx, info.GroupID, info.CustomData, domainInfo, "cache")
if err != nil {
log.Errorf("ConvertModelCustomDataToPb err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, errCode)
}
buildInfo.CustomData = customData
buildInfo.CustomData.DetailDescription = appInfo.CustomData.DetailDescription
buildInfo.GroupId = info.GroupID
buildInfo.GroupName = groupInfo.GroupName
buildInfo.Logo = appInfo.Logo
buildInfo.Name = appInfo.Name
buildInfo.Version = info.Version
buildInfo.AppId = info.AppID
buildInfo.IsTemp = false
buildInfo.NeedCrt = domainInfo.NeedCrt
buildInfo.DeveloperStatus = int32(getAccountStatus(groupInfo))
buildInfo.AppTag = appTagArr
buildInfo.PrivacySettingType = int32(appInfo.PrivacySettingType)
buildInfo.ProjectType = int32(appInfo.ProjectType)
//buildInfoCacheByte, _ = json.Marshal(buildInfo)
//avs.rc.Set(ctx, avs.getDevInfoCacheKey(codeId), string(buildInfoCacheByte), config.Cfg.RedisTrialExpireTime)
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, info.AppID)
if err == nil {
buildInfo.WechatLoginInfo = ConvertWechatLoginInfoToPb(wechatLoginInfo)
//return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
return buildInfo, rsp
}
type GetRuleEngineVerPubListRspItem struct {
Version int `json:"version"`
VersionStr string `json:"versionStr"`
}
type VerToDescItem struct {
Version int `json:"version"`
Desc string `json:"desc"`
}
type GetRuleEngineVerPubListRsp struct {
VerList []GetRuleEngineVerPubListRspItem `json:"verList"` //大于等于MaxPubVer的序列号列表
NowPubVer GetRuleEngineVerPubListRspItem `json:"nowPubVer"` //当前上架版本
MaxPubVer GetRuleEngineVerPubListRspItem `json:"maxPubVer"` //已发布、已下架、审核通过三种状态里面的最大版本号
VerToDesc []VerToDescItem `json:"verToDesc"` //序列号到版本描述的映射
}
func (as *AppService) GetRuleEngineVerPubList(ctx context.Context, appId string) (interface{}, *utility.SvrRsp) {
rspData := GetRuleEngineVerPubListRsp{}
rsp := utility.DefaultSvrRsp()
pubVer, err := as.appRepo.GetOnlineAppVer(ctx, appId)
if err != nil {
if repository.NotFound(err) {
rspData.NowPubVer = GetRuleEngineVerPubListRspItem{Version: -1, VersionStr: ""}
} else {
log.Errorf("GetOnlineAppVer err:%s", err.Error())
return gin.H{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
rspData.NowPubVer.Version = pubVer.Sequence
rspData.NowPubVer.VersionStr = pubVer.Version
maxVerSeq := 0
latestPubVer, err := as.appRepo.GetLatestPubAppVer(ctx, appId)
if err != nil {
if repository.NotFound(err) {
rspData.MaxPubVer.Version = 0
rspData.VerList = make([]GetRuleEngineVerPubListRspItem, 0)
} else {
log.Errorf("GetLatestPubAppVer err:%s", err.Error())
return gin.H{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
maxVerSeq = latestPubVer.Sequence
rspData.MaxPubVer.Version = latestPubVer.Sequence
rspData.MaxPubVer.VersionStr = latestPubVer.Version
permitPubList, err := as.appRepo.GetAllPermitGrayPubVers(ctx, appId, maxVerSeq)
if err != nil {
log.Errorf("GetAllPermitGrayPubVers err:%s", err.Error())
return gin.H{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
for _, v := range permitPubList {
item := GetRuleEngineVerPubListRspItem{
Version: v.Sequence,
VersionStr: v.Version,
}
rspData.VerList = append(rspData.VerList, item)
}
//获取版本号对应的版本说明
type VerToDescTemp struct {
Sequence int `bson:"sequence"`
CustomData map[string]interface{} `bson:"customData"`
}
verList, _, err := as.appRepo.GetAllVers(ctx, appId)
if err != nil {
log.Errorf("GetAllVers err:%s", err.Error())
return gin.H{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
for _, v := range verList {
item := VerToDescItem{}
item.Version = v.Sequence
item.Desc = v.CustomData.VersionDescription
rspData.VerToDesc = append(rspData.VerToDesc, item)
}
log.Infof("GetRuleEngineVerPubList rsp:%+v", rspData)
return rspData, rsp
}
type ListAppsReq struct {
PullType string
PageNo int
PageSize int
SearchText string
SortType string
UserId string
GroupId string
IsDev bool
}
func (as *AppService) DevListApps(ctx context.Context, req *ListAppsReq) (int, []entity.App, error) {
groupInfo, err := hCaller.GetGroupInfoByUserId(ctx, req.UserId)
if err != nil {
log.Errorf("DevListApps GetGroupInfoByUserId err:%s", err.Error())
return 0, nil, err
}
total, list, err := as.appRepo.ListApps(ctx, groupInfo.GroupID, req.PageNo, req.PageSize, req.SearchText, req.SortType, req.PullType)
if err != nil {
if repository.NotFound(err) {
log.Infof("DevListApps empty!")
return 0, []entity.App{}, nil
}
return 0, nil, err
}
return total, list, err
}
func (as *AppService) AdminListApps(ctx context.Context, req *ListAppsReq) (int, []entity.App, error) {
total, list, err := as.appRepo.ListApps(ctx, req.GroupId, req.PageNo, req.PageSize, req.SearchText, req.SortType, req.PullType)
if err != nil {
if repository.NotFound(err) {
log.Infof("DevListApps empty!")
return 0, []entity.App{}, nil
}
return 0, nil, err
}
return total, list, err
}
func (as *AppService) AdminListPubApps(ctx context.Context, req *ListAppsReq) (int, []entity.AppVersion, error) {
list, total, err := as.appRepo.GetPublishedAppList(ctx, req.PageNo, req.PageSize, req.SearchText)
if err != nil {
if repository.NotFound(err) {
log.Infof("DevListApps empty!")
return 0, []entity.AppVersion{}, nil
}
return 0, nil, err
}
return total, list, err
}
type DevListAppsAndReviewsReq struct {
ListType string `form:"listType"`
GroupId string `form:"groupId"`
AppId string `form:"appId"`
Query string `form:"query"`
Sort string `form:"sort"`
SearchFields string `form:"searchFields"`
SearchText string `form:"searchText"`
PageSize int `form:"pageSize"`
PageNo int `form:"pageNo"`
ReviewsPageSize int `form:"reviewsPageSize"`
ReviewsPageNo int `form:"reviewsPageNo"`
}
type DevListAppsAndReviewsRsp struct {
Total int `json:"total"`
List []AppsAndReviewRspItem `json:"list"`
}
type ReviewsRsp struct {
Total int `json:"total"`
List []ReviewsRspItem `json:"list"`
}
type AppsAndReviewRspItem struct {
AppId string `json:"appId"`
Name string `json:"name"`
Logo string `json:"logo"`
Version string `json:"version"`
Status string `json:"status"`
ReviewTotal int `json:"reviewTotal"`
ReviewList []ReviewsRspItem `json:"reviewList"`
}
type ReviewsRspItem struct {
Sequence int `json:"sequence"`
Status string `json:"status"`
Version string `json:"version"`
}
func (as *AppService) ListAppAndReviews(ctx context.Context, appId string, pageNo, pageSize int) (interface{}, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
total, appVers, err := as.appRepo.ListAppVersByAppId(ctx, appId, pageNo, pageSize)
if err != nil {
log.Errorf("ListAppVers err:%s", err.Error())
return gin.H{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
rspData := ReviewsRsp{}
rspData.List = make([]ReviewsRspItem, 0)
for _, v := range appVers {
reviewInfo := ReviewsRspItem{}
reviewInfo.Status = v.Status.Value
reviewInfo.Sequence = v.Sequence
reviewInfo.Version = v.Version
rspData.List = append(rspData.List, reviewInfo)
}
rspData.Total = total
return rspData, rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) GetAppsByAppIds(ctx context.Context, appIds []string) ([]entity.App, error) {
return as.appRepo.GetAppsByAppIds(ctx, appIds)
}
func (as *AppService) GetAppsToBinding(ctx context.Context, req apiproto.ListAppsToBindReq) (int, []entity.App, error) {
return as.appRepo.GetAppsToBinding(ctx, req.BindingId, req.PageNo, req.PageSize, req.SearchText)
}
func (as *AppService) GetLinkAppsByBindingID(ctx context.Context, bindingId string, pageNo, pageSize int, searchText string) (int, []entity.App, error) {
return as.appRepo.GetLinkAppsByBindingId(ctx, bindingId, pageNo, pageSize, searchText)
}
func (as *AppService) GetLinkAppsBySDKKey(ctx context.Context, sdkKey string, pageNo, pageSize int) (int, []entity.App, error) {
return as.appRepo.GetLinkAppsBySDKKey(ctx, sdkKey, pageNo, pageSize)
}
func (as *AppService) AdminGetLinkApps(ctx context.Context, searchText string, pageNo, pageSize int) (int, interface{}, error) {
return as.appRepo.AdminGetLinkApps(ctx, pageNo, pageSize, searchText)
}
func (as *AppService) AdminGetAppReviews(ctx context.Context, req apiproto.AdminGetAppReviewsReq) (int, []entity.AppVersion, error) {
return as.appRepo.GetAppReviews(ctx, req)
}
func (as *AppService) UpdateGrayPubStatus(ctx context.Context, appId string, seq int, status bool) error {
return as.appRepo.UpdateGrayStatus(ctx, appId, seq, status)
}
func (as *AppService) GetAppInfo(ctx context.Context, appId string) (entity.App, error) {
return as.appRepo.GetAppInfo(ctx, appId)
}
func (as *AppService) ListAppVer(ctx context.Context, appId string, pageNo, pageSize int) (int, []entity.AppVersion, error) {
return as.appRepo.ListAppVersByAppId(ctx, appId, pageNo, pageSize)
}
func (as *AppService) AdminListAppVer(ctx context.Context, pageNo, pageSize int, searchText, t string, groupId string) (int, []entity.AppVersion, error) {
return as.appRepo.ListAppVers(ctx, pageNo, pageSize, searchText, t, groupId)
}
func (as *AppService) UpdateBuildInfo(ctx context.Context, c *gin.Context, userId string, req apiproto.UpdateAppInfoReq) error {
accountInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("UpdateBuildInfo err:%s", err.Error())
return err
}
oper := accountInfo.Account
reqFrom := c.GetHeader("C-Open-Api")
if reqFrom != "" {
req.Username = reqFrom
oper = reqFrom
}
info := entity.AppBuildInfo{
Id: bson.NewObjectId().Hex(),
BuildInfoId: req.BuildInfoId,
AppID: req.AppId,
Source: entity.APP_BUILD_SOURCE_BUILD,
Version: req.UpInfo.Version,
//VersionDescription: req.UpInfo.CustomData.VersionDescription,
GroupID: accountInfo.OrganId,
UserId: req.UserId,
Created: utils.GetNowMs(),
CreatedBy: req.Username,
CustomData: req.UpInfo.CustomData,
Status: true,
StartParams: entity.AppStartParams{},
}
info.CustomData.Developer = oper
err = as.buildRepo.Insert(ctx, info)
if err != nil {
log.Errorf("insert build info err:%s", err.Error())
return err
}
//操作日志
logExp := make(map[string]interface{})
go hCaller.AddOperateLog(c, info.GroupID, kafka.GenContent(kafka.APP_EDIT_INFO_LOG, req.UpInfo.Version, info.AppID), logExp, oper)
return nil
}
type GetAppClassPerRspItem struct {
AppClass string `json:"appClass"`
AppClassName string `json:"appClassName"`
Count int `json:"count"`
}
type GetAppClassPerRsp struct {
List []GetAppClassPerRspItem `json:"list"`
}
func (as *AppService) GetAppClassPer(ctx context.Context, status string) (*GetAppClassPerRsp, error) {
rspList, err := as.appRepo.GetAppClassPer(ctx, status)
if err != nil {
return nil, err
}
rspData := GetAppClassPerRsp{}
rspData.List = make([]GetAppClassPerRspItem, 0)
for _, v := range rspList {
item := GetAppClassPerRspItem{
AppClass: v.Class,
Count: v.Count,
}
if len(v.Name) > 0 {
item.AppClassName = v.Name[0]
}
rspData.List = append(rspData.List, item)
}
return &rspData, nil
}
type GetGrayStatisticsVerListRspListItem struct {
PubTime int64 `json:"pub_time"`
UnPubTime int64 `json:"un_pub_time"`
Version int `json:"version"`
VersionStr string `json:"version_str"`
}
type GetGrayStatisticsVerListRsp struct {
Total int `json:"total"`
List []GetGrayStatisticsVerListRspListItem `json:"list"`
}
func (as *AppService) GetGrayStatisticsVerList(ctx context.Context, appId string, ver int, beginTime, endTime int64) (GetGrayStatisticsVerListRsp, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
num, verInfoList, err := as.appRepo.GetGrayStatisticsVerList(ctx, appId, ver, beginTime, endTime)
if err != nil {
log.Errorf("GetGrayStatisticsVerList err:%s", err.Error())
if repository.NotFound(err) {
return GetGrayStatisticsVerListRsp{Total: 0, List: make([]GetGrayStatisticsVerListRspListItem, 0)}, rsp
}
return GetGrayStatisticsVerListRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
log.Debugf("GetGrayStatisticsVerList num:%d,err:%+v,ver list:%+v", num, err, verInfoList)
rspData := GetGrayStatisticsVerListRsp{
List: make([]GetGrayStatisticsVerListRspListItem, 0),
}
for _, v := range verInfoList {
item := GetGrayStatisticsVerListRspListItem{}
item.PubTime = v.PublishedStatus.LastUpdated
item.UnPubTime = v.UnpublishedStatus.LastUpdated
item.Version = v.Sequence
item.VersionStr = v.Version
rspData.List = append(rspData.List, item)
}
rspData.Total = num
return rspData, rsp
}
type InternalGetAppVerInfoRsp struct {
AppID string `json:"appId"`
Name string `json:"name"`
Sequence int `json:"sequence"`
AppClass string `json:"appClass"`
AppTag []string `json:"appTag"`
AppType string `json:"appType"`
Status proto.AppRspStatus `json:"status"`
DeveloperID string `json:"developerId"`
DeveloperStatus int `json:"developerStatus"`
GroupID string `json:"groupId"`
GroupName string `json:"groupName"`
Created int64 `json:"created"`
CreatedBy string `json:"createdBy"`
CustomData proto.AppRspCustomData `json:"customData"`
Version string `json:"version"`
CorporationID string `json:"corporationId"`
CoreDescription string `json:"coreDescription"`
Logo string `json:"logo"`
GroupStatus int `json:"groupStatus,omitempty"` //todo：目前在缓存中,会返回给客户
InGrayRelease bool `json:"inGrayRelease"` //是否在灰度发布中
IsTemp bool `json:"isTemp"`
NeedCrt bool `json:"needCrt"`
WechatLoginInfo proto.WechatLoginInfo `json:"wechatLoginInfo"`
PrivacySettingType int `json:"privacySettingType"`
ProjectType int `json:"projectType"`
}
func (as *AppService) OpenApiGetAppVerInfo(ctx context.Context, appId string, sequence int, sdkVer string) (InternalGetAppVerInfoRsp, *utility.SvrRsp) {
log.Infof("OpenApiGetAppVerInfo appId:%s,sequence:%d,sdkver:%s", appId, sequence, sdkVer)
rsp := utility.DefaultSvrRsp()
tempRspInfo, err := as.getTempAppInfo(ctx, appId, sequence)
log.Debugf("getTempAppInfo rsp:%+v,err:%+v", tempRspInfo, err)
if err == nil {
return tempRspInfo, rsp
}
//if sequence != 0 {
// appVerCacheRspInfo, err := as.openApiGetAppVerInfoFromCache(ctx, appId, sequence, sdkVer)
// if err == nil {
// return appVerCacheRspInfo, http.StatusOK, common.OK
// }
//}
return as.openApiGetAppVerInfoNoCache(ctx, appId, sequence, sdkVer)
}
func (as *AppService) getTempAppBuildInfo(ctx context.Context, codeId string) (*pb.BuildAppInfo, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
tempRspInfo, err := as.getTempAppInfo(ctx, codeId, 1)
log.Infof("getTempAppInfo rsp:%+v,err:%+v", tempRspInfo, err)
if err != nil {
log.Errorf("getTempAppInfo err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
appInfo, err := as.appRepo.GetAppInfo(ctx, tempRspInfo.AppID)
if err != nil && !NotFound(err) {
log.Errorf("GetTrialInfo GetAppInfo err:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appInfo.AppTag) > 0 {
for _, v := range appInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
buildInfo := new(pb.BuildAppInfo)
buildInfo.CodeId = codeId
buildInfo.CoreDescription = tempRspInfo.CoreDescription
buildInfo.Created = tempRspInfo.Created
buildInfo.CreatedBy = tempRspInfo.CreatedBy
buildInfo.CustomData = ConvertRpcCustomDataToPb(tempRspInfo.CustomData)
buildInfo.CustomData.AppRuntimeDomain = new(pb.AppRuntimeDomain)
buildInfo.GroupId = tempRspInfo.GroupID
buildInfo.GroupName = tempRspInfo.GroupName
buildInfo.Logo = tempRspInfo.Logo
buildInfo.Name = tempRspInfo.Name
buildInfo.Version = tempRspInfo.Version
buildInfo.IsTemp = true
buildInfo.NeedCrt = tempRspInfo.NeedCrt
buildInfo.AppId = tempRspInfo.AppID
buildInfo.AppTag = appTagArr
buildInfo.PrivacySettingType = int32(appInfo.PrivacySettingType)
buildInfo.ProjectType = int32(tempRspInfo.ProjectType)
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, tempRspInfo.AppID)
if err == nil {
buildInfo.WechatLoginInfo = ConvertWechatLoginInfoToPb(wechatLoginInfo)
//return nil, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
return buildInfo, rsp.SetLoc(http.StatusOK, utility.OK)
}
func (as *AppService) getTempAppInfo(ctx context.Context, appId string, seq int) (InternalGetAppVerInfoRsp, error) {
rspInfo := InternalGetAppVerInfoRsp{}
//首先判断是否在临时表中
appTempInfo, err := as.tempAppRepo.GetInfoByAppIdAndSeq(ctx, appId, seq)
if err != nil {
return rspInfo, err
}
rspInfo = InternalGetAppVerInfoRsp{
AppID: appTempInfo.AppID,
Name: appTempInfo.Name,
Sequence: appTempInfo.Sequence,
AppClass: appTempInfo.AppClass,
AppType: appTempInfo.AppType,
Status: proto.AppRspStatus{
Value: appTempInfo.Status.Value,
Reason: appTempInfo.Status.Reason,
LastUpdated: appTempInfo.Status.LastUpdated,
ModifiedBy: appTempInfo.Status.ModifiedBy,
},
DeveloperID: appTempInfo.DeveloperID,
GroupID: appTempInfo.GroupID,
GroupName: "",
Created: appTempInfo.Created,
CreatedBy: appTempInfo.CreatedBy,
Version: appTempInfo.Version,
CoreDescription: appTempInfo.CoreDescription,
Logo: appTempInfo.Logo,
ProjectType: appTempInfo.ProjectType,
}
rspInfo.CustomData.DetailDescription = appTempInfo.CustomData.DetailDescription
rspInfo.CustomData.VersionDescription = appTempInfo.CustomData.VersionDescription
rspInfo.CustomData.AppRuntimeDomain.Business.Domains = []string{} // = domainData.Business
rspInfo.CustomData.AppRuntimeDomain.Service.Request = []string{} // = domainData.Service
rspInfo.CustomData.AppRuntimeDomain.Service.Socket = []string{}
rspInfo.CustomData.AppRuntimeDomain.Service.Download = []string{}
rspInfo.CustomData.AppRuntimeDomain.Service.Upload = []string{}
rspInfo.CustomData.AppRuntimeDomain.Whitelist.Domains = []string{} // = domainData.Whitelist
rspInfo.CustomData.AppRuntimeDomain.Blacklist.Domains = []string{}
rspInfo.CustomData.SourceFile = make([]proto.RspCustomDataSourceFile, 0)
if len(appTempInfo.CustomData.SourceFile) > 0 {
temp := appTempInfo.CustomData.SourceFile[0]
item := proto.RspCustomDataSourceFile{}
item.SourceFileUrl = ""
item.FileMd5 = temp.FileMd5
item.Url = temp.Url
item.UploadDate = temp.UploadDate
item.Name = temp.Name
item.BasicPackVer = temp.BasicPackVer
item.Packages = convertPackages2(temp.EncryptPackages)
rspInfo.CustomData.SourceFile = append(rspInfo.CustomData.SourceFile, item)
}
rspInfo.IsTemp = true
rspInfo.NeedCrt = false
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, appId)
if err == nil {
rspInfo.WechatLoginInfo = *wechatLoginInfo
//return rspInfo, errors.New("get wechatLoginInfo err")
}
return rspInfo, nil
}
func (as *AppService) openApiGetAppVerInfoFromCache(ctx context.Context, appId string, sequence int, sdkVer string) (InternalGetAppVerInfoRsp, error) {
return InternalGetAppVerInfoRsp{}, nil
//verCache := cache.NewAppVerCache()
//cacheInfoByte, err := verCache.Get(ctx, avs.genOpenApiCacheKey(appId, sequence))
//if err != nil {
// log.Warnf("cache get app ver info err:[%s],app id:[%s],seq:[%d]", err.Error(), appId, sequence)
// return nil, err
//}
////走缓存
//log.Debugf("AppVerService OpenApiGetAppVerInfo in cache ...")
//cacheRspInfo := OpenApiAppVerCacheInfo{}
//err = json.Unmarshal(cacheInfoByte, &cacheRspInfo)
//if err != nil {
// return nil, err
//}
//
//rspInfo := InternalGetAppVerInfoRsp{
// AppID: cacheRspInfo.AppID,
// Name: cacheRspInfo.Name,
// Sequence: cacheRspInfo.Sequence,
// AppClass: cacheRspInfo.AppClass,
// AppType: cacheRspInfo.AppType,
// Status: cacheRspInfo.Status,
// DeveloperID: cacheRspInfo.DeveloperID,
// DeveloperStatus: cacheRspInfo.DeveloperStatus,
// GroupID: cacheRspInfo.GroupID,
// GroupName: cacheRspInfo.GroupName,
// Created: cacheRspInfo.Created,
// CreatedBy: cacheRspInfo.CreatedBy,
// Version: cacheRspInfo.Version,
// CorporationID: cacheRspInfo.CorporationID,
// CoreDescription: cacheRspInfo.CoreDescription,
// Logo: cacheRspInfo.Logo,
// InGrayRelease: cacheRspInfo.InGrayRelease,
//}
//
//err, _, customData := ConvertModelCustomDataToRpc(ctx, avs, cacheRspInfo.GroupID, cacheRspInfo.CustomData, &cacheRspInfo.DomainData, sdkVer)
//if err != nil {
// log.Errorf("openApiGetAppVerInfoFromCache ConvertModelCustomDataToRpc err:[%s]", err.Error())
// return nil, err
//}
//rspInfo.CustomData = *customData
//rspInfo.IsTemp = false
//rspInfo.NeedCrt = cacheRspInfo.DomainData.NeedCrt
//return &rspInfo, nil
}
func (as *AppService) openApiGetAppVerInfoNoCache(ctx context.Context, appId string, sequence int, sdkVer string) (InternalGetAppVerInfoRsp, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
if sequence == 0 {
return as.GetInDevApp(ctx, appId, sdkVer)
}
appVer, err := as.appRepo.GetAppVerInfo(ctx, appId, sequence)
if err != nil {
log.Errorf("InternalGetAppVerInfo get appVer info err:%s", err.Error())
if repository.NotFound(err) {
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusNotFound, utility.FS_APP_SEQUENCE_NOT_FOUND)
}
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
//校验企业的状态
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appVer.GroupID)
log.Infof("get groupInfo error:%+v,groupInfo:%+v", err, groupInfo)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger group info err:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("InternalGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_COOPERATION_TERMINATED)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("InternalGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_COOPERATION_TERMINATED)
}
}
//获取域名
domainData, err := hCaller.GetDomainInfoByOrganId(ctx, appVer.GroupID)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger domain info err:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_DOMAIN_INFO_ERROR)
}
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("as.appRepo.GetAppInfo err:%s", err.Error())
if repository.NotFound(err) {
log.Errorf("get appVer not found!")
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appVer.AppTag) > 0 {
for _, v := range appVer.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
log.Debugln("AppTag:", appTagArr)
rspInfo := InternalGetAppVerInfoRsp{
AppID: appVer.AppID,
Name: appVer.Name,
Sequence: appVer.Sequence,
AppClass: appVer.AppClass,
AppTag: appTagArr,
AppType: appVer.AppType,
Status: proto.AppRspStatus{
Value: appVer.Status.Value,
Reason: appVer.Status.Reason,
LastUpdated: appVer.Status.LastUpdated,
ModifiedBy: appVer.Status.ModifiedBy,
},
DeveloperID: appVer.DeveloperID,
GroupID: appVer.GroupID,
GroupName: groupInfo.GroupName,
Created: appVer.Created,
CreatedBy: appVer.CreatedBy,
Version: appVer.Version,
CorporationID: appVer.CorporationID,
CoreDescription: appVer.CoreDescription,
Logo: appVer.Logo,
InGrayRelease: appVer.InGrayRelease,
PrivacySettingType: appInfo.PrivacySettingType,
ProjectType: appInfo.ProjectType,
}
err, errCode, customData := ConvertModelCustomDataToRpc(ctx, appVer.GroupID, appVer.CustomData, domainData, sdkVer)
if err != nil {
log.Errorf("openApiGetAppVerInfoFromCache ConvertModelCustomDataToRpc err:[%s]", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, errCode)
}
status := getAccountStatus(groupInfo)
rspInfo.CustomData = *customData
rspInfo.GroupStatus = groupInfo.ReviewStatus
rspInfo.IsTemp = false
rspInfo.NeedCrt = domainData.NeedCrt
rspInfo.DeveloperStatus = status
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, appId)
if err == nil {
rspInfo.WechatLoginInfo = *wechatLoginInfo
//return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
log.Debugf("rsp info:%+v", rspInfo)
return rspInfo, rsp
}
//兼容之前sequence为0的情况
func (as *AppService) GetInDevApp(ctx context.Context, appId, sdkVer string) (InternalGetAppVerInfoRsp, *utility.SvrRsp) {
rsp := utility.DefaultSvrRsp()
app, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("openApiGetAppVerInfoNoCache GetAppInfo err:%,appId:[%]", err.Error(), appId)
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
buildInfo, err := as.buildRepo.GetLatestInfoByAppId(ctx, appId)
if err != nil {
log.Errorf("openApiGetAppVerInfoNoCache GetLatestInfoByAppId err:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
log.Debugf("GetInDevApp buildInfo:%+v", buildInfo)
//校验企业的状态
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, app.GroupID)
log.Infof("get groupInfo error:%+v,groupInfo:%+v", err, groupInfo)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger group info err:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("InternalGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_COOPERATION_TERMINATED)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("InternalGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_COOPERATION_TERMINATED)
}
}
//获取域名
domainData, err := hCaller.GetDomainInfoByOrganId(ctx, app.GroupID)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger domain info err:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_DOMAIN_INFO_ERROR)
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(app.AppTag) > 0 {
for _, v := range app.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
rspInfo := InternalGetAppVerInfoRsp{
AppID: app.AppID,
Name: app.Name,
Sequence: app.Sequence,
AppClass: app.AppClass,
AppType: app.AppType,
Status: proto.AppRspStatus{
Value: app.Status.Value,
Reason: app.Status.Reason,
LastUpdated: app.Status.LastUpdated,
ModifiedBy: app.Status.ModifiedBy,
},
DeveloperID: app.DeveloperID,
GroupID: app.GroupID,
GroupName: groupInfo.GroupName,
Created: app.Created,
CreatedBy: app.CreatedBy,
Version: buildInfo.Version,
CorporationID: app.GroupID,
CoreDescription: app.CoreDescription,
Logo: app.Logo,
InGrayRelease: false,
AppTag: appTagArr,
PrivacySettingType: app.PrivacySettingType,
ProjectType: app.ProjectType,
}
err, errCode, customData := ConvertModelCustomDataToRpc(ctx, app.GroupID, buildInfo.CustomData, domainData, sdkVer)
if err != nil {
log.Errorf("openApiGetAppVerInfoFromCache ConvertModelCustomDataToRpc err:[%s]", err.Error())
return InternalGetAppVerInfoRsp{}, rsp.SetLoc(http.StatusInternalServerError, errCode)
}
status := getAccountStatus(groupInfo)
rspInfo.CustomData = *customData
rspInfo.GroupStatus = groupInfo.ReviewStatus
rspInfo.IsTemp = false
rspInfo.NeedCrt = domainData.NeedCrt
rspInfo.DeveloperStatus = status
log.Debugf("rsp info:%+v", rspInfo)
return rspInfo, rsp
}
func (as *AppService) UpExpire(ctx context.Context, appId string, expire int64) *utility.SvrRsp {
rsp := utility.DefaultSvrRsp()
err := as.appRepo.UpdateExpire(ctx, appId, expire)
if err != nil {
log.Errorf("AppService UpExpire err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
/*err = as.appRepo.UpdateExpireAppVersion(ctx, appId, 0, expire)
if err != nil {
log.Errorf("AppService UpExpire err:%s", err.Error())
return rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}*/
return rsp.SetLoc(http.StatusOK, utility.OK)
}
type RuntimeGetAppResponse struct {
AppID string `json:"appId" bson:"appId"`
Name string `json:"name" bson:"name"`
Sequence int `json:"sequence" bson:"sequence"`
AppClass string `json:"appClass" bson:"appClass"`
AppTag []string `json:"appTag" bson:"appTag"`
AppType string `json:"appType" bson:"appType"`
DeveloperID string `json:"developerId" bson:"developerId"`
DeveloperStatus int `json:"developerStatus" bson:"developerStatus"`
GroupID string `json:"groupId" bson:"groupId"`
GroupName string `json:"groupName" bson:"groupName"`
Created int64 `json:"created" bson:"created"`
CreatedBy string `json:"createdBy" bson:"createdBy"`
CustomData proto.AppRspCustomData `json:"customData" bson:"customData"`
Version string `json:"version" bson:"version"`
CorporationID string `json:"corporationId" bson:"corporationId"`
CoreDescription string `json:"coreDescription" bson:"coreDescription"`
Logo string `json:"logo" bson:"logo"`
Status proto.AppRspStatus `json:"status" bson:"status"`
InGrayRelease bool `json:"inGrayRelease" bson:"inGrayRelease"` //是否在灰度发布中
IsTemp bool `json:"isTemp"`
NeedCrt bool `json:"needCrt"` //是否需要校验域名证书
WechatLoginInfo proto.WechatLoginInfo `json:"wechatLoginInfo"`
PrivacySettingType int `json:"privacySettingType"`
ProjectType int `json:"projectType"`
}
func (as *AppService) RuntimeGetPubAppInfo(ctx context.Context, sdkKey, appId, sdkVer string) (RuntimeGetAppResponse, *utility.SvrRsp) {
resp := &RuntimeGetAppResponse{}
rsp := utility.DefaultSvrRsp()
inWhiteList := utility.InArry(sdkKey, config.WhiteSDKArry)
//未命中缓存
start := time.Now()
log.Infof("RuntimeGetPubAppInfo from cache no match ... ")
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("RuntimeGetPubAppInfo GetAppInfo err:%s", err.Error())
if repository.NotFound(err) {
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusNotFound, utility.FS_APP_ID_NOT_FOUND)
}
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if appInfo.IsForbidden == 1 {
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_IS_FORBIDDEN)
}
app, err := as.appRepo.GetOnlineAppVer(ctx, appId)
if err != nil {
if repository.NotFound(err) {
log.Errorf("RuntimeGetPubAppInfo get info app status invalid,appId:%s", appId)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_SERVICE_UNAVAILABLE)
}
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
log.Debugf("RuntimeGetPubAppInfo online app:%+v", app)
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appInfo.AppTag) > 0 {
for _, v := range appInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
//支付信息过期校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
appStatus, err := as.CheckIdStatus(ctx, appId)
if err != nil {
log.Errorf("CheckIdStatus err:%s,appId:%s", err.Error(), appId)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if appStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("check purch status no ok ")
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_PAY_EXPIRE)
}
}
//获取机构信息
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, app.GroupID)
if err != nil {
log.Errorf("Failed to call GetGroupInfoByUserId: %v", err)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
status := getAccountStatus(groupInfo)
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("group review status no ok ")
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("group review status no ok ")
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
}
//获取域名信息
domainData, err := hCaller.GetAppDomainByOrganId(ctx, app.GroupID)
if err != nil {
log.Errorf("Failed to call GetDomainInfo: %v", err)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
//应用状态信息校验
if !inWhiteList {
//首先判断sdkKey是否存在
var bindingInfo *entity.Binding
bindingInfo, err = as.bindingRepo.GetBindingByGroupIdAndSdkKey(ctx, app.GroupID, sdkKey)
if err != nil {
log.Errorf("GetBindingByGroupIdAndSdkKey err:%s", err.Error())
if repository.NotFound(err) {
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_SIGNATURE_SDKKEY_INVAILD)
}
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if bindingInfo.CooperateStatus.Value != entity.StBindValid {
log.Errorf("binding coop stats valid,appId:%s,sdkKey:%s", appId, sdkKey)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_COOPERATION_TERMINATED)
}
for _, v := range bindingInfo.BundleInfos {
if v.SDKKey == sdkKey && v.IsForbidden == 1 {
log.Errorf("bundleInfo is forbidden", bindingInfo)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
}
isAppAssBind := false
for _, v := range bindingInfo.AppInfos {
if v.AppID == appId {
isAppAssBind = true
}
}
if !isAppAssBind {
log.Errorf("app id not ass binding,appId:%s,sdkKey:%s", appId, sdkKey)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
//支付信息校验
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
bindStatus, err := as.CheckIdStatus(ctx, bindingInfo.BindingID)
if err != nil {
log.Errorf("CheckIdStatus err:%s,bindingId:%s", err.Error(), bindingInfo.BindingID)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if bindStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("binding pay check no ok,bingdingId:%s", bindingInfo.BindingID)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_BIND_PAY_EXPIRE)
}
}
}
if GetLicenseValid() != LICENSE_IS_VALID {
log.Errorf("license valid no ok ... ")
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_LICENSE_INVALID_ERR)
}
//返回数据
err = covertAppToRsp(ctx, &app, resp, sdkVer, domainData)
if err != nil {
log.Errorf("covertAppToRsp err:%s", err.Error())
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
resp.GroupName = groupInfo.GroupName
resp.DeveloperStatus = status
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, appId)
if err == nil {
resp.WechatLoginInfo = *wechatLoginInfo
//return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
resp.AppTag = appTagArr
resp.PrivacySettingType = appInfo.PrivacySettingType
resp.ProjectType = appInfo.ProjectType
log.Infof("resp:%v", resp)
fmt.Println("RuntimeGetPubAppInfo get app no cache time consum:", time.Since(start))
return *resp, rsp.SetLoc(http.StatusOK, utility.OK)
}
//type RuleEngineGetAppVerInfoRsp struct {
// AppID string `json:"appId"`
// Name string `json:"name"`
// Sequence int `json:"sequence"`
// AppClass string `json:"appClass"`
// AppType string `json:"appType"`
// DeveloperID string `json:"developerId"`
// DeveloperStatus int `json:"developerStatus"`
// GroupID string `json:"groupId"`
// GroupName string `json:"groupName"`
// Created int64 `json:"created"`
// CreatedBy string `json:"createdBy"`
// CustomData proto.AppRspCustomData `json:"customData"`
// Version string `json:"version"`
// CorporationID string `json:"corporationId"`
// CoreDescription string `json:"coreDescription"`
// Logo string `json:"logo"`
// Status proto.AppRspStatus `json:"status"`
// InGrayRelease bool `json:"inGrayRelease"` //是否在灰度发布中
// IsTemp bool `json:"isTemp"`
// NeedCrt bool `json:"needCrt"`
//}
func (as *AppService) RuleEngineGetAppVerInfo(ctx context.Context, appId string, sequence int, sdkKey, sdkVer string) (RuntimeGetAppResponse, *utility.SvrRsp) {
//appVerCache := cache.NewAppVerCache()
//appVerCacheInfoByte, err := appVerCache.Get(ctx, avs.genRuleEngineCacheKey(appId, sequence))
//if err == nil {
// log.Infof("RuleEngineGetAppVerInfo in cache ...")
// appVerInfo := RuleEngineAppVerCacheInfo{}
// err = json.Unmarshal(appVerCacheInfoByte, &appVerInfo)
// if err == nil {
// //判断是否关联
// if _, ok := appVerInfo.BindStatus[sdkKey]; ok {
// rsp, err := avs.covertCacheToRuleEngineRsp(ctx, &appVerInfo, sdkVer)
// if err != nil {
// log.Errorf("covertCacheToRuleEngineRsp err:%s", err.Error())
// return nil, http.StatusInternalServerError, common.FS_SYSTEM_CALL
// }
// return rsp, http.StatusOK, common.OK
// }
// }
//}
//未命中缓存
resp := RuntimeGetAppResponse{}
rsp := utility.DefaultSvrRsp()
//首先校验licesne
if GetLicenseValid() != LICENSE_IS_VALID {
log.Errorf("RuleEngineGetAppVerInfo get info license invalid,sdkKey:%s,appId:%s,sequence:%d", sdkKey, appId, sequence)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_LICENSE_INVALID_ERR)
}
appVer, err := as.appRepo.GetAppVerInfo(ctx, appId, sequence)
if err != nil {
log.Errorf("GetAppVerInfo err:%s", err.Error())
if repository.NotFound(err) {
return resp, rsp.SetLoc(http.StatusNotFound, utility.FS_APP_SEQUENCE_NOT_FOUND)
}
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
//校验企业的状态，非法状态不放入缓存
log.Infof("get group info id:%s", appVer.GroupID)
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appVer.GroupID)
log.Infof("get groupInfo error:%+v,groupInfo:%+v", err, groupInfo)
if err != nil {
log.Errorf("RuleEngineGetAppVerInfo ger group info err:%s", err.Error())
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_GROUP_FAILED)
}
status := getAccountStatus(groupInfo)
if config.Cfg.IsUatEnv() {
if !hCaller.UatOrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("RuleEngineGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
} else {
if !hCaller.OrganStatusIsValid(groupInfo.ReviewStatus) {
log.Errorf("RuleEngineGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_ORGAN_STATUS_INVALID)
}
}
//if !avs.isOrganValid(groupInfo.ReviewStatus) {
// log.Errorf("RuleEngineGetAppVerInfo group ReviewStatus invalid,status:%v", groupInfo.ReviewStatus)
// return nil, http.StatusForbidden, common.FS_ORGAN_STATUS_INVALID
//}
inWhiteList := utility.InArry(sdkKey, config.WhiteSDKArry)
if !inWhiteList {
//校验应用关联状态，非法状态不放入缓存
binds, err := as.bindingRepo.GetBindingByGroupIdAndSdkKey(ctx, appVer.GroupID, sdkKey)
if err != nil {
log.Errorf("GetBindingByGroupIdAndSdkKey err:%s,GroupID:%s,sdkKey:%s", err.Error(), appVer.GroupID, sdkKey)
if repository.NotFound(err) {
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_SIGNATURE_SDKKEY_INVAILD)
}
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_DB_ERR)
}
if binds.CooperateStatus.Value != entity.StBindValid {
log.Errorf("RuleEngineGetAppVerInfo CooperateStatus invalid:%s", binds.CooperateStatus.Value)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_COOPERATION_TERMINATED)
}
for _, v := range binds.BundleInfos {
if v.SDKKey == sdkKey && v.IsForbidden == 1 {
log.Errorf("bundleInfo is forbidden", binds)
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
}
isAppAssBinding := false
for _, v := range binds.AppInfos {
if v.AppID == appId {
isAppAssBinding = true
}
}
if !isAppAssBinding {
log.Errorf("RuleEngineGetAppVerInfo get binding info no ass app,appId:%s,sdkKey:%s", appId, sdkKey)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_NOT_ASS_BIND)
}
//校验应用支付状态
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
bindStatus, err := as.CheckIdStatus(ctx, binds.BindingID)
if err != nil {
log.Errorf("RuleEngineGetAppVerInfo get bind id pay status err:%s", err.Error())
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if bindStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("GetGrayAppInfo get info bind pay status invaild,bind id:%s", binds.BindingID)
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_BIND_PAY_EXPIRE)
}
}
}
//校验小程序的上架状态
if appVer.Status.Value != entity.StPublished && !appVer.InGrayRelease {
log.Errorf("RuleEngineGetAppVerInfo appVer status invalid:%s", appVer.Status.Value)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_SERVICE_UNAVAILABLE)
}
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("RuleEngineGetAppVerInfo GetAppInfo err:%s", err.Error())
if repository.NotFound(err) {
return resp, rsp.SetLoc(http.StatusNotFound, utility.FS_APP_ID_NOT_FOUND)
}
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if appInfo.IsForbidden == 1 {
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_IS_FORBIDDEN)
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SERVER_ERR)
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagArr := make([]string, 0)
if len(appInfo.AppTag) > 0 {
for _, v := range appInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagArr = append(appTagArr, tag.Name)
}
}
}
}
//校验支付状态
if config.Cfg.OpenPurchAuth && config.Cfg.IsUatEnv() {
//先校验小程序
appStatus, err := as.CheckIdStatus(ctx, appId)
if err != nil {
log.Errorf("RuleEngineGetAppVerInfo get app id pay status err:%s", err.Error())
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
if appStatus == httpcall.PAY_ID_STATUS_EXPIRE {
log.Errorf("RuleEngineGetAppVerInfo get info app pay status invaild,appId:%s", appId)
return resp, rsp.SetLoc(http.StatusForbidden, utility.FS_APP_PAY_EXPIRE)
}
}
//获取域名
domainData, err := hCaller.GetDomainInfoByOrganId(ctx, appVer.GroupID)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger domain info err:%s", err.Error())
return resp, rsp.SetLoc(http.StatusInternalServerError, utility.FS_GET_DOMAIN_INFO_ERROR)
}
err = covertAppToRsp(ctx, &appVer, &resp, sdkVer, domainData)
if err != nil {
log.Errorf("covertAppToRsp err:%s", err.Error())
return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
resp.DeveloperStatus = status
resp.GroupName = groupInfo.GroupName
resp.PrivacySettingType = appInfo.PrivacySettingType
resp.ProjectType = appInfo.ProjectType
resp.AppTag = appTagArr
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, appId)
if err == nil {
resp.WechatLoginInfo = *wechatLoginInfo
//return RuntimeGetAppResponse{}, rsp.SetLoc(http.StatusInternalServerError, utility.FS_SYSTEM_CALL)
}
return resp, rsp
}
func (as *AppService) CheckIdStatus(ctx context.Context, id string) (int, error) {
return httpcall.PAY_ID_STATUS_USING, nil
/*switch config.Cfg.ReqType {
//case "grpc":
// return grpcClient.PurchasingGetIdStatus(ctx, id)
default:
status, _, err := hCaller.PayCheckIdStatus(ctx, id)
return status, err
}*/
}
func (as *AppService) BatchAppsByIdentity(ctx context.Context, sdkKey string, req *apiproto.BatchAppsByIdentityReq) *pb.BatchAppsByIdentityRsp {
var (
rsp = new(pb.BatchAppsByIdentityRsp)
)
rsp.Data = new(pb.BatchAppsByIdentityRsp_DATA)
rsp.Data.AppList = make([]*pb.BatchAppsByIdentityRsp_AppListItem, 0)
rsp.Result = new(pb.CommonResult)
//判断sdkKey是否存在
sdkExi, err := as.bindingRepo.SdkKeyExi(ctx, sdkKey)
if err != nil {
utility.MakeGrpcCommonResult(http.StatusInternalServerError, utility.FS_SYSTEM_CALL, &rsp.Result)
return rsp
}
if !sdkExi {
utility.MakeGrpcCommonResult(http.StatusInternalServerError, utility.FS_BIND_NOT_FOUND, &rsp.Result)
return rsp
}
for _, item := range req.Apps {
rspAppListItem := as.getOneAppByIdentity(ctx, req.IdentityType, item.AppId, item.Identity, sdkKey)
rsp.Data.AppList = append(rsp.Data.AppList, rspAppListItem)
}
utility.MakeGrpcCommonResult(http.StatusOK, utility.OK, &rsp.Result)
return rsp
}
func (as *AppService) IdentityAppsCheck(ctx context.Context, sdkKey string, req *apiproto.IdentityAppsCheckReq) *pb.IdentityAppsCheckRsp {
var (
rsp = new(pb.IdentityAppsCheckRsp)
)
rsp.Data = new(pb.IdentityAppsCheckRsp_DATA)
rsp.Data.AppList = make([]*pb.IdentityAppsCheckRsp_AppListItem, 0)
rsp.Result = new(pb.CommonResult)
//判断sdkKey是否存在
sdkExi, err := as.bindingRepo.SdkKeyExi(ctx, sdkKey)
if err != nil {
utility.MakeGrpcCommonResult(http.StatusInternalServerError, utility.FS_SYSTEM_CALL, &rsp.Result)
return rsp
}
if !sdkExi {
utility.MakeGrpcCommonResult(http.StatusInternalServerError, utility.FS_BIND_NOT_FOUND, &rsp.Result)
return rsp
}
//判断一个小程序identity是否存在
//todo 加个缓存处理
for _, a := range req.Apps {
rspAppListItem := as.getOneAppCheckResult(ctx, a.AppId, a.Identity, req.IdentityType, sdkKey)
rsp.Data.AppList = append(rsp.Data.AppList, rspAppListItem)
}
utility.MakeGrpcCommonResult(http.StatusOK, utility.OK, &rsp.Result)
return rsp
}
func (as *AppService) getOneAppCheckResult(ctx context.Context, appId, identity, identityType, sdkKey string) (rspAppListItem *pb.IdentityAppsCheckRsp_AppListItem) {
rspAppListItem = &pb.IdentityAppsCheckRsp_AppListItem{
Errcode: utility.OK,
Error: utility.GetErrMsg(utility.OK),
Data: &pb.IdentityAppsCheckRsp_AppListItem_AppListItemData{AppId: appId, Identity: identity, IdentityValid: false},
}
defer func() {
rspAppListItem.Error = utility.GetErrMsg(rspAppListItem.Errcode)
}()
//cacheInfo, err := e.erc.GetAppCheckValid(ctx, appId, identity, sdkKey)
//if err == nil {
// log.Debugf("getOneAppCheckResult from cache,info:%+v", cacheInfo)
// rspAppListItem.Data.IdentityValid = cacheInfo.IdentityValid
// rspAppListItem.Errcode = cacheInfo.Errcode
// return rspAppListItem
//}
//defer func() {
//if rspAppListItem.Errcode != utility.FS_SYSTEM_CALL {
//setCacheInfo := &AppCheckCacheInfo{IdentityValid: rspAppListItem.Data.IdentityValid, Errcode: rspAppListItem.Errcode}
//log.Debugf("set app check cache info:%+v", cacheInfo)
//if err = e.erc.SetAppCheckValid(ctx, appId, identity, sdkKey, setCacheInfo); err != nil {
// log.Errorf("SetAppCheckValid err:%s", err.Error())
//}
//}
//}()
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("get app info err:%s", err.Error())
rspAppListItem.Errcode = utility.FS_SYSTEM_CALL
if repository.NotFound(err) {
rspAppListItem.Errcode = utility.FS_APP_ID_NOT_FOUND
}
return rspAppListItem
}
log.Debugf("get app info:%+v", appInfo)
//判断该小程序是否可用
if appInfo.Status.Value != entity.StPublished {
log.Errorf("app info status invalid,sdkKey:[%s],appInfo:%+v", sdkKey, appInfo)
return rspAppListItem
}
//判断企业状态
organInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appInfo.GroupID)
if err != nil {
log.Errorf("get group info err:%s", err.Error())
rspAppListItem.Errcode = utility.FS_SYSTEM_CALL
return rspAppListItem
} else {
if !hCaller.JudgeGroupStatusValid(organInfo.ReviewStatus) {
log.Errorf("gropu status invalid,sdkKey:[%s],appId:[%s]", sdkKey, appId)
rspAppListItem.Errcode = utility.FS_ORGAN_STATUS_INVALID
return rspAppListItem
}
}
//判断是否关联
bindingInfo, err := as.bindingRepo.GetInfoBySdkKeyOrganId(ctx, appInfo.GroupID, sdkKey)
if err != nil {
log.Errorf("get binging info err:%s", err.Error())
rspAppListItem.Errcode = utility.FS_SYSTEM_CALL
if repository.NotFound(err) {
rspAppListItem.Errcode = utility.FS_BIND_NOT_FOUND
}
return rspAppListItem
} else {
if bindingInfo.CooperateStatus.Value == entity.StBindInvalid {
log.Errorf("binding info coop value invalid:%+v,sdkKey:[%s]", bindingInfo, sdkKey)
rspAppListItem.Errcode = utility.FS_COOPERATION_TERMINATED
return rspAppListItem
}
if !repository.IsAssAppId(bindingInfo, appId) {
log.Errorf("binding not ass the appid,sdkKey:[%s],appId:[%s]", sdkKey, appId)
rspAppListItem.Errcode = utility.FS_APP_NOT_ASS_BIND
return rspAppListItem
}
}
//判断版本状态
appVers, err := as.appRepo.GetAppVerLimitByIdentity(ctx, identityType, appId, identity, config.Cfg.CheckAppVerLimit)
if err != nil {
rspAppListItem.Errcode = utility.FS_SYSTEM_CALL
if repository.NotFound(err) {
rspAppListItem.Errcode = utility.FS_IDENTITY_NOT_FOUND_ERR
}
return rspAppListItem
} else {
if len(appVers) == 0 {
rspAppListItem.Errcode = utility.FS_IDENTITY_NOT_FOUND_ERR
return rspAppListItem
}
rspAppListItem.Data.IdentityValid = as.AppVerIsValid(appVers)
}
return rspAppListItem
}
func (as *AppService) getOneAppByIdentity(ctx context.Context, t, appId, identity, sdkKey string) *pb.BatchAppsByIdentityRsp_AppListItem {
rspItem := &pb.BatchAppsByIdentityRsp_AppListItem{
Errcode: utility.OK,
Error: utility.GetErrMsg(utility.OK),
AppId: appId,
Identity: identity,
AppInfo: nil,
ExternalAppStatus: "",
}
defer func() {
rspItem.Error = utility.GetErrMsg(rspItem.Errcode)
}()
appVers, err := as.appRepo.GetAppVerLimitByIdentity(ctx, t, appId, identity, config.Cfg.CheckAppVerLimit)
if err != nil {
rspItem.Errcode = utility.FS_SYSTEM_CALL
if repository.NotFound(err) {
rspItem.Errcode = utility.FS_IDENTITY_NOT_FOUND_ERR
}
return rspItem
}
if len(appVers) == 0 {
rspItem.Errcode = utility.FS_IDENTITY_NOT_FOUND_ERR
return rspItem
}
//从获取到的三个版本列表中取得一个合适的版本
appVer := as.GetConcreteVer(appVers)
if appVer == nil {
rspItem.Errcode = utility.FS_IDENTITY_NOT_FOUND_ERR
return rspItem
}
//判断企业状态
organInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appVer.GroupID)
if err != nil {
rspItem.Errcode = utility.FS_SYSTEM_CALL
return rspItem
} else {
if !hCaller.JudgeGroupStatusValid(organInfo.ReviewStatus) {
rspItem.Errcode = utility.FS_ORGAN_STATUS_INVALID
return rspItem
}
}
//判断是否关联
bindingInfo, err := as.bindingRepo.GetInfoBySdkKeyOrganId(ctx, appVer.GroupID, sdkKey)
log.Debugf("get binding info:%+v", bindingInfo)
if err != nil {
log.Errorf("get binging info err:%s", err.Error())
rspItem.Errcode = utility.FS_SYSTEM_CALL
if repository.NotFound(err) {
rspItem.Errcode = utility.FS_BIND_NOT_FOUND
}
return rspItem
} else {
if bindingInfo.CooperateStatus.Value == entity.StBindInvalid {
rspItem.Errcode = utility.FS_COOPERATION_TERMINATED
return rspItem
}
if !repository.IsAssAppId(bindingInfo, appId) {
rspItem.Errcode = utility.FS_APP_NOT_ASS_BIND
return rspItem
}
}
rspItem.AppInfo = new(pb.AppInfoRspData)
as.tool.CovertAppVerToAppRspData(appVer, rspItem.AppInfo)
//custom 包装
domainInfo, err := hCaller.GetAppDomainByOrganId(ctx, appVer.GroupID) //域名
if err != nil {
log.Errorf("get domain err:%s", err.Error())
} else {
as.tool.PackDomainToAppRspCustom(rspItem.AppInfo, domainInfo)
}
rspItem.AppInfo.CustomData.MenuInfo = nil //菜单
apiData, err := hCaller.GetApiList(ctx, appVer.GroupID) //api管理
if err != nil {
log.Errorf("get api list err:%s", err.Error())
} else {
as.tool.PackApiInfoToAppRspCustom(rspItem.AppInfo, &apiData)
}
rspItem.AppInfo.GroupName = organInfo.GroupName //企业名称
rspItem.ExternalAppStatus = as.getAppVerExternalStatus(appVer.Status.Value, appVer.UnpublishedStatus.Type) //做一个状态的转换
//放入缓存
//e.erc.SetAppVerCacheInfo(ctx, appId, identity, &ExternalAppVerCacheInfo{AppInfo: rspItem.AppInfo, ExternalStatus: rspItem.ExternalAppStatus})
return rspItem
}
func (as *AppService) GetConcreteVer(appVers []entity.AppVersion) *entity.AppVersion {
if len(appVers) == 0 {
return nil
}
appVer := appVers[0]
for _, v := range appVers {
if v.Status.Value == entity.StPublished {
appVer = v
break
}
if v.Status.Value == entity.StUnpublished &&
v.UnpublishedStatus.Type == entity.TypeUnpublishedDueToNewSeq {
appVer = v
break
}
}
return &appVer
}
func (as *AppService) getAppVerExternalStatus(statusValue, unPubType string) string {
//做一个状态的转换
result := ""
switch statusValue {
case entity.StInDevelopment:
result = AppExternalStatusInDevelopment
case entity.StPublishing:
result = AppExternalStatusPublishing
case entity.StPublishWithdrawed:
result = AppExternalStatusPublishWithdrawed
case entity.StPublishApproved:
result = AppExternalStatusPublishApproved
case entity.StPublishRejected:
result = AppExternalStatusPublishRejected
case entity.StPublished:
result = AppExternalStatusPublished
case entity.StUnpublished:
switch unPubType {
case entity.TypeUnpublishedByDev:
result = AppExternalStatusUnpublishedByDev
case entity.TypeUnpublishedByAdmin:
result = AppExternalStatusUnpublishedByAdmin
case entity.TypeUnpublishedDueToNewSeq:
result = AppExternalStatusUnpublishedByNewSeq
}
}
return result
}
/*
* 第一优先级：AppID 为已上架 ，则可继续使用；如下架则全部不允许使用
* 第二优先级：
* 当AppID上架的情况下，MD5对应 已上架 / 系统下架，则允许继续使用；
* 如对应状态为在途（审核中/审核已撤销）的，则向下轮询3个序列号，如果3个序列号中包含 已上架/系统下架，则允许使用；如3个序列号均为在途状态，则返回不可用
* 如为其他状态（不在上述内容内），则返回不可用
*/
func (as *AppService) AppVerIsValid(appVers []entity.AppVersion) bool {
valid := false
for _, appVerInfo := range appVers {
if appVerInfo.Status.Value == entity.StPublishing ||
appVerInfo.Status.Value == entity.StPublishWithdrawed {
continue
}
//首先判断该版本是否可用
if appVerInfo.Status.Value != entity.StPublished &&
appVerInfo.Status.Value != entity.StUnpublished {
log.Errorf("app ver info invalid,app ver:%+v", appVerInfo)
valid = false
break
}
log.Debugf("get app ver info status:%+v", appVerInfo.Status)
//判断该版本下架方式：被运营端下架、被机构端下架、新版本下架
if appVerInfo.Status.Value == entity.StUnpublished {
if appVerInfo.UnpublishedStatus.Type == entity.TypeUnpublishedDueToNewSeq {
valid = true
break
}
}
if appVerInfo.Status.Value == entity.StPublished {
valid = true
break
}
}
log.Debugf("valid:[%v],appvers:%v", valid, appVers)
return valid
}
func (as *AppService) GenOfflinePackageInfo(ctx context.Context, appId string, seq int, userId string) (string, error) {
userInfo, err := hCaller.GetAccountInfo(ctx, userId)
if err != nil {
log.Errorf("GenOfflinePackageInfo GetDeveloperInfo err:%s", err.Error())
return "", err
}
appVerInfo, err := as.appRepo.GetAppVerInfo(ctx, appId, seq)
if err != nil {
log.Errorf("GenOfflinePackageInfo db err:%s", err.Error())
return "", err
}
if userInfo.OrganId != appVerInfo.GroupID {
log.Errorf("GenOfflinePackageInfo organ id no match app ver info group id")
return "", errors.New("group id not match")
}
//文件生成
if len(appVerInfo.CustomData.SourceFile) == 0 {
log.Errorf("GenOfflinePackageInfo CustomData.SourceFile empty!")
return "", errors.New("db info err")
}
//miniprogram.json
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appVerInfo.GroupID)
if err != nil {
log.Errorf("get group info err:%s", err.Error())
return "", err
}
miniprogramInfo := covertAppVerToRuleEngineRsp(&appVerInfo)
//获取域名
domainData, err := hCaller.GetDomainInfoByOrganId(ctx, appVerInfo.GroupID)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger domain info err:%s", err.Error())
return "", err
}
err, _, customData := ConvertModelCustomDataToRpc(ctx, appVerInfo.GroupID, appVerInfo.CustomData, domainData, "cache")
if err != nil {
log.Errorf("covertCacheInfoToRsp ConvertModelCustomDataToRpc err:[%s]", err.Error())
return "", err
}
wechatLoginInfo, err := hCaller.GetWeChatLoginInfo(ctx, appId)
if err != nil {
log.Errorf("covertCacheInfoToRsp ConvertModelCustomDataToRpc err:[%s]", err.Error())
return "", err
}
miniprogramInfo.CustomData = *customData
miniprogramInfo.GroupName = groupInfo.GroupName //附加
miniprogramInfo.NeedCrt = domainData.NeedCrt
miniprogramInfo.WechatLoginInfo = *wechatLoginInfo
sourceFile := appVerInfo.CustomData.SourceFile[0]
miniprogramJsonRsp := gin.H{
"error": "OK",
"errcode": "",
"data": miniprogramInfo,
}
dir := path.Join("/opt/finclip-offline-packages/", bson.NewObjectId().Hex())
fileDir := path.Join(dir, appVerInfo.AppID)
err = os.MkdirAll(fileDir, os.ModePerm)
if err != nil {
log.Errorf("mkdir err:%s", err.Error())
return "", err
}
defer os.RemoveAll(dir)
miniprogramJsonFileName := path.Join(fileDir, "miniprogram.json")
log.Debugf("file dir:%s", fileDir)
miniprogramJsonFile, err := os.OpenFile(miniprogramJsonFileName, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
log.Errorf("open file err:%s", err.Error())
return "", err
}
defer miniprogramJsonFile.Close()
miniprogramJsonByte, _ := json.Marshal(miniprogramJsonRsp)
_, err = miniprogramJsonFile.Write(miniprogramJsonByte)
if err != nil {
log.Errorf("write file err:%s", err.Error())
return "", err
}
var fileList = make([]string, 0)
fileList = append(fileList, miniprogramJsonFileName)
log.Debugf("sourceFile:%+v", sourceFile)
if len(sourceFile.EncryptPackages) > 0 { //分包
//分包小程序存储位置
splitPackFileDir := path.Join(fileDir, "miniprogram")
log.Debugf("splitPackFileDir:%s", splitPackFileDir)
err = os.Mkdir(splitPackFileDir, os.ModePerm)
if err != nil {
log.Errorf("mkdir splitPackFileDir err:%s", err.Error())
return "", err
}
//下载多个包
splitPackFileList := make([]string, 0)
for _, p := range sourceFile.EncryptPackages {
tempList := strings.Split(p.FileUrl, "/")
fileBody, err := hCaller.DownloadByNetdiskId(ctx, tempList[len(tempList)-1])
if err != nil {
log.Errorf("download file err:%s", err.Error())
return "", err
}
fName := path.Join(splitPackFileDir, p.Filename)
tempFile, err := os.Create(fName)
if err != nil {
log.Errorf("create splitPackFileDir err:%s", err.Error())
return "", err
}
_, err = tempFile.Write(fileBody)
if err != nil {
log.Errorf("tempFile write err:%s", err.Error())
return "", err
}
tempFile.Close()
splitPackFileList = append(splitPackFileList, fName)
}
//压缩之后再删除源文件
miniprogramZipFileName := path.Join(fileDir, "miniprogram.zip")
err = ZipList(splitPackFileList, miniprogramZipFileName)
if err != nil {
log.Errorf("splitPackFileDir zip err:%s", err.Error())
return "", err
}
err = os.RemoveAll(splitPackFileDir)
if err != nil {
log.Errorf("splitPackFileDir remove err:%s", err.Error())
return "", err
}
fileList = append(fileList, miniprogramZipFileName)
} else { //整包
var fileUrl = sourceFile.SourceFileUrl
if sourceFile.EncryptedUrl != "" {
fileUrl = sourceFile.EncryptedUrl
}
if fileUrl == "" {
log.Errorf("file url empty,appId:[%s],sequence:[%d]", appId, seq)
return "", errors.New("db info err")
}
fileBody, err := hCaller.DownloadByNetdiskId(ctx, getFileId(fileUrl))
if err != nil {
log.Errorf("download file err:%s", err.Error())
return "", err
}
appFileName := path.Join(fileDir, "app.zip")
//appFileName := path.Join(fileDir, "miniprogram.zip")
appFile, err := os.OpenFile(appFileName, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
log.Errorf("one packege open err:%s", err.Error())
return "", err
}
_, err = appFile.Write(fileBody)
appFile.Close()
if err != nil {
log.Errorf("one packege write file err:%s", err.Error())
return "", err
}
//再将小程序包压缩为miniprogram.zip
miniprogramZipFileName := path.Join(fileDir, "miniprogram.zip")
err = ZipList([]string{appFileName}, miniprogramZipFileName)
if err != nil {
log.Errorf("zip app file err:%s", err.Error())
return "", err
}
os.Remove(appFileName)
fileList = append(fileList, miniprogramZipFileName)
}
encryptPwd := utils.GenMd5("miniprogram" + appVerInfo.AppID)
log.Debugf("encryptPwd:%s", encryptPwd)
encryptFileName := fileDir + ".zip"
//err = EncryptZip(fileDir, encryptFileName, encryptPwd)
err = EncryptList(fileList, encryptFileName, encryptPwd)
if err != nil {
log.Errorf("EncryptZip err:%s", err.Error())
return "", err
}
encryptFile, err := os.Open(encryptFileName)
if err != nil {
log.Errorf("open file err:%s", err.Error())
return "", err
}
resultUrl, err := hCaller.Upload(ctx, appVerInfo.AppID+".zip", encryptFile, false)
if err != nil {
log.Errorf("upload err:%s", err.Error())
return "", err
}
log.Debugf("upload id:%s", resultUrl)
return getFileId(resultUrl), nil
}
func (as *AppService) GetAppClassList(ctx context.Context) ([]entity.CItem, error) {
appClassList, err := as.appRepo.GetAppClassList(ctx)
if err != nil {
return make([]entity.CItem, 0), err
}
return appClassList, err
}
func (as *AppService) GetAppTagList(ctx context.Context) ([]entity.TagItem, error) {
appTagList, err := as.appRepo.GetAppTagList(ctx)
if err != nil {
return make([]entity.TagItem, 0), err
}
return appTagList, err
}
func (as *AppService) SavePrivacySetting(ctx context.Context, req apiproto.PrivacySettingReq) error {
info := entity.PrivacySettingInfo{}
info.AppId = req.AppId
/*userMessageTypeObj:=entity.UserMessageTypeObj{}
userMessageTypeObj.UserMes=req.UserMessageType.UserMes
userMessageTypeObj.LocationMes=req.UserMessageType.LocationMes
userMessageTypeObj.Microphone=req.UserMessageType.Microphone
userMessageTypeObj.Camera=req.UserMessageType.Camera
userMessageTypeObj.EquipmentMes=req.UserMessageType.EquipmentMes
userMessageTypeObj.AddressBook=req.UserMessageType.AddressBook
userMessageTypeObj.PhotoAlbum=req.UserMessageType.PhotoAlbum
userMessageTypeObj.Calendar=req.UserMessageType.Calendar
userMessageTypeObj.OperationLog=req.UserMessageType.OperationLog
userMessageTypeObj.Bluetooth=req.UserMessageType.Bluetooth
userMessageTypeObj.Others=req.UserMessageType.Others*/
info.CommitType = req.CommitType
info.UserMessageType = utility.InterfaceToJsonString(req.UserMessageType)
info.SdkMessage = utility.InterfaceToJsonString(req.SdkMessage)
info.ContactInfoEmail = req.ContactInfo.Email
info.ContactInfoPhone = req.ContactInfo.Phone
info.ContactInfoWeChat = req.ContactInfo.WeChat
info.ContactInfoOther = req.ContactInfo.Other
info.AdditionalDocName = req.AdditionalDocName
info.AdditionalDocNetDiskId = req.AdditionalDocNetDiskId
info.IsFirstSave = false
info.AdditionalDocContent = req.AdditionalDocContent
info.FixedStorageTime = req.FixedStorageTime
info.EffectiveTime = time.Now().UnixNano() / 1e6
info.CreateTime = time.Now().UnixNano() / 1e6
info.UpdateTime = time.Now().UnixNano() / 1e6
total, err := as.prviacySettingRepo.Count(ctx, req.AppId)
if err != nil {
log.Errorf("PrviacySettingRepo Count err:%s", err.Error())
return err
}
if total > 0 {
err := as.prviacySettingRepo.UpdateInfo(ctx, info)
if err != nil {
log.Errorf("PrviacySettingRepo insert err:%s", err.Error())
return err
}
} else {
err := as.prviacySettingRepo.Insert(ctx, info)
if err != nil {
log.Errorf("PrviacySettingRepo insert err:%s", err.Error())
return err
}
}
appInfo, err := as.appRepo.GetAppInfo(ctx, req.AppId)
if err != nil {
log.Errorf("as.appRepo.GetAppVerInfo err:%s", err.Error())
if repository.NotFound(err) {
log.Errorf("DevPublishApp get appVer not found!")
return err
}
}
appInfo.PrivacySettingType = req.CommitType
err = as.appRepo.UpdateApp(ctx, appInfo)
if err != nil {
log.Errorf("UpdateAppIsPrivacySetting repo err:%s", err.Error())
return err
}
return nil
}
type GetPrivacySettingInfoRsp struct {
AppId string `json:"appId"`
CommitType int `json:"commitType"` //提交类型 //1:本小程序开发者承诺并保证，未以任何方式处理用户的任何信息。如后续有处理用户信息，会及时更新《小程序隐私保护指引》 2:本小程序处理了用户信息，将如实填写并及时更新用户信息处理情况
UserMessageType entity.UserMessageTypeObj `json:"userMessageType"` //用户使用类型
SdkMessage []entity.SdkMessageInfoObj `json:"sdkMessage"` //sdk信息
ContactInfo entity.ContactInfoObj `json:"contactInfo"` //联系方式
FixedStorageTime int `json:"fixedStorageTime"` //固定存储时间
IsShortestTime bool `json:"isShortestTime"` //是否是最短时间
AdditionalDocName string `json:"additionalDocName"` //补充文档名称
AdditionalDocContent string `json:"additionalDocContent"` //补充文档内容
AdditionalDocNetDiskId string `json:"additionalDocNetDiskId"` //补充文档网盘id
IsFirstSave bool `json:"isFirstSave"`
EffectiveTime int64 `json:"effectiveTime"`
CreateTime int64 `json:"createTime"`
UpdateTime int64 `json:"updateTime"`
}
func (as *AppService) GetPrivacySettingInfo(ctx context.Context, appId string) (GetPrivacySettingInfoRsp, error) {
rsp := GetPrivacySettingInfoRsp{}
item, err := as.prviacySettingRepo.GetInfoByAppId(ctx, appId)
if err != nil {
log.Errorf("PrviacySettingRepo insert err:%s", err.Error())
if NotFound(err) {
rsp.IsFirstSave = true
return rsp, nil
}
return rsp, err
}
rsp.AppId = item.AppId
rsp.FixedStorageTime = item.FixedStorageTime
rsp.IsShortestTime = item.IsShortestTime
var userMessageTypeObj entity.UserMessageTypeObj
json.Unmarshal([]byte(item.UserMessageType), &userMessageTypeObj)
rsp.UserMessageType = userMessageTypeObj
var sdkMessage []entity.SdkMessageInfoObj
json.Unmarshal([]byte(item.SdkMessage), &sdkMessage)
rsp.SdkMessage = sdkMessage
rsp.CommitType = item.CommitType
rsp.ContactInfo.Phone = item.ContactInfoPhone
rsp.ContactInfo.Email = item.ContactInfoEmail
rsp.ContactInfo.WeChat = item.ContactInfoWeChat
rsp.ContactInfo.Other = item.ContactInfoOther
rsp.AdditionalDocNetDiskId = item.AdditionalDocNetDiskId
rsp.AdditionalDocName = item.AdditionalDocName
rsp.IsFirstSave = item.IsFirstSave
rsp.AdditionalDocContent = item.AdditionalDocContent
rsp.EffectiveTime = item.EffectiveTime
rsp.CreateTime = item.CreateTime
rsp.UpdateTime = item.UpdateTime
return rsp, nil
}
func (as *AppService) DelPrivacySettingInfo(ctx context.Context, appId string) error {
err := as.prviacySettingRepo.DelInfoByAppId(ctx, appId)
if err != nil {
log.Errorf("PrviacySettingRepo DelInfoByAppId err:%s", err.Error())
return err
}
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Errorf("as.appRepo.GetAppVerInfo err:%s", err.Error())
return err
}
appInfo.PrivacySettingType = 1
err = as.appRepo.UpdateApp(ctx, appInfo)
if err != nil {
log.Errorf("UpdateAppIsPrivacySetting repo err:%s", err.Error())
return err
}
return nil
}
type InternalGetPrivacySettingInfoRsp struct {
AppId string `json:"appId"`
AppName string `json:"appName"`
OrganName string `json:"organName"`
CommitType int `json:"commitType"` //提交类型 //1:本小程序开发者承诺并保证，未以任何方式处理用户的任何信息。如后续有处理用户信息，会及时更新《小程序隐私保护指引》 2:本小程序处理了用户信息，将如实填写并及时更新用户信息处理情况
UserMessageType entity.UserMessageTypeObj `json:"userMessageType"` //用户使用类型
SdkMessage []entity.SdkMessageInfoObj `json:"sdkMessage"` //sdk信息
ContactInfo entity.ContactInfoObj `json:"contactInfo"` //联系方式
FixedStorageTime int `json:"fixedStorageTime"` //固定存储时间
IsShortestTime bool `json:"isShortestTime"` //是否是最短时间
AdditionalDocName string `json:"additionalDocName"` //补充文档名称
AdditionalDocNetDiskId string `json:"additionalDocNetDiskId"` //补充文档网盘id
AdditionalDocContent string `json:"additionalDocContent"` //补充文档内容
IsFirstSave bool `json:"isFirstSave"`
EffectiveTime int64 `json:"effectiveTime"`
CreateTime int64 `json:"createTime"`
UpdateTime int64 `json:"updateTime"`
}
func (as *AppService) InternalGetPrivacySettingInfo(ctx context.Context, appId string) (InternalGetPrivacySettingInfoRsp, error) {
rsp := InternalGetPrivacySettingInfoRsp{}
/*appVerInfo, err := as.appRepo.GetOnlineAppVer(ctx, appId)
if err != nil {
log.Debugf("getApp GetOnlineAppVer err:%s", err.Error())
if !NotFound(err) {
log.Errorf("getApp err:%s", err.Error())
return rsp, err
}
}*/
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Debugf("getApp err:%s", err.Error())
if !NotFound(err) {
log.Errorf("getApp err:%s", err.Error())
return rsp, err
}
}
groupInfo, err := hCaller.GetGroupInfoByGroupId(ctx, appInfo.GroupID)
log.Infof("get groupInfo error:%+v,groupInfo:%+v", err, groupInfo)
if err != nil {
log.Errorf("InternalGetAppVerInfo ger group info err:%s", err.Error())
return rsp, err
}
item, err := as.prviacySettingRepo.GetInfoByAppId(ctx, appId)
if err != nil {
log.Errorf("PrviacySettingRepo insert err:%s", err.Error())
return rsp, err
}
rsp.AppName = appInfo.Name
rsp.OrganName = groupInfo.GroupName
rsp.AppId = item.AppId
rsp.FixedStorageTime = item.FixedStorageTime
rsp.IsShortestTime = item.IsShortestTime
var userMessageTypeObj entity.UserMessageTypeObj
json.Unmarshal([]byte(item.UserMessageType), &userMessageTypeObj)
rsp.UserMessageType = userMessageTypeObj
var sdkMessage []entity.SdkMessageInfoObj
json.Unmarshal([]byte(item.SdkMessage), &sdkMessage)
rsp.SdkMessage = sdkMessage
rsp.CommitType = item.CommitType
rsp.AdditionalDocContent = item.AdditionalDocContent
rsp.ContactInfo.Phone = item.ContactInfoPhone
rsp.ContactInfo.Email = item.ContactInfoEmail
rsp.ContactInfo.WeChat = item.ContactInfoWeChat
rsp.ContactInfo.Other = item.ContactInfoOther
rsp.AdditionalDocNetDiskId = item.AdditionalDocNetDiskId
rsp.AdditionalDocName = item.AdditionalDocName
rsp.IsFirstSave = item.IsFirstSave
rsp.EffectiveTime = item.EffectiveTime
rsp.CreateTime = item.CreateTime
rsp.UpdateTime = item.UpdateTime
return rsp, nil
}
type InternalGetAppSearchDataInfoRsp struct {
AppId string `json:"appId"` //小程序Id
GroupID string `json:"groupId"`
Resource string `json:"resource"` //小程序源码地址
AppName string `json:"appName"` //小程序名称
OrganName string `json:"organName"` //机构名称
AppDesc string `json:"appDesc"` //小程序简介
SdkKeys []string `json:"sdkKeys"` //sdk关联列表
AppTag string `json:"appTag"`
AppClass string `json:"appClass"`
}
func (as *AppService) InternalGetAppSearchDataInfo(ctx context.Context, appId string) (InternalGetAppSearchDataInfoRsp, error) {
rsp := InternalGetAppSearchDataInfoRsp{}
appInfo, err := as.appRepo.GetAppInfo(ctx, appId)
if err != nil {
log.Debugf("getApp GetAppInfo err:%s", err.Error())
if !NotFound(err) {
log.Errorf("getApp err:%s", err.Error())
return rsp, err
}
}
appVerInfo, err := as.appRepo.GetOnlineAppVer(ctx, appId)
if err != nil {
log.Debugf("getApp GetOnlineAppVer err:%s", err.Error())
if !NotFound(err) {
log.Errorf("getApp err:%s", err.Error())
return rsp, err
}
}
appTagInfo, err := hCaller.GetAppTagConfigInfo(ctx)
if err != nil {
log.Errorln("appTagInfo error:%s", err.Error())
return rsp, err
}
//log.Debugln("appTagInfo:", appTagInfo.Data.AppTag)
appTagStr := ""
if len(appVerInfo.AppTag) > 0 {
log.Debugln("AppTag:", appVerInfo.AppTag)
for _, v := range appVerInfo.AppTag {
for _, tag := range appTagInfo.Data.AppTag {
if v == tag.Key {
appTagStr += tag.Name + ","
log.Debugln("appTagStr", appTagStr)
}
}
}
if len(appTagStr) > 0 {
appTagStr = appTagStr[0 : len(appTagStr)-1]
}
}
appClassStr := ""
if len(appVerInfo.AppTag) > 0 {
for _, v := range appTagInfo.Data.AppClass {
if v.Key == appVerInfo.AppClass {
appClassStr = v.Name
}
}
}
bindRepo := impl.InitBindingRepo()
result, err := bindRepo.GetAllAssBinds(ctx, appId)
if err != nil {
log.Errorf("notifySpiderPubApp err:%s", err.Error())
return rsp, err
}
var sdkKeyListMap = make(map[string]bool, 0)
var sdkKeyList = make([]string, 0)
for _, v := range result {
for _, sdkKeyInfo := range v.BundleInfos {
if sdkKeyInfo.IsForbidden == 0 {
if _, ok := sdkKeyListMap[sdkKeyInfo.SDKKey]; !ok {
sdkKeyListMap[sdkKeyInfo.SDKKey] = true
}
}
}
}
for k, _ := range sdkKeyListMap {
sdkKeyList = append(sdkKeyList, k)
}
rsp.AppId = appInfo.AppID
rsp.GroupID = appVerInfo.GroupID
rsp.Resource = appVerInfo.CustomData.SourceFile[0].SourceFileUrl
rsp.AppName = appInfo.Name
rsp.AppDesc = appVerInfo.CoreDescription
rsp.AppTag = appTagStr
rsp.AppClass = appClassStr
rsp.SdkKeys = sdkKeyList
return rsp, nil
}
type AppObject struct {
AppId string `json:"appId"` //小程序Id
AppName string `json:"appName"` //小程序名称
Logo string `json:"logo"`
}
type InternalGetAppInfoBySearchTextRsp struct {
AppInfo []AppObject `json:"appInfo"`
}
func (as *AppService) InternalGetAppInfoBySearchText(ctx context.Context, searchText string) (InternalGetAppInfoBySearchTextRsp, error) {
rsp := InternalGetAppInfoBySearchTextRsp{}
result, err := as.appRepo.GetAppsBySearchText(ctx, searchText)
if err != nil {
log.Debugf("getApp GetAppsBySearchText err:%s", err.Error())
return rsp, err
}
for _, v := range result {
item := AppObject{}
item.AppId = v.AppID
item.Logo = v.Logo
item.AppName = v.Name
rsp.AppInfo = append(rsp.AppInfo, item)
}
return rsp, nil
}
func EncryptZip(src, dst, passwd string) error {
zipfile, err := os.Create(dst)
if err != nil {
return err
}
defer zipfile.Close()
archive := ezip.NewWriter(zipfile)
defer archive.Close()
err = filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if info.IsDir() {
return nil
}
if err != nil {
return err
}
header, err := ezip.FileInfoHeader(info)
if err != nil {
return err
}
header.Name = strings.TrimPrefix(path, filepath.Dir(src)+"/")
//if info.IsDir() {
// header.Name += "/"
//} else {
// header.Method = zip.Deflate
//} // 设置密码
header.Method = zip.Deflate
header.SetPassword(passwd)
writer, err := archive.CreateHeader(header)
if err != nil {
return err
}
if !info.IsDir() {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
_, err = io.Copy(writer, file)
}
return err
})
archive.Flush()
return err
}
func Zip(pathToZip, destinationPath string) error {
destinationFile, err := os.Create(destinationPath)
if err != nil {
return err
}
myZip := zip.NewWriter(destinationFile)
err = filepath.Walk(pathToZip, func(filePath string, info os.FileInfo, err error) error {
if info.IsDir() {
return nil
}
if err != nil {
return err
}
relPath := strings.TrimPrefix(filePath, filepath.Dir(pathToZip))
zipFile, err := myZip.Create(relPath)
if err != nil {
return err
}
fsFile, err := os.Open(filePath)
if err != nil {
return err
}
_, err = io.Copy(zipFile, fsFile)
if err != nil {
return err
}
return nil
})
if err != nil {
return err
}
err = myZip.Close()
if err != nil {
return err
}
return nil
}
func ZipList(fileList []string, destinationPath string) error {
fmt.Println(fileList)
destinationFile, err := os.Create(destinationPath)
if err != nil {
return err
}
myZip := zip.NewWriter(destinationFile)
for _, fileName := range fileList {
f, err := os.Open(fileName)
if err != nil {
return err
}
fInfo, err := f.Stat()
if err != nil {
return err
}
if fInfo.IsDir() {
return fmt.Errorf("file:[%s] is dir", fileName)
}
_, name := filepath.Split(fileName)
zipFile, err := myZip.Create(name)
if err != nil {
return err
}
fsFile, err := os.Open(fileName)
if err != nil {
return err
}
_, err = io.Copy(zipFile, fsFile)
if err != nil {
return err
}
}
err = myZip.Close()
if err != nil {
return err
}
return nil
}
func EncryptList(fileList []string, dst, passwd string) error {
fmt.Println(fileList)
zipfile, err := os.Create(dst)
if err != nil {
return err
}
defer zipfile.Close()
archive := ezip.NewWriter(zipfile)
defer archive.Close()
for _, fileName := range fileList {
fmt.Println("fileName:", fileName)
f, err := os.Open(fileName)
if err != nil {
return err
}
fInfo, err := f.Stat()
if err != nil {
return err
}
if fInfo.IsDir() {
return fmt.Errorf("file:[%s] is dir", fileName)
}
header, err := ezip.FileInfoHeader(fInfo)
if err != nil {
return err
}
_, name := filepath.Split(fileName)
header.Name = name
fmt.Println("header.Name:", header.Name)
header.Method = zip.Deflate
header.SetPassword(passwd)
writer, err := archive.CreateHeader(header)
if err != nil {
return err
}
file, err := os.Open(fileName)
if err != nil {
return err
}
_, err = io.Copy(writer, file)
file.Close()
}
archive.Flush()
return err
}
func getFileId(fileUrl string) string {
tempList := strings.Split(fileUrl, "/")
return tempList[len(tempList)-1]
}