dop

Documentation

Index

• Constants
• Variables

Constants

const APIMAddr = "dop.marathon.l4lb.thisdcos.directory:9527"

Variables

var AADAPTOR_CICD_CRON_LIST = apis.ApiSpec{
	Path:         "/api/cicd-crons",
	BackendPath:  "/api/cicd-crons",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineCronListResponse{},
	Doc:          "summary: 定时 pipeline 列表",
}

var ADAPTOR_CICD_BRANCHES_ALL_VALID = apis.ApiSpec{
	Path:         "/api/cicds/actions/app-all-valid-branch-workspaces",
	BackendPath:  "/api/cicds/actions/app-all-valid-branch-workspaces",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineAppAllValidBranchWorkspaceResponse{},
	Doc:          "summary: 获取应用下所有符合 gitflow 规范的分支列表，以及每个分支对应的 workspace",
}

var ADAPTOR_CICD_CANCEL = apis.ApiSpec{
	Path:         "/api/cicds/<pipelineID>/actions/cancel",
	BackendPath:  "/api/cicds/<pipelineID>/actions/cancel",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineCancelResponse{},
	Doc:          "summary: 取消 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		pipelineId, err := ctx.GetParamUInt64("pipelineID")
		if err != nil {
			return err
		}
		pipelineDTO, err := ctx.Bundle.GetPipeline(pipelineId)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.CancelPipelineTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_CONFIG_GET = apis.ApiSpec{
	Path:        "/api/cicds/multinamespace/configs",
	BackendPath: "/api/cicds/multinamespace/configs",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	Doc:         "summary: 获取Pipeline指定命名空间的所有配置",
}

var ADAPTOR_CICD_CONFIG_NAMESPACES = apis.ApiSpec{
	Path:         "/api/cicds/actions/fetch-config-namespaces",
	BackendPath:  "/api/cicds/actions/fetch-config-namespaces",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineConfigNamespacesFetchResponse{},
	Doc:          "summary: 获取应用级别的配置的命名空间",
}

var ADAPTOR_CICD_CONFIG_WORKSPACES = apis.ApiSpec{
	Path:         "/api/cicds/actions/list-workspaces",
	BackendPath:  "/api/cicds/actions/list-workspaces",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineConfigNamespacesFetchResponse{},
	Doc:          "summary: 获取应用级别的配置的环境名称",
}

var ADAPTOR_CICD_CREATE = apis.ApiSpec{
	Path:         "/api/cicds",
	BackendPath:  "/api/cicds",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.PipelineCreateRequest{},
	ResponseType: apistructs.PipelineCreateResponse{},
	Doc:          "summary: 创建 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.PipelineCreateResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		pipelineDTO := resp.Data
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
				"branch":      pipelineDTO.Branch,
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.CreatePipelineTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_CRON_START = apis.ApiSpec{
	Path:         "/api/cicd-crons/<cronID>/actions/start",
	BackendPath:  "/api/cicd-crons/<cronID>/actions/start",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPut,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineCronStartResponse{},
	Doc:          "summary: 开始定时 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		var res apistructs.PipelineCronStartResponse
		err := ctx.BindResponseData(&res)
		if err != nil {
			return err
		}
		cronDTO := res.Data

		if cronDTO == nil || cronDTO.Extra == nil || cronDTO.Extra.NormalLabels == nil {
			return nil
		}

		app, err := ctx.GetApp(cronDTO.Extra.NormalLabels[apistructs.LabelAppID])
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(app.ProjectID, 10),
				"appId":       strconv.FormatUint(app.ID, 10),
				"projectName": app.ProjectName,
				"appName":     app.Name,
				"pipelineId":  strconv.FormatUint(cronDTO.BasePipelineID, 10),
				"branch":      cronDTO.Extra.NormalLabels[apistructs.LabelBranch],
			},
			ProjectID:    app.ProjectID,
			AppID:        app.ID,
			ScopeType:    "app",
			TemplateName: apistructs.StartPipelineTimerTemplate,
			ScopeID:      app.ID,
		})
	},
}

var ADAPTOR_CICD_CRON_STOP = apis.ApiSpec{
	Path:         "/api/cicd-crons/<cronID>/actions/stop",
	BackendPath:  "/api/cicd-crons/<cronID>/actions/stop",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPut,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineCronStopResponse{},
	Doc:          "summary: 停止定时 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		var res apistructs.PipelineCronStopResponse
		err := ctx.BindResponseData(&res)
		if err != nil {
			return err
		}
		cronDTO := res.Data

		if cronDTO == nil || cronDTO.Extra == nil || cronDTO.Extra.NormalLabels == nil {
			return nil
		}

		app, err := ctx.GetApp(cronDTO.Extra.NormalLabels[apistructs.LabelAppID])
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(app.ProjectID, 10),
				"appId":       strconv.FormatUint(app.ID, 10),
				"projectName": app.ProjectName,
				"appName":     app.Name,
				"pipelineId":  strconv.FormatUint(cronDTO.BasePipelineID, 10),
				"branch":      cronDTO.Extra.NormalLabels[apistructs.LabelBranch],
			},
			ProjectID:    app.ProjectID,
			AppID:        app.ID,
			ScopeType:    "app",
			TemplateName: apistructs.StopPipelineTimerTemplate,
			ScopeID:      app.ID,
		})
	},
}

var ADAPTOR_CICD_FETCH_PIPELINE_ID = apis.ApiSpec{
	Path:        "/api/cicds/actions/fetch-pipeline-id",
	BackendPath: "/api/cicds/actions/fetch-pipeline-id",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 根据 branch & appID 获取 pipelineID",
}

var ADAPTOR_CICD_FILETREE_CREATE = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree",
	BackendPath: "/api/cicd-pipeline/filetree",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodPost,
	IsOpenAPI:   true,
	CheckLogin:  true,
	RequestType: apistructs.UnifiedFileTreeNodeCreateRequest{},
	Doc:         "summary: 创建节点",
}

var ADAPTOR_CICD_FILETREE_DELETE = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree/<inode>",
	BackendPath: "/api/cicd-pipeline/filetree/<inode>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodDelete,
	IsOpenAPI:   true,
	CheckLogin:  true,
	RequestType: apistructs.UnifiedFileTreeNodeDeleteRequest{},
	Doc:         "summary: 删除节点",
}

var ADAPTOR_CICD_FILETREE_FIND_ANCESTORS = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree/<inode>/actions/find-ancestors",
	BackendPath: "/api/cicd-pipeline/filetree/<inode>/actions/find-ancestors",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.UnifiedFileTreeNodeFindAncestorsRequest{},
	Doc:         "summary: 查询所有父节点",
}

var ADAPTOR_CICD_FILETREE_FUZZY_SEARCH = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree/actions/fuzzy-search",
	BackendPath: "/api/cicd-pipeline/filetree/actions/fuzzy-search",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.UnifiedFileTreeNodeFuzzySearchRequest{},
	Doc:         "summary: 模糊搜索节点",
}

var ADAPTOR_CICD_FILETREE_GET = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree/<inode>",
	BackendPath: "/api/cicd-pipeline/filetree/<inode>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.UnifiedFileTreeNodeGetRequest{},
	Doc:         "summary: 查询节点详情",
}

var ADAPTOR_CICD_FILETREE_GET_PIPELINE_FILETREE = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree/actions/get-inode-by-pipeline",
	BackendPath: "/api/cicd-pipeline/filetree/actions/get-inode-by-pipeline",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 根据 pipeline id 查询流水线",
}

var ADAPTOR_CICD_FILETREE_LIST = apis.ApiSpec{
	Path:        "/api/cicd-pipeline/filetree",
	BackendPath: "/api/cicd-pipeline/filetree",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.UnifiedFileTreeNodeListRequest{},
	Doc:         "summary: 查询子节点列表",
}

var ADAPTOR_CICD_GET_BRANCH_RULE = apis.ApiSpec{
	Path:         "/api/cicds/<pipelineid>/actions/get-branch-rule",
	BackendPath:  "/api/cicds/<pipelineid>/actions/get-branch-rule",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineGetBranchRuleResponse{},
	Doc:          "获取pipeline对应的分支规则",
}

var ADAPTOR_CICD_INVOKED_COMBO = apis.ApiSpec{
	Path:         "/api/cicds/actions/app-invoked-combos",
	BackendPath:  "/api/cicds/actions/app-invoked-combos",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.PipelineInvokedComboRequest{},
	ResponseType: apistructs.PipelineInvokedComboResponse{},
	Doc:          "summary: pipeline 侧边栏 combo",
}

var ADAPTOR_CICD_LIST = apis.ApiSpec{
	Path:         "/api/cicds",
	BackendPath:  "/api/cicds",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.PipelinePageListRequest{},
	ResponseType: apistructs.PipelinePageListResponse{},
	Doc:          "summary: pipeline 列表",
}

