607 lines
18 KiB
Go
607 lines
18 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"fmt"
|
||
"net"
|
||
"time"
|
||
|
||
"go-common/app/admin/main/activity/model"
|
||
tagmdl "go-common/app/interface/main/tag/model"
|
||
artmdl "go-common/app/interface/openplatform/article/model"
|
||
acccli "go-common/app/service/main/account/api"
|
||
arcmdl "go-common/app/service/main/archive/api"
|
||
"go-common/library/ecode"
|
||
"go-common/library/log"
|
||
"go-common/library/net/metadata"
|
||
"go-common/library/sync/errgroup"
|
||
xtime "go-common/library/time"
|
||
"go-common/library/xstr"
|
||
|
||
"github.com/jinzhu/gorm"
|
||
)
|
||
|
||
const (
|
||
_approved = 1
|
||
_pending = 0
|
||
_tagArcType = 3
|
||
)
|
||
|
||
// LikesList .
|
||
func (s *Service) LikesList(c context.Context, arg *model.LikesParam) (outRes *model.LikesRes, err error) {
|
||
var (
|
||
likeSubject *model.ActSubject
|
||
list []*model.Like
|
||
likeList map[int64]*model.Like
|
||
ids, wids, mids []int64
|
||
count int64
|
||
offset int
|
||
)
|
||
if likeSubject, err = s.dao.ActSubject(c, arg.Sid); err != nil {
|
||
return
|
||
}
|
||
db := s.DB
|
||
db = db.Where("sid = ?", likeSubject.ID)
|
||
if len(arg.States) > 0 {
|
||
db = db.Where("state in (?)", arg.States)
|
||
}
|
||
if arg.Mid > 0 {
|
||
db = db.Where("mid = ?", arg.Mid)
|
||
}
|
||
if arg.Wid > 0 {
|
||
db = db.Where("wid = ?", arg.Wid)
|
||
}
|
||
if err = db.Model(model.Like{}).Count(&count).Error; err != nil {
|
||
log.Error("db.Model(model.Like{}).Count() arg(%v) error(%v) ", arg, err)
|
||
return
|
||
}
|
||
offset = (arg.Page - 1) * arg.PageSize
|
||
if err = db.Offset(offset).Limit(arg.PageSize).Order("id asc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
|
||
log.Error("db.Model(model.Like{}).Find() arg(%v) error(%v)", arg, err)
|
||
return
|
||
}
|
||
likeList = make(map[int64]*model.Like, len(list))
|
||
ids = make([]int64, 0, len(list))
|
||
wids = make([]int64, 0, len(list))
|
||
mids = make([]int64, 0, len(list))
|
||
for _, val := range list {
|
||
ids = append(ids, val.ID)
|
||
wids = append(wids, val.Wid)
|
||
mids = append(mids, val.Mid)
|
||
likeList[val.ID] = val
|
||
//like 根据最新的逻辑获取，现在无法获取 todo
|
||
likeList[val.ID].Like = 0
|
||
}
|
||
if len(list) > 0 {
|
||
if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
|
||
log.Error("s.GetContent(%d,%v,%v,%v,%v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
|
||
return
|
||
}
|
||
}
|
||
outRes = &model.LikesRes{
|
||
Likes: likeList,
|
||
}
|
||
outRes.Size = arg.PageSize
|
||
outRes.Num = arg.Page
|
||
outRes.Total = count
|
||
return
|
||
}
|
||
|
||
// Likes .
|
||
func (s *Service) Likes(c context.Context, Sid int64, lids []int64) (likeList map[int64]*model.Like, err error) {
|
||
var (
|
||
likeSubject *model.ActSubject
|
||
like []*model.Like
|
||
ids, wids, mids []int64
|
||
)
|
||
if likeSubject, err = s.dao.ActSubject(c, Sid); err != nil {
|
||
return
|
||
}
|
||
if err = s.DB.Where("id in (?)", lids).Find(&like).Error; err != nil {
|
||
log.Error("s.DB.Where(id in (%v)).Find() error(%v)", lids, err)
|
||
return
|
||
}
|
||
likeList = make(map[int64]*model.Like, len(like))
|
||
ids = make([]int64, 0, len(like))
|
||
wids = make([]int64, 0, len(like))
|
||
mids = make([]int64, 0, len(like))
|
||
for _, val := range like {
|
||
ids = append(ids, val.ID)
|
||
wids = append(wids, val.Wid)
|
||
mids = append(mids, val.Mid)
|
||
likeList[val.ID] = val
|
||
//like 根据最新的逻辑获取，现在无法获取 todo
|
||
likeList[val.ID].Like = 0
|
||
}
|
||
if len(like) > 0 {
|
||
if err = s.GetContent(c, likeSubject.Type, likeList, ids, wids, mids); err != nil {
|
||
log.Error("s.GetContent( %d, %v, %v, %v, %v) error(%v)", likeSubject.Type, likeList, ids, mids, wids, err)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// archiveWithTag get archives and tags.
|
||
func (s *Service) archiveWithTag(c context.Context, aids []int64, likes map[int64]*model.Like) (err error) {
|
||
var (
|
||
archives *arcmdl.ArcsReply
|
||
arcErr, tagErr error
|
||
tags map[int64][]*tagmdl.Tag
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
)
|
||
group, errCtx := errgroup.WithContext(c)
|
||
group.Go(func() error {
|
||
if archives, arcErr = s.arcClient.Arcs(errCtx, &arcmdl.ArcsRequest{Aids: aids}); err != nil {
|
||
log.Error("s.arcClient.Arcs(%v, %s) error(%v)", aids, ip, err)
|
||
return arcErr
|
||
}
|
||
return nil
|
||
})
|
||
group.Go(func() error {
|
||
arg := &tagmdl.ArgResTags{Oids: aids, Type: _tagArcType, RealIP: ip}
|
||
if tags, tagErr = s.tagRPC.ResTags(errCtx, arg); tagErr != nil {
|
||
log.Error("ResTags接口错误 s.tag.ResTag(%+v) error(%v)", arg, tagErr)
|
||
return tagErr
|
||
}
|
||
return nil
|
||
})
|
||
if err = group.Wait(); err != nil {
|
||
return
|
||
}
|
||
for _, val := range likes {
|
||
if val.Wid != 0 {
|
||
tem := make(map[string]interface{}, 2)
|
||
if arch, ok := archives.Arcs[val.Wid]; ok && arch.IsNormal() {
|
||
tem["archives"] = arch
|
||
}
|
||
if tag, ok := tags[val.Wid]; ok {
|
||
temps := make([]string, 0, len(tag))
|
||
for _, val := range tag {
|
||
temps = append(temps, val.Name)
|
||
}
|
||
tem["tags"] = temps
|
||
}
|
||
val.Object = tem
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// accountAndContent get likecontent and accountinfo .
|
||
func (s *Service) accountAndContent(c context.Context, ids []int64, mids []int64, likes map[int64]*model.Like) (err error) {
|
||
var (
|
||
contents map[int64]*model.LikeContent
|
||
accRly *acccli.CardsReply
|
||
)
|
||
if contents, err = s.dao.GetLikeContent(c, ids); err != nil {
|
||
log.Error(" s.dao.GetLikeContent(%v) error(%v)", ids, err)
|
||
return
|
||
}
|
||
if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
|
||
log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
|
||
return
|
||
}
|
||
for _, val := range likes {
|
||
temp := make(map[string]interface{}, 2)
|
||
if cont, ok := contents[val.ID]; ok {
|
||
temp["content"] = cont
|
||
}
|
||
if val.Mid != 0 && accRly != nil {
|
||
if acct, ok := accRly.Cards[val.Mid]; ok {
|
||
temp["owner"] = map[string]interface{}{
|
||
"mid": acct.Mid,
|
||
"name": acct.Name,
|
||
"face": acct.Face,
|
||
"sex": acct.Sex,
|
||
"level": acct.Level,
|
||
}
|
||
}
|
||
}
|
||
val.Object = temp
|
||
}
|
||
return
|
||
}
|
||
|
||
// articles .
|
||
func (s *Service) articles(c context.Context, wids []int64, likes map[int64]*model.Like) (err error) {
|
||
var artiRes map[int64]*artmdl.Meta
|
||
if artiRes, err = s.artRPC.ArticleMetas(c, &artmdl.ArgAids{Aids: wids}); err != nil {
|
||
log.Error("s.ArticleMetas(%v) error(%v)", wids, err)
|
||
return
|
||
}
|
||
for _, val := range likes {
|
||
if val.Wid != 0 {
|
||
if v, ok := artiRes[val.Wid]; ok {
|
||
val.Object = map[string]interface{}{
|
||
"article": v,
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// musicsAndAct .
|
||
func (s *Service) musicsAndAct(c context.Context, wids, mids []int64, likes map[int64]*model.Like) (err error) {
|
||
var (
|
||
musics *model.MusicRes
|
||
accRly *acccli.CardsReply
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
)
|
||
if musics, err = s.dao.Musics(c, wids, ip); err != nil {
|
||
log.Error("s.dao.Musics(%v) error(%+v)", wids, err)
|
||
return
|
||
}
|
||
if accRly, err = s.accClient.Cards3(c, &acccli.MidsReq{Mids: mids}); err != nil {
|
||
log.Error("s.AccountsInfo(%v) error(%v)", mids, err)
|
||
return
|
||
}
|
||
for _, val := range likes {
|
||
temp := make(map[string]interface{}, 2)
|
||
if v, ok := musics.Data[val.Wid]; ok {
|
||
temp["music"] = v
|
||
}
|
||
if val.Mid != 0 && accRly != nil {
|
||
if acct, ok := accRly.Cards[val.Mid]; ok {
|
||
temp["owner"] = map[string]interface{}{
|
||
"mid": acct.Mid,
|
||
"name": acct.Name,
|
||
"face": acct.Face,
|
||
"sex": acct.Sex,
|
||
"level": acct.Level,
|
||
}
|
||
}
|
||
}
|
||
val.Object = temp
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetContent get act_subjet extensions .
|
||
func (s *Service) GetContent(c context.Context, likeSubType int, likes map[int64]*model.Like, ids []int64, wids []int64, mids []int64) (err error) {
|
||
switch likeSubType {
|
||
case model.PICTURE, model.PICTURELIKE, model.DRAWYOO, model.DRAWYOOLIKE, model.TEXT, model.TEXTLIKE, model.QUESTION:
|
||
err = s.accountAndContent(c, ids, mids, likes)
|
||
case model.VIDEO, model.VIDEOLIKE, model.ONLINEVOTE, model.VIDEO2, model.PHONEVIDEO, model.SMALLVIDEO:
|
||
err = s.archiveWithTag(c, wids, likes)
|
||
case model.ARTICLE:
|
||
err = s.articles(c, wids, likes)
|
||
case model.MUSIC:
|
||
err = s.musicsAndAct(c, wids, mids, likes)
|
||
default:
|
||
err = ecode.RequestErr
|
||
}
|
||
return
|
||
}
|
||
|
||
// ItemUp .
|
||
func (s *Service) ItemUp(c context.Context, sid, wid int64, state int) (likeList *model.Like, err error) {
|
||
var likeSubject *model.ActSubject
|
||
if likeSubject, err = s.dao.ActSubject(c, sid); err != nil {
|
||
log.Error("s.GetLikesSubjectByID(%d) error(%v)", sid, err)
|
||
return
|
||
}
|
||
likeList = new(model.Like)
|
||
if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
|
||
log.Error("s.DB.Model(model.Like{}).Where(sid =? %d).Where(wid = ?, %d).Last(),error(%v)", likeSubject.ID, wid, err)
|
||
return
|
||
}
|
||
if likeList.ID == 0 {
|
||
err = nil
|
||
return
|
||
}
|
||
likeList.State = state
|
||
likeList.Mtime = xtime.Time(time.Now().Unix())
|
||
if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": state, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
|
||
log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// ItemAdd .
|
||
func (s *Service) ItemAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
|
||
var (
|
||
likeSubject *model.ActSubject
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
)
|
||
if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
|
||
log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
|
||
return
|
||
}
|
||
//怀疑原代码这里是个bug？？ todo
|
||
if args.Type != likeSubject.Type {
|
||
err = errors.New("ItemAdd params liketype error")
|
||
return
|
||
}
|
||
likeList = new(model.Like)
|
||
if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
|
||
log.Error("s.DB.Model(model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
|
||
return
|
||
}
|
||
if err == gorm.ErrRecordNotFound {
|
||
addLike := &model.Like{
|
||
Type: args.Type,
|
||
Wid: args.Wid,
|
||
Sid: likeSubject.ID,
|
||
Mid: args.Mid,
|
||
State: args.State,
|
||
}
|
||
ipv6 := net.ParseIP(ip)
|
||
if ipv6 == nil {
|
||
ipv6 = []byte{}
|
||
}
|
||
addLikeContent := &model.LikeContent{
|
||
Plat: args.Plat,
|
||
Device: args.Device,
|
||
Message: "no",
|
||
Image: "no",
|
||
IPv6: ipv6,
|
||
}
|
||
tx := s.DB.Begin()
|
||
if err = tx.Create(addLike).Error; err != nil {
|
||
log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
addLikeContent.ID = addLike.ID
|
||
if err = tx.Create(addLikeContent).Error; err != nil {
|
||
log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", addLikeContent, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
tx.Commit()
|
||
likeList = addLike
|
||
} else {
|
||
likeList.State = args.State
|
||
likeList.Mtime = xtime.Time(time.Now().Unix())
|
||
if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": args.State, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
|
||
log.Error("s.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
|
||
}
|
||
}
|
||
return
|
||
|
||
}
|
||
|
||
// AddPicContent .
|
||
func (s *Service) AddPicContent(c context.Context, args *model.AddPic) (likeID int64, err error) {
|
||
var (
|
||
likeSubject *model.ActSubject
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
)
|
||
if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
|
||
log.Error(" s.GetLikesSubjectByID(%d) error(%v) ", args.Sid, err)
|
||
return
|
||
}
|
||
likes := &model.Like{
|
||
Sid: likeSubject.ID,
|
||
Wid: args.Wid,
|
||
Type: args.Type,
|
||
Mid: args.Mid,
|
||
State: _pending,
|
||
}
|
||
ipv6 := net.ParseIP(ip)
|
||
if ipv6 == nil {
|
||
ipv6 = []byte{}
|
||
}
|
||
likeContent := &model.LikeContent{
|
||
IPv6: ipv6,
|
||
Plat: args.Plat,
|
||
Device: args.Device,
|
||
Message: args.Message,
|
||
Link: args.Link,
|
||
Image: args.Image, //只支持传image串（需要支持传文件）todo
|
||
}
|
||
tx := s.DB.Begin()
|
||
if err = tx.Create(likes).Error; err != nil {
|
||
log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", likes, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
likeContent.ID = likes.ID
|
||
if err = tx.Create(likeContent).Error; err != nil {
|
||
log.Error("db.Model(&model.LikeContent{}).Create(%v) error(%v)\n", likeContent, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
tx.Commit()
|
||
likeID = likes.ID // need to update todo
|
||
return
|
||
}
|
||
|
||
// BatchLikes .
|
||
func (s *Service) BatchLikes(c context.Context, args *model.BatchLike) (err error) {
|
||
var (
|
||
likes []*model.Like
|
||
likeMap map[int64]*model.Like
|
||
addWid []int64
|
||
ipv6 = net.ParseIP(metadata.String(c, metadata.RemoteIP))
|
||
)
|
||
if ipv6 == nil {
|
||
ipv6 = []byte{}
|
||
}
|
||
if err = s.DB.Where(fmt.Sprintf("sid = ? and wid in (%s)", xstr.JoinInts(args.Wid)), args.Sid).Find(&likes).Error; err != nil && err != gorm.ErrRecordNotFound {
|
||
log.Error("s.DB.Where(%d,%v) error(%v)", args.Sid, args.Wid, err)
|
||
return
|
||
}
|
||
if err == gorm.ErrRecordNotFound {
|
||
addWid = args.Wid
|
||
} else {
|
||
likeMap = make(map[int64]*model.Like, len(likes))
|
||
for _, v := range likes {
|
||
likeMap[v.Wid] = v
|
||
}
|
||
addWid = make([]int64, 0, len(args.Wid))
|
||
for _, v := range args.Wid {
|
||
if _, ok := likeMap[v]; !ok {
|
||
addWid = append(addWid, v)
|
||
}
|
||
}
|
||
}
|
||
if len(addWid) == 0 {
|
||
return
|
||
}
|
||
item := &model.Like{
|
||
Sid: args.Sid,
|
||
Mid: args.Mid,
|
||
Type: args.Type,
|
||
State: _pending,
|
||
}
|
||
if err = s.dao.BatchLike(c, item, addWid, ipv6); err != nil {
|
||
log.Error("s.dao.BatchLike(%v) error(%+v)", addWid, err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// VideoAdd .
|
||
func (s *Service) VideoAdd(c context.Context, args *model.AddLikes) (likeList *model.Like, err error) {
|
||
var (
|
||
likeSubject *model.ActSubject
|
||
ip = metadata.String(c, metadata.RemoteIP)
|
||
)
|
||
if likeSubject, err = s.dao.ActSubject(c, args.Sid); err != nil {
|
||
log.Error("s.dao.ActSubject(%d) error(%v) ", args.Sid, err)
|
||
return
|
||
}
|
||
if likeSubject.Type != model.VIDEO && likeSubject.Type != model.VIDEOLIKE && likeSubject.Type != model.VIDEO2 {
|
||
err = errors.New("VideoAdd params liketype error")
|
||
return
|
||
}
|
||
likeList = new(model.Like)
|
||
if err = s.DB.Where("sid =?", likeSubject.ID).Where("wid = ?", args.Wid).Last(likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
|
||
log.Error("s.DB.Model(&model.Like{}).Where(sid =?, %d).Where(wid = ?, %d).Last() error(%v)", likeSubject.ID, args.Wid, err)
|
||
return
|
||
}
|
||
if err == gorm.ErrRecordNotFound {
|
||
addLike := &model.Like{
|
||
Type: args.Type,
|
||
Wid: args.Wid,
|
||
Sid: likeSubject.ID,
|
||
Mid: args.Mid,
|
||
State: _approved,
|
||
}
|
||
ipv6 := net.ParseIP(ip)
|
||
if ipv6 == nil {
|
||
ipv6 = []byte{}
|
||
}
|
||
addLikeContent := &model.LikeContent{
|
||
IPv6: ipv6,
|
||
Plat: args.Plat,
|
||
Device: args.Device,
|
||
Message: "no",
|
||
Image: "no",
|
||
}
|
||
tx := s.DB.Begin()
|
||
if err = tx.Create(addLike).Error; err != nil {
|
||
log.Error("db.Model(&model.Like{}).Create(%v) error(%v)", addLike, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
addLikeContent.ID = addLike.ID
|
||
if err = tx.Create(addLikeContent).Error; err != nil {
|
||
log.Error("tx.Model(&model.LikeContent{}).Create(%v) error(%v)", addLikeContent, err)
|
||
tx.Rollback()
|
||
return
|
||
}
|
||
tx.Commit()
|
||
likeList = addLike
|
||
} else {
|
||
likeList.State = _approved
|
||
likeList.Mtime = xtime.Time(time.Now().Unix())
|
||
if err = s.DB.Model(&model.Like{}).Where("id =?", likeList.ID).Update(map[string]interface{}{"state": _approved, "mtime": likeList.Mtime.Time().Format("2006-01-02 15:04:05")}).Error; err != nil {
|
||
log.Error("ls.DB.Model(&model.Like{}).Where(id =?, %d).Update() error(%v) ", likeList.ID, err)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpLikesState .
|
||
func (s *Service) UpLikesState(c context.Context, IDs []int64, state int, reply string, username string) (err error) {
|
||
if err = s.DB.Model(&model.Like{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"state": state}).Error; err != nil {
|
||
log.Info("s.DB.Model(&model.Like{}).Where(id = ?,%d).Update() error(%v)", IDs, err)
|
||
return
|
||
}
|
||
if reply != "" {
|
||
s.DB.Model(&model.LikeContent{}).Where("id in (?)", xstr.JoinInts(IDs)).Update(map[string]interface{}{"reply": reply})
|
||
}
|
||
if state != 0 {
|
||
for _, v := range IDs {
|
||
likeLog := &model.ActLikeLog{
|
||
Lid: v,
|
||
User: username,
|
||
State: int64(state),
|
||
}
|
||
s.DB.Create(likeLog)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpLike .
|
||
func (s *Service) UpLike(c context.Context, args *model.UpLike, username string) (res int64, err error) {
|
||
likes := map[string]interface{}{
|
||
"Type": args.Type,
|
||
"Mid": args.Mid,
|
||
"Wid": args.Wid,
|
||
"State": args.State,
|
||
"StickTop": args.StickTop,
|
||
}
|
||
if err = s.DB.Model(model.Like{}).Where("id = ?", args.Lid).Update(likes).Error; err != nil {
|
||
log.Error("s.DB.Model(model.Like{}).Where(id = ?, %d).Update() error(%v)", args.Lid, err)
|
||
return
|
||
}
|
||
likeContent := map[string]interface{}{
|
||
"Message": args.Message,
|
||
"Reply": args.Reply,
|
||
"Link": args.Link,
|
||
"Image": args.Image,
|
||
}
|
||
if err = s.DB.Model(model.LikeContent{}).Where("id = ?", args.Lid).Update(likeContent).Error; err != nil {
|
||
log.Error("s.DB.Model(model.LikeContent{}).Where(id = ?,%d).Update() error(%v)", args.Lid, err)
|
||
return
|
||
}
|
||
if args.State != 0 {
|
||
likeLog := &model.ActLikeLog{
|
||
Lid: args.Lid,
|
||
User: username,
|
||
State: int64(args.State),
|
||
}
|
||
s.DB.Create(likeLog)
|
||
}
|
||
res = args.Lid
|
||
return
|
||
}
|
||
|
||
// AddLike .
|
||
func (s *Service) AddLike(c context.Context, args *model.AddLikes) (likesRes *model.Like, err error) {
|
||
switch args.DealType {
|
||
case "itemUp":
|
||
likesRes, err = s.ItemUp(c, args.Sid, args.Wid, args.State)
|
||
case "itemAdd":
|
||
likesRes, err = s.ItemAdd(c, args)
|
||
case "videoAdd":
|
||
likesRes, err = s.VideoAdd(c, args)
|
||
default:
|
||
err = errors.New("type error")
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpWid .
|
||
func (s *Service) UpWid(c context.Context, args *model.UpWid) (err error) {
|
||
var (
|
||
subject *model.ActSubject
|
||
)
|
||
if subject, err = s.dao.ActSubject(c, args.Sid); err != nil {
|
||
return
|
||
}
|
||
like := map[string]interface{}{
|
||
"state": args.State,
|
||
"mtime": xtime.Time(time.Now().Unix()),
|
||
}
|
||
if err := s.DB.Model(&model.Like{}).Where("sid = ? and wid = ?", subject.ID, args.Wid).Update(like).Limit(1).Error; err != nil {
|
||
log.Error("actSrv.DB.Where(sid = %d and wid = %d).Update().Limit(1) error(%v)", subject.ID, args.Wid, err)
|
||
}
|
||
return
|
||
}
|