feat:完善项目信息

This commit is contained in:
henry
2021-12-27 10:34:06 +08:00
parent c80e581956
commit 41aa6f337c
10 changed files with 610 additions and 224 deletions

View File

@ -1,12 +1,10 @@
package manage
import (
"SciencesServer/app/api/website/controller/technology"
"SciencesServer/app/api/website/model"
"SciencesServer/app/basic/controller"
model2 "SciencesServer/app/common/model"
"SciencesServer/app/session"
"errors"
"strings"
)
@ -33,40 +31,6 @@ type (
Researchs []string `json:"researchs"`
Introduce string `json:"introduce"`
}
// ExpertAchievementInfo 专家成果信息
ExpertAchievementInfo struct {
*model.TechnologyAchievementInfo
ChargeInfo *model2.TechnologyAchievementChargeInfo `json:"charge_info"`
}
// ExpertProjectInfo 专家项目信息
ExpertProjectInfo struct {
ID string `json:"id"`
*model2.TechnologyProject
}
// ExpertPatentInfo 专利信息
ExpertPatentInfo struct {
ID string `json:"id"`
*model.PatentInfo
}
// ExpertPaperInfo 论文信息
ExpertPaperInfo struct {
ID string `json:"id"`
*model2.TechnologyPaper
Keywords []string `json:"keywords"`
}
// ExpertCompanyInfo 合作企业信息
ExpertCompanyInfo struct {
ID string `json:"id"`
Title string `json:"title"`
PatentCount int `json:"patent_count"`
PaperCount int `json:"paper_count"`
}
// ExpertCompanyDetailInfo 合作企业详细信息
ExpertCompanyDetailInfo struct {
Title string `json:"title"`
Patent []*technology.PatentInfo `json:"patent"`
Paper []*technology.PaperInfo `json:"paper"`
}
)
func (c *Expert) user(id uint64) ([]uint64, error) {
@ -109,24 +73,8 @@ func (c *Expert) Achievement(id uint64, page, pageSize int) (*controller.ReturnP
if err != nil {
return nil, err
}
mTechnologyAchievement := model.NewTechnologyAchievement()
var count int64
out := make([]*model.TechnologyAchievementInfo, 0)
if out, err = mTechnologyAchievement.Achievement(page, pageSize, &count, model2.NewWhereIn("uid", uids)); err != nil {
return nil, err
}
list := make([]*ExpertAchievementInfo, 0)
for _, v := range out {
list = append(list, &ExpertAchievementInfo{
TechnologyAchievementInfo: v,
ChargeInfo: v.GetChargeInfoAttribute(),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
return achievement(uids, page, pageSize)
}
// Project 项目信息
@ -137,29 +85,8 @@ func (c *Expert) Project(id uint64, page, pageSize int) (*controller.ReturnPages
if err != nil {
return nil, err
}
mTechnologyProject := model.NewTechnologyProject()
out := make([]*model2.TechnologyProject, 0)
var count int64
if err = model2.Pages(mTechnologyProject.TechnologyProject, &out, page, pageSize, &count,
&model2.ModelWhereOrder{
Where: model2.NewWhereIn("uid", uids),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}, &model2.ModelWhereOrder{
Where: model2.NewWhere("shelf_status", model2.ShelfStatusForUp),
}); err != nil {
return nil, err
}
list := make([]*ExpertProjectInfo, 0)
for _, v := range out {
list = append(list, &ExpertProjectInfo{
ID: v.GetEncodeID(),
TechnologyProject: v,
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
return project(uids, page, pageSize)
}
// Patent 专利信息
@ -170,23 +97,8 @@ func (c *Expert) Patent(id uint64, page, pageSize int) (*controller.ReturnPages,
if err != nil {
return nil, err
}
mUserPatent := model.NewUserPatent()
var count int64
out := make([]*model.PatentInfo, 0)
if out, err = mUserPatent.Patent(page, pageSize, &count, model2.NewWhereIn("u_p.uid", uids)); err != nil {
return nil, err
}
list := make([]*ExpertPatentInfo, 0)
for _, v := range out {
list = append(list, &ExpertPatentInfo{
ID: v.GetEncodeID(),
PatentInfo: v,
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
return paper(uids, page, pageSize)
}
// Paper 论文信息
@ -197,115 +109,25 @@ func (c *Expert) Paper(id uint64, page, pageSize int) (*controller.ReturnPages,
if err != nil {
return nil, err
}
mTechnologyPaper := model.NewTechnologyPaper()
out := make([]*model2.TechnologyPaper, 0)
var count int64
if err = model2.PagesFields(mTechnologyPaper.TechnologyPaper, &out, []string{"id", "title", "ext", "keyword"},
page, pageSize, &count, &model2.ModelWhereOrder{
Where: model2.NewWhereIn("uid", uids),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}); err != nil {
return nil, err
}
list := make([]*ExpertPaperInfo, 0)
for _, v := range out {
list = append(list, &ExpertPaperInfo{
ID: v.GetEncodeID(),
TechnologyPaper: v,
Keywords: v.GetKeywordAttribute(),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
return paper(uids, page, pageSize)
}
// Company 企业信息
func (c *Expert) Company(id uint64, page, pageSize int) (*controller.ReturnPages, error) {
// Cooperate 企业信息
func (c *Expert) Cooperate(id uint64, page, pageSize int) (*controller.ReturnPages, error) {
// 查询专家身份下用户信息
uids, err := c.user(id)
if err != nil {
return nil, err
}
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
out := make([]*model2.UserCooperateEnterprise, 0)
var count int64
if err = model2.PagesFields(mUserCooperateEnterprise.UserCooperateEnterprise, &out, []string{"id", "title", "paper", "patent"},
page, pageSize, &count, &model2.ModelWhereOrder{
Where: model2.NewWhereIn("uid", uids),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}, &model2.ModelWhereOrder{
Where: model2.NewWhere("kind", model2.UserCooperateEnterpriseModeForCooperateAlready)}); err != nil {
return nil, err
}
list := make([]*ExpertCompanyInfo, 0)
for _, v := range out {
list = append(list, &ExpertCompanyInfo{
ID: v.GetEncodeID(),
Title: v.Title,
PatentCount: len(v.GetPatentAttribute()),
PaperCount: len(v.GetPaperAttribute()),
})
}
return &controller.ReturnPages{Data: list, Count: count}, nil
return cooperate(uids, page, pageSize)
}
// CompanyDetail 公司企业详细信息
func (c *Expert) CompanyDetail(id uint64) (*ExpertCompanyDetailInfo, error) {
mUserCooperateEnterprise := model.NewUserCooperateEnterprise()
mUserCooperateEnterprise.ID = id
isExist, err := model2.FirstField(mUserCooperateEnterprise.UserCooperateEnterprise, []string{"id", "title", "paper", "patent"})
if err != nil {
return nil, err
} else if !isExist {
return nil, errors.New("操作错误,企业信息不存在或已被删除")
}
out := &ExpertCompanyDetailInfo{
Title: mUserCooperateEnterprise.Title,
Patent: make([]*technology.PatentInfo, 0),
Paper: make([]*technology.PaperInfo, 0),
}
// 专利信息
mSysPatent := model.NewSysPatent()
patents := make([]*model.SysPatentInfo, 0)
if patents, err = mSysPatent.Instance(model2.NewWhereIn("p.id", mUserCooperateEnterprise.GetPatentAttribute())); err != nil {
return nil, err
}
for _, v := range patents {
out.Patent = append(out.Patent, &technology.PatentInfo{
ID: v.GetEncodeID(),
SysPatentInfo: v,
})
}
// 论文信息
mTechnologyPaper := model.NewTechnologyPaper()
papers := make([]*model2.TechnologyPaper, 0)
if err = model2.ScanFields(mTechnologyPaper.TechnologyPaper, &papers, []string{"id", "title", "ext", "keyword"},
&model2.ModelWhereOrder{
Where: model2.NewWhereIn("id", mUserCooperateEnterprise.GetPaperAttribute()),
Order: model2.NewOrder("id", model2.OrderModeToDesc),
}); err != nil {
return nil, err
}
for _, v := range papers {
out.Paper = append(out.Paper, &technology.PaperInfo{
ID: v.GetEncodeID(), Title: v.Title, Ext: v.Ext, Keywords: v.GetKeywordAttribute(),
})
}
return out, nil
// CooperateDetail 公司企业详细信息
func (c *Expert) CooperateDetail(id uint64) (*CooperateDetailInfo, error) {
return cooperateDetail(id)
}
func NewExpert() ExpertHandle {