var ADAPTOR_CICD_OPERATE = apis.ApiSpec{
	Path:         "/api/cicds/<pipelineID>",
	BackendPath:  "/api/cicds/<pipelineID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.PipelineOperateRequest{},
	ResponseType: apistructs.PipelineOperateResponse{},
	Doc:          "summary: 操作 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		pipelineId, err := ctx.GetParamUInt64("pipelineID")
		if err != nil {
			return err
		}
		var req apistructs.PipelineOperateRequest
		err = ctx.BindRequestData(&req)
		if err != nil {
			return err
		}
		pipelineDTO, err := ctx.Bundle.GetPipeline(pipelineId)
		if err != nil {
			return err
		}
		taskName := ""
		for _, operate := range req.TaskOperates {
			task, err := ctx.Bundle.GetPipelineTask(pipelineDTO.ID, operate.TaskID)
			if err != nil {
				return err
			}
			taskName = task.Name
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
				"taskName":    taskName,
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.TogglePipelineTaskTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_PIPELINE_DETAIL = apis.ApiSpec{
	Path:        "/api/cicds/actions/pipeline-detail",
	BackendPath: "/api/cicds/actions/pipeline-detail",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: pipeline 详情",
}

var ADAPTOR_CICD_PIPELINE_YML_LIST = apis.ApiSpec{
	Path:         "/api/cicds/actions/pipelineYmls",
	BackendPath:  "/api/cicds/actions/pipelineYmls",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CICDPipelineYmlListRequest{},
	ResponseType: apistructs.CICDPipelineYmlListResponse{},
	Doc:          "summary: pipeline yml列表",
}

var ADAPTOR_CICD_PROJECT_CREATE = apis.ApiSpec{
	Path:        "/api/cicds-project",
	BackendPath: "/api/cicds-project",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodPost,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
}

var ADAPTOR_CICD_PROJECT_DETAIL = apis.ApiSpec{
	Path:        "/api/cicds-project/actions/pipeline-detail",
	BackendPath: "/api/cicds-project/actions/pipeline-detail",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
}

var ADAPTOR_CICD_RERUN = apis.ApiSpec{
	Path:         "/api/cicds/<pipelineID>/actions/rerun",
	BackendPath:  "/api/cicds/<pipelineID>/actions/rerun",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineRerunResponse{},
	Doc:          "summary: pipeline 全流程重试",
	Audit: func(ctx *spec.AuditContext) error {
		pipelineId, err := ctx.GetParamUInt64("pipelineID")
		if err != nil {
			return err
		}
		pipelineDTO, err := ctx.Bundle.GetPipeline(pipelineId)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.RerunPipelineTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_RERUN_FAILED = apis.ApiSpec{
	Path:        "/api/cicds/<pipelineID>/actions/rerun-failed",
	BackendPath: "/api/cicds/<pipelineID>/actions/rerun-failed",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodPost,
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.PipelineRerunFailedResponse{},
	Doc:         "summary: pipeline 从失败节点处开始重试",
	Audit: func(ctx *spec.AuditContext) error {
		pipelineId, err := ctx.GetParamUInt64("pipelineID")
		if err != nil {
			return err
		}
		pipelineDTO, err := ctx.Bundle.GetPipeline(pipelineId)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.RetryPipelineTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_RUN = apis.ApiSpec{
	Path:         "/api/cicds/<pipelineID>/actions/run",
	BackendPath:  "/api/cicds/<pipelineID>/actions/run",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineRunResponse{},

	Doc: "summary: 开始 pipeline",
	Audit: func(ctx *spec.AuditContext) error {
		pipelineId, err := ctx.GetParamUInt64("pipelineID")
		if err != nil {
			return err
		}
		pipelineDTO, err := ctx.Bundle.GetPipeline(pipelineId)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(pipelineDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(pipelineDTO.ApplicationID, 10),
				"projectName": pipelineDTO.ProjectName,
				"appName":     pipelineDTO.ApplicationName,
				"pipelineId":  strconv.FormatUint(pipelineDTO.ID, 10),
			},
			ProjectID:    pipelineDTO.ProjectID,
			AppID:        pipelineDTO.ApplicationID,
			ScopeType:    "app",
			TemplateName: apistructs.StartPipelineTemplate,
			ScopeID:      pipelineDTO.ApplicationID,
		})
	},
}

var ADAPTOR_CICD_TASK_LOG = apis.ApiSpec{
	Path:        "/api/cicd/<pipelineID>/tasks/<taskID>/logs",
	BackendPath: "/api/cicd/<pipelineID>/tasks/<taskID>/logs",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: cicd 获取任务日志",
}

var ADAPTOR_CICD_TASK_LOG_DOWNLOAD = apis.ApiSpec{
	Path:        "/api/cicd/<pipelineID>/tasks/<taskID>/logs/actions/download",
	BackendPath: "/api/cicd/<pipelineID>/tasks/<taskID>/logs/actions/download",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	ChunkAPI:    true,
	Doc:         "summary: cicd 下载任务日志",
}

var APIDocWebsocket = apis.ApiSpec{
	Path:         "/api/apim-ws/api-docs/filetree/<inode>",
	BackendPath:  "/api/apim-ws/api-docs/filetree/<inode>",
	Host:         APIMAddr,
	Scheme:       "ws",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "api doc websocket",
}

var APITEST_ATTEMPT = apis.ApiSpec{
	Path:         "/api/apitests/actions/attempt-test",
	BackendPath:  "/api/apitests/actions/attempt-test",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 手动尝试执行单个 usecase API 测试",
	RequestType:  apistructs.APITestsAttemptRequest{},
	ResponseType: apistructs.APITestsAttemptResponse{},
	IsOpenAPI:    true,
}

var APPLICATIONS_RESOURCES_LIST = apis.ApiSpec{
	Path:        "/api/projects/<projectID>/applications-resources",
	BackendPath: "/api/projects/<projectID>/applications-resources",
	Method:      http.MethodGet,
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "the list of applications resources in the project",
	IsOpenAPI:   true,
}

var APP_PUBLISH_ITEM_RELATION_GET = apis.ApiSpec{
	Path:         "/api/applications/<application>/actions/get-publish-item-relations",
	BackendPath:  "/api/applications/<application>/actions/get-publish-item-relations",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.QueryAppPublishItemRelationResponse{},
	Doc:          "summary: 查询应用发布关联",
}

var APP_PUBLISH_ITEM_RELATION_UPDATE = apis.ApiSpec{
	Path:         "/api/applications/<application>/actions/update-publish-item-relations",
	BackendPath:  "/api/applications/<application>/actions/update-publish-item-relations",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.UpdateAppPublishItemRelationRequest{},
	ResponseType: apistructs.UpdateAppPublishItemRelationResponse{},
	Doc:          "summary: 更新应用发布关联",
}

var CI_SONAR_STORE = apis.ApiSpec{
	Path:         "/api/qa/actions/sonar-results-store",
	BackendPath:  "/api/qa/actions/sonar-results-store",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 存储 sonar issue",
	RequestType:  apistructs.SonarStoreRequest{},
	ResponseType: apistructs.SonarStoreResponse{},
	IsOpenAPI:    true,
}

var CMDB_APPLICATION_CREATE = apis.ApiSpec{
	Path:         "/api/applications",
	BackendPath:  "/api/applications",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	IsOpenAPI:    true,
	RequestType:  apistructs.ApplicationCreateRequest{},
	ResponseType: apistructs.ApplicationCreateResponse{},
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 创建应用",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.ApplicationCreateResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		applicationDTO := resp.Data
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(applicationDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(applicationDTO.ID, 10),
				"projectName": applicationDTO.ProjectName,
				"appName":     applicationDTO.Name,
			},
			ScopeType:    "app",
			ScopeID:      applicationDTO.ID,
			AppID:        applicationDTO.ID,
			ProjectID:    applicationDTO.ProjectID,
			Result:       apistructs.SuccessfulResult,
			TemplateName: apistructs.CreateAppTemplate,
		})
	},
}

var CMDB_APPLICATION_DELETE = apis.ApiSpec{
	Path:         "/api/applications/<applicationId>",
	BackendPath:  "/api/applications/<applicationId>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	IsOpenAPI:    true,
	RequestType:  apistructs.ApplicationDeleteRequest{},
	ResponseType: apistructs.ApplicationDeleteResponse{},
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 删除应用",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.ApplicationDeleteResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		applicationDTO := resp.Data
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(applicationDTO.ProjectID, 10),
				"appId":       strconv.FormatUint(applicationDTO.ID, 10),
				"projectName": applicationDTO.ProjectName,
				"appName":     applicationDTO.Name,
			},
			AppID:        applicationDTO.ID,
			ProjectID:    applicationDTO.ProjectID,
			ScopeType:    "app",
			ScopeID:      applicationDTO.ID,
			Result:       apistructs.SuccessfulResult,
			TemplateName: apistructs.DeleteAppTemplate,
		})
	},
}

var CMDB_APPLICATION_INIT = apis.ApiSpec{
	Path:        "/api/applications/<applicationID>/actions/init",
	BackendPath: "/api/applications/<applicationID>/actions/init",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "PUT",
	RequestType: apistructs.ApplicationInitRequest{},
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 应用初始化",
}

var CMDB_APPLICATION_UPDATE = apis.ApiSpec{
	Path:         "/api/applications/<applicationID>",
	BackendPath:  "/api/applications/<applicationID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ApplicationUpdateRequest{},
	ResponseType: apistructs.ApplicationUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 更新应用",
	Audit: func(ctx *spec.AuditContext) error {
		appID, err := ctx.GetParamInt64("applicationId")
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    "app",
			ScopeID:      uint64(appID),
			TemplateName: apistructs.UpdateAppTemplate,
			Context:      make(map[string]interface{}, 0),
		})
	},
}

