You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
606 lines
18 KiB
606 lines
18 KiB
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 |
|
}
|
|
|