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" ) type Expert struct { *session.Enterprise } type ExpertHandle func(session *session.Enterprise) *Expert type ( // ExpertBasicInfo 基本信息 ExpertBasicInfo struct { ID string `json:"id"` Name string `json:"name"` School string `json:"school"` Major string `json:"major"` Industrys []string `json:"industrys"` Keywords []string `json:"keywords"` PatentTitles []string `json:"patent_titles"` } // ExpertInstanceInfo 专家信息 ExpertInstanceInfo struct { ExpertBasicInfo 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) { mUserExpert := model.NewUserExpert() uids := make([]uint64, 0) err := model2.Pluck(mUserExpert.UserExpert, "uid", &uids, model2.NewWhere("expert_id", id)) return uids, err } // Instance 专家信息 func (c *Expert) Instance(id uint64) (*ExpertInstanceInfo, error) { mManageExpert := model.NewManageExpert() out, err := mManageExpert.Detail(3, id) if err != nil { return nil, err } return &ExpertInstanceInfo{ ExpertBasicInfo: ExpertBasicInfo{ ID: out.GetEncodeID(), Name: out.Name, School: out.School, Major: out.Major, Industrys: out.GetIndustryAttribute(), Keywords: out.GetKeywordAttribute(), PatentTitles: strings.Split(out.PatentTitle, "&&"), }, Researchs: out.GetResearchAttribute(), Introduce: out.Introduce, }, nil } // Achievement 成果信息 func (c *Expert) Achievement(id uint64, page, pageSize int) (*controller.ReturnPages, error) { uids, err := c.user(id) 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 } // Project 项目信息 func (c *Expert) Project(id uint64, page, pageSize int) (*controller.ReturnPages, error) { // 查询专家身份下用户信息 uids, err := c.user(id) 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 } // Patent 专利信息 func (c *Expert) Patent(id uint64, page, pageSize int) (*controller.ReturnPages, error) { // 查询专家身份下用户信息 uids, err := c.user(id) 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 } // Paper 论文信息 func (c *Expert) Paper(id uint64, page, pageSize int) (*controller.ReturnPages, error) { // 查询专家身份下用户信息 uids, err := c.user(id) 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 } // Company 企业信息 func (c *Expert) Company(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 } // 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 } func NewExpert() ExpertHandle { return func(session *session.Enterprise) *Expert { return &Expert{session} } }