var CMDB_BRANCH_RULE_CREATE = apis.ApiSpec{
	Path:         "/api/branch-rules",
	BackendPath:  "/api/branch-rules",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	RequestType:  apistructs.CreateBranchRuleRequest{},
	ResponseType: apistructs.CreateBranchRuleResponse{},
	Doc:          "summary: 创建分支规则",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.CreateBranchRuleResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		ruleDTO := resp.Data
		if ruleDTO.ScopeType != apistructs.ProjectScope {
			return nil
		}
		project, err := ctx.GetProject(ruleDTO.ScopeID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(project.ID, 10),
				"projectName": project.Name,
				"ruleName":    ruleDTO.Rule,
			},
			ScopeType:    "project",
			ScopeID:      project.ID,
			Result:       apistructs.SuccessfulResult,
			TemplateName: apistructs.CreateBranchRuleTemplate,
		})
	},
}

var CMDB_BRANCH_RULE_DELETE = apis.ApiSpec{
	Path:         "/api/branch-rules/<id>",
	BackendPath:  "/api/branch-rules/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	ResponseType: apistructs.DeleteBranchRuleResponse{},
	Doc:          "summary: 删除分支规则",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.DeleteBranchRuleResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		ruleDTO := resp.Data
		if ruleDTO.ScopeType != apistructs.ProjectScope {
			return nil
		}
		project, err := ctx.GetProject(ruleDTO.ScopeID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(project.ID, 10),
				"projectName": project.Name,
				"ruleName":    ruleDTO.Rule,
			},
			ScopeType:    "project",
			ScopeID:      project.ID,
			Result:       apistructs.SuccessfulResult,
			TemplateName: apistructs.DeleteBranchRuleTemplate,
		})
	},
}

var CMDB_BRANCH_RULE_QUERY = apis.ApiSpec{
	Path:         "/api/branch-rules",
	BackendPath:  "/api/branch-rules",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	RequestType:  apistructs.QueryBranchRuleRequest{},
	ResponseType: apistructs.QueryBranchRuleResponse{},
	Doc:          "summary: 查询分支规则",
}

var CMDB_BRANCH_RULE_UPDATE = apis.ApiSpec{
	Path:         "/api/branch-rules/<ID>",
	BackendPath:  "/api/branch-rules/<ID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	RequestType:  apistructs.UpdateBranchRuleRequest{},
	ResponseType: apistructs.UpdateBranchRuleResponse{},
	Doc:          "summary: 更新分支规则",
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.UpdateBranchRuleResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		ruleDTO := resp.Data
		if ruleDTO.ScopeType != apistructs.ProjectScope {
			return nil
		}
		project, err := ctx.GetProject(ruleDTO.ScopeID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			Context: map[string]interface{}{
				"projectId":   strconv.FormatUint(project.ID, 10),
				"projectName": project.Name,
				"ruleName":    ruleDTO.Rule,
			},
			ScopeType:    "project",
			ScopeID:      project.ID,
			Result:       apistructs.SuccessfulResult,
			TemplateName: apistructs.UpdateBranchRuleTemplate,
		})
	},
}

var CMDB_CERTIFICATES_APP_LIST = apis.ApiSpec{
	Path:         "/api/certificates/actions/list-application-quotes",
	BackendPath:  "/api/certificates/actions/list-application-quotes",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.AppCertificateListRequest{},
	ResponseType: apistructs.PagingAppCertificateDTO{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取指定应用的所有引用证书列表",
}

var CMDB_CERTIFICATES_LIST = apis.ApiSpec{
	Path:         "/api/certificates/actions/list-certificates",
	BackendPath:  "/api/certificates/actions/list-certificates",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CertificateListRequest{},
	ResponseType: apistructs.CertificateListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 查询所有证书列表",
}

var CMDB_CERTIFICATE_APP_CANCEL = apis.ApiSpec{
	Path:        "/api/certificates/actions/application-cancel-quote",
	BackendPath: "/api/certificates/actions/application-cancel-quote",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "DELETE",
	CheckLogin:  true,
	Doc:         "summary: 应用取消引用证书",
}

var CMDB_CERTIFICATE_APP_CONFIG = apis.ApiSpec{
	Path:        "/api/certificates/actions/push-configs",
	BackendPath: "/api/certificates/actions/push-configs",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	RequestType: apistructs.PushCertificateConfigsRequest{},
	Doc:         "summary: 推送应用证书到配置管理",
}

var CMDB_CERTIFICATE_APP_QUOTE = apis.ApiSpec{
	Path:        "/api/certificates/actions/application-quote",
	BackendPath: "/api/certificates/actions/application-quote",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	RequestType: apistructs.CertificateQuoteRequest{},
	Doc:         "summary: 应用引用证书",
}

var CMDB_CERTIFICATE_CREATE = apis.ApiSpec{
	Path:         "/api/certificates",
	BackendPath:  "/api/certificates",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	RequestType:  apistructs.CertificateCreateRequest{},
	ResponseType: apistructs.CertificateCreateResponse{},
	Doc:          "summary: 创建证书",
	Audit: func(ctx *spec.AuditContext) error {

		var resp apistructs.CertificateCreateResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		if resp.Success {
			return ctx.CreateAudit(&apistructs.Audit{
				ScopeType:    apistructs.OrgScope,
				ScopeID:      uint64(ctx.OrgID),
				TemplateName: apistructs.CreateCertificatesTemplate,
				Context:      map[string]interface{}{"certificateName": resp.Data.Name},
			})
		} else {
			return nil
		}
	},
}

var CMDB_CERTIFICATE_DELETE = apis.ApiSpec{
	Path:         "/api/certificates/<certificatesID>",
	BackendPath:  "/api/certificates/<certificatesID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	ResponseType: apistructs.CertificateDeleteResponse{},
	Doc:          "summary: 删除证书",
	Audit: func(ctx *spec.AuditContext) error {

		var resp apistructs.CertificateDeleteResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		if resp.Success {
			return ctx.CreateAudit(&apistructs.Audit{
				ScopeType:    apistructs.OrgScope,
				ScopeID:      uint64(ctx.OrgID),
				TemplateName: apistructs.DeleteCertificatesTemplate,
				Context:      map[string]interface{}{"certificateName": resp.Data.Name},
			})

		} else {
			return nil
		}

	},
}

var CMDB_CERTIFICATE_GET = apis.ApiSpec{
	Path:         "/api/certificates/<certificateID>",
	BackendPath:  "/api/certificates/<certificateID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	ResponseType: apistructs.CertificateDetailResponse{},
	Doc:          "summary: 获取证书详情",
}

var CMDB_CERTIFICATE_UPDATE = apis.ApiSpec{
	Path:         "/api/certificates/<certificateID>",
	BackendPath:  "/api/certificates/<certificateID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	RequestType:  apistructs.CertificateUpdateRequest{},
	ResponseType: apistructs.CertificateUpdateResponse{},
	Doc:          "summary: 更新证书",
	Audit: func(ctx *spec.AuditContext) error {

		var resp apistructs.CertificateUpdateResponse
		err := ctx.BindResponseData(&resp)
		if err != nil {
			return err
		}
		if resp.Success {
			return ctx.CreateAudit(&apistructs.Audit{
				ScopeType:    apistructs.OrgScope,
				ScopeID:      uint64(ctx.OrgID),
				TemplateName: apistructs.UpdateCertificatesTemplate,
				Context:      map[string]interface{}{"certificateName": resp.Data.Name},
			})

		} else {
			return nil
		}
	},
}

var CMDB_COMMENT_CREATE = apis.ApiSpec{
	Path:         "/api/comments",
	BackendPath:  "/api/comments",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CommentCreateRequest{},
	ResponseType: apistructs.CommentCreateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 创建工单评论",
	Group:        "tickets",
}

var CMDB_COMMENT_LIST = apis.ApiSpec{
	Path:         "/api/comments",
	BackendPath:  "/api/comments",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CommentListRequest{},
	ResponseType: apistructs.CommentListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 工单评论列表",
	Group:        "tickets",
}

var CMDB_COMMENT_UPDATE = apis.ApiSpec{
	Path:         "/api/comments/<commentID>",
	BackendPath:  "/api/comments/<commentID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CommentUpdateRequest{},
	ResponseType: apistructs.CommentUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 更新工单评论",
	Group:        "tickets",
}

var CMDB_ITERATION_CREATE = apis.ApiSpec{
	Path:         "/api/iterations",
	BackendPath:  "/api/iterations",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.IterationCreateRequest{},
	ResponseType: apistructs.IterationCreateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 创建迭代",
	Audit: func(ctx *spec.AuditContext) error {
		var reqBody apistructs.IterationCreateRequest
		if err := ctx.BindRequestData(&reqBody); err != nil {
			return err
		}

		var respBody apistructs.IterationCreateResponse
		if err := ctx.BindResponseData(&respBody); err != nil {
			return err
		}

		project, err := ctx.Bundle.GetProject(reqBody.ProjectID)
		if err != nil {
			return err
		}

		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			ProjectID:    project.ID,
			TemplateName: apistructs.CreateIterationTemplate,
			Context: map[string]interface{}{"iterationId": respBody.Data.ID, "iterationName": reqBody.Title,
				"projectName": project.Name},
		})
	},
}

