serverService

package
v0.0.0-...-8d4f09a Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 19, 2024 License: GPL-3.0 Imports: 30 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	MockServiceDataMap                = map[string]domain.MockPathMap{}
	MockServiceDataDefMap             = map[string]string{}
	MockServiceDataRegxPathToOrigPath = map[string]map[string]string{}
)

Functions

func GetRelatedPathWithResDir 

func GetRelatedPathWithResDir(p string) (ret string)

Types

type ConfigService 

type ConfigService struct {
	ConfigRepo  *serverRepo.ConfigRepo  `inject:""`
	ResService  *ResService             `inject:""`
	SectionRepo *serverRepo.SectionRepo `inject:""`

	SectionService *SectionService       `inject:""`
	RangeService   *service.RangeService `inject:""`
}

func (*ConfigService) Create 

func (s *ConfigService) Create(config *model.ZdConfig) (err error)

func (*ConfigService) GConfigItemTree 

func (s *ConfigService) GConfigItemTree(configId int) (root model.ZdRangesItem)

func (*ConfigService) Get 

func (s *ConfigService) Get(id int) (config model.ZdConfig, dirs []domain.Dir)

func (*ConfigService) List 

func (s *ConfigService) List(keywords string, page int) (list []*model.ZdConfig, total int)

func (*ConfigService) Remove 

func (s *ConfigService) Remove(id int) (err error)

func (*ConfigService) Save 

func (s *ConfigService) Save(config *model.ZdConfig) (err error)

func (*ConfigService) Sync 

func (s *ConfigService) Sync(files []domain.ResFile) (err error)

func (*ConfigService) SyncToDB 

func (s *ConfigService) SyncToDB(fi domain.ResFile) (err error)

func (*ConfigService) Update 

func (s *ConfigService) Update(config *model.ZdConfig) (err error)

type DataService 

type DataService struct {
}

type DefService 

type DefService struct {
	DefRepo     *serverRepo.DefRepo     `inject:""`
	FieldRepo   *serverRepo.FieldRepo   `inject:""`
	ReferRepo   *serverRepo.ReferRepo   `inject:""`
	SectionRepo *serverRepo.SectionRepo `inject:""`
	MockRepo    *serverRepo.MockRepo    `inject:""`

	ResService     *ResService     `inject:""`
	SectionService *SectionService `inject:""`

	RangeService *service.RangeService `inject:""`
}

func (*DefService) Create 

func (s *DefService) Create(def *model.ZdDef) (err error)

func (*DefService) Get 

func (s *DefService) Get(id int) (def model.ZdDef, dirs []domain.Dir)

func (*DefService) List 

func (s *DefService) List(keywords string, page int) (list []*model.ZdDef, total int)

func (*DefService) Remove 

func (s *DefService) Remove(id int) (err error)

func (*DefService) Save 

func (s *DefService) Save(def *model.ZdDef) (err error)

func (*DefService) Sync 

func (s *DefService) Sync(files []domain.ResFile) (err error)

func (*DefService) SyncToDB 

func (s *DefService) SyncToDB(fi domain.ResFile, isMock bool) (err error, id uint)

func (*DefService) Update 

func (s *DefService) Update(def *model.ZdDef) (err error)

type ExcelService 

type ExcelService struct {
	ExcelRepo  *serverRepo.ExcelRepo `inject:""`
	ResService *ResService           `inject:""`
}

func NewExcelService 

func NewExcelService(excelRepo *serverRepo.ExcelRepo) *ExcelService

func (*ExcelService) Get 

func (s *ExcelService) Get(id int) (excel model.ZdExcel, dirs []domain.Dir)

func (*ExcelService) List 

func (s *ExcelService) List(keywords string, page int) (list []*model.ZdExcel, total int)

func (*ExcelService) Remove 

func (s *ExcelService) Remove(id int) (err error)

func (*ExcelService) Save 

func (s *ExcelService) Save(excel *model.ZdExcel) (err error)

func (*ExcelService) Sync 

func (s *ExcelService) Sync(files []domain.ResFile) (err error)

func (*ExcelService) SyncToDB 

func (s *ExcelService) SyncToDB(file domain.ResFile) (err error)

func (*ExcelService) Update 

func (s *ExcelService) Update(excel *model.ZdExcel) (err error)

type FieldService 

type FieldService struct {
	DefRepo   *serverRepo.DefRepo   `inject:""`
	FieldRepo *serverRepo.FieldRepo `inject:""`
	ReferRepo *serverRepo.ReferRepo `inject:""`

	DefService *DefService `inject:""`
}

