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"
    "xps/cmd/middleware"
    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"
    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))

        // Upload
        uploadService := sysServices.NewUploadService()
        uploadApp := mvc.New(sysParty.Party("/upload"))
        uploadApp.Register(uploadService)
        uploadApp.Handle(new(sysControllers.UploadController))

    }

    // 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))
    }

    // 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))
    }

}