var CMDB_ITERATION_DELETE = apis.ApiSpec{
	Path:        "/api/iterations/<id>",
	BackendPath: "/api/iterations/<id>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodDelete,
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 删除迭代",
	Audit: func(ctx *spec.AuditContext) error {
		var respBody apistructs.IterationGetResponse
		if err := ctx.BindResponseData(&respBody); err != nil {
			return err
		}
		project, err := ctx.Bundle.GetProject(respBody.Data.ProjectID)
		if err != nil {
			return err
		}

		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			ProjectID:    project.ID,
			TemplateName: apistructs.DeleteIterationTemplate,
			Context: map[string]interface{}{"projectName": project.Name, "iterationId": respBody.Data.ID,
				"iterationName": respBody.Data.Title},
		})
	},
}

var CMDB_ITERATION_GET = apis.ApiSpec{
	Path:         "/api/iterations/<id>",
	BackendPath:  "/api/iterations/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	ResponseType: apistructs.IterationGetResponse{},
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	Doc:          "summary: 迭代详情",
}

var CMDB_ITERATION_PAGING = apis.ApiSpec{
	Path:         "/api/iterations",
	BackendPath:  "/api/iterations",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.IterationPagingRequest{},
	ResponseType: apistructs.IterationPagingResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 分页查询迭代",
}

var CMDB_ITERATION_UPDATE = apis.ApiSpec{
	Path:         "/api/iterations/<id>",
	BackendPath:  "/api/iterations/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.IterationUpdateRequest{},
	ResponseType: apistructs.IterationUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 更新迭代",
	Audit: func(ctx *spec.AuditContext) error {
		var respBody apistructs.IterationUpdateResponse
		if err := ctx.BindResponseData(&respBody); err != nil {
			return err
		}
		iteration, err := ctx.Bundle.GetIteration(respBody.Data)
		if err != nil {
			return err
		}
		project, err := ctx.Bundle.GetProject(iteration.ProjectID)
		if err != nil {
			return err
		}

		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			ProjectID:    project.ID,
			TemplateName: apistructs.UpdateIterationTemplate,
			Context: map[string]interface{}{"projectName": project.Name, "iterationId": iteration.ID,
				"iterationName": iteration.Title},
		})
	},
}

var CMDB_LIBREFERENCE_CREATE = apis.ApiSpec{
	Path:         "/api/lib-references",
	BackendPath:  "/api/lib-references",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.LibReferenceCreateRequest{},
	ResponseType: apistructs.LibReferenceCreateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 创建库引用",
}

var CMDB_LIBREFERENCE_DELETE = apis.ApiSpec{
	Path:        "/api/lib-references/<id>",
	BackendPath: "/api/lib-references/<id>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodDelete,
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 删除库引用",
}

var CMDB_LIBREFERENCE_LIST = apis.ApiSpec{
	Path:         "/api/lib-references",
	BackendPath:  "/api/lib-references",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.LibReferenceListRequest{},
	ResponseType: apistructs.LibReferenceListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 库引用列表",
}

var CMDB_LIBREFERENCE_LIST_VERSION = apis.ApiSpec{
	Path:        "/api/lib-references/actions/fetch-versions",
	BackendPath: "/api/lib-references/actions/fetch-versions",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      http.MethodGet,
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 获取模块订阅版本",
}

var CMDB_MY_PUBLISHERS_LIST = apis.ApiSpec{
	Path:         "/api/publishers/actions/list-my-publishers",
	BackendPath:  "/api/publishers/actions/list-my-publishers",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.PublisherListRequest{},
	ResponseType: apistructs.PublisherListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 查询我的Publisher列表",
}

var CMDB_ORG_CREATE = apis.ApiSpec{
	Path:         "/api/orgs",
	BackendPath:  "/api/orgs",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgCreateRequest{},
	ResponseType: apistructs.OrgCreateResponse{},
	Doc:          "summary: 创建组织",
	Audit: func(ctx *spec.AuditContext) error {
		var requestBody apistructs.OrgCreateRequest
		if err := ctx.BindRequestData(&requestBody); err != nil {
			return err
		}
		var responseBody apistructs.OrgCreateResponse
		if err := ctx.BindResponseData(&responseBody); err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.SysScope,
			ScopeID:      1,
			OrgID:        responseBody.Data.ID,
			TemplateName: apistructs.CreateOrgTemplate,
			Context:      map[string]interface{}{"orgName": requestBody.Name},
		})
	},
}

var CMDB_ORG_DELETE = apis.ApiSpec{
	Path:        "/api/orgs/<orgID>",
	BackendPath: "/api/orgs/<orgID>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "DELETE",
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 删除企业",
	Audit: func(ctx *spec.AuditContext) error {
		orgID, err := ctx.GetParamInt64("orgID")
		if err != nil {
			return err
		}
		var response struct {
			Data apistructs.OrgDTO
		}
		if err := ctx.BindResponseData(&response); err != nil {
			return err
		}

		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.SysScope,
			ScopeID:      1,
			OrgID:        uint64(orgID),
			TemplateName: apistructs.DeleteOrgTemplate,
			Context:      map[string]interface{}{"orgName": response.Data.Name},
		})
	},
}

var CMDB_ORG_FETCH = apis.ApiSpec{
	Path:         "/api/orgs/<orgID>",
	BackendPath:  "/api/orgs/<orgID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgFetchRequest{},
	ResponseType: apistructs.OrgSearchResponse{},
	Doc:          "summary: 获取组织",
}

var CMDB_ORG_GET_BY_DOMAIN = apis.ApiSpec{
	Path:          "/api/orgs/actions/get-by-domain",
	BackendPath:   "/api/orgs/actions/get-by-domain",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "GET",
	TryCheckLogin: true,
	CheckToken:    true,
	IsOpenAPI:     true,
	RequestType:   apistructs.OrgGetByDomainRequest{},
	ResponseType:  apistructs.OrgGetByDomainResponse{},
	Doc:           "summary: 通过域名获取组织",
}

var CMDB_ORG_NEXUS_FETCH = apis.ApiSpec{
	Path:         "/api/orgs/<orgID>/nexus",
	BackendPath:  "/api/orgs/<orgID>/nexus",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgNexusGetRequest{},
	ResponseType: apistructs.OrgNexusGetResponse{},
	Doc:          "summary: 获取企业 nexus 信息",
}

var CMDB_ORG_NEXUS_SHOW_PASSWORD = apis.ApiSpec{
	Path:         "/api/orgs/<orgID>/show-nexus-password",
	BackendPath:  "/api/orgs/<orgID>/show-nexus-password",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgNexusShowPasswordRequest{},
	ResponseType: apistructs.OrgNexusShowPasswordResponse{},
	Doc:          "summary: 获取企业 nexus 密码",
}

var CMDB_ORG_PUBLIC = apis.ApiSpec{
	Path:          "/api/orgs/actions/list-public",
	BackendPath:   "/api/orgs/actions/list-public",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "GET",
	TryCheckLogin: true,
	CheckToken:    true,
	IsOpenAPI:     true,
	RequestType:   apistructs.OrgSearchRequest{},
	ResponseType:  apistructs.OrgSearchResponse{},
	Doc:           "summary: 查询公开组织",
}

var CMDB_ORG_PUBLISHER_CREATE = apis.ApiSpec{
	Path:        "/api/orgs/<orgID>/actions/create-publisher",
	BackendPath: "/api/orgs/<orgID>/actions/create-publisher",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 创建发布商",
}

var CMDB_ORG_PUBLISHER_CREATE_GET = apis.ApiSpec{
	Path:        "/api/orgs/<orgID>/actions/create-publisher",
	BackendPath: "/api/orgs/<orgID>/actions/create-publisher",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	Doc:         "summary: 创建发布商",
}

var CMDB_ORG_RESOURCE_GET = apis.ApiSpec{
	Path:         "/api/orgs/actions/fetch-resources",
	BackendPath:  "/api/orgs/actions/fetch-resources",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.OrgResourceInfo{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取企业资源使用",
}

var CMDB_ORG_SEARCH = apis.ApiSpec{
	Path:         "/api/orgs",
	BackendPath:  "/api/orgs",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgSearchRequest{},
	ResponseType: apistructs.OrgSearchResponse{},
	Doc:          "summary: 查询组织",
}

var CMDB_ORG_UPDATE = apis.ApiSpec{
	Path:         "/api/orgs/<orgID>",
	BackendPath:  "/api/orgs/<orgID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.OrgUpdateRequest{},
	ResponseType: apistructs.OrgUpdateRequestBody{},
	Doc:          "summary: 更新组织",
	Audit: func(ctx *spec.AuditContext) error {
		var (
			resp struct{ Data apistructs.OrgDTO }
		)
		if err := ctx.BindResponseData(&resp); err != nil {
			return err
		}

		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.SysScope,
			ScopeID:      1,
			OrgID:        resp.Data.ID,
			TemplateName: apistructs.UpdateOrgTemplateV2,
			Context: map[string]interface{}{
				"orgName":   resp.Data.Name,
				"contentZH": resp.Data.AuditMessage.MessageZH,
				"contentEN": resp.Data.AuditMessage.MessageEN,
			},
		})
	},
}

