335 lines
9.7 KiB
Go
335 lines
9.7 KiB
Go
package controller
|
|
|
|
import (
|
|
"SciencesServer/app/api/website/model"
|
|
config2 "SciencesServer/app/basic/config"
|
|
model2 "SciencesServer/app/common/model"
|
|
"SciencesServer/app/session"
|
|
"SciencesServer/config"
|
|
"SciencesServer/utils"
|
|
"strings"
|
|
)
|
|
|
|
type Index struct {
|
|
*session.Enterprise
|
|
}
|
|
|
|
type IndexHandle func(session *session.Enterprise) *Index
|
|
|
|
type (
|
|
// InstanceInfo 首页信息
|
|
InstanceInfo struct {
|
|
*InstanceStaticInfo
|
|
Distribution *InstanceDistributionInfo `json:"distribution"`
|
|
}
|
|
// InstanceStaticInfo 统计信息
|
|
InstanceStaticInfo struct {
|
|
ExpertCount int64 `json:"expert_count"` // 专家数量
|
|
CompanyCount int64 `json:"company_count"` // 公司数量
|
|
PatentCount int64 `json:"patent_count"` // 专利数量
|
|
AchievementCount int64 `json:"achievement_count"` // 成果数量
|
|
DemandCount int64 `json:"demand_count"` // 需求数量
|
|
DockingCount int64 `json:"docking_count"` // 对接数量
|
|
}
|
|
// InstanceDistributionInfo 分布信息
|
|
InstanceDistributionInfo struct {
|
|
Expert map[string]*InstanceDistributionDetailInfo `json:"expert"` // 专家信息
|
|
Laboratory map[string]*InstanceDistributionDetailInfo `json:"laboratory"` // 实验室信息
|
|
Demand map[string]*InstanceDistributionDetailInfo `json:"demand"` // 专利信息
|
|
Patent map[string]*InstanceDistributionDetailInfo `json:"patent"` // 成果信息
|
|
Achievement map[string]*InstanceDistributionDetailInfo `json:"achievement"` // 需求信息
|
|
Company map[string]*InstanceDistributionDetailInfo `json:"company"` // 公司企业信息
|
|
}
|
|
// InstanceDistributionDetailInfo 分布区域信息
|
|
InstanceDistributionDetailInfo struct {
|
|
Code string `json:"code"` // 区域编码
|
|
Name string `json:"name"` // 区域名称
|
|
Count int `json:"count"` // 数量
|
|
Industry map[string]int `json:"industry"` // 行业领域
|
|
Children map[string]*InstanceDistributionDetailInfo `json:"children"` // 子集信息
|
|
}
|
|
)
|
|
|
|
// industry 所属行业信息
|
|
func (c *Index) industry(src, sep string) map[string]int {
|
|
values := strings.Split(src, sep)
|
|
|
|
out := make(map[string]int, 0)
|
|
|
|
for _, value := range values {
|
|
_values := make([]string, 0)
|
|
_ = utils.FromJSON(value, &_values)
|
|
|
|
for _, v := range _values {
|
|
// 解析
|
|
title := "未知"
|
|
|
|
_industry := make([]string, 0)
|
|
|
|
objs := strings.Split(v, "-")
|
|
|
|
for _, obj := range objs {
|
|
if data, has := config2.MemoryForIndustryInfo[obj]; has {
|
|
_industry = append(_industry, data)
|
|
}
|
|
}
|
|
if len(_industry) > 0 {
|
|
title = strings.Join(_industry, "-")
|
|
}
|
|
if _, has := out[title]; has {
|
|
out[title]++
|
|
continue
|
|
}
|
|
out[title] = 1
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// distribution 分布统计
|
|
func (c *Index) distribution(src []*model.DataAreaDistributionInfo) map[string]*InstanceDistributionDetailInfo {
|
|
out := make(map[string]*InstanceDistributionDetailInfo, 0)
|
|
|
|
for _, v := range src {
|
|
industrys := c.industry(v.Industry, "&")
|
|
|
|
_, has := out[v.Province]
|
|
|
|
if !has {
|
|
out[v.Province] = &InstanceDistributionDetailInfo{
|
|
Code: v.Province,
|
|
Name: config2.MemoryForAreaInfo[config.DefaultChinaAreaCode][v.Province],
|
|
Industry: make(map[string]int, 0),
|
|
Count: 1,
|
|
Children: make(map[string]*InstanceDistributionDetailInfo, 0),
|
|
}
|
|
goto NEXT1
|
|
}
|
|
out[v.Province].Count++
|
|
NEXT1:
|
|
if v.City != "" {
|
|
if _, has = out[v.Province].Children[v.City]; !has {
|
|
out[v.Province].Children[v.City] = &InstanceDistributionDetailInfo{
|
|
Code: v.City,
|
|
Count: 1,
|
|
Name: config2.MemoryForAreaInfo[v.Province][v.City],
|
|
Industry: make(map[string]int, 0),
|
|
Children: make(map[string]*InstanceDistributionDetailInfo, 0),
|
|
}
|
|
goto NEXT2
|
|
}
|
|
out[v.Province].Children[v.City].Count++
|
|
} else {
|
|
out[v.Province].Industry = industrys
|
|
}
|
|
NEXT2:
|
|
if v.District != "" {
|
|
if _, has = out[v.Province].Children[v.City].Children[v.District]; !has {
|
|
out[v.Province].Children[v.City].Children[v.District] = &InstanceDistributionDetailInfo{
|
|
Code: v.District,
|
|
Count: 1,
|
|
Name: config2.MemoryForAreaInfo[v.City][v.District],
|
|
Industry: industrys,
|
|
}
|
|
continue
|
|
}
|
|
out[v.Province].Children[v.City].Children[v.District].Count++
|
|
} else {
|
|
out[v.Province].Children[v.City].Industry = industrys
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *Index) filterIndustry(src *InstanceDistributionDetailInfo, out map[string]int) {
|
|
if len(src.Children) > 0 {
|
|
for _, v := range src.Children {
|
|
for key, val := range v.Industry {
|
|
if _, has := out[key]; !has {
|
|
out[key] = val
|
|
continue
|
|
}
|
|
out[key] += val
|
|
}
|
|
c.filterIndustry(v, out)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Index) filter(src map[string]*InstanceDistributionDetailInfo) {
|
|
for _, v := range src {
|
|
c.filterIndustry(v, v.Industry)
|
|
c.filter(v.Children)
|
|
}
|
|
}
|
|
|
|
// static 数量统计
|
|
func (c *Index) static() (*InstanceStaticInfo, error) {
|
|
out := new(InstanceStaticInfo)
|
|
var err error
|
|
// 专家信息
|
|
mManageExpert := model.NewManageExpert()
|
|
|
|
if err = model2.Count(mManageExpert.ManageExpert, &out.ExpertCount, model2.NewWhere("examine_status", model2.ExamineStatusForAgree)); err != nil {
|
|
return nil, err
|
|
}
|
|
// 专利信息
|
|
mTechnologyPatent := model.NewTechnologyPatent()
|
|
|
|
if err = model2.Count(mTechnologyPatent.TechnologyPatent, &out.PatentCount, model2.NewWhere("shelf_status", model2.ShelfStatusForUp)); err != nil {
|
|
return nil, err
|
|
}
|
|
//成果信息
|
|
mTechnologyAchievement := model.NewTechnologyAchievement()
|
|
|
|
if err = model2.Count(mTechnologyAchievement.TechnologyAchievement, &out.AchievementCount, model2.NewWhere("shelf_status", model2.ShelfStatusForUp),
|
|
model2.NewWhere("status", model2.TechnologyStatusKindForAgree)); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 公司信息
|
|
mManageCompany := model.NewManageCompany()
|
|
|
|
if err = model2.Count(mManageCompany.ManageCompany, &out.CompanyCount, model2.NewWhere("examine_status", model2.ExamineStatusForAgree)); err != nil {
|
|
return nil, err
|
|
}
|
|
// 需求信息
|
|
mTechnologyDemand := model.NewTechnologyDemand()
|
|
|
|
if err = model2.Count(mTechnologyDemand.TechnologyDemand, &out.DemandCount,
|
|
model2.NewWhere("status", model2.TechnologyStatusKindForAgree)); err != nil {
|
|
return nil, err
|
|
}
|
|
// 对接信息
|
|
mServiceDocking := model.NewServiceDocking()
|
|
|
|
if err = model2.Count(mServiceDocking.ServiceDocking, &out.DockingCount); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// DistributionExpert 专家分布
|
|
func (c *Index) DistributionExpert(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
mManageExpert := model.NewManageExpert()
|
|
out, err := mManageExpert.Distribution(province, city)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
return _out, nil
|
|
}
|
|
|
|
// DistributionLaboratory 实验室分布
|
|
func (c *Index) DistributionLaboratory(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
mManageLaboratory := model.NewManageLaboratory()
|
|
out, err := mManageLaboratory.Distribution()
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
return _out, nil
|
|
}
|
|
|
|
// DistributionDemand 需求信息
|
|
func (c *Index) DistributionDemand(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
mTechnologyDemand := model.NewTechnologyDemand()
|
|
out, err := mTechnologyDemand.Distribution()
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
return _out, nil
|
|
}
|
|
|
|
// DistributionPatent 专利信息
|
|
func (c *Index) DistributionPatent(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
mTechnologyPatent := model.NewTechnologyPatent()
|
|
out, err := mTechnologyPatent.Distribution()
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
return _out, nil
|
|
}
|
|
|
|
// DistributionAchievement 技术成果信息
|
|
func (c *Index) DistributionAchievement(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
// 成果信息
|
|
mTechnologyAchievement := model.NewTechnologyAchievement()
|
|
out, err := mTechnologyAchievement.Distribution()
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
return _out, nil
|
|
}
|
|
|
|
func (c *Index) DistributionAchievementAndPatent(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
achievement := make([]*model.DataAreaDistributionInfo, 0)
|
|
patent := make([]*model.DataAreaDistributionInfo, 0)
|
|
|
|
var err error
|
|
|
|
mTechnologyPatent := model.NewTechnologyPatent()
|
|
// 专利信息
|
|
if patent, err = mTechnologyPatent.Distribution(); err != nil {
|
|
return nil, err
|
|
}
|
|
mTechnologyAchievement := model.NewTechnologyAchievement()
|
|
// 成果信息
|
|
if achievement, err = mTechnologyAchievement.Distribution(); err != nil {
|
|
return nil, err
|
|
}
|
|
achievement = append(achievement, patent...)
|
|
|
|
_out := c.distribution(achievement)
|
|
c.filter(_out)
|
|
|
|
return _out, nil
|
|
}
|
|
|
|
// DistributionCompany 公司企业信息
|
|
func (c *Index) DistributionCompany(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
|
|
mManageCompany := model.NewManageCompany()
|
|
out, err := mManageCompany.Distribution(province, city)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_out := c.distribution(out)
|
|
c.filter(_out)
|
|
|
|
return _out, nil
|
|
}
|
|
|
|
// Instance 首页信息
|
|
func (c *Index) Instance() (*InstanceInfo, error) {
|
|
out := &InstanceInfo{
|
|
InstanceStaticInfo: new(InstanceStaticInfo),
|
|
Distribution: new(InstanceDistributionInfo),
|
|
}
|
|
var err error
|
|
// 数量统计信息
|
|
if out.InstanceStaticInfo, err = c.static(); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func NewIndex() IndexHandle {
|
|
return func(session *session.Enterprise) *Index {
|
|
return &Index{session}
|
|
}
|
|
}
|