init

repositories/api_repo.go

@@ -77,6 +77,23 @@ func (d *ApiRepo) GetList(m map[string]interface{}) ([]viewmodels.ApiInfo, error
     }
 }
 
+func (d *ApiRepo) GetAll() ([]viewmodels.ApiInfo, error) {
+    
+    sqlSelect := ` SELECT    A.*,
+                             B.mod_title  `
+    sqlFrom   := ` FROM      ps_api    AS A
+                   LEFT JOIN ps_module AS B ON (A.mod_id = B.mod_id) `
+    sqlWhere  := ` WHERE  A.deleted_flag = 0 `
+    sqlOrderBy := " ORDER BY mod_id ASC "
+    datalist := make([]viewmodels.ApiInfo, 0)
+    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+    if err != nil {
+        return nil, err
+    } else {
+        return datalist, nil
+    }
+}
+
 func (d *ApiRepo) GetById(modId, apiId int64) (*viewmodels.ApiInfo, error) {
     sqlSelect := ` SELECT    A.*,
                              B.mod_title  `

repositories/api_trans_unit_repo.go

@@ -89,6 +89,24 @@ func (d *ApiTransUnitRepo) GetList(m map[string]interface{}) ([]viewmodels.ApiTr
     }
 }
 
+func (d *ApiTransUnitRepo) GetAll() ([]viewmodels.ApiTransUnitInfo, error) {
+    sqlSelect := ` SELECT     A.*,
+                              B.model_title,
+                              C.object_title `
+    sqlFrom   := ` FROM       ps_api_trans_unit AS A
+                   LEFT  JOIN ds_model          AS B ON (A.model_id = B.model_id)
+                   LEFT  JOIN ds_object         AS C ON (A.model_id = C.model_id AND A.object_id = C.object_id)`
+    sqlWhere  := ` WHERE A.deleted_flag = 0 `
+    sqlOrderBy := " ORDER BY A.api_id, A.sort_no ASC "
+    datalist := make([]viewmodels.ApiTransUnitInfo, 0)
+    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+    if err != nil {
+        return nil, err
+    } else {
+        return datalist, nil
+    }
+}
+
 func (d *ApiTransUnitRepo) GetListById(apiId int64) ([]viewmodels.ApiTransUnitInfo, error) {
     sqlSelect := ` SELECT     A.*,
                               B.model_title,

service/api_gateway_service.go

@@ -19,17 +19,13 @@ type apiGatewayService struct {
     dataBus *repositories.DataBusRepo
 }
 
-
 func NewApiGatewayService() ApiGatewayService {
     return &apiGatewayService{
         dataBus: repositories.NewDataBusRepo(datasource.InstanceMaster()),
     }
 }
 
-
 func (a apiGatewayService) Get(apiCode string, m map[string]interface{}) ([]map[string]interface{}, error) {
-    
-    
     return nil, errors.New("TEST")
 }
 

service/init_service.go

@@ -0,0 +1,122 @@
+package service
+
+import (
+    "errors"
+    "xps/cache"
+    "xps/datasource"
+    "xps/repositories"
+    "xps/viewmodels"
+)
+
+type InitService interface {
+    CacheObjectData() error
+    CacheApiData() error
+    CacheDBData() error
+}
+
+type initService struct {
+    objectRepo              *repositories.ObjectRepo
+    objectAttrRepo          *repositories.ObjectAttrRepo
+    apiRepo                 *repositories.ApiRepo
+    apiTransUnitRepo        *repositories.ApiTransUnitRepo
+}
+
+func NewInitService() InitService {
+    return &initService{
+        objectRepo:         repositories.NewObjectRepo(datasource.InstanceMaster()),
+        objectAttrRepo:     repositories.NewObjectAttrRepo(datasource.InstanceMaster()),
+        apiRepo:            repositories.NewApiRepo(datasource.InstanceMaster()),
+        apiTransUnitRepo:   repositories.NewApiTransUnitRepo(datasource.InstanceMaster()),
+    }
+}
+
+func (s *initService) CacheObjectData() error {
+    objectList, err1 := s.objectRepo.GetAll()
+    if err1 != nil {
+        return err1
+    }
+
+    attrsList, err2 := s.objectAttrRepo.GetAll()
+    if err2 != nil {
+        return err2
+    }
+    
+    for _, object := range objectList {
+        objectId := object.ObjectId
+        
+        attrs := make([]viewmodels.ObjectAttrInfo, 0)
+        for _, attr := range attrsList {
+            if attr.ObjectId == objectId {
+                attrs = append(attrs, attr)
+            }
+        }
+        
+        cacheData := &viewmodels.ObjectDataInfo{
+            ModelId:     object.ModelId,
+            ModelTitle:  object.ModelTitle,
+            ObjectId:    object.ObjectId,
+            ObjectType:  object.ObjectType,
+            ObjectTitle: object.ObjectTitle,
+            ObjectCode:  object.ObjectCode,
+            Comment:     object.Comment,
+            IsFixed:     object.IsFixed,
+            Attrs:       attrs,
+        }
+    
+        // 缓存数据
+        err3 := cache.SetObjectData(object.ObjectCode, cacheData)
+        if err3 != nil {
+            return errors.New("Redis缓存Object数据失败")
+        }
+    }
+    
+    return nil
+}
+
+func (s *initService) CacheApiData() error {
+    apiList, err1 := s.apiRepo.GetAll()
+    if err1 != nil {
+        return nil
+    }
+    
+    transList, err2 := s.apiTransUnitRepo.GetAll()
+    if err2 != nil {
+        return nil
+    }
+    
+    for _, api := range apiList {
+        apiId := api.ApiId
+        trans := make([]viewmodels.ApiTransUnitInfo, 0)
+        for _, tran := range transList{
+            if tran.ApiId == apiId {
+               trans = append(trans, tran)
+            }
+        }
+    
+        cacheData := &viewmodels.ApiDataInfo{
+            ModId: api.ModId,
+            ModTitle: api.ModTitle,
+            ApiId: api.ApiId,
+            ApiCode: api.ApiCode,
+            ApiTitle: api.ApiTitle,
+            ApiType: api.ApiType,
+            ApiParams: api.ApiParams,
+            ApiDesc: api.ApiDesc,
+            Status: api.Status,
+            TransUnits: trans,
+        }
+    
+        // 缓存数据
+        err3 := cache.SetApiData(api.ApiCode, cacheData)
+        if err3 != nil {
+            return errors.New("Redis缓存Api数据失败")
+        }
+    }
+    
+    return nil
+}
+
+func (i initService) CacheDBData() error {
+    return nil
+}
+