func NewFieldService 

func NewFieldService(defRepo *serverRepo.DefRepo, fieldRepo *serverRepo.FieldRepo,
	referRepo *serverRepo.ReferRepo,
	defService *DefService) *FieldService

func (*FieldService) Create 

func (s *FieldService) Create(defId, targetId uint, name string, mode string) (field *model.ZdField, err error)

func (*FieldService) Get 

func (s *FieldService) Get(fieldId int) (field model.ZdField, err error)

func (*FieldService) GetTree 

func (s *FieldService) GetTree(defId uint) (root *model.ZdField, err error)

func (*FieldService) Move 

func (s *FieldService) Move(srcId, targetId uint, mode string) (defId uint, srcField model.ZdField, err error)

func (*FieldService) Remove 

func (s *FieldService) Remove(id int) (defId int, err error)

func (*FieldService) Save 

func (s *FieldService) Save(field *model.ZdField) (err error)

type InstancesService 

type InstancesService struct {
	InstancesRepo  *serverRepo.InstancesRepo `inject:""`
	ReferRepo      *serverRepo.ReferRepo     `inject:""`
	ResService     *ResService               `inject:""`
	SectionService *SectionService           `inject:""`
	SectionRepo    *serverRepo.SectionRepo   `inject:""`

	RangeService *service.RangeService `inject:""`
}

func NewInstancesService 

func NewInstancesService(instancesRepo *serverRepo.InstancesRepo, referRepo *serverRepo.ReferRepo,
	sectionRepo *serverRepo.SectionRepo) *InstancesService

func (*InstancesService) Create 

func (s *InstancesService) Create(instances *model.ZdInstances) (err error)

func (*InstancesService) CreateItem 

func (s *InstancesService) CreateItem(domainId, targetId int, mode string) (item *model.ZdInstancesItem, err error)

func (*InstancesService) Get 

func (s *InstancesService) Get(id int) (instances model.ZdInstances, dirs []domain.Dir)

func (*InstancesService) GetItem 

func (s *InstancesService) GetItem(id int) (item model.ZdInstancesItem)

func (*InstancesService) GetItemTree 

func (s *InstancesService) GetItemTree(instancesId uint) (root model.ZdInstancesItem)

func (*InstancesService) List 

func (s *InstancesService) List(keywords string, page int) (list []*model.ZdInstances, total int)

func (*InstancesService) Remove 

func (s *InstancesService) Remove(id int) (err error)

func (*InstancesService) RemoveItem 

func (s *InstancesService) RemoveItem(id int) (err error)

func (*InstancesService) Save 

func (s *InstancesService) Save(instances *model.ZdInstances) (err error)

func (*InstancesService) SaveItem 

func (s *InstancesService) SaveItem(item *model.ZdInstancesItem) (err error)

func (*InstancesService) Sync 

func (s *InstancesService) Sync(files []domain.ResFile)

func (*InstancesService) SyncToDB 

func (s *InstancesService) SyncToDB(fi domain.ResFile) (err error)

func (*InstancesService) Update 

func (s *InstancesService) Update(instances *model.ZdInstances) (err error)

type MockService 

type MockService struct {
	MainService   *service.MainService   `inject:""`
	OutputService *service.OutputService `inject:""`
	MockService   *service.MockService   `inject:""`
	DefService    *DefService            `inject:""`
	MockRepo      *serverRepo.MockRepo   `inject:""`
}

func (*MockService) ChangeSampleSrc 

func (s *MockService) ChangeSampleSrc(mockId int, req model.ZdMockSampleSrc) (err error)

func (*MockService) GenDataForMockPreview 

func (s *MockService) GenDataForMockPreview(endpoint *domain.EndPoint, dataConfig string) (ret interface{}, err error)

func (*MockService) GenDataForServerRequest 

func (s *MockService) GenDataForServerRequest(endpoint *domain.EndPoint, dataConfigContent string) (ret interface{}, err error)

func (*MockService) Get 

func (s *MockService) Get(id int) (po model.ZdMock, err error)

func (*MockService) GetPreviewData 

func (s *MockService) GetPreviewData(id int) (data domain.MockData, err error)

func (*MockService) GetPreviewResp 

func (s *MockService) GetPreviewResp(req domain.MockPreviewReq) (ret interface{}, err error)

func (*MockService) GetResp 

func (s *MockService) GetResp(reqPath, reqMethod, respCode, mediaType string) (ret interface{}, err error)

