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.
775 lines
18 KiB
775 lines
18 KiB
package http |
|
|
|
import ( |
|
"encoding/json" |
|
"io/ioutil" |
|
"net/http" |
|
"time" |
|
|
|
"go-common/app/admin/main/creative/model/academy" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
bm "go-common/library/net/http/blademaster" |
|
"go-common/library/net/http/blademaster/binding" |
|
"go-common/library/net/http/blademaster/render" |
|
"go-common/library/sync/errgroup" |
|
"go-common/library/xstr" |
|
|
|
"github.com/jinzhu/gorm" |
|
) |
|
|
|
func addOccupation(c *bm.Context) { |
|
var ( |
|
err error |
|
now = time.Now().Format("2006-01-02 15:04:05") |
|
) |
|
v := new(academy.Occupation) |
|
if err = c.Bind(v); err != nil { |
|
log.Error("addOccupation c.Bind error(%v)", err) |
|
return |
|
} |
|
m := &academy.Occupation{ |
|
State: academy.StateNormal, |
|
Name: v.Name, |
|
Desc: v.Desc, |
|
Logo: v.Logo, |
|
MainStep: v.MainStep, |
|
MainSoftware: v.MainSoftware, |
|
CTime: now, |
|
MTime: now, |
|
} |
|
tx := svc.DB.Begin() |
|
if err = tx.Create(m).Error; err != nil { |
|
log.Error("academy addOccupation error(%v)", err) |
|
c.JSON(nil, err) |
|
tx.Rollback() |
|
return |
|
} |
|
if err = tx.Model(&academy.Occupation{}).Where("id=?", m.ID).Updates(map[string]interface{}{ |
|
"rank": m.ID, |
|
}).Error; err != nil { |
|
log.Error("academy addOccupation error(%v)", err) |
|
tx.Rollback() |
|
} |
|
tx.Commit() |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "添加职业", TID: m.ID, OName: m.Name}) |
|
c.JSON(map[string]interface{}{ |
|
"id": m.ID, |
|
}, nil) |
|
} |
|
|
|
func upOccupation(c *bm.Context) { |
|
var ( |
|
oc = &academy.Occupation{} |
|
err error |
|
) |
|
v := new(academy.Occupation) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(oc).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if oc == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Occupation{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"name": v.Name, |
|
"desc": v.Desc, |
|
"logo": v.Logo, |
|
"main_step": v.MainStep, |
|
"main_software": v.MainSoftware, |
|
}).Error; err != nil { |
|
log.Error("academy bindOccupation error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新职业", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func bindOccupation(c *bm.Context) { |
|
var ( |
|
oc = &academy.Occupation{} |
|
err error |
|
) |
|
v := new(academy.Occupation) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(oc).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if oc == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Occupation{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"state": v.State, |
|
}).Error; err != nil { |
|
log.Error("academy upOccupation error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新职业", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func addSkill(c *bm.Context) { |
|
var ( |
|
err error |
|
now = time.Now().Format("2006-01-02 15:04:05") |
|
) |
|
v := new(academy.Skill) |
|
if err = c.Bind(v); err != nil { |
|
log.Error("addSkill c.Bind error(%v)", err) |
|
return |
|
} |
|
m := &academy.Skill{ |
|
State: academy.StateNormal, |
|
OID: v.OID, |
|
Name: v.Name, |
|
Desc: v.Desc, |
|
CTime: now, |
|
MTime: now, |
|
} |
|
if err = svc.DB.Create(m).Error; err != nil { |
|
log.Error("academy addSkill error(%v)", err) |
|
c.JSON(nil, err) |
|
return |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "添加步骤", TID: m.ID, OName: m.Name}) |
|
c.JSON(map[string]interface{}{ |
|
"id": m.ID, |
|
}, nil) |
|
} |
|
|
|
func upSkill(c *bm.Context) { |
|
var ( |
|
sk = &academy.Skill{} |
|
err error |
|
) |
|
v := new(academy.Skill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(sk).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if sk == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Skill{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"name": v.Name, |
|
"desc": v.Desc, |
|
}).Error; err != nil { |
|
log.Error("academy upSkill error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新步骤", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func bindSkill(c *bm.Context) { |
|
var ( |
|
oc = &academy.Skill{} |
|
err error |
|
) |
|
v := new(academy.Skill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(oc).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if oc == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Skill{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"state": v.State, |
|
}).Error; err != nil { |
|
log.Error("academy bindSkill error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新职业", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func addSoftware(c *bm.Context) { |
|
var ( |
|
err error |
|
now = time.Now().Format("2006-01-02 15:04:05") |
|
) |
|
v := new(academy.Software) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
m := &academy.Software{ |
|
State: academy.StateNormal, |
|
SkID: v.SkID, |
|
Name: v.Name, |
|
Desc: v.Desc, |
|
CTime: now, |
|
MTime: now, |
|
} |
|
if err = svc.DB.Create(m).Error; err != nil { |
|
log.Error("academy addSoftware error(%v)", err) |
|
c.JSON(nil, err) |
|
return |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "添加步骤", TID: m.ID, OName: m.Name}) |
|
c.JSON(map[string]interface{}{ |
|
"id": m.ID, |
|
}, nil) |
|
} |
|
|
|
func upSoftware(c *bm.Context) { |
|
var ( |
|
oc = &academy.Software{} |
|
err error |
|
) |
|
v := new(academy.Software) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(oc).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if oc == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Software{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"name": v.Name, |
|
"desc": v.Desc, |
|
}).Error; err != nil { |
|
log.Error("academy upSoftware error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新步骤", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func bindSoftware(c *bm.Context) { |
|
var ( |
|
oc = &academy.Software{} |
|
err error |
|
) |
|
v := new(academy.Software) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if err = svc.DB.Where("id=?", v.ID).Find(oc).Error; err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if oc == nil { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.Software{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"state": v.State, |
|
}).Error; err != nil { |
|
log.Error("academy bindSoftware error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新职业", TID: v.ID, OName: v.Name}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func listOccupation(c *bm.Context) { |
|
var ( |
|
ocs []*academy.Occupation |
|
sks []*academy.Skill |
|
sfs []*academy.Software |
|
|
|
sfMap map[int64][]*academy.Software |
|
skMap map[int64][]*academy.Skill |
|
|
|
sfIDs, skIDs, oIDs []int64 |
|
softMap, skillMap, occMap map[int64]int |
|
|
|
g, _ = errgroup.WithContext(c) |
|
err error |
|
) |
|
|
|
g.Go(func() error { //软件 |
|
if err = svc.DB.Find(&sfs).Error; err != nil { |
|
log.Error("listSoftware error(%v)", err) |
|
return err |
|
} |
|
|
|
if len(sfs) == 0 { |
|
return nil |
|
} |
|
|
|
sfMap = make(map[int64][]*academy.Software) |
|
sfIDs = make([]int64, 0, len(sfs)) |
|
for _, v := range sfs { |
|
sfMap[v.SkID] = append(sfMap[v.SkID], v) //按技能聚合软件 |
|
sfIDs = append(sfIDs, v.ID) |
|
} |
|
softMap, _ = arcCountBySids(sfIDs) //获取软件对应稿件数量 |
|
|
|
if len(softMap) == 0 { |
|
return nil |
|
} |
|
for _, v := range sfs { |
|
if n, ok := softMap[v.ID]; ok { //映射软件对应稿件数量 |
|
v.Count = n |
|
} |
|
} |
|
|
|
return nil |
|
}) |
|
|
|
g.Go(func() error { //技能 |
|
if err = svc.DB.Find(&sks).Error; err != nil { |
|
log.Error("listSkill error(%v)", err) |
|
return err |
|
} |
|
|
|
if len(sks) == 0 { |
|
return nil |
|
} |
|
|
|
skMap = make(map[int64][]*academy.Skill) |
|
skIDs = make([]int64, 0, len(sks)) |
|
for _, v := range sks { |
|
skMap[v.OID] = append(skMap[v.OID], v) //按职业聚合技能 |
|
skIDs = append(skIDs, v.ID) |
|
} |
|
skillMap, _ = arcCountBySkids(skIDs) //获取技能对应稿件数量 |
|
return nil |
|
}) |
|
|
|
g.Go(func() error { //职业 |
|
if err = svc.DB.Order("rank ASC").Find(&ocs).Error; err != nil { |
|
log.Error("listOccupation error(%v)", err) |
|
return err |
|
} |
|
|
|
if len(ocs) == 0 { |
|
return nil |
|
} |
|
|
|
oIDs = make([]int64, 0, len(ocs)) |
|
for _, v := range ocs { |
|
oIDs = append(oIDs, v.ID) |
|
} |
|
occMap, _ = arcCountByPids(oIDs) //获取职业对应稿件数量 |
|
|
|
return nil |
|
}) |
|
|
|
if err = g.Wait(); err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
|
|
for _, v := range sks { |
|
if sf, ok := sfMap[v.ID]; ok { //添加软件节点 |
|
v.Software = sf |
|
} |
|
if n, ok := skillMap[v.ID]; ok { //映射技能对应稿件数量 |
|
v.Count = n |
|
} |
|
} |
|
|
|
for _, v := range ocs { |
|
if sk, ok := skMap[v.ID]; ok { //添加技能节点 |
|
v.Skill = sk |
|
} |
|
if n, ok := occMap[v.ID]; ok { //映射职业对应稿件数量 |
|
v.Count = n |
|
} |
|
} |
|
|
|
c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{ |
|
"code": 0, |
|
"message": "0", |
|
"data": ocs, |
|
})) |
|
} |
|
|
|
func arcCountByPids(tids []int64) (res map[int64]int, err error) { |
|
var ( |
|
countSQL = "SELECT pid AS tid, count(DISTINCT aid) AS count FROM academy_arc_skill WHERE state=0 AND pid IN (?) GROUP BY pid" |
|
ats []*academy.ArchiveCount |
|
) |
|
if err = svc.DB.Raw(countSQL, tids).Find(&ats).Error; err != nil { |
|
log.Error("occupation arcCountByPids error(%v)", err) |
|
return |
|
} |
|
if len(ats) == 0 { |
|
return |
|
} |
|
res = make(map[int64]int) |
|
for _, a := range ats { |
|
res[a.TID] = a.Count |
|
} |
|
return |
|
} |
|
|
|
func arcCountBySkids(tids []int64) (res map[int64]int, err error) { |
|
var ( |
|
countSQL = "SELECT skid AS tid, count(DISTINCT aid) AS count FROM academy_arc_skill WHERE state=0 AND skid IN (?) GROUP BY skid" |
|
ats []*academy.ArchiveCount |
|
) |
|
if err = svc.DB.Raw(countSQL, tids).Find(&ats).Error; err != nil { |
|
log.Error("skill arcCountByPids error(%v)", err) |
|
return |
|
} |
|
if len(ats) == 0 { |
|
return |
|
} |
|
res = make(map[int64]int) |
|
for _, a := range ats { |
|
res[a.TID] = a.Count |
|
} |
|
return |
|
} |
|
|
|
func arcCountBySids(tids []int64) (res map[int64]int, err error) { |
|
var ( |
|
countSQL = "SELECT sid AS tid, count(DISTINCT aid) AS count FROM academy_arc_skill WHERE state=0 AND sid IN (?) GROUP BY sid" |
|
ats []*academy.ArchiveCount |
|
) |
|
if err = svc.DB.Raw(countSQL, tids).Find(&ats).Error; err != nil { |
|
log.Error("software arcCountBySids error(%v)", err) |
|
return |
|
} |
|
if len(ats) == 0 { |
|
return |
|
} |
|
res = make(map[int64]int) |
|
for _, a := range ats { |
|
res[a.TID] = a.Count |
|
} |
|
return |
|
} |
|
|
|
func orderOccupation(c *bm.Context) { |
|
var err error |
|
v := new(struct { |
|
ID int64 `form:"id" validate:"required"` |
|
Rank int64 `form:"rank" validate:"required"` |
|
SwitchID int64 `form:"switch_id" validate:"required"` |
|
SwitchRank int64 `form:"switch_rank" validate:"required"` |
|
}) |
|
if err = c.BindWith(v, binding.Form); err != nil { |
|
return |
|
} |
|
tx := svc.DB.Begin() |
|
var oc academy.Occupation |
|
if err = tx.Where("id=?", v.ID).First(&oc).Error; err != nil { |
|
log.Error("academy orderOccupation error(%v)", err) |
|
c.JSON(nil, err) |
|
tx.Rollback() |
|
return |
|
} |
|
var soc academy.Occupation |
|
if err = tx.Where("id=?", v.SwitchID).First(&soc).Error; err != nil { |
|
log.Error("academy orderOccupation error(%v)", err) |
|
c.JSON(nil, err) |
|
tx.Rollback() |
|
return |
|
} |
|
|
|
if err = tx.Model(&academy.Occupation{}).Where("id=?", v.ID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.SwitchRank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("academy orderOccupation error(%v)", err) |
|
c.JSON(nil, err) |
|
tx.Rollback() |
|
return |
|
} |
|
if err = tx.Model(&academy.Occupation{}).Where("id=?", v.SwitchID).Updates( |
|
map[string]interface{}{ |
|
"rank": v.Rank, |
|
}, |
|
).Error; err != nil { |
|
log.Error("academy orderOccupation error(%v)", err) |
|
c.JSON(nil, err) |
|
tx.Rollback() |
|
return |
|
} |
|
tx.Commit() |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新职业排序", TID: v.ID, OName: ""}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func checkSkillArcExist(aid, sid int64) (res *academy.ArcSkill, err error) { |
|
var as academy.ArcSkill |
|
err = svc.DB.Where("aid=?", aid).Where("sid=?", sid).Find(&as).Error |
|
if err != nil { |
|
if err == gorm.ErrRecordNotFound { |
|
err = nil |
|
} |
|
log.Error("academy checkSkillArcExist aid(%d)|sid(%d)|error(%v)", aid, sid, err) |
|
} |
|
res = &as |
|
return |
|
} |
|
|
|
func viewSkillArc(c *bm.Context) { |
|
var ( |
|
err error |
|
as = &academy.ArcSkill{} |
|
) |
|
v := new(academy.ArcSkill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.AID == 0 { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
arc, err := svc.Archive(c, v.AID) |
|
if err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
|
|
if arc != nil { |
|
as.AID = v.AID |
|
as.Title = arc.Title |
|
as.Pic = arc.Pic |
|
} |
|
c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{ |
|
"code": 0, |
|
"message": "0", |
|
"data": as, |
|
})) |
|
} |
|
|
|
func addSkillArc(c *bm.Context) { |
|
var ( |
|
err error |
|
now = time.Now().Format("2006-01-02 15:04:05") |
|
) |
|
v := new(academy.ArcSkill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.AID == 0 || v.PID == 0 || v.SkID == 0 || v.SID == 0 || v.Type == 0 { |
|
log.Error("academy addSkillArc v(%+v)", v) |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
|
|
res, err := checkSkillArcExist(v.AID, v.SID) |
|
if err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if res != nil && res.ID != 0 { |
|
c.JSON(nil, ecode.CreativeAcademyDuplicateSoftIDErr) |
|
return |
|
} |
|
|
|
m := &academy.ArcSkill{ |
|
State: academy.StateNormal, |
|
AID: v.AID, |
|
Type: v.Type, |
|
PID: v.PID, |
|
SkID: v.SkID, |
|
SID: v.SID, |
|
CTime: now, |
|
MTime: now, |
|
} |
|
if err = svc.DB.Create(m).Error; err != nil { |
|
log.Error("academy addSoftware error(%v)", err) |
|
c.JSON(nil, err) |
|
return |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "添加技能稿件", OIDs: xstr.JoinInts([]int64{v.AID})}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func upSkillArc(c *bm.Context) { |
|
var err error |
|
v := new(academy.ArcSkill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.ID == 0 || v.AID == 0 || v.PID == 0 || v.SkID == 0 || v.SID == 0 || v.Type == 0 { |
|
log.Error("academy upSkillArc v(%+v)", v) |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
|
|
if err = svc.DB.Model(&academy.ArcSkill{}).Where("id=?", v.ID).Updates(map[string]interface{}{ |
|
"aid": v.AID, |
|
"type": v.Type, |
|
"pid": v.PID, |
|
"skid": v.SkID, |
|
"sid": v.SID, |
|
}).Error; err != nil { |
|
log.Error("academy upSkillArc error(%v)", err) |
|
} |
|
|
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新技能稿件", OIDs: xstr.JoinInts([]int64{v.AID})}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func bindSkillArc(c *bm.Context) { |
|
var err error |
|
v := new(academy.ArcSkill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.AID == 0 || v.SID == 0 { |
|
log.Error("academy bindSkillArc v(%+v)", v) |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
res, err := checkSkillArcExist(v.AID, v.SID) |
|
if err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
if res != nil && res.ID == 0 { |
|
c.JSON(nil, ecode.NothingFound) |
|
return |
|
} |
|
if err = svc.DB.Model(&academy.ArcSkill{}).Where("aid=?", v.AID).Where("sid=?", v.SID).Updates(map[string]interface{}{ |
|
"state": v.State, |
|
}).Error; err != nil { |
|
log.Error("academy bindSkillArc error(%v)", err) |
|
} |
|
uid, uname := getUIDName(c) |
|
svc.SendAcademyLog(c, &academy.LogParam{UID: uid, UName: uname, Action: "更新技能稿件状态", TID: v.ID, OName: v.Title}) |
|
c.JSON(nil, err) |
|
} |
|
|
|
func skillArcList(c *bm.Context) { |
|
var ( |
|
items []*academy.ArcSkill |
|
aids []int64 |
|
total int |
|
err error |
|
) |
|
v := new(academy.ArcSkill) |
|
if err = c.Bind(v); err != nil { |
|
return |
|
} |
|
if v.Pn < 1 { |
|
v.Pn = 1 |
|
} |
|
if v.Ps > 20 { |
|
v.Ps = 20 |
|
} |
|
db := svc.DB.Model(&academy.ArcSkill{}) |
|
if v.PID != 0 { |
|
db = db.Where("pid=?", v.PID) |
|
} |
|
if v.SkID != 0 { |
|
db = db.Where("skid=?", v.SkID) |
|
} |
|
db.Count(&total) |
|
if err = db.Order("ctime DESC").Offset((v.Pn - 1) * v.Ps).Limit(v.Ps).Find(&items).Error; err != nil { |
|
log.Error("academy skillArcList error(%v)", err) |
|
c.JSON(nil, err) |
|
return |
|
} |
|
for _, v := range items { |
|
aids = append(aids, v.AID) |
|
} |
|
arcs, err := svc.Archives(c, aids) |
|
if err != nil { |
|
log.Error("academy skillArcList error(%v)", err) |
|
} |
|
for _, v := range items { |
|
if a, ok := arcs[v.AID]; ok { |
|
v.Pic = a.Pic |
|
v.Title = a.Title |
|
} |
|
} |
|
data := &academy.ArcSkills{ |
|
Items: items, |
|
Pager: &academy.Pager{ |
|
Num: v.Pn, |
|
Size: v.Ps, |
|
Total: total, |
|
}, |
|
} |
|
c.Render(http.StatusOK, render.MapJSON(map[string]interface{}{ |
|
"code": 0, |
|
"message": "0", |
|
"data": data, |
|
})) |
|
} |
|
|
|
func subSearchKeywords(c *bm.Context) { |
|
var err error |
|
bs, err := ioutil.ReadAll(c.Request.Body) |
|
if err != nil { |
|
log.Error("subSearchKeywords ioutil.ReadAll error(%v)", err) |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
c.Request.Body.Close() |
|
|
|
var v []*academy.SearchKeywords |
|
err = json.Unmarshal(bs, &v) |
|
if err != nil { |
|
log.Error("subSearchKeywords json.Unmarshal v(%+v) error(%v)", v, err) |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
|
|
if err = svc.SubSearchKeywords(v); err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
|
|
c.JSON(nil, nil) |
|
} |
|
|
|
func searchKeywords(c *bm.Context) { |
|
res, err := svc.SearchKeywords() |
|
if err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
c.JSON(res, nil) |
|
}
|
|
|