282 lines
8.6 KiB
Go
282 lines
8.6 KiB
Go
package manage
|
|
|
|
import (
|
|
"SciencesServer/app/api/website/controller/technology"
|
|
"SciencesServer/app/api/website/model"
|
|
"SciencesServer/app/basic/config"
|
|
"SciencesServer/app/basic/controller"
|
|
model2 "SciencesServer/app/common/model"
|
|
"errors"
|
|
"strings"
|
|
)
|
|
|
|
// 公用参数信息
|
|
|
|
type (
|
|
// AchievementInfo 成果信息
|
|
AchievementInfo struct {
|
|
//*model.TechnologyAchievementInfo
|
|
ID string `json:"id"`
|
|
Title string `json:"title"`
|
|
Industrys []string `json:"industrys"`
|
|
Keywords []string `json:"keywords"`
|
|
CooperationModeTitle string `json:"cooperation_mode_title"`
|
|
ResearchName string `json:"research_name"`
|
|
VisitCount int `json:"visit_count"`
|
|
CollectCount int `json:"collect_count"`
|
|
}
|
|
// ProjectInfo 项目信息
|
|
ProjectInfo struct {
|
|
ID string `json:"id"`
|
|
*model2.TechnologyProject
|
|
}
|
|
// PatentInfo 专利信息
|
|
PatentInfo struct {
|
|
ID string `json:"id"`
|
|
*model.TechnologyPatentBasicInfo
|
|
}
|
|
// PaperInfo 论文信息
|
|
PaperInfo struct {
|
|
ID string `json:"id"`
|
|
*model2.TechnologyPaper
|
|
Keywords []string `json:"keywords"`
|
|
}
|
|
// CooperateInfo 合作的企业信息
|
|
CooperateInfo struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
PatentCount int `json:"patent_count"`
|
|
PaperCount int `json:"paper_count"`
|
|
}
|
|
// CooperateDetailInfo 合作的企业详细信息
|
|
CooperateDetailInfo struct {
|
|
Name string `json:"name"`
|
|
Patent []*technology.PatentInfo `json:"patent"`
|
|
Paper []*technology.PaperInfo `json:"paper"`
|
|
}
|
|
EquipmentInfo struct {
|
|
ID string `json:"id"`
|
|
*model2.ManageEquipment
|
|
}
|
|
)
|
|
|
|
// achievement 技术成果信息
|
|
func achievement(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
mTechnologyAchievement := model.NewTechnologyAchievement()
|
|
|
|
var count int64
|
|
|
|
out, err := mTechnologyAchievement.Achievements(page, pageSize, &count, model2.NewWhereIn("a.uid", uids))
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list := make([]*AchievementInfo, 0)
|
|
|
|
for _, v := range out {
|
|
_industrys := make([]string, 0)
|
|
|
|
for _, v := range v.GetIndustryAttribute() {
|
|
_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/").Value)
|
|
}
|
|
list = append(list, &AchievementInfo{
|
|
ID: v.GetEncodeID(),
|
|
Title: v.Title,
|
|
Industrys: _industrys,
|
|
Keywords: v.GetKeywordAttribute(),
|
|
CooperationModeTitle: config.GetTechnologyCooperationModeTitle(v.CooperationMode),
|
|
ResearchName: v.ResearchName,
|
|
VisitCount: v.VisitCount,
|
|
CollectCount: v.CollectCount,
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|
|
|
|
// project 项目信息
|
|
func project(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
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([]*ProjectInfo, 0)
|
|
|
|
for _, v := range out {
|
|
list = append(list, &ProjectInfo{
|
|
ID: v.GetEncodeID(),
|
|
TechnologyProject: v,
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|
|
|
|
// patent 专利信息
|
|
func patent(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
mTechnologyPatent := model.NewTechnologyPatent()
|
|
var count int64
|
|
out := make([]*model.TechnologyPatentBasicInfo, 0)
|
|
|
|
if err := model2.PagesFields(mTechnologyPatent.TechnologyPatent, &out, []string{
|
|
"id", "title", "apply_at", "description",
|
|
}, page, pageSize, &count, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhere("uid", uids),
|
|
Order: model2.NewOrder("id", model2.OrderModeToDesc),
|
|
}, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhere("shelf_status", model2.ShelfStatusForUp),
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
list := make([]*PatentInfo, 0)
|
|
|
|
for _, v := range out {
|
|
list = append(list, &PatentInfo{
|
|
ID: v.GetEncodeID(), TechnologyPatentBasicInfo: v,
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|
|
|
|
func paper(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
mTechnologyPaper := model.NewTechnologyPaper()
|
|
|
|
out := make([]*model2.TechnologyPaper, 0)
|
|
|
|
var count int64
|
|
|
|
if err := model2.PagesFields(mTechnologyPaper.TechnologyPaper, &out, []string{"id", "title", "ext", "author", "keyword", "remark", "publish_at"},
|
|
page, pageSize, &count, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhereIn("uid", uids),
|
|
Order: model2.NewOrder("id", model2.OrderModeToDesc),
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
list := make([]*PaperInfo, 0)
|
|
|
|
for _, v := range out {
|
|
list = append(list, &PaperInfo{
|
|
ID: v.GetEncodeID(),
|
|
TechnologyPaper: v,
|
|
Keywords: v.GetKeywordAttribute(),
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|
|
|
|
// cooperate 合作的信息
|
|
func cooperate(uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
|
|
|
|
out := make([]*model2.ManageCooperateEnterprise, 0)
|
|
|
|
var count int64
|
|
|
|
if err := model2.PagesFields(mManageCooperateEnterprise.ManageCooperateEnterprise, &out, []string{"id", "name", "paper", "patent"},
|
|
page, pageSize, &count, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhereIn("uid", uids),
|
|
Order: model2.NewOrder("id", model2.OrderModeToDesc),
|
|
}, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhere("mode", model2.ManageCooperateEnterpriseModeForCooperateAlready)}); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
list := make([]*CooperateInfo, 0)
|
|
|
|
for _, v := range out {
|
|
list = append(list, &CooperateInfo{
|
|
ID: v.GetEncodeID(),
|
|
Name: v.Name,
|
|
PatentCount: len(v.GetPatentAttribute()),
|
|
PaperCount: len(v.GetPaperAttribute()),
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|
|
|
|
// cooperateDetail 合作企业详情
|
|
func cooperateDetail(id uint64) (*CooperateDetailInfo, error) {
|
|
mManageCooperateEnterprise := model.NewManageCooperateEnterprise()
|
|
mManageCooperateEnterprise.ID = id
|
|
|
|
isExist, err := model2.FirstField(mManageCooperateEnterprise.ManageCooperateEnterprise,
|
|
[]string{"id", "paper", "patent", "created_at"})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
} else if !isExist {
|
|
return nil, errors.New("操作错误，企业信息不存在或已被删除")
|
|
}
|
|
out := &CooperateDetailInfo{
|
|
Name: mManageCooperateEnterprise.Name,
|
|
Patent: make([]*technology.PatentInfo, 0),
|
|
Paper: make([]*technology.PaperInfo, 0),
|
|
}
|
|
// 专利信息
|
|
mTechnologyPatent := model.NewTechnologyPatent()
|
|
|
|
patents := make([]*model.TechnologyPatentInfo, 0)
|
|
|
|
if patents, err = mTechnologyPatent.Instance(model2.NewWhereIn("p.id", strings.Split(mManageCooperateEnterprise.Patent, ","))); err != nil {
|
|
return nil, err
|
|
}
|
|
for _, v := range patents {
|
|
out.Patent = append(out.Patent, &technology.PatentInfo{
|
|
ID: v.GetEncodeID(),
|
|
TechnologyPatentInfo: v,
|
|
})
|
|
}
|
|
// 论文信息
|
|
mTechnologyPaper := model.NewTechnologyPaper()
|
|
|
|
papers := make([]*model2.TechnologyPaper, 0)
|
|
|
|
if err = model2.ScanFields(mTechnologyPaper.TechnologyPaper, &papers, []string{"id", "title", "ext", "keyword", "remark", "publish_at"},
|
|
&model2.ModelWhereOrder{
|
|
Where: model2.NewWhereIn("id", strings.Split(mManageCooperateEnterprise.Paper, ",")),
|
|
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(),
|
|
Remark: v.Remark, PublishAt: v.PublishAt,
|
|
})
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// equipment 设备信息
|
|
func equipment(kind model2.ManageEquipmentKind, uids []uint64, page, pageSize int) (*controller.ReturnPages, error) {
|
|
mManageEquipment := model.NewManageEquipment()
|
|
|
|
out := make([]*model2.ManageEquipment, 0)
|
|
|
|
var count int64
|
|
|
|
if err := model2.Pages(mManageEquipment.ManageEquipment, &out, page, pageSize, &count, &model2.ModelWhereOrder{
|
|
Where: model2.NewWhere("kind", kind),
|
|
Order: model2.NewOrder("id", model2.OrderModeToDesc),
|
|
}, &model2.ModelWhereOrder{Where: model2.NewWhereIn("uid", uids)}); err != nil {
|
|
return nil, err
|
|
}
|
|
list := make([]*EquipmentInfo, 0)
|
|
|
|
for _, v := range out {
|
|
list = append(list, &EquipmentInfo{
|
|
ID: v.GetEncodeID(),
|
|
ManageEquipment: v,
|
|
})
|
|
}
|
|
return &controller.ReturnPages{Data: list, Count: count}, nil
|
|
}
|