xps-server-g5/cmd/router/routes.go

package router

import (
	"github.com/iris-contrib/middleware/cors"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/mvc"
	"xps/cmd/bootstrap"
	apiControllers "xps/pkg/api/controller"
	apiServices "xps/pkg/api/service"
	appControllers "xps/pkg/app/controller"
	appServices "xps/pkg/app/service"
	bizControllers "xps/pkg/biz/controller"
	bizServices "xps/pkg/biz/service"
	wfControllers "xps/pkg/bpm/controller"
	wfServices "xps/pkg/bpm/service"
	"xps/pkg/gateway"
	"xps/pkg/middleware"
	modelControllers "xps/pkg/model/controller"
	modelServices "xps/pkg/model/service"
	repoControllers "xps/pkg/repo/controller"
	repoServices "xps/pkg/repo/service"
	sysControllers "xps/pkg/system/controller"
	sysServices "xps/pkg/system/service"
)

func Configure(b *bootstrap.Bootstrapper) {
	crs := cors.New(cors.Options{
		AllowedOrigins:   []string{"*"},
		AllowedMethods:   []string{"PUT", "PATCH", "GET", "POST", "OPTIONS", "DELETE"},
		AllowedHeaders:   []string{"*"},
		ExposedHeaders:   []string{"Accept", "Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization"},
		AllowCredentials: true,
	})

	// Static Resource
	b.HandleDir("/", "./public")

	// Login
	loginService := sysServices.NewLoginService()
	loginApp := mvc.New(b.Party("/", crs).AllowMethods(iris.MethodOptions))
	loginApp.Register(loginService)
	loginApp.Handle(new(sysControllers.LoginController))

	// System
	sysParty := b.Party("/sys", crs).AllowMethods(iris.MethodOptions)
	{
		sysParty.Use(middleware.AuthToken)

		// Role
		roleService := sysServices.NewRoleService()
		roleApp := mvc.New(sysParty.Party("/role"))
		roleApp.Register(roleService)
		roleApp.Handle(new(sysControllers.RoleController))

	}

	// Company Profile
	companyParty := b.Party("/company", crs).AllowMethods(iris.MethodOptions)
	{
		companyParty.Use(middleware.AuthToken)
		companyProfileService := sysServices.NewCompanyProfileService()
		companyProfileApp := mvc.New(companyParty.Party("/profile"))
		companyProfileApp.Register(companyProfileService)
		companyProfileApp.Handle(new(sysControllers.CompanyProfileController))
	}

	// Group
	groupParty := b.Party("/group", crs).AllowMethods(iris.MethodOptions)
	{
		groupParty.Use(middleware.AuthToken)
		groupService := sysServices.NewGroupService()
		groupApp := mvc.New(groupParty.Party(""))
		groupApp.Register(groupService)
		groupApp.Handle(new(sysControllers.GroupController))

		// GroupCat
		groupCatService := sysServices.NewGroupCatService()
		groupCatApp := mvc.New(groupParty.Party("/cat"))
		groupCatApp.Register(groupCatService)
		groupCatApp.Handle(new(sysControllers.GroupCatController))
	}

	// User
	userParty := b.Party("/user", crs).AllowMethods(iris.MethodOptions)
	{
		userParty.Use(middleware.AuthToken)

		// user
		userService := sysServices.NewUserService()
		userApp := mvc.New(userParty.Party(""))
		userApp.Register(userService)
		userApp.Handle(new(sysControllers.UserController))
	}

	// Position
	positionParty := b.Party("/position", crs).AllowMethods(iris.MethodOptions)
	{
		positionParty.Use(middleware.AuthToken)
		positionService := sysServices.NewPositionService()
		positionApp := mvc.New(positionParty.Party(""))
		positionApp.Register(positionService)
		positionApp.Handle(new(sysControllers.PositionController))
	}

	// App
	appParty := b.Party("/app", crs).AllowMethods(iris.MethodOptions)
	{
		appParty.Use(middleware.AuthToken)

		appService := appServices.NewAppService()
		appApp := mvc.New(appParty.Party(""))
		appApp.Register(appService)
		appApp.Handle(new(appControllers.AppController))

		appCatService := appServices.NewAppCatService()
		appCatApp := mvc.New(appParty.Party("/cat"))
		appCatApp.Register(appCatService)
		appCatApp.Handle(new(appControllers.AppCatController))

		appPermitService := appServices.NewAppPermitService()
		appPermitApp := mvc.New(appParty.Party("/permit"))
		appPermitApp.Register(appPermitService)
		appPermitApp.Handle(new(appControllers.AppPermitController))
	}

	// Task
	taskParty := b.Party("/task", crs).AllowMethods(iris.MethodOptions)
	{
		taskParty.Use(middleware.AuthToken)

		taskService := sysServices.NewTaskService()
		taskApp := mvc.New(taskParty.Party(""))
		taskApp.Register(taskService)
		taskApp.Handle(new(sysControllers.TaskController))

		taskCatService := sysServices.NewTaskCatService()
		taskCatApp := mvc.New(taskParty.Party("/cat"))
		taskCatApp.Register(taskCatService)
		taskCatApp.Handle(new(sysControllers.TaskCatController))
	}

	// Msg
	msgParty := b.Party("/msg", crs).AllowMethods(iris.MethodOptions)
	{
		msgParty.Use(middleware.AuthToken)

		msgService := sysServices.NewMsgService()
		msgApp := mvc.New(msgParty.Party(""))
		msgApp.Register(msgService)
		msgApp.Handle(new(sysControllers.MsgController))

		msgCatService := sysServices.NewMsgCatService()
		msgCatApp := mvc.New(msgParty.Party("/cat"))
		msgCatApp.Register(msgCatService)
		msgCatApp.Handle(new(sysControllers.MsgCatController))
	}

	// oc
	ocParty := b.Party("/oc", crs).AllowMethods(iris.MethodOptions)
	{
		ocParty.Use(middleware.AuthToken)

		ocService := sysServices.NewOcService()
		ocApp := mvc.New(ocParty.Party(""))
		ocApp.Register(ocService)
		ocApp.Handle(new(sysControllers.OcController))

		ocTypeService := sysServices.NewOcTypeService()
		ocTypeApp := mvc.New(ocParty.Party("/type"))
		ocTypeApp.Register(ocTypeService)
		ocTypeApp.Handle(new(sysControllers.OcTypeController))

		ocCatService := sysServices.NewOcCatService()
		ocCatApp := mvc.New(ocParty.Party("/cat"))
		ocCatApp.Register(ocCatService)
		ocCatApp.Handle(new(sysControllers.OcCatController))
	}

	// Model
	modelParty := b.Party("/model", crs).AllowMethods(iris.MethodOptions)
	{
		modelParty.Use(middleware.AuthToken)

		modelService := modelServices.NewModelService()
		modelApp := mvc.New(modelParty.Party(""))
		modelApp.Register(modelService)
		modelApp.Handle(new(modelControllers.ModelController))

		modelObjectService := modelServices.NewModelObjectService()
		modelObjectApp := mvc.New(modelParty.Party("/object"))
		modelObjectApp.Register(modelObjectService)
		modelObjectApp.Handle(new(modelControllers.ModelObjectController))

		modelObjectAttrService := modelServices.NewModelObjectAttrService()
		modelObjectAttrApp := mvc.New(modelParty.Party("/object/attr"))
		modelObjectAttrApp.Register(modelObjectAttrService)
		modelObjectAttrApp.Handle(new(modelControllers.ModelObjectAttrController))

		modelObjectOAMService := modelServices.NewModelObjectOAMService()
		modelObjectOAMApp := mvc.New(modelParty.Party("/object/oam"))
		modelObjectOAMApp.Register(modelObjectOAMService)
		modelObjectOAMApp.Handle(new(modelControllers.ModelObjectOAMController))
	}

	// Biz
	bizParty := b.Party("/biz", crs).AllowMethods(iris.MethodOptions)
	{
		bizParty.Use(middleware.AuthToken)

		bizService := bizServices.NewBizService()
		bizApp := mvc.New(bizParty.Party(""))
		bizApp.Register(bizService)
		bizApp.Handle(new(bizControllers.BizController))

		bizObjectService := bizServices.NewBizObjectService()
		bizObjectApp := mvc.New(bizParty.Party("/object"))
		bizObjectApp.Register(bizObjectService)
		bizObjectApp.Handle(new(bizControllers.BizObjectController))

		bizObjectMappingService := bizServices.NewBizObjectMappingService()
		bizObjectMappingApp := mvc.New(bizParty.Party("/object/mapping"))
		bizObjectMappingApp.Register(bizObjectMappingService)
		bizObjectMappingApp.Handle(new(bizControllers.BizObjectMappingController))

		bizObjectAttrService := bizServices.NewBizObjectAttrService()
		bizObjectAttrApp := mvc.New(bizParty.Party("/object/attr"))
		bizObjectAttrApp.Register(bizObjectAttrService)
		bizObjectAttrApp.Handle(new(bizControllers.BizObjectAttrController))

		bizObjectOAMService := bizServices.NewBizObjectOAMService()
		bizObjectOAMApp := mvc.New(bizParty.Party("/object/oam"))
		bizObjectOAMApp.Register(bizObjectOAMService)
		bizObjectOAMApp.Handle(new(bizControllers.BizObjectOAMController))

		bizRuleService := bizServices.NewBizRuleService()
		bizRuleApp := mvc.New(bizParty.Party("/rule"))
		bizRuleApp.Register(bizRuleService)
		bizRuleApp.Handle(new(bizControllers.BizRuleController))

		bizObjectOAMRuleService := bizServices.NewBizObjectOAMRuleService()
		bizObjectOAMRuleApp := mvc.New(bizParty.Party("/object/oam/rule"))
		bizObjectOAMRuleApp.Register(bizObjectOAMRuleService)
		bizObjectOAMRuleApp.Handle(new(bizControllers.BizObjectOAMRuleController))

		bizObjectOAMParamsService := bizServices.NewBizObjectOAMParamsService()
		bizObjectOAMParamsApp := mvc.New(bizParty.Party("/object/oam/params"))
		bizObjectOAMParamsApp.Register(bizObjectOAMParamsService)
		bizObjectOAMParamsApp.Handle(new(bizControllers.BizObjectOAMParamsController))

		bizObjectOAMMappingService := bizServices.NewBizObjectOAMMappingService()
		bizObjectOAMMappingApp := mvc.New(bizParty.Party("/object/oam/mapping"))
		bizObjectOAMMappingApp.Register(bizObjectOAMMappingService)
		bizObjectOAMMappingApp.Handle(new(bizControllers.BizObjectOAMMappingController))
	}

	// Repo
	repoParty := b.Party("/repo", crs).AllowMethods(iris.MethodOptions)
	{
		repoParty.Use(middleware.AuthToken)

		repoTypeService := repoServices.NewRepoTypeService()
		repoTypeApp := mvc.New(repoParty.Party("/type"))
		repoTypeApp.Register(repoTypeService)
		repoTypeApp.Handle(new(repoControllers.RepoTypeController))

		repoCatService := repoServices.NewRepoCatService()
		repoCatApp := mvc.New(repoParty.Party("/cat"))
		repoCatApp.Register(repoCatService)
		repoCatApp.Handle(new(repoControllers.RepoCatController))

		repoObjectService := repoServices.NewRepoObjectService()
		repoObjectApp := mvc.New(repoParty.Party("/object"))
		repoObjectApp.Register(repoObjectService)
		repoObjectApp.Handle(new(repoControllers.RepoObjectController))

		repoService := repoServices.NewRepoService()
		repoApp := mvc.New(repoParty.Party(""))
		repoApp.Register(repoService)
		repoApp.Handle(new(repoControllers.RepoController))

		repoDBService := repoServices.NewRepoDBService()
		repoDBApp := mvc.New(repoParty.Party("/db"))
		repoDBApp.Register(repoDBService)
		repoDBApp.Handle(new(repoControllers.RepoDBController))
	}

	// Api
	apiParty := b.Party("/api", crs).AllowMethods(iris.MethodOptions)
	{
		apiParty.Use(middleware.AuthToken)

		apiService := apiServices.NewApiService()
		apiApp := mvc.New(apiParty.Party(""))
		apiApp.Register(apiService)
		apiApp.Handle(new(apiControllers.ApiController))

		apiLogService := apiServices.NewApiLogService()
		apiLogApp := mvc.New(apiParty.Party("/log"))
		apiLogApp.Register(apiLogService)
		apiLogApp.Handle(new(apiControllers.ApiLogController))

	}

	// Art
	artParty := b.Party("/art", crs).AllowMethods(iris.MethodOptions)
	{
		artParty.Use(middleware.AuthToken)

		artService := sysServices.NewArtService()
		artApp := mvc.New(artParty.Party(""))
		artApp.Register(artService)
		artApp.Handle(new(sysControllers.ArtController))

		artCatService := sysServices.NewArtCatService()
		artCatApp := mvc.New(artParty.Party("/cat"))
		artCatApp.Register(artCatService)
		artCatApp.Handle(new(sysControllers.ArtCatController))
	}

	// Doc
	docParty := b.Party("/doc", crs).AllowMethods(iris.MethodOptions)
	{
		docParty.Use(middleware.AuthToken)

		docCatService := sysServices.NewDocCatService()
		docCatApp := mvc.New(artParty.Party("/cat"))
		docCatApp.Register(docCatService)
		docCatApp.Handle(new(sysControllers.DocCatController))

		docDirService := sysServices.NewDocDirService()
		docDirApp := mvc.New(artParty.Party("/dir"))
		docDirApp.Register(docDirService)
		docDirApp.Handle(new(sysControllers.DocDirController))

		docFileService := sysServices.NewDocFileService()
		docFileApp := mvc.New(artParty.Party("/file"))
		docFileApp.Register(docFileService)
		docFileApp.Handle(new(sysControllers.DocFileController))
	}

	// Upload
	uploadParty := b.Party("/upload", crs).AllowMethods(iris.MethodOptions)
	{
		uploadParty.Use(middleware.AuthToken)

		uploadService := sysServices.NewUploadService()
		uploadApp := mvc.New(artParty.Party(""))
		uploadApp.Register(uploadService)
		uploadApp.Handle(new(sysControllers.UploadController))

	}

	// Workflow
	wfParty := b.Party("/wf", crs).AllowMethods(iris.MethodOptions)
	{
		wfParty.Use(middleware.AuthToken)

		wfDefService := wfServices.NewWfDefService()
		wfDefApp := mvc.New(wfParty.Party("/def"))
		wfDefApp.Register(wfDefService)
		wfDefApp.Handle(new(wfControllers.WfDefController))

		wfInsService := wfServices.NewWfInsService()
		wfInsApp := mvc.New(wfParty.Party("/ins"))
		wfInsApp.Register(wfInsService)
		wfInsApp.Handle(new(wfControllers.WfInsController))

		wfActivityDefService := wfServices.NewWfActivityDefService()
		wfActivityDefApp := mvc.New(wfParty.Party("/activity/def"))
		wfActivityDefApp.Register(wfActivityDefService)
		wfActivityDefApp.Handle(new(wfControllers.WfActivityDefController))

		wfActivityInsService := wfServices.NewWfActivityInsService()
		wfActivityInsApp := mvc.New(wfParty.Party("/activity/ins"))
		wfActivityInsApp.Register(wfActivityInsService)
		wfActivityInsApp.Handle(new(wfControllers.WfActivityInsController))

		wfActivityActionDefService := wfServices.NewWfActivityActionDefService()
		wfActivityActionDefApp := mvc.New(wfParty.Party("/activity/action/def"))
		wfActivityActionDefApp.Register(wfActivityActionDefService)
		wfActivityActionDefApp.Handle(new(wfControllers.WfActivityActionDefController))

		wfActivityActionInsService := wfServices.NewWfActivityActionInsService()
		wfActivityActionInsApp := mvc.New(wfParty.Party("/activity/action/ins"))
		wfActivityActionInsApp.Register(wfActivityActionInsService)
		wfActivityActionInsApp.Handle(new(wfControllers.WfActivityActionInsController))

		wfInsAttachService := wfServices.NewWfInsAttachService()
		wfInsAttachApp := mvc.New(wfParty.Party("/ins/attach"))
		wfInsAttachApp.Register(wfInsAttachService)
		wfInsAttachApp.Handle(new(wfControllers.WfInsAttachController))
	}

	// x
	xParty := b.Party("/x", crs).AllowMethods(iris.MethodOptions)
	{
		xParty.Use(middleware.AuthToken)
		apiGatewayService := gateway.NewHttpHandler()
		apiGatewayApp := mvc.New(xParty.Party(""))
		apiGatewayApp.Register(apiGatewayService)
		apiGatewayApp.Handle(new(gateway.ApiGatewayController))
	}

}