xps-server-go/service/init_service.go

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
}