1056 lines
32 KiB
Go
1056 lines
32 KiB
Go
|
package mongo
|
||
|
|
|
||
|
|
import (
|
||
|
|
"context"
|
||
|
|
"finclip-app-manager/domain/entity"
|
||
|
|
"finclip-app-manager/domain/entity/proto/apiproto"
|
||
|
|
"finclip-app-manager/infrastructure/db/entity/mongo"
|
||
|
|
"finclip-app-manager/infrastructure/utility"
|
||
|
|
"finclip-app-manager/infrastructure/utils"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"gitlab.finogeeks.club/finclip-backend-v2/finclip-mgo/bson"
|
||
|
|
)
|
||
|
|
|
||
|
|
type AppRepo struct {
|
||
|
|
}
|
||
|
|
|
||
|
|
func NewAppRepo() *AppRepo {
|
||
|
|
return &AppRepo{}
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) AppCount(ctx context.Context, organId string) (int, error) {
|
||
|
|
match := bson.M{"isForbidden": 0}
|
||
|
|
if organId != "" {
|
||
|
|
match["organId"] = organId
|
||
|
|
}
|
||
|
|
return appTable.Count(ctx, match)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) InsertApp(ctx context.Context, info entity.App) error {
|
||
|
|
mgoInfo := tr.CovertAppToMgo(&info)
|
||
|
|
return appTable.Insert(ctx, mgoInfo)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) InsertAppVer(ctx context.Context, info entity.AppVersion) error {
|
||
|
|
mgoInfo := tr.CovertAppVerToMgo(&info)
|
||
|
|
return appVerTable.Insert(ctx, mgoInfo)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppInfo(ctx context.Context, appId string) (entity.App, error) {
|
||
|
|
mgoInfo := mongo.App{}
|
||
|
|
err := appTable.GetOne(ctx, bson.M{"appId": appId}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.App{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
log.Errorf("GetAppInfo err:%s", err.Error())
|
||
|
|
return entity.App{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UpdateApp(ctx context.Context, info entity.App) error {
|
||
|
|
mgoInfo := tr.CovertAppToMgo(&info)
|
||
|
|
return appTable.UpSert(bson.M{"appId": info.AppID}, mgoInfo)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppVerInfo(ctx context.Context, appId string, seq int) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
err := appVerTable.GetOne(ctx, bson.M{"appId": appId, "sequence": seq}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
log.Errorf("GetAppInfo err:%s", err.Error())
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetOnlineAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
match := bson.M{"appId": appId, "status.value": entity.StPublished}
|
||
|
|
err := appVerTable.GetSortOne(ctx, match, []string{"-sequence"}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) SubmitApp(ctx context.Context, req entity.SubmitAppReq, expire int64, userId string) error {
|
||
|
|
nowMaxSeq := 0
|
||
|
|
maxAppVerInfo, err := ar.GetMaxSeqAppVer(ctx, req.AppId)
|
||
|
|
if err == nil {
|
||
|
|
nowMaxSeq = maxAppVerInfo.Sequence
|
||
|
|
} else {
|
||
|
|
if err != entity.NotFoundErr {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
buildInfo, err := NewAppBuildInfoMongoRepo().GetInfoById(ctx, req.BuildId)
|
||
|
|
if NotFound(err) {
|
||
|
|
buildInfo, err = NewAppBuildInfoMongoRepo().GetInfoByBuildId(ctx, req.BuildId)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
log.Debugln("SubmitApp buildInfo:%+v", buildInfo)
|
||
|
|
appInfo, err := ar.GetAppInfo(ctx, req.AppId)
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
now := utils.GetNowMs()
|
||
|
|
appVerInfo := mongo.AppVersion{
|
||
|
|
AppID: appInfo.AppID,
|
||
|
|
Name: appInfo.Name,
|
||
|
|
AppClass: appInfo.AppClass,
|
||
|
|
AppTag: appInfo.AppTag,
|
||
|
|
AppType: entity.AppTypeApplet,
|
||
|
|
Status: mongo.Status{
|
||
|
|
Reason: "",
|
||
|
|
Value: entity.StPublishing,
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: req.Account,
|
||
|
|
},
|
||
|
|
PublishingStatus: mongo.SpecificStatus{
|
||
|
|
Reason: "",
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: req.Account,
|
||
|
|
},
|
||
|
|
UnpublishingStatus: mongo.SpecificStatus{},
|
||
|
|
PublishingApprovalStatus: mongo.SpecificStatus{},
|
||
|
|
UnpublishingApprovalStatus: mongo.SpecificStatus{},
|
||
|
|
PublishedStatus: mongo.SpecificStatus{},
|
||
|
|
UnpublishedStatus: mongo.UnpublishedStatus{},
|
||
|
|
RequestStatus: mongo.SpecificStatus{},
|
||
|
|
ApprovalStatus: mongo.SpecificStatus{},
|
||
|
|
ActionStatus: mongo.SpecificStatus{
|
||
|
|
Reason: "",
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: req.Account,
|
||
|
|
},
|
||
|
|
DeveloperID: userId,
|
||
|
|
GroupID: appInfo.GroupID,
|
||
|
|
Created: now,
|
||
|
|
CreatedBy: req.Account,
|
||
|
|
CustomData: tr.CovertCustomDataToMgo(buildInfo.CustomData),
|
||
|
|
Version: buildInfo.Version,
|
||
|
|
Sequence: nowMaxSeq + 1,
|
||
|
|
CoreDescription: appInfo.CoreDescription,
|
||
|
|
Logo: appInfo.Logo,
|
||
|
|
TestInfo: tr.CovertTestInfoToMgo(req.TestInfo),
|
||
|
|
NeedAutoPub: req.NeedAutoPub,
|
||
|
|
InGrayRelease: false,
|
||
|
|
Expire: expire,
|
||
|
|
AppBuildID: req.BuildId,
|
||
|
|
}
|
||
|
|
appVerInfo.CustomData.DetailDescription = appInfo.CustomData.DetailDescription
|
||
|
|
|
||
|
|
return appVerTable.Insert(ctx, appVerInfo)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) WithdrawPubApp(ctx context.Context, appId string, seq int, account string) error {
|
||
|
|
params := map[string]interface{}{}
|
||
|
|
now := utils.GetNowMs()
|
||
|
|
params["status"] = mongo.Status{
|
||
|
|
Value: entity.StPublishWithdrawed,
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
}
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
"sequence": seq,
|
||
|
|
}
|
||
|
|
return appVerTable.UpdateOne(ctx, filter, bson.M{"$set": params})
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetMaxSeqAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
match := bson.M{"appId": appId}
|
||
|
|
err := appVerTable.GetSortOne(ctx, match, []string{"-sequence"}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetLatestPubAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
match := bson.M{"appId": appId, "publishedStatus.lastUpdated": bson.M{"$ne": 0}}
|
||
|
|
err := appVerTable.GetSortOne(ctx, match, []string{"-publishedStatus.lastUpdated"}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UpdateAppVerAppName(ctx context.Context, appId, appName string) error {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetNowPubAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
match := bson.M{"appId": appId, "status.value": entity.StPublished}
|
||
|
|
err := appVerTable.GetSortOne(ctx, match, []string{"-status.lastUpdated"}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetLatestReviewAppVer(ctx context.Context, appId string) (entity.AppVersion, error) {
|
||
|
|
mgoInfo := mongo.AppVersion{}
|
||
|
|
//match := bson.M{"appId": appId, "status.value": bson.M{"$in": []string{entity.StPublishing, entity.StPublishWithdrawed, entity.StPublishApproved, entity.StPublishRejected, entity.StPublished, entity.StUnpublished}}}
|
||
|
|
match := bson.M{"appId": appId, "publishingStatus.lastUpdated": bson.M{"$ne": 0}}
|
||
|
|
err := appVerTable.GetSortOne(ctx, match, []string{"-sequence"}, &mgoInfo)
|
||
|
|
if err != nil {
|
||
|
|
if NotFound(err) {
|
||
|
|
return entity.AppVersion{}, entity.NotFoundErr
|
||
|
|
}
|
||
|
|
return entity.AppVersion{}, err
|
||
|
|
}
|
||
|
|
return *tr.CovertAppVerToEntity(&mgoInfo), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAllPermitGrayPubVers(ctx context.Context, appId string, maxSeq int) ([]entity.AppVersion, error) {
|
||
|
|
filter := bson.M{"appId": appId, "status.value": entity.StPublishApproved, "sequence": bson.M{"$gt": maxSeq}}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
_, err := appVerTable.GetAll(ctx, filter, []string{"-sequence"}, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) PubApp(ctx context.Context, appId string, seq int, account string, isDev, isRollback bool) error {
|
||
|
|
//结束所有低版本的灰度
|
||
|
|
err := appVerTable.UpdateAll(ctx, bson.M{"appId": appId, "sequence": bson.M{"$lte": seq}}, bson.M{"$set": bson.M{"inGrayRelease": false}})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
now := time.Now().UnixNano() / 1e6
|
||
|
|
//下架之前上架的小程序版本
|
||
|
|
oldAppVer, err := ar.GetNowPubAppVer(ctx, appId)
|
||
|
|
if err != nil && !NotFound(err) {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
if !NotFound(err) {
|
||
|
|
unpublishedStatus := mongo.UnpublishedStatus{
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
Type: entity.TypeUnpublishedDueToNewSeq, // Mark the type.
|
||
|
|
}
|
||
|
|
//if !isDev {
|
||
|
|
// unpublishedStatus.Type = entity.TypeUnpublishedByAdmin
|
||
|
|
//}
|
||
|
|
unPubUpInfo := map[string]interface{}{
|
||
|
|
"unpublishedStatus": unpublishedStatus,
|
||
|
|
"status": mongo.Status{
|
||
|
|
Value: entity.StUnpublished,
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
err = appVerTable.UpdateOne(ctx, bson.M{"appId": oldAppVer.AppID, "sequence": oldAppVer.Sequence}, bson.M{"$set": unPubUpInfo})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//上架当前小程序版本
|
||
|
|
upInfo := make(map[string]interface{})
|
||
|
|
upInfo["status"] = mongo.Status{
|
||
|
|
Value: entity.StPublished,
|
||
|
|
Reason: "",
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
}
|
||
|
|
upInfo["publishedStatus"] = mongo.SpecificStatus{
|
||
|
|
Reason: "",
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
}
|
||
|
|
upInfo["actionStatus"] = mongo.SpecificStatus{
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
}
|
||
|
|
//修改小程序元数据信息
|
||
|
|
err = appTable.UpdateOne(ctx, bson.M{"appId": appId}, bson.M{"$set": upInfo})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
upInfo["isRollback"] = isRollback
|
||
|
|
err = appVerTable.UpdateOne(ctx, bson.M{"appId": appId, "sequence": seq}, bson.M{"$set": upInfo})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) ListApps(ctx context.Context, groupId string, pageNo, pageSize int, searchText string, sortType, pullType string) (int, []entity.App, error) {
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
sortList := make([]string, 0)
|
||
|
|
switch sortType {
|
||
|
|
case "-created":
|
||
|
|
sortList = append(sortList, "-created") //按创建时间倒序排序
|
||
|
|
case "created":
|
||
|
|
sortList = append(sortList, "created") //按创建时间正序排序
|
||
|
|
case "-expire":
|
||
|
|
sortList = append(sortList, "-expire") //按过期时间倒序排序
|
||
|
|
case "expire":
|
||
|
|
sortList = append(sortList, "expire") //按过期时间正序排序
|
||
|
|
default:
|
||
|
|
sortList = append(sortList, "-created")
|
||
|
|
|
||
|
|
}
|
||
|
|
filter := bson.M{}
|
||
|
|
if groupId != "" {
|
||
|
|
filter["groupId"] = groupId
|
||
|
|
}
|
||
|
|
if searchText != "" {
|
||
|
|
r := bson.RegEx{Pattern: searchText, Options: "i"}
|
||
|
|
filter["$or"] = []bson.M{{"name": r}, {"appId": r}}
|
||
|
|
}
|
||
|
|
switch pullType {
|
||
|
|
case "published":
|
||
|
|
filter["status.value"] = entity.StPublished
|
||
|
|
}
|
||
|
|
total, err := appTable.GetSome(ctx, filter, sortList, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, err
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) ListAppVers(ctx context.Context, pageNo, pageSize int, searchText string, t string, groupId string) (int, []entity.AppVersion, error) {
|
||
|
|
filter := bson.M{}
|
||
|
|
filterList := make([]bson.M, 0)
|
||
|
|
if groupId != "" {
|
||
|
|
filterList = append(filterList, bson.M{
|
||
|
|
"groupId": groupId,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
filterList = append(filterList, bson.M{
|
||
|
|
"sequence": bson.M{"$ne": 0},
|
||
|
|
})
|
||
|
|
if searchText != "" {
|
||
|
|
r := bson.RegEx{Pattern: searchText, Options: "i"}
|
||
|
|
filterList = append(filterList, bson.M{"$or": []bson.M{
|
||
|
|
{"name": r},
|
||
|
|
{"appId": r},
|
||
|
|
}})
|
||
|
|
}
|
||
|
|
sortList := make([]string, 0)
|
||
|
|
sortList = append(sortList, "-publishingStatus.lastUpdated")
|
||
|
|
switch t {
|
||
|
|
case "pendingReview": //待审核
|
||
|
|
filterList = append(filterList, bson.M{"status.value": bson.M{"$in": []string{entity.StPublishing, entity.StUnpublishing}}})
|
||
|
|
case "reviewed": //已审核
|
||
|
|
filterList = append(filterList, bson.M{"status.value": bson.M{"$nin": []string{entity.StPublishing, entity.StPublishWithdrawed}}})
|
||
|
|
case "revoked": //已撤销
|
||
|
|
//PublishWithdrawed
|
||
|
|
filterList = append(filterList, bson.M{"status.value": bson.M{"$in": []string{entity.StPublishWithdrawed}}})
|
||
|
|
//default:
|
||
|
|
}
|
||
|
|
filter["$and"] = filterList
|
||
|
|
log.Debugln("filter:%v", filter)
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
total, err := appVerTable.GetSome(ctx, filter, sortList, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UnpubApp(ctx context.Context, appId string, seq int, account, reason string, isDev bool) error {
|
||
|
|
unpublishedType := ""
|
||
|
|
if isDev {
|
||
|
|
unpublishedType = entity.TypeUnpublishedByDev
|
||
|
|
} else {
|
||
|
|
unpublishedType = entity.TypeUnpublishedByAdmin
|
||
|
|
}
|
||
|
|
now := time.Now().UnixNano() / 1e6
|
||
|
|
params := map[string]interface{}{}
|
||
|
|
params["status"] = mongo.Status{
|
||
|
|
Value: entity.StUnpublished,
|
||
|
|
ModifiedBy: account,
|
||
|
|
LastUpdated: now,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
params["unpublishedStatus"] = mongo.UnpublishedStatus{
|
||
|
|
ModifiedBy: account,
|
||
|
|
LastUpdated: now,
|
||
|
|
Reason: reason,
|
||
|
|
Type: unpublishedType,
|
||
|
|
}
|
||
|
|
params["actionStatus"] = mongo.SpecificStatus{
|
||
|
|
ModifiedBy: account,
|
||
|
|
LastUpdated: now,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
err := appVerTable.UpdateOne(ctx, bson.M{"appId": appId, "sequence": seq}, bson.M{"$set": params})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return appTable.UpdateOne(ctx, bson.M{"appId": appId}, bson.M{"$set": params})
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) ApproveApp(ctx context.Context, appId string, seq int, account, reason string, isPass bool) error {
|
||
|
|
params := map[string]interface{}{}
|
||
|
|
now := utils.GetNowMs()
|
||
|
|
if isPass {
|
||
|
|
params["status"] = entity.Status{
|
||
|
|
Value: entity.StPublishApproved,
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
params["status"] = entity.Status{
|
||
|
|
Value: entity.StPublishRejected,
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
params["publishingApprovalStatus"] = mongo.SpecificStatus{
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
params["approvalStatus"] = mongo.SpecificStatus{
|
||
|
|
LastUpdated: now,
|
||
|
|
ModifiedBy: account,
|
||
|
|
Reason: reason,
|
||
|
|
}
|
||
|
|
return appVerTable.UpdateOne(ctx, bson.M{"appId": appId, "sequence": seq}, bson.M{"$set": params})
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) ListAppVersByAppId(ctx context.Context, appId string, pageNo, pageSize int) (int, []entity.AppVersion, error) {
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
"sequence": bson.M{"$ne": 0},
|
||
|
|
"status.value": bson.M{"$ne": entity.StDeleted},
|
||
|
|
}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
total, err := appVerTable.GetSome(ctx, filter, []string{"-sequence"}, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppReviews(ctx context.Context, req apiproto.AdminGetAppReviewsReq) (int, []entity.AppVersion, error) {
|
||
|
|
return 0, nil, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAllPublishedVerList(ctx context.Context, appId string) ([]entity.AppVersion, int, error) {
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
"status.value": entity.StPublished,
|
||
|
|
}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
total, err := appVerTable.GetAll(ctx, filter, []string{"-sequence"}, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, 0, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, total, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetPublishedAppList(ctx context.Context, pageNo, pageSize int, searchText string) ([]entity.AppVersion, int, error) {
|
||
|
|
filter := bson.M{
|
||
|
|
"status.value": entity.StPublished,
|
||
|
|
}
|
||
|
|
if searchText != "" {
|
||
|
|
r := bson.RegEx{Pattern: searchText, Options: "i"}
|
||
|
|
filter["$or"] = []bson.M{
|
||
|
|
{"name": r},
|
||
|
|
{"appId": r},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
total, err := appVerTable.GetSome(ctx, filter, []string{"-created"}, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, 0, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, total, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAllVers(ctx context.Context, appId string) ([]entity.AppVersion, int, error) {
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
total, err := appVerTable.GetAll(ctx, filter, []string{"-sequence"}, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, 0, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, total, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppsByAppIds(ctx context.Context, appIds []string) ([]entity.App, error) {
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
_, err := appTable.GetAllV2(ctx, bson.M{"appId": bson.M{"$in": appIds}}, []string{"-created"}, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppsByGroupIds(ctx context.Context, groupIds []string) (int, []entity.App, error) {
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
total, err := appTable.GetAllV2(ctx, bson.M{"groupId": bson.M{"$in": groupIds}}, []string{"-created"}, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppsToBinding(ctx context.Context, bindingId string, pageNo, pageSize int, searchText string) (int, []entity.App, error) {
|
||
|
|
br := NewBindingByMongoRepo()
|
||
|
|
bindingInfo, err := br.GetBindingByBindingId(ctx, bindingId)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
//获取应用关联的小程序Id
|
||
|
|
assAppIdList := make([]string, 0)
|
||
|
|
for _, v := range bindingInfo.AppInfos {
|
||
|
|
assAppIdList = append(assAppIdList, v.AppID)
|
||
|
|
}
|
||
|
|
filter := bson.M{"groupId": bindingInfo.GroupID, "appId": bson.M{"$nin": assAppIdList}}
|
||
|
|
if searchText != "" {
|
||
|
|
filter["name"] = bson.RegEx{
|
||
|
|
Pattern: searchText,
|
||
|
|
Options: "i",
|
||
|
|
}
|
||
|
|
}
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
total, err := appTable.GetSome(ctx, filter, []string{"-created"}, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetLinkAppsByBindingId(ctx context.Context, bindingId string, pageNo, pageSize int, searchText string) (int, []entity.App, error) {
|
||
|
|
br := NewBindingByMongoRepo()
|
||
|
|
bindingInfo, err := br.GetBindingByBindingId(ctx, bindingId)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
//获取应用关联的小程序Id
|
||
|
|
assAppIdList := make([]string, 0)
|
||
|
|
for _, v := range bindingInfo.AppInfos {
|
||
|
|
assAppIdList = append(assAppIdList, v.AppID)
|
||
|
|
}
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
total, err := appTable.GetSome(ctx, bson.M{"groupId": bindingInfo.GroupID, "appId": bson.M{"$in": assAppIdList}}, []string{"-created"}, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetLinkAppsBySDKKey(ctx context.Context, sdkKey string, pageNo, pageSize int) (int, []entity.App, error) {
|
||
|
|
br := NewBindingByMongoRepo()
|
||
|
|
bindingInfos, err := br.GetBindListBySdkKey(ctx, sdkKey)
|
||
|
|
log.Infof(utility.InterfaceToJsonString(bindingInfos))
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
//获取应用关联的小程序Id
|
||
|
|
assAppIdList := make([]string, 0)
|
||
|
|
for _, v := range bindingInfos {
|
||
|
|
for _, y := range v.AppInfos {
|
||
|
|
assAppIdList = append(assAppIdList, y.AppID)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
list := make([]mongo.App, 0)
|
||
|
|
total, err := appTable.GetSome(ctx, bson.M{"status.value": entity.StPublished, "appId": bson.M{"$in": assAppIdList}}, []string{"-created"}, pageSize, pageNo, &list)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.App, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppToEntity(&temp))
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) AdminGetLinkApps(ctx context.Context, pageNo, pageSize int, searchText string) (int, []entity.AdminGetLinkAppsRspItem, error) {
|
||
|
|
//这里需要连接三个表 app表、binding表、typeConfig表
|
||
|
|
//todo 做优化的时候进行修改
|
||
|
|
type TempItem struct {
|
||
|
|
Id bson.ObjectId `bson:"_id"`
|
||
|
|
AppIdDetail struct {
|
||
|
|
AppId string `bson:"appId"`
|
||
|
|
Name string `bson:"name"`
|
||
|
|
Sequence int `bson:"sequence"`
|
||
|
|
} `bson:"appIdDetail"`
|
||
|
|
AppInfos struct {
|
||
|
|
AssociatedAt int64 `bson:"associatedAt"`
|
||
|
|
} `bson:"app_infos"`
|
||
|
|
BindingId string `bson:"binding_id"`
|
||
|
|
GroupName string `bson:"group_name"`
|
||
|
|
Name string `bson:"name"`
|
||
|
|
}
|
||
|
|
binds := make([]TempItem, 0)
|
||
|
|
//连接app表
|
||
|
|
lookupFind := bson.M{"from": AppTableName, "localField": "app_infos.appId", "foreignField": "appId", "as": "appIdDetail"}
|
||
|
|
//分组
|
||
|
|
unwindValue := "$app_infos"
|
||
|
|
//小程序创建时间倒序
|
||
|
|
sortValue := bson.M{"app_infos.associatedAt": -1}
|
||
|
|
skipValue := pageNo * pageSize
|
||
|
|
limitValue := pageSize
|
||
|
|
//模糊匹配
|
||
|
|
matchValue := bson.M{
|
||
|
|
"$or": []bson.M{
|
||
|
|
{"name": bson.M{"$regex": bson.RegEx{Pattern: searchText, Options: "i"}}},
|
||
|
|
{"appIdDetail.name": bson.M{"$regex": bson.RegEx{Pattern: searchText, Options: "i"}}},
|
||
|
|
{"group_name": bson.M{"$regex": bson.RegEx{Pattern: searchText, Options: "i"}}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
//typeConfig 小程序开发匹配namespace为appClass的
|
||
|
|
//typeConfigMatchValue := bson.M{"appClassDetail.namespace": "appClass"}
|
||
|
|
//需要的字段
|
||
|
|
projectValue := bson.M{
|
||
|
|
"binding_id": 1,
|
||
|
|
"appClassDetail.customData.chinese": 1,
|
||
|
|
"appIdDetail.name": 1,
|
||
|
|
"appIdDetail.appId": 1,
|
||
|
|
"appIdDetail.sequence": 1,
|
||
|
|
"name": 1,
|
||
|
|
"group_name": 1,
|
||
|
|
"app_infos.associatedAt": 1,
|
||
|
|
}
|
||
|
|
//连接typeConfig表
|
||
|
|
//appClassLookup := bson.M{"from": "typeConfig", "localField": "appIdDetail.appClass", "foreignField": "value", "as": "appClassDetail"}
|
||
|
|
pipSelector := []bson.M{
|
||
|
|
{"$unwind": unwindValue},
|
||
|
|
{"$lookup": lookupFind},
|
||
|
|
{"$match": matchValue},
|
||
|
|
{"$sort": sortValue},
|
||
|
|
{"$skip": skipValue},
|
||
|
|
{"$limit": limitValue},
|
||
|
|
{"$unwind": "$appIdDetail"},
|
||
|
|
//{"$lookup": appClassLookup},
|
||
|
|
//{"$match": typeConfigMatchValue},
|
||
|
|
//{"$unwind": "$appClassDetail"},
|
||
|
|
{"$project": projectValue},
|
||
|
|
}
|
||
|
|
countSelector := []bson.M{
|
||
|
|
{"$unwind": unwindValue},
|
||
|
|
{"$lookup": lookupFind},
|
||
|
|
{"$match": matchValue},
|
||
|
|
{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": 1}}},
|
||
|
|
}
|
||
|
|
log.Infof("pipe selector:%+v,countSelector:%+v\n", pipSelector, countSelector)
|
||
|
|
err := bindingTable.Aggregate(ctx, pipSelector, &binds)
|
||
|
|
if err != nil && !NotFound(err) {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
total, err := bindingTable.AggregateCount(ctx, countSelector)
|
||
|
|
if err != nil {
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AdminGetLinkAppsRspItem, 0)
|
||
|
|
for _, v := range binds {
|
||
|
|
item := entity.AdminGetLinkAppsRspItem{}
|
||
|
|
item.Id = v.Id.Hex()
|
||
|
|
item.AppIdDetail.AppId = v.AppIdDetail.AppId
|
||
|
|
item.AppIdDetail.Name = v.AppIdDetail.Name
|
||
|
|
item.AppIdDetail.Sequence = v.AppIdDetail.Sequence
|
||
|
|
item.AppInfos.AssociatedAt = v.AppInfos.AssociatedAt
|
||
|
|
item.BindingId = v.BindingId
|
||
|
|
item.GroupName = v.GroupName
|
||
|
|
item.Name = v.Name
|
||
|
|
|
||
|
|
result = append(result, item)
|
||
|
|
}
|
||
|
|
return total, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UpdateGrayStatus(ctx context.Context, appId string, seq int, status bool) error {
|
||
|
|
err := appVerTable.UpdateOne(ctx, bson.M{"appId": appId, "sequence": seq}, bson.M{"$set": bson.M{"inGrayRelease": status}})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UpdateExpire(ctx context.Context, appId string, expire int64) error {
|
||
|
|
err := appTable.UpdateOne(ctx, bson.M{"appId": appId}, bson.M{"$set": bson.M{"expire": expire}})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) UpdateExpireAppVersion(ctx context.Context, appId string, seq int, expire int64) error {
|
||
|
|
err := appVerTable.UpdateOne(ctx, bson.M{"appId": appId, "sequence": seq}, bson.M{"$set": bson.M{"expire": expire}})
|
||
|
|
if err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetRollbackAbleList(ctx context.Context, groupId, appId string, latestPubSeq int) ([]entity.AppVersion, error) {
|
||
|
|
appVers := make([]mongo.AppVersion, 0)
|
||
|
|
limitVersion := 5 // 最近5个版本, 不是最近下架的5个版本
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
"groupId": groupId,
|
||
|
|
"status.value": bson.M{"$eq": entity.StUnpublished},
|
||
|
|
"sequence": bson.M{"$gte": latestPubSeq - limitVersion, "$lt": latestPubSeq},
|
||
|
|
"$or": []bson.M{
|
||
|
|
{"unpublishedStatus.type": entity.TypeUnpublishedByDev},
|
||
|
|
{"unpublishedStatus.type": entity.TypeUnpublishedDueToNewSeq},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
_, err := appVerTable.GetSome(ctx, filter, []string{"-sequence"}, limitVersion, 1, &appVers)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range appVers {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetCreatedStatistics(ctx context.Context, startTime, endTime int64, groupId string, isForbidden int) (int, error) {
|
||
|
|
filter := bson.M{}
|
||
|
|
if groupId != "" {
|
||
|
|
filter["groupId"] = groupId
|
||
|
|
}
|
||
|
|
if startTime != -1 && startTime != 0 {
|
||
|
|
filter["created"] = bson.M{"$gt": startTime}
|
||
|
|
}
|
||
|
|
if endTime != -1 && endTime != 0 {
|
||
|
|
if _, ok := filter["created"]; ok {
|
||
|
|
filter["created"] = bson.M{"$gt": startTime, "$lte": endTime}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
switch isForbidden {
|
||
|
|
case entity.APP_FORBIDDEN_NOT_STATUS:
|
||
|
|
filter["$or"] = []bson.M{{"isForbidden": entity.APP_FORBIDDEN_NOT_STATUS}, {"isForbidden": bson.M{"$exists": false}}}
|
||
|
|
case entity.APP_FORBIDDEN_IS_STATUS:
|
||
|
|
filter["isForbidden"] = entity.APP_FORBIDDEN_IS_STATUS
|
||
|
|
}
|
||
|
|
log.Debugf("GetCreatedStatistics filter:%+v", filter)
|
||
|
|
return appTable.Count(ctx, filter)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetPublishedStatistics(ctx context.Context, startTime, endTime int64, groupId string) (int, error) {
|
||
|
|
filter := bson.M{}
|
||
|
|
if groupId != "" {
|
||
|
|
filter["groupId"] = groupId
|
||
|
|
}
|
||
|
|
if startTime != -1 && startTime != 0 {
|
||
|
|
filter["publishedStatus.lastUpdated"] = bson.M{"$gt": startTime}
|
||
|
|
}
|
||
|
|
if endTime != -1 && endTime != 0 {
|
||
|
|
filter["publishedStatus.lastUpdated"] = bson.M{"$gt": startTime, "$lte": endTime}
|
||
|
|
}
|
||
|
|
filter["status.value"] = entity.StPublished
|
||
|
|
return appTable.Count(ctx, filter)
|
||
|
|
}
|
||
|
|
|
||
|
|
//GetSubmittedStatistics 累计审核的小程序----只要小程序被审核过都算
|
||
|
|
func (ar *AppRepo) GetSubmittedStatistics(ctx context.Context, startTime, endTime int64, groupId string, distinct bool) (int, error) {
|
||
|
|
filter := bson.M{}
|
||
|
|
if groupId != "" {
|
||
|
|
filter["groupId"] = groupId
|
||
|
|
}
|
||
|
|
if startTime != -1 && startTime != 0 {
|
||
|
|
filter = bson.M{"$and": []bson.M{
|
||
|
|
filter,
|
||
|
|
{
|
||
|
|
"publishingStatus.lastUpdated": bson.M{"$gt": startTime},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if endTime != -1 && endTime != 0 {
|
||
|
|
filter = bson.M{"$and": []bson.M{
|
||
|
|
filter,
|
||
|
|
{
|
||
|
|
"publishingStatus.lastUpdated": bson.M{"$lte": endTime},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
filter = bson.M{"$and": []bson.M{
|
||
|
|
filter,
|
||
|
|
{
|
||
|
|
"status.value": bson.M{
|
||
|
|
"$ne": entity.StInDevelopment,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
if distinct {
|
||
|
|
aggregate := []bson.M{
|
||
|
|
{
|
||
|
|
"$project": bson.M{
|
||
|
|
"appId": 1,
|
||
|
|
"publishingStatus": 1,
|
||
|
|
"status": 1,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
"$match": filter,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
"$group": bson.M{
|
||
|
|
"_id": "appId",
|
||
|
|
"total": bson.M{"$sum": 1},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
return appVerTable.AggregateCount(ctx, aggregate)
|
||
|
|
}
|
||
|
|
return appVerTable.Count(ctx, filter)
|
||
|
|
}
|
||
|
|
|
||
|
|
//审核通过小程序
|
||
|
|
func (ar *AppRepo) GetApprovedStatistics(ctx context.Context, startTime, endTime int64, groupId string, distinct bool) (int, error) {
|
||
|
|
filter := bson.M{}
|
||
|
|
if groupId != "" {
|
||
|
|
filter["groupId"] = groupId
|
||
|
|
}
|
||
|
|
filter = bson.M{
|
||
|
|
"$and": []bson.M{
|
||
|
|
filter,
|
||
|
|
{
|
||
|
|
"status.value": bson.M{
|
||
|
|
"$in": []string{
|
||
|
|
entity.StPublishApproved,
|
||
|
|
entity.StPublished,
|
||
|
|
entity.StUnpublishing,
|
||
|
|
entity.StUnpublishApproved,
|
||
|
|
entity.StUnpublishRejected,
|
||
|
|
entity.StUnpublished,
|
||
|
|
},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
if distinct {
|
||
|
|
return appTable.Count(ctx, filter)
|
||
|
|
}
|
||
|
|
return appVerTable.Count(ctx, filter)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppClassPer(ctx context.Context, status string) ([]entity.AppClassPerRsp, error) {
|
||
|
|
match := bson.M{}
|
||
|
|
if status != "" {
|
||
|
|
if status == "published" {
|
||
|
|
match["status.value"] = entity.StPublished
|
||
|
|
}
|
||
|
|
}
|
||
|
|
group := bson.M{"_id": "$appClass", "count": bson.M{"$sum": 1}}
|
||
|
|
|
||
|
|
type perRsp struct {
|
||
|
|
Class string `bson:"class"`
|
||
|
|
Count int `bson:"count"`
|
||
|
|
Name []string `bson:"name"`
|
||
|
|
}
|
||
|
|
lookUp := bson.M{
|
||
|
|
"from": TypeConfigTableName,
|
||
|
|
"localField": "_id",
|
||
|
|
"foreignField": "value",
|
||
|
|
"as": "classInfo",
|
||
|
|
}
|
||
|
|
project := bson.M{
|
||
|
|
"class": "$_id",
|
||
|
|
"count": 1,
|
||
|
|
"name": "$classInfo.chinese",
|
||
|
|
}
|
||
|
|
perRspList := make([]perRsp, 0)
|
||
|
|
pipSelector := []bson.M{
|
||
|
|
{"$match": match},
|
||
|
|
{"$group": group},
|
||
|
|
{"$lookup": lookUp},
|
||
|
|
{"$project": project},
|
||
|
|
}
|
||
|
|
err := appTable.AggregateOnly(ctx, pipSelector, &perRspList)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
rspData := make([]entity.AppClassPerRsp, 0)
|
||
|
|
for _, v := range perRspList {
|
||
|
|
rspData = append(rspData, entity.AppClassPerRsp{
|
||
|
|
Class: v.Class,
|
||
|
|
Count: v.Count,
|
||
|
|
Name: v.Name,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return rspData, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppVerLimitByIdentity(ctx context.Context, t, appId, identity string, limit int) ([]entity.AppVersion, error) {
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
var filter bson.M
|
||
|
|
//默认md5
|
||
|
|
filter = bson.M{"appId": appId, "customData.sourceFile.fileMd5": identity}
|
||
|
|
if t == "sha256" {
|
||
|
|
filter = bson.M{"appId": appId, "customData.sourceFile.encryptedFileSha256": identity}
|
||
|
|
}
|
||
|
|
err := appVerTable.OnlyGetSome(ctx, filter, []string{"-sequence"}, limit, 1, &list)
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetGrayStatisticsVerList(ctx context.Context, appId string, seq int, begin, end int64) (int, []entity.AppVersion, error) {
|
||
|
|
filter := bson.M{
|
||
|
|
"appId": appId,
|
||
|
|
"sequence": bson.M{"$lt": seq},
|
||
|
|
}
|
||
|
|
if end == 0 {
|
||
|
|
filter["$or"] = []bson.M{
|
||
|
|
{"status.value": entity.StPublished},
|
||
|
|
{"status.value": entity.StUnpublished, "unpublishedStatus.lastUpdated": bson.M{"$gte": begin}},
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
filter["$or"] = []bson.M{
|
||
|
|
{"status.value": entity.StPublished, "publishedStatus.lastUpdated": bson.M{"$lte": end}},
|
||
|
|
{"status.value": entity.StUnpublished, "$or": []bson.M{
|
||
|
|
{"publishedStatus.lastUpdated": bson.M{"$gte": begin, "$lte": end}},
|
||
|
|
{"unpublishedStatus.lastUpdated": bson.M{"$gte": begin, "$lte": end}},
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
log.Debugf("GetGrayStatisticsVerList filter:%+v", filter)
|
||
|
|
sort := []string{"sequence"}
|
||
|
|
list := make([]mongo.AppVersion, 0)
|
||
|
|
num, err := appVerTable.GetAll(ctx, filter, sort, &list)
|
||
|
|
if err != nil {
|
||
|
|
log.Errorf("GetGrayStatisticsVerList db err:%s", err.Error())
|
||
|
|
return 0, nil, err
|
||
|
|
}
|
||
|
|
result := make([]entity.AppVersion, 0)
|
||
|
|
for _, v := range list {
|
||
|
|
temp := v
|
||
|
|
result = append(result, *tr.CovertAppVerToEntity(&temp))
|
||
|
|
}
|
||
|
|
return num, result, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppClassList(ctx context.Context) ([]entity.CItem, error) {
|
||
|
|
appClassList := make([]entity.CItem, 0)
|
||
|
|
group := bson.M{"_id": "$appClass"}
|
||
|
|
pipSelector := []bson.M{
|
||
|
|
{"$group": group},
|
||
|
|
}
|
||
|
|
err := appTable.AggregateOnly(ctx, pipSelector, &appClassList)
|
||
|
|
if err != nil {
|
||
|
|
return make([]entity.CItem, 0), err
|
||
|
|
}
|
||
|
|
|
||
|
|
return appClassList, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppTagList(ctx context.Context) ([]entity.TagItem, error) {
|
||
|
|
appTagList := make([]entity.TagItem, 0)
|
||
|
|
group := bson.M{"_id": "$appTag"}
|
||
|
|
pipSelector := []bson.M{
|
||
|
|
{"$group": group},
|
||
|
|
}
|
||
|
|
err := appTable.AggregateOnly(ctx, pipSelector, &appTagList)
|
||
|
|
if err != nil {
|
||
|
|
return make([]entity.TagItem, 0), err
|
||
|
|
}
|
||
|
|
|
||
|
|
return appTagList, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppsBySearchText(ctx context.Context, searchText string) ([]entity.App, error) {
|
||
|
|
return nil, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (ar *AppRepo) GetAppByCreator(ctx context.Context, phone string) ([]entity.App, error) {
|
||
|
|
return nil, nil
|
||
|
|
}
|