cas_tt_cloud_backend/app/common/init.go

package common

import (
	config2 "SciencesServer/app/basic/config"
	"SciencesServer/app/common/model"
	"SciencesServer/config"
	"SciencesServer/serve/orm"
	"SciencesServer/utils"
	"fmt"
)

type synchronized struct {
	iModel  model.IModel
	iValues func() interface{}
	Catch   func() interface{}
}

type caches struct {
	iModel  model.IModel
	iValues func() interface{}
	toCache func(values interface{})
}

func initModel() {
	db := orm.GetDB()

	function := func(synchronized ...*synchronized) {
		for _, v := range synchronized {
			if !db.Migrator().HasTable(v.iModel) {
				err := db.Migrator().CreateTable(v.iModel)
				if err != nil {
					panic(err)
				}
				if v.iValues != nil && v.iValues() != nil {
					db.Table(v.iModel.TableName()).Create(v.iValues())
				}
			} else if v.Catch != nil && v.Catch() != nil {
				v.Catch()
			}
		}
	}
	function(
		&synchronized{iModel: model.NewSysTenant()}, &synchronized{iModel: model.NewSysTenantMenu()},
		&synchronized{iModel: model.NewSysConfig()},
		&synchronized{iModel: model.NewSysMenu()}, &synchronized{iModel: model.NewSysAuth()},
		&synchronized{iModel: model.NewSysUser(), iValues: func() interface{} {
			return &model.SysUser{Account: "admin", Name: "商挈智能", Mobile: "13888888888", Password: utils.Md5String("123456"),
				IsAdmin: model.SysUserAdministratorForAdmin, Remark: "超级管理员"}
		}},
		&synchronized{iModel: model.NewSysUserRole()}, &synchronized{iModel: model.NewSysUserTenant()},
		&synchronized{iModel: model.NewSysDepartment()},
		&synchronized{iModel: model.NewSysRole()}, &synchronized{iModel: model.NewSysRoleMenu()}, &synchronized{iModel: model.NewSysRoleAuth()},
		// 配置管理
		&synchronized{iModel: model.NewSysConfig(), iValues: func() interface{} {
			return nil
		}},
		&synchronized{iModel: model.NewSysPatent(), iValues: func() interface{} {
			return nil
		}},
		&synchronized{iModel: model.NewSysPatentClassify()},
		&synchronized{iModel: model.NewSysIdentity(), iValues: func() interface{} {
			out := make([]*model.SysIdentity, 0)

			for k, v := range config2.TenantUserIdentityData {
				registerCount := 1

				if k == config2.TenantUserIdentityForCompany {
					registerCount = -1
				}
				out = append(out, &model.SysIdentity{
					Identity:      k,
					Name:          v,
					RegisterCount: registerCount,
					IsExamine:     1,
				})
			}
			return out
		}},
		&synchronized{iModel: model.NewSysIndustry(), iValues: func() interface{} {
			file := "./file/sys_industry.json"
			src := make([]*config2.MemoryForIndustry, 0)
			utils.LoadConfig(file, &src)
			out := make([]*model.SysIndustry, 0)

			var id uint64 = 1

			for _, v := range src {
				var parentID uint64 = 0

				data := &model.SysIndustry{
					Model: model.Model{
						ID: id,
					},
					ParentID: parentID,
					Name:     v.Name,
				}
				out = append(out, data)

				if v.Children != nil && len(v.Children) > 0 {
					parentID = id
					for _, val := range v.Children {
						id++
						data = &model.SysIndustry{
							Model: model.Model{
								ID: id,
							},
							ParentID: parentID,
							Name:     val.Name,
						}
						out = append(out, data)
					}
				}
			}
			return out
		}},
		&synchronized{iModel: model.NewSysPlatform()}, &synchronized{iModel: model.NewSysNavigation()},
		// 日志管理
		&synchronized{iModel: model.NewSysLog()}, &synchronized{iModel: model.NewSysUserLoginLog()},
		// 用户管理
		&synchronized{iModel: model.NewUserInstance()}, &synchronized{iModel: model.NewUserIdentity()},
		&synchronized{iModel: model.NewUserAssets()},
		&synchronized{iModel: model.NewUserPatent()}, &synchronized{iModel: model.NewUserBank()},
		&synchronized{iModel: model.NewUserCompany()}, &synchronized{iModel: model.NewUserExpert()},
		&synchronized{iModel: model.NewUserLaboratory()}, &synchronized{iModel: model.NewUserResearch()},
		&synchronized{iModel: model.NewUserAgent()},
		// 数据管理
		&synchronized{iModel: model.NewManageCompany()}, &synchronized{iModel: model.NewManageExpert()},
		&synchronized{iModel: model.NewManageLaboratory()}, &synchronized{iModel: model.NewManageResearch()},
		&synchronized{iModel: model.NewManageAgent()},
		&synchronized{iModel: model.NewTechnologyAchievement()}, &synchronized{iModel: model.NewTechnologyDemand()},
		&synchronized{iModel: model.NewTechnologyPaper()}, &synchronized{iModel: model.NewTechnologyProduct()},
		&synchronized{iModel: model.NewTechnologyProject()}, &synchronized{iModel: model.NewTechnologyTopic()},
		&synchronized{iModel: model.NewServiceDocking()}, &synchronized{iModel: model.NewServiceMessage()},
		&synchronized{iModel: model.NewServiceSolutionCase()}, &synchronized{iModel: model.NewServiceSolutionCaseDetail()},
		// 活动管理
		&synchronized{iModel: model.NewActivityInstance()}, &synchronized{iModel: model.NewActivityApply()},
		&synchronized{iModel: model.NewActivityExamine()}, &synchronized{iModel: model.NewActivityJoin()},
	)
}
func initCacheMode() {
	db := orm.GetDB()

	function := func(cache ...*caches) {
		for _, v := range cache {
			if db.Migrator().HasTable(v.iModel) {
				if v.iValues != nil {
					if values := v.iValues(); values != nil {
						v.toCache(values)
					}
				}
			}
		}
	}
	function(
		&caches{iModel: model.NewSysTenant(), iValues: func() interface{} {
			out := make([]*model.SysConfig, 0)
			_ = model.Find(model.NewSysConfig(), &out)
			return out
		}, toCache: func(values interface{}) {
			out := values.([]*model.SysConfig)
			for _, v := range out {
				config.SystemConfig[v.Key] = v.Value
			}
		}},
	)
	function(
		&caches{iModel: model.NewSysIndustry(), iValues: func() interface{} {
			out := make([]*model.SysIndustry, 0)
			_ = model.ScanFields(model.NewSysIndustry(), &out, []string{"id", "name"})
			return out
		}, toCache: func(values interface{}) {
			out := values.([]*model.SysIndustry)
			for _, v := range out {
				config2.MemoryForIndustryInfo[fmt.Sprintf("%d", v.ID)] = v.Name
			}
		}},
	)
	function(
		&caches{iModel: model.NewSysPlatform(), iValues: func() interface{} {
			out := make([]*model.SysPlatform, 0)
			_ = model.ScanFields(model.NewSysPlatform(), &out, []string{"id", "key", "link"})
			return out
		}, toCache: func(values interface{}) {
			out := values.([]*model.SysPlatform)
			for _, v := range out {
				if v.Link == "" {
					continue
				}
				config2.MemoryForPlatformInfo[v.Link] = v.Key
			}
		}},
	)
}

func Init() {
	initModel()
	initCacheMode()
}