353 lines
9.8 KiB
Go
353 lines
9.8 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"` // 需求信息
|
|
}
|
|
// 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 {
|
|
if _, has := out[v]; has {
|
|
out[v]++
|
|
continue
|
|
}
|
|
out[v] = 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: 105,
|
|
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: 105,
|
|
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: 105,
|
|
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
|
|
}
|
|
// 专利信息
|
|
mSysPatent := model.NewSysPatent()
|
|
|
|
if err = model2.Count(mSysPatent.SysPatent, &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.TechnologyAchievementStatusForAgree)); 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.TechnologyDemandStatusForAgree)); 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)
|
|
_out["500000"] = &InstanceDistributionDetailInfo{
|
|
Code: "500000",
|
|
Name: "重庆",
|
|
Count: 300,
|
|
Industry: nil,
|
|
Children: map[string]*InstanceDistributionDetailInfo{
|
|
"500100": &InstanceDistributionDetailInfo{
|
|
Code: "500100",
|
|
Name: "市辖区",
|
|
Count: 300,
|
|
Industry: nil,
|
|
Children: nil,
|
|
},
|
|
},
|
|
}
|
|
_out["630000"] = &InstanceDistributionDetailInfo{
|
|
Code: "630000",
|
|
Name: "青海省",
|
|
Count: 1200,
|
|
Industry: nil,
|
|
Children: map[string]*InstanceDistributionDetailInfo{
|
|
"630200": &InstanceDistributionDetailInfo{
|
|
Code: "630200",
|
|
Name: "海东市",
|
|
Count: 1200,
|
|
Industry: nil,
|
|
Children: nil,
|
|
},
|
|
},
|
|
}
|
|
_out["230000"] = &InstanceDistributionDetailInfo{
|
|
Code: "230000",
|
|
Name: "黑龙江",
|
|
Count: 6000,
|
|
Industry: nil,
|
|
Children: map[string]*InstanceDistributionDetailInfo{
|
|
"230100": &InstanceDistributionDetailInfo{
|
|
Code: "230100",
|
|
Name: "哈尔滨市",
|
|
Count: 3000,
|
|
Industry: nil,
|
|
Children: nil,
|
|
},
|
|
"230200": &InstanceDistributionDetailInfo{
|
|
Code: "230200",
|
|
Name: "齐齐哈尔市",
|
|
Count: 3000,
|
|
Industry: nil,
|
|
Children: nil,
|
|
},
|
|
},
|
|
}
|
|
_out["330000"] = &InstanceDistributionDetailInfo{
|
|
Code: "330000",
|
|
Name: "浙江省",
|
|
Count: 5000,
|
|
Industry: nil,
|
|
Children: map[string]*InstanceDistributionDetailInfo{
|
|
"330100": &InstanceDistributionDetailInfo{
|
|
Code: "330100",
|
|
Name: "杭州市",
|
|
Count: 5000,
|
|
Industry: nil,
|
|
Children: nil,
|
|
},
|
|
},
|
|
}
|
|
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) {
|
|
mSysPatent := model.NewSysPatent()
|
|
out, err := mSysPatent.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
|
|
}
|
|
|
|
// 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,
|
|
}
|
|
}
|
|
}
|