308 lines
9.5 KiB
Go
308 lines
9.5 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"go-common/app/admin/main/activity/model"
|
|
articlemodel "go-common/app/interface/openplatform/article/model"
|
|
"go-common/library/log"
|
|
"go-common/library/net/metadata"
|
|
|
|
"github.com/jinzhu/gorm"
|
|
)
|
|
|
|
// GetArticleMetas from rpc .
|
|
func (s *Service) GetArticleMetas(c context.Context, aids []int64) (res map[int64]*articlemodel.Meta, err error) {
|
|
if res, err = s.artRPC.ArticleMetas(c, &articlemodel.ArgAids{Aids: aids}); err != nil {
|
|
log.Error("s.ArticleMetas(%v) error(%v)", aids, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SubjectList get subject list .
|
|
func (s *Service) SubjectList(c context.Context, listParams *model.ListSub) (listRes *model.SubListRes, err error) {
|
|
var (
|
|
count int64
|
|
list []*model.ActSubject
|
|
)
|
|
db := s.DB
|
|
if listParams.Keyword != "" {
|
|
names := listParams.Keyword + "%"
|
|
db = db.Where("`id` = ? or `name` like ? or `author` like ?", listParams.Keyword, names, names)
|
|
}
|
|
if listParams.Sctime != 0 {
|
|
parseScime := time.Unix(listParams.Sctime, 0)
|
|
db = db.Where("ctime >= ?", parseScime.Format("2006-01-02 15:04:05"))
|
|
}
|
|
if listParams.Ectime != 0 {
|
|
parseEcime := time.Unix(listParams.Ectime, 0)
|
|
db = db.Where("etime <= ?", parseEcime.Format("2006-01-02 15:04:05"))
|
|
}
|
|
if len(listParams.States) > 0 {
|
|
db = db.Where("state in (?)", listParams.States)
|
|
}
|
|
if len(listParams.Types) > 0 {
|
|
db = db.Where("type in (?)", listParams.Types)
|
|
}
|
|
if err = db.Offset((listParams.Page - 1) * listParams.PageSize).Limit(listParams.PageSize).Order("id desc").Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error(" db.Model(&model.ActSubject{}).Find() args(%v) error(%v)", listParams, err)
|
|
return
|
|
}
|
|
if err = db.Model(&model.ActSubject{}).Count(&count).Error; err != nil {
|
|
log.Error("db.Model(&model.ActSubject{}).Count() args(%v) error(%v)", listParams, err)
|
|
return
|
|
}
|
|
listRes = &model.SubListRes{
|
|
List: list,
|
|
Page: &model.PageRes{
|
|
Num: listParams.Page,
|
|
Size: listParams.PageSize,
|
|
Total: count,
|
|
},
|
|
}
|
|
return
|
|
}
|
|
|
|
// VideoList .
|
|
func (s *Service) VideoList(c context.Context) (res []*model.ActSubjectResult, err error) {
|
|
var (
|
|
types = []int{1, 4}
|
|
list []*model.ActSubject
|
|
likeList []*model.Like
|
|
)
|
|
db := s.DB
|
|
if err = db.Where("state = ?", 1).Where("type in (?)", types).Find(&list).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("db.Model(&model.ActSubject{}).Where(state = ?, 1).Where(type in (?), %v).Find() error(%v)", types, err)
|
|
return
|
|
}
|
|
listCount := len(list)
|
|
if listCount == 0 {
|
|
return
|
|
}
|
|
sids := make([]int64, 0, listCount)
|
|
for _, value := range list {
|
|
sids = append(sids, value.ID)
|
|
}
|
|
if err = db.Where("sid in (?)", sids).Where("wid > ?", 0).Find(&likeList).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("db.Model(&model.Like{}).Where(sid in (?), %v).Find() error(%v)", sids, err)
|
|
return
|
|
}
|
|
hashList := make(map[int64][]int64)
|
|
for _, value := range likeList {
|
|
hashList[value.Sid] = append(hashList[value.Sid], value.Wid)
|
|
}
|
|
res = make([]*model.ActSubjectResult, 0, len(list))
|
|
for _, value := range list {
|
|
rs := &model.ActSubjectResult{
|
|
ActSubject: value,
|
|
}
|
|
if v, ok := hashList[value.ID]; ok {
|
|
rs.Aids = v
|
|
}
|
|
res = append(res, rs)
|
|
}
|
|
return
|
|
}
|
|
|
|
// AddActSubject .
|
|
func (s *Service) AddActSubject(c context.Context, params *model.AddList) (res int64, err error) {
|
|
if params.ScreenSet != 2 {
|
|
params.ScreenSet = 1
|
|
}
|
|
protect := &model.ActSubjectProtocol{
|
|
Protocol: params.Protocol,
|
|
Types: params.Types,
|
|
Pubtime: params.Pubtime,
|
|
Deltime: params.Deltime,
|
|
Editime: params.Editime,
|
|
Tags: params.Tags,
|
|
Hot: params.Hot,
|
|
BgmID: params.BgmID,
|
|
Oids: params.Oids,
|
|
ScreenSet: params.ScreenSet,
|
|
PasterID: params.PasterID,
|
|
}
|
|
actTime := &model.ActTimeConfig{
|
|
Interval: params.Interval,
|
|
Tlimit: params.Tlimit,
|
|
Ltime: params.Ltime,
|
|
}
|
|
if params.Tags != "" {
|
|
if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
|
|
log.Error("s.AddTags(%s,) error(%v)", params.Tags, err)
|
|
return
|
|
}
|
|
}
|
|
actSub := &model.ActSubject{
|
|
Oid: params.ActSubject.Oid,
|
|
Type: params.ActSubject.Type,
|
|
State: params.ActSubject.State,
|
|
Level: params.ActSubject.Level,
|
|
Flag: params.ActSubject.Flag,
|
|
Rank: params.ActSubject.Rank,
|
|
Stime: params.ActSubject.Stime,
|
|
Etime: params.ActSubject.Etime,
|
|
Lstime: params.ActSubject.Lstime,
|
|
Letime: params.ActSubject.Letime,
|
|
Uetime: params.ActSubject.Uetime,
|
|
Ustime: params.ActSubject.Ustime,
|
|
Name: params.ActSubject.Name,
|
|
Author: params.ActSubject.Author,
|
|
ActURL: params.ActSubject.ActURL,
|
|
Cover: params.ActSubject.Cover,
|
|
Dic: params.ActSubject.Dic,
|
|
H5Cover: params.ActSubject.H5Cover,
|
|
LikeLimit: params.ActSubject.LikeLimit,
|
|
AndroidURL: params.ActSubject.AndroidURL,
|
|
IosURL: params.ActSubject.IosURL,
|
|
}
|
|
if err = s.DB.Create(actSub).Error; err != nil {
|
|
log.Error("s.DB.Create(%v) error(%v)", actSub, err)
|
|
return
|
|
}
|
|
protect.Sid = actSub.ID
|
|
if err = s.DB.Create(protect).Error; err != nil {
|
|
log.Error("s.DB.Create(%v) error(%v)", protect, err)
|
|
return
|
|
}
|
|
if params.Type == model.ONLINEVOTE {
|
|
actTime.Sid = actSub.ID
|
|
if err = s.DB.Create(actTime).Error; err != nil {
|
|
log.Error("s.DB.Create(%v) error(%v)", actTime, err)
|
|
return
|
|
}
|
|
}
|
|
res = actSub.ID
|
|
return
|
|
}
|
|
|
|
// UpActSubject .
|
|
func (s *Service) UpActSubject(c context.Context, params *model.AddList, sid int64) (res int64, err error) {
|
|
if params.ScreenSet != 2 {
|
|
params.ScreenSet = 1
|
|
}
|
|
onlineData := &model.ActTimeConfig{
|
|
Interval: params.Interval,
|
|
Tlimit: params.Tlimit,
|
|
Ltime: params.Ltime,
|
|
}
|
|
actSubject := new(model.ActSubject)
|
|
if err = s.DB.Where("id = ?", sid).Last(actSubject).Error; err != nil {
|
|
log.Error("s.DB.Where(id = ?, %d).Last(%v) error(%v)", sid, actSubject, err)
|
|
return
|
|
}
|
|
data := map[string]interface{}{
|
|
"Oid": params.Oid,
|
|
"Type": params.Type,
|
|
"State": params.State,
|
|
"Level": params.Level,
|
|
"Flag": params.Flag,
|
|
"Rank": params.Rank,
|
|
"Stime": params.Stime,
|
|
"Etime": params.Etime,
|
|
"Lstime": params.Lstime,
|
|
"Uetime": params.Uetime,
|
|
"Ustime": params.Ustime,
|
|
"Name": params.Name,
|
|
"Author": params.Author,
|
|
"ActURL": params.ActURL,
|
|
"Cover": params.Cover,
|
|
"Dic": params.Dic,
|
|
"H5Cover": params.H5Cover,
|
|
"LikeLimit": params.LikeLimit,
|
|
"AndroidURL": params.AndroidURL,
|
|
"IosURL": params.IosURL,
|
|
}
|
|
if err = s.DB.Model(&model.ActSubject{}).Where("id = ?", sid).Update(data).Error; err != nil {
|
|
log.Error("s.DB.Model(&model.ActSubject{}).Where(id = ?, %d).Update(%v) error(%v)", sid, data, err)
|
|
return
|
|
}
|
|
item := new(model.ActSubjectProtocol)
|
|
if err = s.DB.Where("sid = ? ", sid).Last(item).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("s.DB.Where(sid = ? , %d).Last(%v) error(%v)", sid, item, err)
|
|
return
|
|
}
|
|
//item有值
|
|
if item.ID > 0 {
|
|
if params.Tags != "" {
|
|
if item.Tags != params.Tags {
|
|
if err = s.dao.AddTags(c, params.Tags, metadata.String(c, metadata.RemoteIP)); err != nil {
|
|
log.Error("s.AddTags(%s) error(%v)", params.Tags, err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
upProtectData := map[string]interface{}{
|
|
"Protocol": params.Protocol,
|
|
"Types": params.Types,
|
|
"Pubtime": params.Pubtime,
|
|
"Deltime": params.Deltime,
|
|
"Editime": params.Editime,
|
|
"Hot": params.Hot,
|
|
"BgmID": params.BgmID,
|
|
"Oids": params.Oids,
|
|
"ScreenSet": params.ScreenSet,
|
|
"PasterID": params.PasterID,
|
|
"Tags": params.Tags,
|
|
}
|
|
if err = s.DB.Model(&model.ActSubjectProtocol{}).Where("id = ?", item.ID).Update(upProtectData).Error; err != nil {
|
|
log.Error("s.DB.Model(&model.ActSubjectProtocol{}).Where(id = ?, %d).Update(%v) error(%v)", item.ID, upProtectData, err)
|
|
return
|
|
}
|
|
} else {
|
|
protectDtata := &model.ActSubjectProtocol{
|
|
Protocol: params.Protocol,
|
|
Types: params.Types,
|
|
Pubtime: params.Pubtime,
|
|
Deltime: params.Deltime,
|
|
Editime: params.Editime,
|
|
Hot: params.Hot,
|
|
BgmID: params.BgmID,
|
|
Oids: params.Oids,
|
|
ScreenSet: params.ScreenSet,
|
|
PasterID: params.PasterID,
|
|
Sid: sid,
|
|
}
|
|
if err = s.DB.Create(protectDtata).Error; err != nil {
|
|
log.Error("s.DB.Create(%v) error(%v)", protectDtata, err)
|
|
return
|
|
}
|
|
}
|
|
if actSubject.Type == model.ONLINEVOTE {
|
|
onlineData.Sid = sid
|
|
output := new(model.ActTimeConfig)
|
|
if err = s.DB.Where("sid = ?", sid).Last(output).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("s.DB.Where(sid = ?, %d).Last(%v) error(%v)", sid, output, err)
|
|
return
|
|
}
|
|
if output.ID > 0 {
|
|
if err = s.DB.Model(&model.ActTimeConfig{}).Where("id = ?", output.ID).Update(onlineData).Error; err != nil {
|
|
log.Error("s.DB.Model(&model.ActTimeConfig{}).Where(id = ?, %d).Update(%v) error(%v)", output.ID, onlineData, err)
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
res = sid
|
|
return
|
|
}
|
|
|
|
// SubProtocol .
|
|
func (s *Service) SubProtocol(c context.Context, sid int64) (res *model.ActSubjectProtocol, err error) {
|
|
res = &model.ActSubjectProtocol{}
|
|
if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("s.DB.Where(sid = %d ) error(%v)", sid, err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// TimeConf .
|
|
func (s *Service) TimeConf(c context.Context, sid int64) (res *model.ActTimeConfig, err error) {
|
|
res = new(model.ActTimeConfig)
|
|
if err = s.DB.Where("sid = ?", sid).First(res).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
log.Error("actSrv.DB.Where(sid = ?, %d) error(%v)", sid, err)
|
|
}
|
|
return
|
|
}
|