func (*MockService) List 

func (s *MockService) List(keywords string, page int) (pos []*model.ZdMock, total int, err error)

func (*MockService) ListSampleSrc 

func (s *MockService) ListSampleSrc(mockId int) (ret map[string]string, err error)

func (*MockService) LoadDef 

func (s *MockService) LoadDef(pth string, files *[]string, level int) (err error)

func (*MockService) Remove 

func (s *MockService) Remove(id int) (err error)

func (*MockService) Save 

func (s *MockService) Save(po *model.ZdMock) (err error)

func (*MockService) StartMockService 

func (s *MockService) StartMockService(id int) (err error)

func (*MockService) StopMockService 

func (s *MockService) StopMockService(id int) (err error)

func (*MockService) Upload 

func (s *MockService) Upload(ctx iris.Context, fh *multipart.FileHeader) (
	name, content, mockConf, dataConf, pth string, err error, dataPath string)

type PreviewService 

type PreviewService struct {
	DefRepo       *serverRepo.DefRepo       `inject:""`
	FieldRepo     *serverRepo.FieldRepo     `inject:""`
	ReferRepo     *serverRepo.ReferRepo     `inject:""`
	InstancesRepo *serverRepo.InstancesRepo `inject:""`

	MainService   *service.MainService   `inject:""`
	OutputService *service.OutputService `inject:""`
	RangeService  *service.RangeService  `inject:""`
}

func (*PreviewService) PreviewDefData 

func (s *PreviewService) PreviewDefData(defId uint) (data string)

func (*PreviewService) PreviewFieldData 

func (s *PreviewService) PreviewFieldData(fieldId uint, fieldType string) (data string)

type RangesService 

type RangesService struct {
	RangesRepo  *serverRepo.RangesRepo  `inject:""`
	ResService  *ResService             `inject:""`
	SectionRepo *serverRepo.SectionRepo `inject:""`

	SectionService *SectionService       `inject:""`
	RangeService   *service.RangeService `inject:""`
}

func NewRangesService 

func NewRangesService(rangesRepo *serverRepo.RangesRepo, sectionRepo *serverRepo.SectionRepo) *RangesService

func (*RangesService) Create 

func (s *RangesService) Create(ranges *model.ZdRanges) (err error)

func (*RangesService) CreateItem 

func (s *RangesService) CreateItem(domainId, targetId int, mode string) (item *model.ZdRangesItem, err error)

func (*RangesService) Get 

func (s *RangesService) Get(id int) (ranges model.ZdRanges, dirs []domain.Dir)

func (*RangesService) GetItem 

func (s *RangesService) GetItem(id int) (item model.ZdRangesItem)

func (*RangesService) GetItemTree 

func (s *RangesService) GetItemTree(rangesId int) (root model.ZdRangesItem)

func (*RangesService) List 

func (s *RangesService) List(keywords string, page int) (list []*model.ZdRanges, total int)

func (*RangesService) Remove 

func (s *RangesService) Remove(id int) (err error)

func (*RangesService) RemoveItem 

func (s *RangesService) RemoveItem(id, domainId int) (err error)

func (*RangesService) Save 

func (s *RangesService) Save(ranges *model.ZdRanges) (err error)

func (*RangesService) SaveItem 

func (s *RangesService) SaveItem(item *model.ZdRangesItem) (err error)

func (*RangesService) Sync 

func (s *RangesService) Sync(files []domain.ResFile) (err error)

func (*RangesService) SyncToDB 

func (s *RangesService) SyncToDB(fi domain.ResFile) (err error)

func (*RangesService) Update 

func (s *RangesService) Update(ranges *model.ZdRanges) (err error)

type ReferService 

type ReferService struct {
	FieldRepo *serverRepo.FieldRepo `inject:""`
	ReferRepo *serverRepo.ReferRepo `inject:""`

	DefService *DefService `inject:""`
}

func NewReferService 

func NewReferService(fieldRepo *serverRepo.FieldRepo, referRepo *serverRepo.ReferRepo, defService *DefService) *ReferService

func (*ReferService) Get 

func (s *ReferService) Get(ownerId uint, ownerType string) (refer model.ZdRefer, err error)

func (*ReferService) Update 

func (s *ReferService) Update(ref *model.ZdRefer) (err error)

type ResService 

