xps-server-go/service/api_service.go

package service

import (
    "errors"
    "xps/cache"
    "xps/datamodels"
    "xps/datasource"
    "xps/repositories"
    "xps/viewmodels"
)

type ApiService interface {
    GetList(m map[string]interface{}) ([]viewmodels.ApiInfo, error)
    GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
    GetById(moduleId, apiId int64) (*viewmodels.ApiInfo, error)
    Create(d *datamodels.Api) error
    Update(d *datamodels.Api) error
    ChangeStatus(moduleId, apiId, status int64) error
    Delete(m map[string]interface{}) error
    CacheApiData(moduleId, apiId int64) error
}

type apiService struct {
    apiRepo *repositories.ApiRepo
    transRepo *repositories.ApiTransUnitRepo
}

func NewApiService() ApiService {
    return &apiService{
        apiRepo: repositories.NewApiRepo(datasource.InstanceMaster()),
        transRepo: repositories.NewApiTransUnitRepo(datasource.InstanceMaster()),
    }
}

func (s *apiService) GetList(m map[string]interface{}) ([]viewmodels.ApiInfo, error) {
    return s.apiRepo.GetList(m)
}

func (s *apiService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
    return s.apiRepo.GetPage(m)
}

func (s *apiService) GetById(moduleId, apiId int64) (*viewmodels.ApiInfo, error) {
    return s.apiRepo.GetById(moduleId, apiId)
}

func (s *apiService) Create(api *datamodels.Api) error {
    api.ApiId = NewID()
    err := s.apiRepo.Create(api)
    if err != nil {
        return err
    }
    
    moduleId := api.ModuleId
    apiId    := api.ApiId
    return s.CacheApiData(moduleId, apiId)
}

func (s *apiService) Update(api *datamodels.Api) error {
    err :=  s.apiRepo.Update(api)
    if err != nil {
        return err
    }
    
    moduleId := api.ModuleId
    apiId    := api.ApiId
    return s.CacheApiData(moduleId, apiId)
}

func (s *apiService) ChangeStatus(moduleId, apiId, status int64) error {
    data := &datamodels.Api{
        ModuleId: moduleId,
        ApiId: apiId,
        Status: status,
    }
    err := s.apiRepo.Update(data)
    if err != nil {
        return err
    }
    
    return s.CacheApiData(moduleId, apiId)
}

func (s *apiService) Delete(m map[string]interface{}) error {
    return s.apiRepo.Delete(m)
}

func (s *apiService) CacheApiData(moduleId, apiId int64) error {
    api, err := s.apiRepo.GetById(moduleId, apiId)
    if err != nil {
        return nil
    }
    
    trans, err := s.transRepo.GetListById(moduleId, apiId)
    if err != nil {
        return nil
    }
    
    cacheData := &viewmodels.ApiDataInfo{
        ModuleId:    api.ModuleId,
        ModuleTitle: api.ModuleTitle,
        ApiId:       api.ApiId,
        ApiCode:     api.ApiCode,
        ApiTitle:    api.ApiTitle,
        ApiType:     api.ApiType,
        ApiParams:   api.ApiParams,
        ApiDesc:     api.ApiDesc,
        Status:      api.Status,
        TransUnits: trans,
    }
    
    // 缓存数据
    err = cache.SetApiData(api.ApiCode, cacheData)
    if err != nil {
        return errors.New("Redis缓存Model数据失败")
    }
    
    return nil
}