service/app/mix/service/logic/zonemoment.go

package logic

import (
	"service/api/consts"
	zonemomentproto "service/api/proto/zonemoment/proto"
	"service/app/mix/dao"
	"service/dbstruct"
	"service/library/logger"
	"time"

	"github.com/gin-gonic/gin"
	goproto "google.golang.org/protobuf/proto"
)

type ZoneMoment struct {
	store *dao.Store
}

func NewZoneMoment(store *dao.Store) (a *ZoneMoment) {
	a = &ZoneMoment{
		store: store,
	}
	return
}

func (p *ZoneMoment) OpCreate(ctx *gin.Context, req *zonemomentproto.OpCreateReq) (int64, error) {

	//产生zid
	zoneMomentIdSeq, err := p.store.GetAndUpdateZoneMomentIdSeq(ctx)
	if err != nil {
		logger.Error("GetAndUpdateZoneMomentIdSeq failed : %v", err)
		return 0, err
	}

	req.ZoneMoment.Id = goproto.Int64(zoneMomentIdSeq.Seq)
	req.ZoneMoment.Ct = goproto.Int64(time.Now().Unix())
	req.ZoneMoment.Ut = goproto.Int64(time.Now().Unix())
	req.ZoneMoment.DelFlag = goproto.Int64(consts.Exist)
	req.ZoneMoment.IsHeaded = goproto.Int64(consts.IsHeaded_No) // 未置顶
	err = p.store.CreateZoneMoment(ctx, req.ZoneMoment)
	if err != nil {
		logger.Error("CreateZoneMoment fail, err: %v", err)
		return 0, err
	}
	return zoneMomentIdSeq.Seq, nil
}

func (p *ZoneMoment) OpUpdate(ctx *gin.Context, req *zonemomentproto.OpUpdateReq) error {
	err := p.store.UpdateZoneMoment(ctx, req.ZoneMoment)
	if err != nil {
		logger.Error("UpdateZoneMoment fail, err: %v", err)
		return err
	}
	return nil
}

func (p *ZoneMoment) OpDelete(ctx *gin.Context, id int64) error {
	err := p.store.DeleteZoneMoment(ctx, id)
	if err != nil {
		logger.Error("DeleteZoneMoment fail, err: %v", err)
		return err
	}
	return nil
}

func (p *ZoneMoment) OpList(ctx *gin.Context, req *zonemomentproto.OpListReq) ([]*dbstruct.ZoneMoment, error) {
	list, err := p.store.GetZoneMomentList(ctx, req)
	if err != nil {
		logger.Error("GetZoneMomentList fail, err: %v", err)
		return make([]*dbstruct.ZoneMoment, 0), err
	}
	return list, nil
}

func (p *ZoneMoment) GetById(ctx *gin.Context, id int64) (*dbstruct.ZoneMoment, error) {
	zonemoment, err := p.store.GetZoneMomentById(ctx, id)
	if err != nil {
		logger.Error("GetZoneMomentList fail, err: %v", err)
		return &dbstruct.ZoneMoment{}, err
	}
	return zonemoment, nil
}

func (p *ZoneMoment) OpListByZidsOrMid(ctx *gin.Context, req *zonemomentproto.OpListByZidsOrMidReq) ([]*dbstruct.ZoneMoment, error) {
	list, err := p.store.GetZoneMomentListByZidsOrMid(ctx, req)
	if err != nil {
		logger.Error("GetZoneMomentListByZids fail, err: %v", err)
		return make([]*dbstruct.ZoneMoment, 0), err
	}
	return list, nil
}

func (p *ZoneMoment) OpListByZid(ctx *gin.Context, req *zonemomentproto.OpListByZidReq) ([]*dbstruct.ZoneMoment, error) {
	list, err := p.store.GetZoneMomentListByZid(ctx, req)
	if err != nil {
		logger.Error("GetZoneMomentListByZid fail, err: %v", err)
		return make([]*dbstruct.ZoneMoment, 0), err
	}
	return list, nil
}

func (p *ZoneMoment) OpListByMid(ctx *gin.Context, req *zonemomentproto.OpListByMidReq) ([]*dbstruct.ZoneMoment, error) {
	list, err := p.store.GetZoneMomentListByMid(ctx, req)
	if err != nil {
		logger.Error("GetZoneMomentListByMid fail, err: %v", err)
		return make([]*dbstruct.ZoneMoment, 0), err
	}
	return list, nil
}

func (p *ZoneMoment) OpZoneMomentThumbsUp(ctx *gin.Context, req *zonemomentproto.OpZoneMomentThumbsUpReq) (err error) {
	//更新Moment中的点赞个数
	err = p.store.ThumbsUpZoneMoment(ctx, req)

	if err != nil {
		logger.Error("ThumbsUpMoment fail, err: %v", err)
		return
	}
	return
}

func (p *ZoneMoment) TryToCompleteAudit(ctx *gin.Context, zonemomentId int64) error {
	err := p.store.TryToCompleteZoneMomentAudit(ctx, zonemomentId)
	if err != nil {
		logger.Error("TryToCompleteZoneMomentAudit fail, err: %v", err)
		return err
	}
	return nil
}

func (p *ZoneMoment) OpCountByMidAndCType(ctx *gin.Context, mid int64, cType int64) (int64, error) {
	count, err := p.store.GetZoneMomentCountByMidAndCType(ctx, mid, cType)
	if err != nil {
		logger.Error("GetZoneMomentCountByMidAndCType fail, err: %v", err)
		return 0, err
	}
	return count, nil
}

func (p *ZoneMoment) OpUpdateByIdsAndStatus(ctx *gin.Context, req *zonemomentproto.OpUpdateReq, ids []int64, status int64) error {
	err := p.store.UpdateZoneMomentByIdsAndStatus(ctx, req.ZoneMoment, ids, status)
	if err != nil {
		logger.Error("UpdateZoneMomentByIdsAndStatus fail, err: %v", err)
		return err
	}
	return nil
}

func (p *ZoneMoment) GetZidsByZoneMomentIds(ctx *gin.Context, zonemomentIds []int64) ([]int64, error) {
	zids, err := p.store.GetZidsByZoneMomentIds(ctx, zonemomentIds)
	if err != nil {
		logger.Error("GetZidsByZoneMomentIds fail, err: %v", err)
		return nil, err
	}
	return zids, err
}

func (p *ZoneMoment) OpHeadByIds(ctx *gin.Context, ids []int64, opType int64) error {
	err := p.store.HeadZoneMomentByIds(ctx, ids, opType)
	if err != nil {
		logger.Error("HeadZoneMomentByIds fail, err: %v", err)
		return err
	}
	return nil
}

func (p *ZoneMoment) OpCountByMidAndStatus(ctx *gin.Context, mid int64, status int64) (int64, error) {
	count, err := p.store.GetZoneMomentCountByMidAndStatus(ctx, mid, status)
	if err != nil {
		logger.Error("GetZoneMomentCountByMidAndStatus fail, err: %v", err)
		return 0, err
	}
	return count, nil
}