var CMDB_PROJECTS_FETCH = apis.ApiSpec{
	Path:         "/api/projects",
	BackendPath:  "/api/projects",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.ProjectListRequest{},
	ResponseType: apistructs.ProjectListResponse{},
	Doc:          "summary: 查询项目",
}

* add for standard

var CMDB_PROJECT_CREATE = apis.ApiSpec{
	Path:         "/api/projects",
	BackendPath:  "/api/projects",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.ProjectCreateRequest{},
	ResponseType: apistructs.ProjectCreateResponse{},
	Doc:          "summary: 创建项目",
	Audit: func(ctx *spec.AuditContext) error {
		var requestBody apistructs.ProjectCreateRequest
		if err := ctx.BindRequestData(&requestBody); err != nil {
			return err
		}
		var responseBody apistructs.ProjectCreateResponse
		if err := ctx.BindResponseData(&responseBody); err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.OrgScope,
			ScopeID:      uint64(ctx.OrgID),
			ProjectID:    responseBody.Data,
			TemplateName: apistructs.CreateProjectTemplate,
			Context:      map[string]interface{}{"projectName": requestBody.Name},
		})
	},
}

var CMDB_PROJECT_DELETE = apis.ApiSpec{
	Path:         "/api/projects/<projectID>",
	BackendPath:  "/api/projects/<projectID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.ProjectDeleteRequest{},
	ResponseType: apistructs.ProjectDeleteResponse{},
	Doc:          "summary: 删除项目",
	Audit: func(ctx *spec.AuditContext) error {
		// 由于与删除project时产生审计事件所需要的返回一样，所以删除project时也用这个接收返回
		var responseBody apistructs.ProjectDetailResponse
		if err := ctx.BindResponseData(&responseBody); err != nil {
			return err
		}
		projectID := responseBody.Data.ID
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      projectID,
			ProjectID:    projectID,
			TemplateName: apistructs.DeleteProjectTemplate,
			Context:      map[string]interface{}{"projectName": responseBody.Data.Name},
		})
	},
}

* migration

var CMDB_PROJECT_DETAIL = apis.ApiSpec{
	Path:         "/api/projects/<projectIDOrName>",
	BackendPath:  "/api/projects/<projectIDOrName>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	RequestType:  apistructs.ProjectDetailRequest{},
	ResponseType: apistructs.ProjectDetailResponse{},
	Doc:          "summary: 获取项目详情",
}

var CMDB_PUBLISHERS_LIST = apis.ApiSpec{
	Path:         "/api/publishers",
	BackendPath:  "/api/publishers",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.PublisherListRequest{},
	ResponseType: apistructs.PublisherListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 查询所有Publisher列表",
}

var CMDB_PUBLISHER_CREATE = apis.ApiSpec{
	Path:         "/api/publishers",
	BackendPath:  "/api/publishers",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	RequestType:  apistructs.PublisherCreateRequest{},
	ResponseType: apistructs.PublisherCreateResponse{},
	Doc:          "summary: 创建 Publisher",
}

var CMDB_PUBLISHER_DELETE = apis.ApiSpec{
	Path:         "/api/publishers/<publisherID>",
	BackendPath:  "/api/publishers/<publisherID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	ResponseType: apistructs.PublisherDeleteResponse{},
	Doc:          "summary: 删除 Publisher",
}

var CMDB_PUBLISHER_GET = apis.ApiSpec{
	Path:         "/api/publishers/<publisherID>",
	BackendPath:  "/api/publishers/<publisherID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	ResponseType: apistructs.PublisherDetailResponse{},
	Doc:          "summary: 获取Publisher详情",
}

var CMDB_PUBLISHER_UPDATE = apis.ApiSpec{
	Path:         "/api/publishers",
	BackendPath:  "/api/publishers",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	RequestType:  apistructs.PublisherUpdateRequest{},
	ResponseType: apistructs.PublisherUpdateResponse{},
	Doc:          "summary: 更新 Publisher",
}

var CMDB_ROLES_LIST = apis.ApiSpec{
	Path:         "/api/members/actions/list-roles",
	BackendPath:  "/api/members/actions/list-roles",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	ResponseType: apistructs.MemberRoleListResponse{},
	Doc:          "summary: 获取成员角色列表",
}

var CMDB_TICKET_CLOSE = apis.ApiSpec{
	Path:         "/api/tickets/<ticketID>/actions/close",
	BackendPath:  "/api/tickets/<ticketID>/actions/close",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketCloseRequest{},
	ResponseType: apistructs.TicketCloseResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 关闭工单",
}

var CMDB_TICKET_CREATE = apis.ApiSpec{
	Path:         "/api/tickets",
	BackendPath:  "/api/tickets",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketCreateRequest{},
	ResponseType: apistructs.TicketCreateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 创建工单",
}

var CMDB_TICKET_DELETE = apis.ApiSpec{
	Path:         "/api/tickets/<ticketID>",
	BackendPath:  "/api/tickets/<ticketID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketDeleteRequest{},
	ResponseType: apistructs.TicketDeleteResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 删除工单",
}

var CMDB_TICKET_FETCH = apis.ApiSpec{
	Path:         "/api/tickets/<ticketID>",
	BackendPath:  "/api/tickets/<ticketID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketFetchRequest{},
	ResponseType: apistructs.TicketFetchResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取工单详情",
}

var CMDB_TICKET_LIST = apis.ApiSpec{
	Path:         "/api/tickets",
	BackendPath:  "/api/tickets",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketListRequest{},
	ResponseType: apistructs.TicketListResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 工单列表",
}

var CMDB_TICKET_REOPEN = apis.ApiSpec{
	Path:         "/api/tickets/<ticketID>/actions/reopen",
	BackendPath:  "/api/tickets/<ticketID>/actions/reopen",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketReopenRequest{},
	ResponseType: apistructs.TicketReopenResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 重新打开已关闭工单",
}

var CMDB_TICKET_UPDATE = apis.ApiSpec{
	Path:         "/api/tickets/<ticketID>",
	BackendPath:  "/api/tickets/<ticketID>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.TicketUpdateRequest{},
	ResponseType: apistructs.TicketUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 更新工单",
}

var CODE_COVERAGE_END_CALLBACK = apis.ApiSpec{
	Path:        "/api/code-coverage/actions/end-callBack",
	BackendPath: "/api/code-coverage/actions/end-callBack",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.CodeCoverageUpdateRequest{},
	IsOpenAPI:   true,
	Doc:         "summary: end callback",
}

var CODE_COVERAGE_READY_CALLBACK = apis.ApiSpec{
	Path:        "/api/code-coverage/actions/ready-callBack",
	BackendPath: "/api/code-coverage/actions/ready-callBack",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.CodeCoverageUpdateRequest{},
	IsOpenAPI:   true,
	Doc:         "summary: ready callback",
}

var CODE_COVERAGE_READY_STATUS = apis.ApiSpec{
	Path:        "/api/code-coverage/actions/status",
	BackendPath: "/api/code-coverage/actions/status",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.CodeCoverageUpdateRequest{},
	IsOpenAPI:   true,
	Doc:         "summary: status",
}

var CODE_COVERAGE_REPORT_CALLBACK = apis.ApiSpec{
	Path:        "/api/code-coverage/actions/report-callBack",
	BackendPath: "/api/code-coverage/actions/report-callBack",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	RequestType: apistructs.CodeCoverageUpdateRequest{},
	IsOpenAPI:   true,
	Doc:         "summary: end callback",
}

var CreateAPIAsset = apis.ApiSpec{
	Path:         "/api/api-assets",
	BackendPath:  "/api/api-assets",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.APIAssetCreateRequest{},
	ResponseType: nil,
	Doc:          "创建 API 资料",
}

var CreateAPIAssetVersion = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions",
	BackendPath:  "/api/api-assets/<assetID>/versions",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.APIAssetVersionCreateRequest{},
	ResponseType: apistructs.CreateAPIAssetVersionBody{},
	Doc:          "新增 API 资料版本",
}

var CreateAccess = apis.ApiSpec{
	Path:         "/api/api-access",
	BackendPath:  "/api/api-access",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CreateAccessReq{},
	ResponseType: nil,
	Doc:          "create access",
}

var CreateAttempTest = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/attempt-test",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/attempt-test",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.APITestReq{},
	ResponseType: apistructs.Header{},
	Doc:          "list access",
}

var CreateClient = apis.ApiSpec{
	Path:         "/api/api-clients",
	BackendPath:  "/api/api-clients",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CreateClientReq{},
	ResponseType: nil,
	Doc:          "create client",
}

var CreateContract = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts",
	BackendPath:  "/api/api-clients/<clientID>/contracts",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CreateContractReq{},
	ResponseType: nil,
	Doc:          "create contract",
}

var CreateInstantiation = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CreateInstantiationReq{},
	ResponseType: nil,
	Doc:          "create instantiation",
}

var CreateSLA = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.CreateSLAReq{},
	ResponseType: apistructs.Header{},
	Doc:          "create SLA",
}

