web_hghl_server/web/service/srv_actress/actress.go

package srv_actress

import (
	"context"
	"time"
	"videoweb/pub/common/log"
	"videoweb/pub/common/slugx"
	"videoweb/pub/common/srvdef"
	"videoweb/pub/common/utils"
	"videoweb/pub/models/actress"
	"videoweb/pub/mongos"
	"videoweb/pub/pubdef"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo/options"
)

func ActressList(ctx context.Context, req *ActressListReq) (*ActressListResp, *srvdef.SrvErr) {
	filter := bson.M{}
	if req.Id != nil && *req.Id > 0 {
		filter[actress.FN.Actress.Id] = *req.Id
	}
	if req.TranslationCategoryId != nil && *req.TranslationCategoryId > 0 {
		filter[actress.FN.Actress.TranslationCategoryId] = *req.TranslationCategoryId
	}
	if req.Region != nil && len(*req.Region) > 0 {
		filter[actress.FN.Actress.Region] = bson.M{"$regex": *req.Region}
	}
	if req.Status != nil {
		filter[actress.FN.Actress.Status] = *req.Status
	}
	if req.Alias != nil && *req.Alias != "" {
		filter[actress.FN.Actress.Alias] = bson.M{"$regex": *req.Alias}
	}
	count, err := actress.CountActresss(ctx, filter)
	if err != nil {
		log.Warn("ActressList CountActresss", log.Any("filter", filter), log.E(err))
		return nil, err
	}
	resp := &ActressListResp{
		Total: 0,
		List:  make([]*actress.Actress, 0),
	}
	if count == 0 {
		return resp, nil
	}
	opts := &options.FindOptions{}
	opts.SetLimit(req.PageSize)
	opts.SetSkip((req.PageNum - 1) * req.PageSize)
	sort := bson.M{actress.FN.Actress.CreatedAt: -1}
	switch req.SortType {
	case 1:
		sort = bson.M{actress.FN.Actress.Score: -1}
	case 2:
		sort = bson.M{actress.FN.Actress.Rank: -1}
	case 3:
		sort = bson.M{actress.FN.Actress.Works: -1}
	case 4:
		sort = bson.M{actress.FN.Actress.Real.WatchTimes: -1}
	case 5:
		sort = bson.M{actress.FN.Actress.HotValue: -1, actress.FN.Actress.Id: -1}
	}
	opts.SetSort(sort)
	list, err := actress.FindManyActresss(ctx, filter, opts)
	if err != nil {
		log.Warn("ActressList FindManyActresss", log.Any("filter", filter), log.E(err))
		return nil, err
	}
	resp.Total = count
	resp.List = list
	return resp, nil
}

func UpdateActress(ctx context.Context, req *ActressUpdateReq) *srvdef.SrvErr {
	current, err := actress.FindOneActress(ctx, bson.M{actress.FN.Actress.Id: req.Id})
	if err != nil {
		log.Warn("UpdateActress", log.Any("id", req.Id), log.E(err))
		return err
	}
	alias := current.Alias
	if req.Param.Alias != nil {
		alias = *req.Param.Alias
	}
	keywords := current.SeoInfo.Keyworld
	if req.Param.SeoInfo != nil {
		keywords = req.Param.SeoInfo.Keyworld
	}
	exists := func(s string) bool {
		doc, _ := actress.FindOneActress(ctx, slugx.Filter(actress.FN.Actress.Slug, actress.FN.Actress.Id, s, req.Id))
		return doc != nil
	}
	slug, changed, serr := slugx.PrepareOnUpdate(current.Slug, req.Param.Slug,
		utils.SlugSourceFromKeywordsOrTitle(keywords, alias), exists)
	if serr != nil {
		return serr
	}
	if changed {
		req.Param.Slug = &slug
	} else {
		req.Param.Slug = nil
	}
	now := time.Now()
	req.Param.UpdatedAt = &now
	return actress.UpdateOneActress(ctx, bson.M{actress.FN.Actress.Id: req.Id}, bson.M{"$set": req.Param})
}

func AddActress(ctx context.Context, req *ActressAddReq) *srvdef.SrvErr {
	if len(req.Alias) == 0 {
		return srvdef.New(srvdef.ErrParamError, "alias 不能为空", "alias 不能为空")
	}
	_, err := actress.FindOneActress(ctx, bson.M{
		actress.FN.Actress.Alias: req.Alias,
	})
	if err != nil && err.Code != srvdef.ErrNoData {
		log.Warn("AddActress", log.Any("req", req), log.E(err))
		return err
	}
	if err == nil {
		log.Warn("AddActress Re", log.Any("req", req))
		return srvdef.New(srvdef.RepeatActress)
	}

	now := time.Now()
	info := &actress.Actress{
		Id:                    mongos.Lid.Actress.Get(),
		Alias:                 req.Alias,
		Slug:                  req.Slug,
		SeoInfo:               req.SeoInfo,
		Avatar:                req.Avatar,
		Cover:                 req.Cover,
		Desc:                  req.Desc,
		TranslationCategoryId: req.TranslationCategoryId,
		Meas:                  req.Meas,
		Office:                req.Office,
		DebutDate:             req.DebutDate,
		BornDate:              req.BornDate,
		Region:                req.Region,
		Score:                 req.Score,
		Rank:                  req.Rank,
		HotValue:              req.HotValue,
		Status:                req.Status,
		Works:                 0,
		Real:                  pubdef.Flow{},
		CreatedAt:             now,
		UpdatedAt:             now,
	}
	exists := func(s string) bool {
		doc, _ := actress.FindOneActress(ctx, slugx.Filter(actress.FN.Actress.Slug, actress.FN.Actress.Id, s, 0))
		return doc != nil
	}
	if serr := slugx.Ensure(&info.Slug, utils.SlugSourceFromKeywordsOrTitle(info.SeoInfo.Keyworld, info.Alias), exists); serr != nil {
		return serr
	}
	return actress.InsertOneActress(ctx, info)
}

func DeleteActress(ctx context.Context, req *ActressDelReq) *srvdef.SrvErr {
	_, err := actress.FindOneActress(ctx, bson.M{actress.FN.Actress.Id: req.Id})
	if err != nil {
		log.Warn("DeleteActress", log.Any("id", req.Id), log.E(err))
		return err
	}
	_, err = actress.DelOneActress(ctx, bson.M{actress.FN.Actress.Id: req.Id})
	return err
}