type ResService struct {
	RangesRepo    *serverRepo.RangesRepo    `inject:""`
	InstancesRepo *serverRepo.InstancesRepo `inject:""`
	ConfigRepo    *serverRepo.ConfigRepo    `inject:""`
	ExcelRepo     *serverRepo.ExcelRepo     `inject:""`
	TextRepo      *serverRepo.TextRepo      `inject:""`
	DefRepo       *serverRepo.DefRepo       `inject:""`
}

func NewResService 

func NewResService(rangesRepo *serverRepo.RangesRepo,
	instancesRepo *serverRepo.InstancesRepo,
	configRepo *serverRepo.ConfigRepo,
	excelRepo *serverRepo.ExcelRepo,
	textRepo *serverRepo.TextRepo,
	defRepo *serverRepo.DefRepo) *ResService

func (*ResService) ListReferExcelColForSelection 

func (s *ResService) ListReferExcelColForSelection(referName string) (ret []domain.ResField)

func (*ResService) ListReferFileForSelection 

func (s *ResService) ListReferFileForSelection(resType string) (ret interface{})

func (*ResService) ListReferResFieldForSelection 

func (s *ResService) ListReferResFieldForSelection(resId int, resType string) (ret []domain.ResField)

func (*ResService) ListReferSheetForSelection 

func (s *ResService) ListReferSheetForSelection(referName string) (ret []*model.ZdExcel)

func (*ResService) LoadRes 

func (s *ResService) LoadRes(resType string) (ret []domain.ResFile)

type SectionService 

type SectionService struct {
	FieldRepo     *serverRepo.FieldRepo     `inject:""`
	ConfigRepo    *serverRepo.ConfigRepo    `inject:""`
	RangesRepo    *serverRepo.RangesRepo    `inject:""`
	InstancesRepo *serverRepo.InstancesRepo `inject:""`

	SectionRepo      *serverRepo.SectionRepo `inject:""`
	DefService       *DefService             `inject:""`
	ConfigService    *ConfigService          `inject:""`
	InstancesService *InstancesService       `inject:""`
	RangesService    *RangesService          `inject:""`

	RangesService2 *service.RangeService `inject:""`
}

func (*SectionService) Create 

func (s *SectionService) Create(ownerId, sectionsId uint, ownerType string) (err error)

func (*SectionService) List 

func (s *SectionService) List(ownerId uint, ownerType string) (sections []*model.ZdSection, err error)

func (*SectionService) Remove 

func (s *SectionService) Remove(sectionId int, ownerType string) (ownerId uint, err error)

func (*SectionService) SaveFieldSectionToDB 

func (s *SectionService) SaveFieldSectionToDB(rangeSection string, ord int, fieldID uint, ownerType string)

func (*SectionService) Update 

func (s *SectionService) Update(section *model.ZdSection) (err error)

type SyncService 

type SyncService struct {
	DefService       *DefService       `inject:""`
	FieldService     *FieldService     `inject:""`
	RangesService    *RangesService    `inject:""`
	InstancesService *InstancesService `inject:""`
	ConfigService    *ConfigService    `inject:""`
	ExcelService     *ExcelService     `inject:""`
	TextService      *TextService      `inject:""`
	ReferService     *ReferService     `inject:""`
	ResService       *ResService       `inject:""`
}

func NewSyncService 

func NewSyncService(
	defService *DefService,
	fieldService *FieldService,
	rangesService *RangesService,
	instancesService *InstancesService,
	configService *ConfigService,
	excelService *ExcelService,
	textService *TextService,
	referService *ReferService,
	resService *ResService) *SyncService

func (*SyncService) SyncData 

func (s *SyncService) SyncData()

type TextService 

type TextService struct {
	TextRepo   *serverRepo.TextRepo `inject:""`
	ResService *ResService          `inject:""`
}

func NewTextService 

func NewTextService(textRepo *serverRepo.TextRepo) *TextService

func (*TextService) Create 

func (s *TextService) Create(text *model.ZdText) (err error)

func (*TextService) Get 

func (s *TextService) Get(id int) (text model.ZdText, dirs []domain.Dir)

func (*TextService) List 

func (s *TextService) List(keywords string, page int) (list []*model.ZdText, total int)

func (*TextService) Remove 

func (s *TextService) Remove(id int) (err error)

func (*TextService) Save 

func (s *TextService) Save(text *model.ZdText) (err error)

func (*TextService) Sync 

func (s *TextService) Sync(files []domain.ResFile) (err error)

func (*TextService) SyncToDB 

func (s *TextService) SyncToDB(file domain.ResFile) (err error)

func (*TextService) Update 

func (s *TextService) Update(text *model.ZdText) (err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.