var DeleteAPIAssetVersion = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions/<versionID>",
	BackendPath:  "/api/api-assets/<assetID>/versions/<versionID>",
	Method:       http.MethodDelete,
	Host:         APIMAddr,
	Scheme:       "http",
	CheckLogin:   true,
	Doc:          "删除指定版本的 API 资料",
	RequestType:  nil,
	ResponseType: nil,
}

var DeleteAPIAssets = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>",
	BackendPath:  "/api/api-assets/<assetID>",
	Method:       http.MethodDelete,
	Host:         APIMAddr,
	Scheme:       "http",
	CheckLogin:   true,
	Doc:          "删除 API 资料",
	RequestType:  nil,
	ResponseType: nil,
}

var DeleteAccess = apis.ApiSpec{
	Path:         "/api/api-access/<accessID>",
	BackendPath:  "/api/api-access/<accessID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodDelete,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "delete access",
}

var DeleteClient = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>",
	BackendPath:  "/api/api-clients/<clientID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodDelete,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "delete client",
}

var DeleteContract = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts/<contractID>",
	BackendPath:  "/api/api-clients/<clientID>/contracts/<contractID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodDelete,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetContractReq{},
	ResponseType: nil,
	Doc:          "delete contract",
}

var DeleteSLA = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodDelete,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.DeleteSLAReq{},
	ResponseType: apistructs.Header{},
	Doc:          "delete SLA",
}

var ExportSpec = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions/<versionID>/export",
	BackendPath:  "/api/api-assets/<assetID>/versions/<versionID>/export",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  apistructs.DownloadSpecTextReq{},
	ResponseType: nil,
	Doc:          "导出 swagger 文本",
}

var FileTreeCreateNode = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree",
	BackendPath:  "/api/apim/<treeName>/filetree",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.APIDocCreateNodeReq{},
	ResponseType: nil,
	Doc:          "create file tree node",
}

var FileTreeDeleteNode = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree/<inode>",
	BackendPath:  "/api/apim/<treeName>/filetree/<inode>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodDelete,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "delete file tree node",
}

var FileTreeGetNode = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree/<inode>",
	BackendPath:  "/api/apim/<treeName>/filetree/<inode>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "get file tree node",
}

var FileTreeListNodes = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree",
	BackendPath:  "/api/apim/<treeName>/filetree",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "list file tree nodes",
}

var FileTreeMvCpNode = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree/<inode>/actions/<action>",
	BackendPath:  "/api/apim/<treeName>/filetree/<inode>/actions/<action>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPost,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "mv or cp file tree node",
}

var FileTreeUpdateNode = apis.ApiSpec{
	Path:         "/api/apim/<treeName>/filetree/<inode>",
	BackendPath:  "/api/apim/<treeName>/filetree/<inode>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "update file tree node",
}

var FuncPointsQuery = apis.ApiSpec{
	Path:        "/api/func-points-trend/actions/query",
	BackendPath: "/api/func-points-trend/actions/query",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 功能点生产率PDR查询",
}

var GetAPIAssetVersion = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions/<versionID>",
	BackendPath:  "/api/api-assets/<assetID>/versions/<versionID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  apistructs.GetAPIAssetVersionReq{},
	ResponseType: apistructs.GetAssetVersionRsp{},
	Doc:          "查询 API 资料版本详情",
}

var GetAPIAssets = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>",
	BackendPath:  "/api/api-assets/<assetID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  apistructs.GetAPIAssetReq{},
	ResponseType: apistructs.APIAssetGetResponse{},
	Doc:          "查询 API 资料",
}

var GetAccess = apis.ApiSpec{
	Path:         "/api/api-access/<accessID>",
	BackendPath:  "/api/api-access/<accessID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "get access",
	Parameters: &apis.Parameters{
		Tag:    "apim",
		Header: nil,
		QueryValues: url.Values{
			"accessID": nil,
		},
		Body:     nil,
		Response: &apistructs.GetAccessRspAccess{},
	},
}

var GetClient = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>",
	BackendPath:  "/api/api-clients/<clientID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetClientReq{},
	ResponseType: nil,
	Doc:          "get client",
}

var GetContract = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts/<contractID>",
	BackendPath:  "/api/api-clients/<clientID>/contracts/<contractID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetContractReq{},
	ResponseType: nil,
	Doc:          "get contract",
}

var GetInstantiations = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetInstantiationsReq{},
	ResponseType: apistructs.GetAddonInstanceDetailResponse{},
	Doc:          "get instantiations",
}

var GetOperation = apis.ApiSpec{
	Path:         "/api/apim/operations/<id>",
	BackendPath:  "/api/apim/operations/<id>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetOperationReq{},
	ResponseType: apistructs.BaseResponse{},
	Doc:          "搜索集市中的接口",
}

var GetSLA = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListSLAsReq{},
	ResponseType: apistructs.ListSLAsRsp{},
	Doc:          "get SLA",
}

var ListAPIAssetVersions = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions",
	BackendPath:  "/api/api-assets/<assetID>/versions",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  apistructs.GetAPIAssetVersionReq{},
	ResponseType: apistructs.GetAssetVersionRsp{},
	Doc:          "查询 API 资料版本列表",
}

var ListAPIGateways = apis.ApiSpec{
	Path:         "api/api-assets/<assetID>/api-gateways",
	BackendPath:  "api/api-assets/<assetID>/api-gateways",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListAPIGatewaysReq{},
	ResponseType: apistructs.ListAPIGatewaysResp{},
	Doc:          "list api-gateways",
}

var ListAccess = apis.ApiSpec{
	Path:         "/api/api-access",
	BackendPath:  "/api/api-access",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListAccessReq{},
	ResponseType: apistructs.ListAccessRsp{},
	Doc:          "list access",
}

var ListContract = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts",
	BackendPath:  "/api/api-clients/<clientID>/contracts",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListContractsReq{},
	ResponseType: apistructs.ListContractsRsp{},
	Doc:          "list contract",
}

var ListContractRecords = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts/<contractID>/operation-records",
	BackendPath:  "/api/api-clients/<clientID>/contracts/<contractID>/operation-records",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListContractRecordsReq{},
	ResponseType: apistructs.ListContractRecordsRsp{},
	Doc:          "list contract records",
}

var ListInstantiations = apis.ApiSpec{
	Path:         "/api/api-instantiations",
	BackendPath:  "/api/api-instantiations",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "get instantiations",
}

var ListMyClients = apis.ApiSpec{
	Path:         "/api/api-clients",
	BackendPath:  "/api/api-clients",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListMyClientsReq{},
	ResponseType: nil,
	Doc:          "list my client",
}

var ListProjectAPIGateways = apis.ApiSpec{
	Path:         "api/api-gateways/<projectID>",
	BackendPath:  "api/api-gateways/<projectID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListProjectAPIGatewaysReq{},
	ResponseType: apistructs.ListAPIGatewaysResp{},
	Doc:          "list api-gateways",
}

var ListRuntimeServices = apis.ApiSpec{
	Path:         "/api/api-app-services/<appID>",
	BackendPath:  "/api/api-app-services/<appID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: apistructs.Header{},
	Doc:          "list access",
}

var ListSLA = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.GetSLAReq{},
	ResponseType: apistructs.GetSLARsp{},
	Doc:          "list SLA",
}

var ListSwaggerVersionClients = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/clients",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/clients",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListSwaggerVersionClientsReq{},
	ResponseType: apistructs.ListSwaggerVersionRsp{},
	Doc:          "list swagger version clients",
}

var ListSwaggerVersions = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ListSwaggerVersionsReq{},
	ResponseType: apistructs.ListSwaggerVersionRsp{},
	Doc:          "list swagger versions",
}

var PUBLISH_ITEM_CERTIFICATION_GET = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/certification",
	BackendPath: "/api/publish-items/<publishItemId>/certification",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         `summary: 发布内容认证列表`,
}

var PUBLISH_ITEM_CHANNELS = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/statistics/channels",
	BackendPath:  "/api/publish-items/<publishItemId>/statistics/channels",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	RequestType:  apistructs.PublishItemStatisticsDetailRequest{},
	ResponseType: apistructs.PublishItemStatisticsDetailData{},
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          `summary: 渠道详情，明细数据`,
}

var PUBLISH_ITEM_CREATE_OFFLINE_VERSION = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/versions/create-offline-version",
	BackendPath: "/api/publish-items/<publishItemId>/versions/create-offline-version",
	Host:        "erda-server.marathon.l4lb.thisdcos.directory:9095",
	Scheme:      "http",
	Method:      http.MethodPost,
	CheckLogin:  true,
	CheckToken:  true,
	IsOpenAPI:   true,
	ChunkAPI:    true,
	Doc:         "summary: 移动应用上传离线包",
}

var PUBLISH_ITEM_DISTRIBUTION = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/distribution",
	BackendPath:  "/api/publish-items/<publishItemId>/distribution",
	Host:         "erda-server.marathon.l4lb.thisdcos.directory:9095",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   false,
	CheckToken:   false,
	ResponseType: apistructs.PublishItemDistributionResponse{},
	Doc:          "summary: 发布下载信息",
}

var PUBLISH_ITEM_ERR_EFFACTS = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/err/effacts",
	BackendPath: "/api/publish-items/<publishItemId>/err/effacts",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         `summary: 错误统计，影响用户占比`,
}

var PUBLISH_ITEM_ERR_LIST = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/err/list",
	BackendPath:  "/api/publish-items/<publishItemId>/err/list",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	ResponseType: apistructs.PublishItemStatisticsErrListData{},
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          `summary: 错误报告，错误列表`,
}

var PUBLISH_ITEM_ERR_RATE = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/err/rate",
	BackendPath: "/api/publish-items/<publishItemId>/err/rate",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         `summary: 错误统计，崩溃率`,
}

var PUBLISH_ITEM_ERR_TREND = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/err/trend",
	BackendPath:  "/api/publish-items/<publishItemId>/err/trend",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	ResponseType: apistructs.PublishItemStatisticsErrTrendData{},
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          `summary: 错误报告，错误趋势`,
}

var PUBLISH_ITEM_METIRCS_COMMON = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/metrics/<metricName>",
	BackendPath: "/api/publish-items/<publishItemId>/metrics/<metricName>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	Doc:         `summary: 通用metrcis接口，转发使用`,
}

var PUBLISH_ITEM_METIRCS_HISTOGRAM_COMMON = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/metrics/<metricName>/histogram",
	BackendPath: "/api/publish-items/<publishItemId>/metrics/<metricName>/histogram",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	Doc:         `summary: 通用metrcis histogram接口，转发使用`,
}

var PUBLISH_ITEM_STATISTICS_TREND = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/statistics/trend",
	BackendPath:  "/api/publish-items/<publishItemId>/statistics/trend",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	ResponseType: apistructs.PublishItemStatisticsTrendData{},
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          `summary: 统一大盘，整体趋势接口`,
}

var PUBLISH_ITEM_USERS = apis.ApiSpec{
	Path:        "/api/publish-items/<publishItemId>/statistics/users",
	BackendPath: "/api/publish-items/<publishItemId>/statistics/users",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	IsOpenAPI:   true,
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         `summary: 统计大盘，累计用户`,
}

var PUBLISH_ITEM_VERSION_GET_LATEST = apis.ApiSpec{
	Path:          "/api/publish-items/actions/latest-versions",
	BackendPath:   "/api/publish-items/actions/latest-versions",
	Host:          "erda-server.marathon.l4lb.thisdcos.directory:9095",
	Scheme:        "http",
	Method:        "POST",
	CheckLogin:    false,
	TryCheckLogin: true,
	CheckToken:    true,
	IsOpenAPI:     true,
	ChunkAPI:      true,
	RequestType:   apistructs.GetPublishItemLatestVersionRequest{},
	ResponseType:  apistructs.GetPublishItemLatestVersionResponse{},
	Doc:           "summary: 获取移动应用最新的版本",
}

var PUBLISH_ITEM_VERSION_INFO_LIST = apis.ApiSpec{
	Path:         "/api/publish-items/<publishItemId>/statistics/versions",
	BackendPath:  "/api/publish-items/<publishItemId>/statistics/versions",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	RequestType:  apistructs.PublishItemStatisticsDetailRequest{},
	ResponseType: apistructs.PublishItemStatisticsDetailData{},
	IsOpenAPI:    true,
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          `summary: 版本详情，明细数据`,
}

var PagingAPIAssets = apis.ApiSpec{
	Path:         "/api/api-assets",
	BackendPath:  "/api/api-assets",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  apistructs.PagingAPIAssetsReq{},
	ResponseType: apistructs.APIAssetPagingResponse{},
	Doc:          "分页查询 API 资料",
}

var PerformanceMeasureQuery = apis.ApiSpec{
	Path:        "/api/efficiency-measure/actions/query",
	BackendPath: "/api/efficiency-measure/actions/query",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询效能度量",
}

var PersonalContributorQuery = apis.ApiSpec{
	Path:        "/api/personal-contribution/actions/query",
	BackendPath: "/api/personal-contribution/actions/query",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 个人贡献查询接口",
}

var ProjectPackageExport = apis.ApiSpec{
	Path:          "/api/orgs/<orgID>/projects/<projectID>/package/actions/export",
	BackendPath:   "/api/orgs/<orgID>/projects/<projectID>/package/actions/export",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "POST",
	TryCheckLogin: true,
	RequestType:   apistructs.ExportProjectPackageRequest{},
	Doc:           "summary: 导出项目工程包",
}

var ProjectPackageImport = apis.ApiSpec{
	Path:          "/api/orgs/<orgID>/projects/<projectID>/package/actions/import",
	BackendPath:   "/api/orgs/<orgID>/projects/<projectID>/package/actions/import",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "POST",
	TryCheckLogin: true,
	RequestType:   apistructs.ImportProjectPackageRequest{},
	Doc:           "summary: 导入项目工程包",
}

var ProjectPackageParse = apis.ApiSpec{
	Path:          "/api/projects/package/actions/parse",
	BackendPath:   "/api/projects/package/actions/parse",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "POST",
	TryCheckLogin: true,
	Doc:           "summary: 解析项目工程包",
}

var ProjectReportQuery = apis.ApiSpec{
	Path:        "/api/project-report/actions/query",
	BackendPath: "/api/project-report/actions/query",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询项目交付报表",
}

var ProjectTemplateExport = apis.ApiSpec{
	Path:          "/api/orgs/<orgID>/projects/<projectID>/template/actions/export",
	BackendPath:   "/api/orgs/<orgID>/projects/<projectID>/template/actions/export",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "GET",
	TryCheckLogin: true,
	RequestType:   apistructs.ExportProjectTemplateRequest{},
	Doc:           "summary: 导出项目模版",
}

var ProjectTemplateImport = apis.ApiSpec{
	Path:          "/api/orgs/<orgID>/projects/<projectID>/template/actions/import",
	BackendPath:   "/api/orgs/<orgID>/projects/<projectID>/template/actions/import",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "POST",
	TryCheckLogin: true,
	RequestType:   apistructs.ImportProjectTemplateRequest{},
	Doc:           "summary: 导入项目模版",
}

var ProjectTemplateParse = apis.ApiSpec{
	Path:          "/api/projects/template/actions/parse",
	BackendPath:   "/api/projects/template/actions/parse",
	Host:          "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:        "http",
	Method:        "POST",
	TryCheckLogin: true,
	RequestType:   apistructs.ImportProjectTemplateRequest{},
	Doc:           "summary: 解析项目模版",
}

var ProxyMetrics = apis.ApiSpec{
	Path:         "/api/apim/metrics/<*>",
	BackendPath:  "/api/apim/metrics/<*>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "转发 metrics 请求",
}

var QA_APITESTS_CANCEL = apis.ApiSpec{
	Path:         "/api/apitests/actions/cancel-testplan",
	BackendPath:  "/api/apitests/actions/cancel-testplan",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ApiTestCancelRequest{},
	ResponseType: apistructs.ApiTestCancelResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 取消测试计划",
}

var QA_APITESTS_GET = apis.ApiSpec{
	Path:         "/api/apitests/<id>",
	BackendPath:  "/api/apitests/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.ApiTestsGetResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取apitest详情",
}

var QA_APITESTS_UPDATE = apis.ApiSpec{
	Path:         "/api/apitests/<id>",
	BackendPath:  "/api/apitests/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.ApiTestsUpdateRequest{},
	ResponseType: apistructs.ApiTestsUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          `更新 api test的信息`,
}

var QA_AUTOTEST_SPACE_GET = apis.ApiSpec{
	Path:         "/api/autotests/spaces/<id>",
	BackendPath:  "/api/autotests/spaces/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.AutoTestSpaceResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取autotest-space详情",
}

var QA_PIPELINE_TASK_LOGS = apis.ApiSpec{
	Path:         "/api/apitests/pipeline/<pipelineID>/task/<taskID>/logs",
	BackendPath:  "/api/apitests/pipeline/<pipelineID>/task/<taskID>/logs",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.DashboardSpotLogResponse{},
	Doc:          "summary: 查询测试记录的pipeline task 日志",
}

var QA_RECORDS_GET = apis.ApiSpec{
	Path:         "/api/test-file-records/<id>",
	BackendPath:  "/api/test-file-records/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: get file record",
	ResponseType: apistructs.GetTestFileRecordResponse{},
	IsOpenAPI:    true,
}

var QA_RECORDS_LIST = apis.ApiSpec{
	Path:         "/api/test-file-records",
	BackendPath:  "/api/test-file-records",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: get file records",
	RequestType:  apistructs.ListTestFileRecordsRequest{},
	ResponseType: apistructs.ListTestFileRecordsResponse{},
	IsOpenAPI:    true,
}

var QA_SONAR_GET_CREDENTIAL = apis.ApiSpec{
	Path:         "/api/qa/actions/get-sonar-credential",
	BackendPath:  "/api/qa/actions/get-sonar-credential",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   false,
	CheckToken:   true,
	Doc:          "summary: action 获取 sonar credential",
	ResponseType: apistructs.SonarCredentialGetResponse{},
}

var QA_SONAR_ISSUES = apis.ApiSpec{
	Path:         "/api/qa",
	BackendPath:  "/api/qa",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 获取 sonar issues",
	ResponseType: apistructs.SonarIssueResponse{},
	IsOpenAPI:    true,
}

var QA_SONAR_METRIC_RULES_BATCH_DELETE = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/actions/batch-delete",
	BackendPath: "/api/sonar-metric-rules/actions/batch-delete",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "DELETE",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 批量删除 sonar 扫描规则",
	RequestType: apistructs.SonarMetricRulesBatchDeleteRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_BATCH_INSERT = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/actions/batch-insert",
	BackendPath: "/api/sonar-metric-rules/actions/batch-insert",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "POST",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 批量插入 sonar 扫描规则",
	RequestType: apistructs.SonarMetricRulesBatchInsertRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_DELETE = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/<ID>",
	BackendPath: "/api/sonar-metric-rules/<ID>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "DELETE",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 删除 sonar 扫描规则",
	RequestType: apistructs.SonarMetricRulesDeleteRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_GET = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/<id>",
	BackendPath: "/api/sonar-metric-rules/<id>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询 sonar 扫描规则",
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_PAGING = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules",
	BackendPath: "/api/sonar-metric-rules",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 分页查询 sonar 扫描规则",
	RequestType: apistructs.SonarMetricRulesPagingRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_QUERY_DEFINITION = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/actions/query-metric-definition",
	BackendPath: "/api/sonar-metric-rules/actions/query-metric-definition",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询 sonar 还未添加的扫描规则",
	RequestType: apistructs.SonarMetricRulesDefinitionListRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_QUERY_LIST = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/actions/query-list",
	BackendPath: "/api/sonar-metric-rules/actions/query-list",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询 sonar 的配置列表",
	RequestType: apistructs.SonarMetricRulesListRequest{},
	IsOpenAPI:   true,
}

var QA_SONAR_METRIC_RULES_UPDATE = apis.ApiSpec{
	Path:        "/api/sonar-metric-rules/<ID>",
	BackendPath: "/api/sonar-metric-rules/<ID>",
	Host:        "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:      "http",
	Method:      "PUT",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 更新 sonar 扫描规则",
	RequestType: apistructs.SonarMetricRulesUpdateRequest{},
	IsOpenAPI:   true,
}

var QA_TESTENV_CREATE = apis.ApiSpec{
	Path:         "/api/testenv",
	BackendPath:  "/api/testenv",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "POST",
	ResponseType: apistructs.APITestEnvCreateRequest{},
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	Doc:          `summary: 更新项目环境变量信息`,
	Audit: func(ctx *spec.AuditContext) error {
		var req apistructs.APITestEnvCreateRequest
		if err := ctx.BindRequestData(&req); err != nil {
			return err
		}
		project, err := ctx.GetProject(req.EnvID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			TemplateName: apistructs.QaTestEnvCreateTemplate,
			Context: map[string]interface{}{
				"projectName": project.Name,
				"testEnvName": req.Name,
			},
		})
	},
}

var QA_TESTENV_DELETE = apis.ApiSpec{
	Path:         "/api/testenv/<id>",
	BackendPath:  "/api/testenv/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "DELETE",
	CheckLogin:   true,
	CheckToken:   true,
	IsOpenAPI:    true,
	ResponseType: apistructs.APITestEnvDeleteResponse{},
	Doc:          `summary: 更新项目环境变量信息`,
	Audit: func(ctx *spec.AuditContext) error {
		var resp apistructs.APITestEnvDeleteResponse
		if err := ctx.BindResponseData(&resp); err != nil {
			return err
		}
		project, err := ctx.GetProject(resp.Data.EnvID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			TemplateName: apistructs.QaTestEnvDeleteTemplate,
			Context: map[string]interface{}{
				"projectName": project.Name,
				"testEnvName": resp.Data.Name,
			},
		})
	},
}

var QA_TESTENV_GET = apis.ApiSpec{
	Path:         "/api/testenv/<id>",
	BackendPath:  "/api/testenv/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.APITestEnvGetResponse{},
	IsOpenAPI:    true,
	Doc:          "summary: 获取API项目测试的环境变量信息",
}

var QA_TESTENV_LIST = apis.ApiSpec{
	Path:         "/api/testenv/actions/list-envs",
	BackendPath:  "/api/testenv/actions/list-envs",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	Doc:          "summary: 获取项目API测试环境变量列表",
	ResponseType: apistructs.APITestEnvListResponse{},
	IsOpenAPI:    true,
}

var QA_TESTENV_UPDATE = apis.ApiSpec{
	Path:         "/api/testenv/<id>",
	BackendPath:  "/api/testenv/<id>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "PUT",
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.APITestEnvUpdateRequest{},
	ResponseType: apistructs.APITestEnvUpdateResponse{},
	IsOpenAPI:    true,
	Doc:          `更新项目环境变量信息`,
	Audit: func(ctx *spec.AuditContext) error {
		var req apistructs.APITestEnvUpdateRequest
		if err := ctx.BindRequestData(&req); err != nil {
			return err
		}
		project, err := ctx.GetProject(req.EnvID)
		if err != nil {
			return err
		}
		return ctx.CreateAudit(&apistructs.Audit{
			ScopeType:    apistructs.ProjectScope,
			ScopeID:      project.ID,
			TemplateName: apistructs.QaTestEnvUpdateTemplate,
			Context: map[string]interface{}{
				"projectName": project.Name,
				"testEnvName": req.Name,
			},
		})
	},
}

var QA_TESTPLAN_PIPELINE_DETAIL = apis.ApiSpec{
	Path:         "/api/apitests/pipeline/<pipelineId>",
	BackendPath:  "/api/apitests/pipeline/<pipelineId>",
	Host:         "dop.marathon.l4lb.thisdcos.directory:9527",
	Scheme:       "http",
	Method:       "GET",
	CheckLogin:   true,
	CheckToken:   true,
	ResponseType: apistructs.PipelineDetailResponse{},
	Doc:          "summary: 查询测试记录的pipeline详情",
}

var SPOT_APITESTS_LOGS = apis.ApiSpec{
	Path:        "/api/apitests/logs",
	BackendPath: "/api/logs",
	Host:        "monitor.marathon.l4lb.thisdcos.directory:7096",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	Doc:         "summary: 查询 apitest 的日志内容",
}

var SPOT_APITESTS_LOGS_DOWNLOAD = apis.ApiSpec{
	Path:        "/api/apitests/logs/actions/download",
	BackendPath: "/api/logs/actions/download",
	Host:        "monitor.marathon.l4lb.thisdcos.directory:7096",
	Scheme:      "http",
	Method:      "GET",
	CheckLogin:  true,
	CheckToken:  true,
	ChunkAPI:    true,
	Doc:         "summary: Apitests 下载日志内容",
}

var SearchOperations = apis.ApiSpec{
	Path:         "/api/apim/operations",
	BackendPath:  "/api/apim/operations",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodGet,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.SearchOperationsReq{},
	ResponseType: apistructs.BaseResponse{},
	Doc:          "搜索集市中的接口",
}

var UpdateAPIAssset = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>",
	BackendPath:  "/api/api-assets/<assetID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.UpdateAPIAssetReq{},
	ResponseType: nil,
	Doc:          "修改 API 资料",
}

var UpdateAccess = apis.ApiSpec{
	Path:         "/api/api-access/<accessID>",
	BackendPath:  "/api/api-access/<accessID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "update access",
}

var UpdateAssetVersion = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/versions/<versionID>",
	BackendPath:  "/api/api-assets/<assetID>/versions/<versionID>",
	Method:       http.MethodPut,
	Host:         APIMAddr,
	Scheme:       "http",
	CheckLogin:   true,
	Doc:          "修改指定版本的 API 资料",
	RequestType:  apistructs.UpdateAssetVersionReq{},
	ResponseType: apistructs.Header{},
}

var UpdateClient = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>",
	BackendPath:  "/api/api-clients/<clientID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.UpdateClientReq{},
	ResponseType: map[string]interface{}{"client": "", "sk": 1},
	Doc:          "get client",
}

var UpdateContract = apis.ApiSpec{
	Path:         "/api/api-clients/<clientID>/contracts/<contractID>",
	BackendPath:  "/api/api-clients/<clientID>/contracts/<contractID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  nil,
	ResponseType: nil,
	Doc:          "update contract",
}

var UpdateInstantiation = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations/<instantiationID>",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/minors/<minor>/instantiations/<instantiationID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.UpdateInstantiationReq{},
	ResponseType: nil,
	Doc:          "update instantiation",
}

var UpdateSLA = apis.ApiSpec{
	Path:         "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	BackendPath:  "/api/api-assets/<assetID>/swagger-versions/<swaggerVersion>/slas/<slaID>",
	Host:         APIMAddr,
	Scheme:       "http",
	Method:       http.MethodPut,
	CheckLogin:   true,
	CheckToken:   true,
	RequestType:  apistructs.UpdateSLAReq{},
	ResponseType: apistructs.Header{},
	Doc:          "update SLA",
}

var ValidateSwagger = apis.ApiSpec{
	Path:        "/api/apim/validate-swagger",
	BackendPath: "/api/apim/validate-swagger",
	Host:        APIMAddr,
	Scheme:      "http",
	Method:      http.MethodPost,
	CheckLogin:  false,
	CheckToken:  false,

	ResponseType: nil,
	Doc:          "validate swagger",
}