// Code generated by protoc-gen-go-errors. DO NOT EDIT.

package v1

import (
	fmt "fmt"
	errors "github.com/go-kratos/kratos/v2/errors"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the kratos package it is being compiled against.
const _ = errors.SupportPackageIsVersion1

// 数据库错误
func IsDbError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DB_ERROR.String() && e.Code == 500
}

// 数据库错误
func ErrorDbError(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_DB_ERROR.String(), fmt.Sprintf(format, args...))
}

// 缓存错误
func IsRdsError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_RDS_ERROR.String() && e.Code == 500
}

// 缓存错误
func ErrorRdsError(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_RDS_ERROR.String(), fmt.Sprintf(format, args...))
}

// 参数错误
func IsInvalidParams(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_INVALID_PARAMS.String() && e.Code == 400
}

// 参数错误
func ErrorInvalidParams(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_INVALID_PARAMS.String(), fmt.Sprintf(format, args...))
}

// 第三方服务错误
func IsThirdPartyServiceErr(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_THIRD_PARTY_SERVICE_ERR.String() && e.Code == 500
}

// 第三方服务错误
func ErrorThirdPartyServiceErr(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_THIRD_PARTY_SERVICE_ERR.String(), fmt.Sprintf(format, args...))
}

// 服务器内部错误/未知错误
func IsUnknown(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_UNKNOWN.String() && e.Code == 500
}

// 服务器内部错误/未知错误
func ErrorUnknown(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_UNKNOWN.String(), fmt.Sprintf(format, args...))
}

// 文件找不到
func IsFileNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_FILE_NOT_FOUND.String() && e.Code == 404
}

// 文件找不到
func ErrorFileNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(404, ErrorReason_FILE_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// 文件类操作失败，如新建、删除、移动等
func IsFileOperateError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_FILE_OPERATE_ERROR.String() && e.Code == 400
}

// 文件类操作失败，如新建、删除、移动等
func ErrorFileOperateError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_FILE_OPERATE_ERROR.String(), fmt.Sprintf(format, args...))
}

// 消息队列错误
func IsMqError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MQ_ERROR.String() && e.Code == 500
}

// 消息队列错误
func ErrorMqError(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_MQ_ERROR.String(), fmt.Sprintf(format, args...))
}

// 任务系统错误
func IsAsynqError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_ASYNQ_ERROR.String() && e.Code == 500
}

// 任务系统错误
func ErrorAsynqError(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_ASYNQ_ERROR.String(), fmt.Sprintf(format, args...))
}

// k8s error
func IsKubernetesOperatorError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_KUBERNETES_OPERATOR_ERROR.String() && e.Code == 400
}

// k8s error
func ErrorKubernetesOperatorError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_KUBERNETES_OPERATOR_ERROR.String(), fmt.Sprintf(format, args...))
}

// call rpc error
func IsRpcError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_RPC_ERROR.String() && e.Code == 400
}

// call rpc error
func ErrorRpcError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_RPC_ERROR.String(), fmt.Sprintf(format, args...))
}

// 身份认证
func IsAuthInvalidClientId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_INVALID_CLIENT_ID.String() && e.Code == 400
}

// 身份认证
func ErrorAuthInvalidClientId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AUTH_INVALID_CLIENT_ID.String(), fmt.Sprintf(format, args...))
}

// 未提供Range
func IsAuthMissingRange(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_MISSING_RANGE.String() && e.Code == 401
}

// 未提供Range
func ErrorAuthMissingRange(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_MISSING_RANGE.String(), fmt.Sprintf(format, args...))
}

// 未提供Token
func IsAuthMissingJwtToken(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_MISSING_JWT_TOKEN.String() && e.Code == 401
}

// 未提供Token
func ErrorAuthMissingJwtToken(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_MISSING_JWT_TOKEN.String(), fmt.Sprintf(format, args...))
}

func IsAuthMissingKeyFunc(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_MISSING_KEY_FUNC.String() && e.Code == 401
}

func ErrorAuthMissingKeyFunc(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_MISSING_KEY_FUNC.String(), fmt.Sprintf(format, args...))
}

// 无效Token
func IsAuthTokenInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_TOKEN_INVALID.String() && e.Code == 401
}

// 无效Token
func ErrorAuthTokenInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_TOKEN_INVALID.String(), fmt.Sprintf(format, args...))
}

// Token已过期
func IsAuthTokenExpired(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_TOKEN_EXPIRED.String() && e.Code == 401
}

// Token已过期
func ErrorAuthTokenExpired(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_TOKEN_EXPIRED.String(), fmt.Sprintf(format, args...))
}

// Token解析失败
func IsAuthTokenParseFail(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_TOKEN_PARSE_FAIL.String() && e.Code == 401
}

// Token解析失败
func ErrorAuthTokenParseFail(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_TOKEN_PARSE_FAIL.String(), fmt.Sprintf(format, args...))
}

// 未提供Teco_claims
func IsAuthMissingTecoClaims(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_MISSING_TECO_CLAIMS.String() && e.Code == 401
}

// 未提供Teco_claims
func ErrorAuthMissingTecoClaims(format string, args ...interface{}) *errors.Error {
	return errors.New(401, ErrorReason_AUTH_MISSING_TECO_CLAIMS.String(), fmt.Sprintf(format, args...))
}

// 租户ID无效
func IsAuthInvalidTenantId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_INVALID_TENANT_ID.String() && e.Code == 400
}

// 租户ID无效
func ErrorAuthInvalidTenantId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AUTH_INVALID_TENANT_ID.String(), fmt.Sprintf(format, args...))
}

// 工作空间ID无效
func IsAuthInvalidWorkspaceId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_INVALID_WORKSPACE_ID.String() && e.Code == 400
}

// 工作空间ID无效
func ErrorAuthInvalidWorkspaceId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AUTH_INVALID_WORKSPACE_ID.String(), fmt.Sprintf(format, args...))
}

// 项目ID无效
func IsAuthInvalidProjectId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AUTH_INVALID_PROJECT_ID.String() && e.Code == 400
}

// 项目ID无效
func ErrorAuthInvalidProjectId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AUTH_INVALID_PROJECT_ID.String(), fmt.Sprintf(format, args...))
}

// 个人中心
func IsPersonalIncorrectOldPassword(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_INCORRECT_OLD_PASSWORD.String() && e.Code == 400
}

// 个人中心
func ErrorPersonalIncorrectOldPassword(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_INCORRECT_OLD_PASSWORD.String(), fmt.Sprintf(format, args...))
}

// 新密码格式错误
func IsPersonalInvalidNewPassword(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_INVALID_NEW_PASSWORD.String() && e.Code == 400
}

// 新密码格式错误
func ErrorPersonalInvalidNewPassword(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_INVALID_NEW_PASSWORD.String(), fmt.Sprintf(format, args...))
}

// 新密码不能与原密码相同
func IsPersonalSameAsOriginalPassword(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_SAME_AS_ORIGINAL_PASSWORD.String() && e.Code == 400
}

// 新密码不能与原密码相同
func ErrorPersonalSameAsOriginalPassword(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_SAME_AS_ORIGINAL_PASSWORD.String(), fmt.Sprintf(format, args...))
}

// 修改密码失败
func IsPersonalModifyPasswordFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_MODIFY_PASSWORD_FAILED.String() && e.Code == 400
}

// 修改密码失败
func ErrorPersonalModifyPasswordFailed(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_MODIFY_PASSWORD_FAILED.String(), fmt.Sprintf(format, args...))
}

// 操作码错误
func IsPersonalInvalidOpCode(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_INVALID_OP_CODE.String() && e.Code == 400
}

// 操作码错误
func ErrorPersonalInvalidOpCode(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_INVALID_OP_CODE.String(), fmt.Sprintf(format, args...))
}

// 验证码错误
func IsPersonalIncorrectVerificationCode(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_INCORRECT_VERIFICATION_CODE.String() && e.Code == 400
}

// 验证码错误
func ErrorPersonalIncorrectVerificationCode(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_INCORRECT_VERIFICATION_CODE.String(), fmt.Sprintf(format, args...))
}

// 新用户名格式错误
func IsPersonalInvalidUsername(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_INVALID_USERNAME.String() && e.Code == 400
}

// 新用户名格式错误
func ErrorPersonalInvalidUsername(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_INVALID_USERNAME.String(), fmt.Sprintf(format, args...))
}

// 修改用户名失败
func IsPersonalModifyUsernameFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_MODIFY_USERNAME_FAILED.String() && e.Code == 500
}

// 修改用户名失败
func ErrorPersonalModifyUsernameFailed(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_PERSONAL_MODIFY_USERNAME_FAILED.String(), fmt.Sprintf(format, args...))
}

// 发送验证码失败
func IsPersonalSendEmailFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_SEND_EMAIL_FAILED.String() && e.Code == 500
}

// 发送验证码失败
func ErrorPersonalSendEmailFailed(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_PERSONAL_SEND_EMAIL_FAILED.String(), fmt.Sprintf(format, args...))
}

// 邮箱已存在
func IsPersonalEmailExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_EMAIL_EXISTS.String() && e.Code == 400
}

// 邮箱已存在
func ErrorPersonalEmailExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_EMAIL_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 用户名已存在
func IsPersonalUsernameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PERSONAL_USERNAME_EXISTS.String() && e.Code == 400
}

// 用户名已存在
func ErrorPersonalUsernameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PERSONAL_USERNAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 管理台用户管理
func IsUserDeleteUserFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_USER_DELETE_USER_FAILED.String() && e.Code == 500
}

// 管理台用户管理
func ErrorUserDeleteUserFailed(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_USER_DELETE_USER_FAILED.String(), fmt.Sprintf(format, args...))
}

// 无效的用户ID
func IsUserInvalidUserId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_USER_INVALID_USER_ID.String() && e.Code == 400
}

// 无效的用户ID
func ErrorUserInvalidUserId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_USER_INVALID_USER_ID.String(), fmt.Sprintf(format, args...))
}

// 管理台-租户管理
func IsTenantNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_NAME_EXISTS.String() && e.Code == 400
}

// 管理台-租户管理
func ErrorTenantNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 超过上限(100个)
func IsTenantExceedMax(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_EXCEED_MAX.String() && e.Code == 400
}

// 超过上限(100个)
func ErrorTenantExceedMax(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_EXCEED_MAX.String(), fmt.Sprintf(format, args...))
}

// 无效的管理员ID
func IsTenantInvalidSuperAdminId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_INVALID_SUPER_ADMIN_ID.String() && e.Code == 400
}

// 无效的管理员ID
func ErrorTenantInvalidSuperAdminId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_INVALID_SUPER_ADMIN_ID.String(), fmt.Sprintf(format, args...))
}

// 租户名格式错误
func IsTenantInvalidName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_INVALID_NAME.String() && e.Code == 400
}

// 租户名格式错误
func ErrorTenantInvalidName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_INVALID_NAME.String(), fmt.Sprintf(format, args...))
}

// 此租户下还有未删除的工作空间，请全部删除后再进行删除
func IsTenantNotAllowedToDelete(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_NOT_ALLOWED_TO_DELETE.String() && e.Code == 400
}

// 此租户下还有未删除的工作空间，请全部删除后再进行删除
func ErrorTenantNotAllowedToDelete(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_NOT_ALLOWED_TO_DELETE.String(), fmt.Sprintf(format, args...))
}

// 配额
func IsQuotaLessThenOccupied(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_LESS_THEN_OCCUPIED.String() && e.Code == 400
}

// 配额
func ErrorQuotaLessThenOccupied(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_LESS_THEN_OCCUPIED.String(), fmt.Sprintf(format, args...))
}

// 超过上级配额
func IsQuotaExceedParent(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_EXCEED_PARENT.String() && e.Code == 400
}

// 超过上级配额
func ErrorQuotaExceedParent(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_EXCEED_PARENT.String(), fmt.Sprintf(format, args...))
}

// 无效的配额单位
func IsQuotaInvalidUnit(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_INVALID_UNIT.String() && e.Code == 400
}

// 无效的配额单位
func ErrorQuotaInvalidUnit(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_INVALID_UNIT.String(), fmt.Sprintf(format, args...))
}

// 无效的配额类型
func IsQuotaInvalidType(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_INVALID_TYPE.String() && e.Code == 400
}

// 无效的配额类型
func ErrorQuotaInvalidType(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_INVALID_TYPE.String(), fmt.Sprintf(format, args...))
}

// 存在重复条目(同一类型出现多次)
func IsQuotaDuplicatedType(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_DUPLICATED_TYPE.String() && e.Code == 400
}

// 存在重复条目(同一类型出现多次)
func ErrorQuotaDuplicatedType(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_DUPLICATED_TYPE.String(), fmt.Sprintf(format, args...))
}

// 超过可分配上限
func IsQuotaExceedLimit(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_EXCEED_LIMIT.String() && e.Code == 400
}

// 超过可分配上限
func ErrorQuotaExceedLimit(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_EXCEED_LIMIT.String(), fmt.Sprintf(format, args...))
}

// 配额项不存在/未设置配额
func IsQuotaNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_NOT_FOUND.String() && e.Code == 400
}

// 配额项不存在/未设置配额
func ErrorQuotaNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// 无法释放配额(整机分配模式无法释放配额)
func IsQuotaCanNotRelease(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_CAN_NOT_RELEASE.String() && e.Code == 403
}

// 无法释放配额(整机分配模式无法释放配额)
func ErrorQuotaCanNotRelease(format string, args ...interface{}) *errors.Error {
	return errors.New(403, ErrorReason_QUOTA_CAN_NOT_RELEASE.String(), fmt.Sprintf(format, args...))
}

// 无效的配额模式(工作空间配额模式必须与租户一致)
func IsQuotaInvalidMode(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_INVALID_MODE.String() && e.Code == 400
}

// 无效的配额模式(工作空间配额模式必须与租户一致)
func ErrorQuotaInvalidMode(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_INVALID_MODE.String(), fmt.Sprintf(format, args...))
}

// 节点已占用
func IsQuotaNodeHasBeenAssigned(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_NODE_HAS_BEEN_ASSIGNED.String() && e.Code == 400
}

// 节点已占用
func ErrorQuotaNodeHasBeenAssigned(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_NODE_HAS_BEEN_ASSIGNED.String(), fmt.Sprintf(format, args...))
}

// 该节点上有正在运行实例，请检查并停止后才可以释放此节点
func IsQuotaNodeIsBusy(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_NODE_IS_BUSY.String() && e.Code == 400
}

// 该节点上有正在运行实例，请检查并停止后才可以释放此节点
func ErrorQuotaNodeIsBusy(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_NODE_IS_BUSY.String(), fmt.Sprintf(format, args...))
}

// 非独享节点
func IsQuotaNodeNonExclusive(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_NODE_NON_EXCLUSIVE.String() && e.Code == 400
}

// 非独享节点
func ErrorQuotaNodeNonExclusive(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_NODE_NON_EXCLUSIVE.String(), fmt.Sprintf(format, args...))
}

// 非当前租户节点
func IsQuotaNodeDoesNotBelongToTenant(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_QUOTA_NODE_DOES_NOT_BELONG_TO_TENANT.String() && e.Code == 400
}

// 非当前租户节点
func ErrorQuotaNodeDoesNotBelongToTenant(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_QUOTA_NODE_DOES_NOT_BELONG_TO_TENANT.String(), fmt.Sprintf(format, args...))
}

// 多租户插件
func IsPluginInitFailed(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PLUGIN_INIT_FAILED.String() && e.Code == 500
}

// 多租户插件
func ErrorPluginInitFailed(format string, args ...interface{}) *errors.Error {
	return errors.New(500, ErrorReason_PLUGIN_INIT_FAILED.String(), fmt.Sprintf(format, args...))
}

// 事件监控
func IsEventRuleName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_NAME.String() && e.Code == 400
}

// 事件监控
func ErrorEventRuleName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_NAME.String(), fmt.Sprintf(format, args...))
}

// 事件监控产品模块不能为空
func IsEventRuleProduct(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_PRODUCT.String() && e.Code == 400
}

// 事件监控产品模块不能为空
func ErrorEventRuleProduct(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_PRODUCT.String(), fmt.Sprintf(format, args...))
}

// 事件监控联系人信息不能为空
func IsEventRuleContacts(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_CONTACTS.String() && e.Code == 400
}

// 事件监控联系人信息不能为空
func ErrorEventRuleContacts(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_CONTACTS.String(), fmt.Sprintf(format, args...))
}

// 事件监控发送消息通道类型不能为空
func IsEventRuleChannel(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_CHANNEL.String() && e.Code == 400
}

// 事件监控发送消息通道类型不能为空
func ErrorEventRuleChannel(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_CHANNEL.String(), fmt.Sprintf(format, args...))
}

// 事件规则-事件名称无效
func IsEventRuleEventIdInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_EVENT_ID_INVALID.String() && e.Code == 400
}

// 事件规则-事件名称无效
func ErrorEventRuleEventIdInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_EVENT_ID_INVALID.String(), fmt.Sprintf(format, args...))
}

// 上报事件-事件等级无效
func IsEventRuleEventLevelInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_EVENT_LEVEL_INVALID.String() && e.Code == 400
}

// 上报事件-事件等级无效
func ErrorEventRuleEventLevelInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_EVENT_LEVEL_INVALID.String(), fmt.Sprintf(format, args...))
}

// 事件监控规则ID不能为空
func IsEventRuleId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_ID.String() && e.Code == 400
}

// 事件监控规则ID不能为空
func ErrorEventRuleId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_ID.String(), fmt.Sprintf(format, args...))
}

// 事件监控规则状态不能为空
func IsEventRuleState(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_STATE.String() && e.Code == 400
}

// 事件监控规则状态不能为空
func ErrorEventRuleState(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_STATE.String(), fmt.Sprintf(format, args...))
}

// 事件监控事件等级不能为空
func IsEventLevel(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_LEVEL.String() && e.Code == 400
}

// 事件监控事件等级不能为空
func ErrorEventLevel(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_LEVEL.String(), fmt.Sprintf(format, args...))
}

// 事件监控上报事件内容不能为空
func IsEventContentInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_CONTENT_INVALID.String() && e.Code == 400
}

// 事件监控上报事件内容不能为空
func ErrorEventContentInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_CONTENT_INVALID.String(), fmt.Sprintf(format, args...))
}

// 上报事件-事件类型值无效
func IsEventTypeInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_TYPE_INVALID.String() && e.Code == 400
}

// 上报事件-事件类型值无效
func ErrorEventTypeInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_TYPE_INVALID.String(), fmt.Sprintf(format, args...))
}

// 事件规则-创建事件用户下规则名称重复
func IsEventRuleRepeat(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RULE_REPEAT.String() && e.Code == 400
}

// 事件规则-创建事件用户下规则名称重复
func ErrorEventRuleRepeat(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RULE_REPEAT.String(), fmt.Sprintf(format, args...))
}

// 联系人为空
func IsEventRidsInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_RIDS_INVALID.String() && e.Code == 400
}

// 联系人为空
func ErrorEventRidsInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_RIDS_INVALID.String(), fmt.Sprintf(format, args...))
}

// 事件监控数据删除失败
func IsEventMonitorDelete(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_MONITOR_DELETE.String() && e.Code == 400
}

// 事件监控数据删除失败
func ErrorEventMonitorDelete(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_MONITOR_DELETE.String(), fmt.Sprintf(format, args...))
}

// 创建自定义事件规则时事件名称为空
func IsEventName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_EVENT_NAME.String() && e.Code == 400
}

// 创建自定义事件规则时事件名称为空
func ErrorEventName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_EVENT_NAME.String(), fmt.Sprintf(format, args...))
}

// 操作记录
func IsOperatorPlantGroupInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPERATOR_PLANT_GROUP_INVALID.String() && e.Code == 400
}

// 操作记录
func ErrorOperatorPlantGroupInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPERATOR_PLANT_GROUP_INVALID.String(), fmt.Sprintf(format, args...))
}

// 事件模块分组的值无效
func IsOperatorSubGroupInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPERATOR_SUB_GROUP_INVALID.String() && e.Code == 400
}

// 事件模块分组的值无效
func ErrorOperatorSubGroupInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPERATOR_SUB_GROUP_INVALID.String(), fmt.Sprintf(format, args...))
}

// 事件操作类型的值无效
func IsOperatorTypeInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPERATOR_TYPE_INVALID.String() && e.Code == 400
}

// 事件操作类型的值无效
func ErrorOperatorTypeInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPERATOR_TYPE_INVALID.String(), fmt.Sprintf(format, args...))
}

// 租户id不能为空
func IsOperatorTenantIdEmpty(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPERATOR_TENANT_ID_EMPTY.String() && e.Code == 400
}

// 租户id不能为空
func ErrorOperatorTenantIdEmpty(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPERATOR_TENANT_ID_EMPTY.String(), fmt.Sprintf(format, args...))
}

// 创建者id不能为空
func IsOperatorCreatorIdEmpty(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPERATOR_CREATOR_ID_EMPTY.String() && e.Code == 400
}

// 创建者id不能为空
func ErrorOperatorCreatorIdEmpty(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPERATOR_CREATOR_ID_EMPTY.String(), fmt.Sprintf(format, args...))
}

// 集群管理
func IsClusterNameInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_CLUSTER_NAME_INVALID.String() && e.Code == 400
}

// 集群管理
func ErrorClusterNameInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_CLUSTER_NAME_INVALID.String(), fmt.Sprintf(format, args...))
}

// routeId不能为空
func IsRouteIdEmpty(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_ROUTE_ID_EMPTY.String() && e.Code == 400
}

// routeId不能为空
func ErrorRouteIdEmpty(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_ROUTE_ID_EMPTY.String(), fmt.Sprintf(format, args...))
}

// 集群概览
func IsNodeNameNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NODE_NAME_NOT_FOUND.String() && e.Code == 400
}

// 集群概览
func ErrorNodeNameNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NODE_NAME_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// 创建参数不对
func IsSshSecretCreatSshSecretParamsError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_PARAMS_ERROR.String() && e.Code == 400
}

// 创建参数不对
func ErrorSshSecretCreatSshSecretParamsError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_PARAMS_ERROR.String(), fmt.Sprintf(format, args...))
}

// 创建类型错误
func IsSshSecretCreatSshSecretTypeError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_TYPE_ERROR.String() && e.Code == 400
}

// 创建类型错误
func ErrorSshSecretCreatSshSecretTypeError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_TYPE_ERROR.String(), fmt.Sprintf(format, args...))
}

// 密钥名称已存在
func IsSshSecretCreatSshSecretNicknameError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_NICKNAME_ERROR.String() && e.Code == 400
}

// 密钥名称已存在
func ErrorSshSecretCreatSshSecretNicknameError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_NICKNAME_ERROR.String(), fmt.Sprintf(format, args...))
}

// 创建密钥最多为10条
func IsSshSecretCreatSshSecretMaxNumError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_MAX_NUM_ERROR.String() && e.Code == 400
}

// 创建密钥最多为10条
func ErrorSshSecretCreatSshSecretMaxNumError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_CREAT_SSH_SECRET_MAX_NUM_ERROR.String(), fmt.Sprintf(format, args...))
}

// 分页错误
func IsSshSecretGetSshSecretListPagingError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_GET_SSH_SECRET_LIST_PAGING_ERROR.String() && e.Code == 400
}

// 分页错误
func ErrorSshSecretGetSshSecretListPagingError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_GET_SSH_SECRET_LIST_PAGING_ERROR.String(), fmt.Sprintf(format, args...))
}

// 没查询到有效的secretKey的信息
func IsSshSecretCheckGetSshSecretKeyError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_CHECK_GET_SSH_SECRET_KEY_ERROR.String() && e.Code == 400
}

// 没查询到有效的secretKey的信息
func ErrorSshSecretCheckGetSshSecretKeyError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_CHECK_GET_SSH_SECRET_KEY_ERROR.String(), fmt.Sprintf(format, args...))
}

// 当前为非生效状态
func IsSshSecretInvalidSshSecretKeyError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_INVALID_SSH_SECRET_KEY_ERROR.String() && e.Code == 400
}

// 当前为非生效状态
func ErrorSshSecretInvalidSshSecretKeyError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_INVALID_SSH_SECRET_KEY_ERROR.String(), fmt.Sprintf(format, args...))
}

// 该条密钥记录不存在或者已过期
func IsSshSecretKeyNotExistOrExpiredError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_NOT_EXIST_OR_EXPIRED_ERROR.String() && e.Code == 400
}

// 该条密钥记录不存在或者已过期
func ErrorSshSecretKeyNotExistOrExpiredError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_KEY_NOT_EXIST_OR_EXPIRED_ERROR.String(), fmt.Sprintf(format, args...))
}

// 当前状态已经是禁用中
func IsSshSecretKeyStatusDisabledError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_STATUS_DISABLED_ERROR.String() && e.Code == 400
}

// 当前状态已经是禁用中
func ErrorSshSecretKeyStatusDisabledError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_KEY_STATUS_DISABLED_ERROR.String(), fmt.Sprintf(format, args...))
}

// 当前状态已经是生效中
func IsSshSecretKeyStatusInEffectError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_STATUS_IN_EFFECT_ERROR.String() && e.Code == 400
}

// 当前状态已经是生效中
func ErrorSshSecretKeyStatusInEffectError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_KEY_STATUS_IN_EFFECT_ERROR.String(), fmt.Sprintf(format, args...))
}

// 该条密钥记录不存在
func IsSshSecretKeyNotExistError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_NOT_EXIST_ERROR.String() && e.Code == 409
}

// 该条密钥记录不存在
func ErrorSshSecretKeyNotExistError(format string, args ...interface{}) *errors.Error {
	return errors.New(409, ErrorReason_SSH_SECRET_KEY_NOT_EXIST_ERROR.String(), fmt.Sprintf(format, args...))
}

// 过期时间不正确
func IsSshSecretKeyExpiredTimeError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_EXPIRED_TIME_ERROR.String() && e.Code == 400
}

// 过期时间不正确
func ErrorSshSecretKeyExpiredTimeError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_KEY_EXPIRED_TIME_ERROR.String(), fmt.Sprintf(format, args...))
}

// 该条密钥记录不存在或者是禁用状态
func IsSshSecretKeyNotExistOrDisabledError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_NOT_EXIST_OR_DISABLED_ERROR.String() && e.Code == 400
}

// 该条密钥记录不存在或者是禁用状态
func ErrorSshSecretKeyNotExistOrDisabledError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_KEY_NOT_EXIST_OR_DISABLED_ERROR.String(), fmt.Sprintf(format, args...))
}

// 密钥已经配置过该实例
func IsSshSecretKeyAlreadyConfigError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_KEY_ALREADY_CONFIG_ERROR.String() && e.Code == 409
}

// 密钥已经配置过该实例
func ErrorSshSecretKeyAlreadyConfigError(format string, args ...interface{}) *errors.Error {
	return errors.New(409, ErrorReason_SSH_SECRET_KEY_ALREADY_CONFIG_ERROR.String(), fmt.Sprintf(format, args...))
}

// 密钥不存在
func IsSshSecretInjectSshSecretKeyNotExistError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_INJECT_SSH_SECRET_KEY_NOT_EXIST_ERROR.String() && e.Code == 400
}

// 密钥不存在
func ErrorSshSecretInjectSshSecretKeyNotExistError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_INJECT_SSH_SECRET_KEY_NOT_EXIST_ERROR.String(), fmt.Sprintf(format, args...))
}

// 过期时间参数不正确
func IsSshSecretInvalidExpiredTimeError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_INVALID_EXPIRED_TIME_ERROR.String() && e.Code == 400
}

// 过期时间参数不正确
func ErrorSshSecretInvalidExpiredTimeError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_INVALID_EXPIRED_TIME_ERROR.String(), fmt.Sprintf(format, args...))
}

// 解析用户信息错误
func IsSshSecretUserInfoError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_USER_INFO_ERROR.String() && e.Code == 400
}

// 解析用户信息错误
func ErrorSshSecretUserInfoError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_USER_INFO_ERROR.String(), fmt.Sprintf(format, args...))
}

// 下载私钥失败
func IsSshSecretDownloadSecretError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_SSH_SECRET_DOWNLOAD_SECRET_ERROR.String() && e.Code == 400
}

// 下载私钥失败
func ErrorSshSecretDownloadSecretError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_SSH_SECRET_DOWNLOAD_SECRET_ERROR.String(), fmt.Sprintf(format, args...))
}

// AccessKey
func IsAkSkMaxNumError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AK_SK_MAX_NUM_ERROR.String() && e.Code == 400
}

// AccessKey
func ErrorAkSkMaxNumError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AK_SK_MAX_NUM_ERROR.String(), fmt.Sprintf(format, args...))
}

// 参数错误
func IsAkSkParamsError(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_AK_SK_PARAMS_ERROR.String() && e.Code == 400
}

// 参数错误
func ErrorAkSkParamsError(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_AK_SK_PARAMS_ERROR.String(), fmt.Sprintf(format, args...))
}

// 自定义建模
func IsNotebookDisplayNameExisted(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_DISPLAY_NAME_EXISTED.String() && e.Code == 409
}

// 自定义建模
func ErrorNotebookDisplayNameExisted(format string, args ...interface{}) *errors.Error {
	return errors.New(409, ErrorReason_NOTEBOOK_DISPLAY_NAME_EXISTED.String(), fmt.Sprintf(format, args...))
}

// 创建实例错误
func IsNotebookCreateNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_CREATE_NOTEBOOK.String() && e.Code == 400
}

// 创建实例错误
func ErrorNotebookCreateNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_CREATE_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 获取实例信息错误
func IsNotebookGetNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_GET_NOTEBOOK.String() && e.Code == 400
}

// 获取实例信息错误
func ErrorNotebookGetNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_GET_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 更新实例配置信息错误
func IsNotebookUpdateNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_UPDATE_NOTEBOOK.String() && e.Code == 400
}

// 更新实例配置信息错误
func ErrorNotebookUpdateNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_UPDATE_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 获取自定建模列表信息错误
func IsNotebookGetListNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_GET_LIST_NOTEBOOK.String() && e.Code == 400
}

// 获取自定建模列表信息错误
func ErrorNotebookGetListNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_GET_LIST_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 启动/停止实例错误
func IsNotebookPatchNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_PATCH_NOTEBOOK.String() && e.Code == 400
}

// 启动/停止实例错误
func ErrorNotebookPatchNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_PATCH_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 保存镜像失败
func IsNotebookSaveImage(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_SAVE_IMAGE.String() && e.Code == 400
}

// 保存镜像失败
func ErrorNotebookSaveImage(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_SAVE_IMAGE.String(), fmt.Sprintf(format, args...))
}

// 配置ssh错误
func IsNotebookInjectSshSecret(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_INJECT_SSH_SECRET.String() && e.Code == 400
}

// 配置ssh错误
func ErrorNotebookInjectSshSecret(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_INJECT_SSH_SECRET.String(), fmt.Sprintf(format, args...))
}

// 获取模型文件失败
func IsNotebookListNotebookOutputFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_LIST_NOTEBOOK_OUTPUT_FILES.String() && e.Code == 400
}

// 获取模型文件失败
func ErrorNotebookListNotebookOutputFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_LIST_NOTEBOOK_OUTPUT_FILES.String(), fmt.Sprintf(format, args...))
}

// 模型保存失败
func IsNotebookSaveModelFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_SAVE_MODEL_FILES.String() && e.Code == 400
}

// 模型保存失败
func ErrorNotebookSaveModelFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_SAVE_MODEL_FILES.String(), fmt.Sprintf(format, args...))
}

// 获取模型列表失败
func IsNotebookListAllNotebookOutputFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_LIST_ALL_NOTEBOOK_OUTPUT_FILES.String() && e.Code == 400
}

// 获取模型列表失败
func ErrorNotebookListAllNotebookOutputFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_LIST_ALL_NOTEBOOK_OUTPUT_FILES.String(), fmt.Sprintf(format, args...))
}

// 删除实例
func IsNotebookDeleteNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_DELETE_NOTEBOOK.String() && e.Code == 400
}

// 删除实例
func ErrorNotebookDeleteNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_DELETE_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 检查配额错误
func IsNotebookCheckQuotas(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_CHECK_QUOTAS.String() && e.Code == 400
}

// 检查配额错误
func ErrorNotebookCheckQuotas(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_CHECK_QUOTAS.String(), fmt.Sprintf(format, args...))
}

// 实例不存在
func IsNotebookNotFount(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_NOT_FOUNT.String() && e.Code == 400
}

// 实例不存在
func ErrorNotebookNotFount(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_NOT_FOUNT.String(), fmt.Sprintf(format, args...))
}

// 批量删除实例
func IsNotebookDeleteBatchNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_DELETE_BATCH_NOTEBOOK.String() && e.Code == 400
}

// 批量删除实例
func ErrorNotebookDeleteBatchNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_DELETE_BATCH_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 批量启动/停止实例错误
func IsNotebookPatchBatchNotebook(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_PATCH_BATCH_NOTEBOOK.String() && e.Code == 400
}

// 批量启动/停止实例错误
func ErrorNotebookPatchBatchNotebook(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_PATCH_BATCH_NOTEBOOK.String(), fmt.Sprintf(format, args...))
}

// 批量启动/停止实例错误
func IsNotebookOptimizeDebug(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_OPTIMIZE_DEBUG.String() && e.Code == 400
}

// 批量启动/停止实例错误
func ErrorNotebookOptimizeDebug(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_OPTIMIZE_DEBUG.String(), fmt.Sprintf(format, args...))
}

// 删除环境失败
func IsNotebookDeleteNotebookCollection(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_DELETE_NOTEBOOK_COLLECTION.String() && e.Code == 400
}

// 删除环境失败
func ErrorNotebookDeleteNotebookCollection(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_DELETE_NOTEBOOK_COLLECTION.String(), fmt.Sprintf(format, args...))
}

// 解析错误
func IsNotebookHeaderAnalysis(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_NOTEBOOK_HEADER_ANALYSIS.String() && e.Code == 400
}

// 解析错误
func ErrorNotebookHeaderAnalysis(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_NOTEBOOK_HEADER_ANALYSIS.String(), fmt.Sprintf(format, args...))
}

// 主界面
func IsTenantInvalidInviteCode(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_INVALID_INVITE_CODE.String() && e.Code == 400
}

// 主界面
func ErrorTenantInvalidInviteCode(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_INVALID_INVITE_CODE.String(), fmt.Sprintf(format, args...))
}

// 用户未加入该租户
func IsTenantUserNotInTenant(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_USER_NOT_IN_TENANT.String() && e.Code == 400
}

// 用户未加入该租户
func ErrorTenantUserNotInTenant(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_USER_NOT_IN_TENANT.String(), fmt.Sprintf(format, args...))
}

// 用户已加入该租户
func IsTenantAlreadyInTenant(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TENANT_ALREADY_IN_TENANT.String() && e.Code == 400
}

// 用户已加入该租户
func ErrorTenantAlreadyInTenant(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TENANT_ALREADY_IN_TENANT.String(), fmt.Sprintf(format, args...))
}

// 工作空间
func IsWorkspaceNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_NAME_EXISTS.String() && e.Code == 400
}

// 工作空间
func ErrorWorkspaceNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 该租户工作空间数量超过上限(20个)
func IsWorkspaceExceedMax(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_EXCEED_MAX.String() && e.Code == 400
}

// 该租户工作空间数量超过上限(20个)
func ErrorWorkspaceExceedMax(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_EXCEED_MAX.String(), fmt.Sprintf(format, args...))
}

// 不是普通用户
func IsWorkspaceNotNormalUser(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_NOT_NORMAL_USER.String() && e.Code == 400
}

// 不是普通用户
func ErrorWorkspaceNotNormalUser(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_NOT_NORMAL_USER.String(), fmt.Sprintf(format, args...))
}

// 工作空间名格式错误
func IsWorkspaceInvalidName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_INVALID_NAME.String() && e.Code == 400
}

// 工作空间名格式错误
func ErrorWorkspaceInvalidName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_INVALID_NAME.String(), fmt.Sprintf(format, args...))
}

// 租户ID有误
func IsWorkspaceInvalidTenantId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_INVALID_TENANT_ID.String() && e.Code == 400
}

// 租户ID有误
func ErrorWorkspaceInvalidTenantId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_INVALID_TENANT_ID.String(), fmt.Sprintf(format, args...))
}

// 此工作空间中还有未删除的项目，请全部删除后再进行删除
func IsWorkspaceNotAllowedToDelete(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_WORKSPACE_NOT_ALLOWED_TO_DELETE.String() && e.Code == 400
}

// 此工作空间中还有未删除的项目，请全部删除后再进行删除
func ErrorWorkspaceNotAllowedToDelete(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_WORKSPACE_NOT_ALLOWED_TO_DELETE.String(), fmt.Sprintf(format, args...))
}

// 项目
func IsProjectNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PROJECT_NAME_EXISTS.String() && e.Code == 400
}

// 项目
func ErrorProjectNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PROJECT_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 该工作空间项目数量超过上限(20个)
func IsProjectExceedMax(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PROJECT_EXCEED_MAX.String() && e.Code == 400
}

// 该工作空间项目数量超过上限(20个)
func ErrorProjectExceedMax(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PROJECT_EXCEED_MAX.String(), fmt.Sprintf(format, args...))
}

// 项目名格式错误
func IsProjectInvalidName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PROJECT_INVALID_NAME.String() && e.Code == 400
}

// 项目名格式错误
func ErrorProjectInvalidName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PROJECT_INVALID_NAME.String(), fmt.Sprintf(format, args...))
}

// 此项目中有运行状态的实例，请处理后再进行删除
func IsProjectNotAllowedToDelete(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_PROJECT_NOT_ALLOWED_TO_DELETE.String() && e.Code == 400
}

// 此项目中有运行状态的实例，请处理后再进行删除
func ErrorProjectNotAllowedToDelete(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_PROJECT_NOT_ALLOWED_TO_DELETE.String(), fmt.Sprintf(format, args...))
}

// ---------------------------------------------算法生态中心相关---------------------------------------------
// 应用管理
func IsAppWorkflowNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_APP_WORKFLOW_NAME_EXISTS.String() && e.Code == 400
}

// ---------------------------------------------算法生态中心相关---------------------------------------------
// 应用管理
func ErrorAppWorkflowNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_APP_WORKFLOW_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 无效的训练工作流ID
func IsAppInvalidTrainingWorkflowId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_APP_INVALID_TRAINING_WORKFLOW_ID.String() && e.Code == 400
}

// 无效的训练工作流ID
func ErrorAppInvalidTrainingWorkflowId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_APP_INVALID_TRAINING_WORKFLOW_ID.String(), fmt.Sprintf(format, args...))
}

// 无法推理(前置条件不满足)
func IsAppCannotInference(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_APP_CANNOT_INFERENCE.String() && e.Code == 400
}

// 无法推理(前置条件不满足)
func ErrorAppCannotInference(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_APP_CANNOT_INFERENCE.String(), fmt.Sprintf(format, args...))
}

// 可用配额不足
func IsAppInsufficientQuotas(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_APP_INSUFFICIENT_QUOTAS.String() && e.Code == 400
}

// 可用配额不足
func ErrorAppInsufficientQuotas(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_APP_INSUFFICIENT_QUOTAS.String(), fmt.Sprintf(format, args...))
}

// 镜像管理
func IsImageLabelExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_IMAGE_LABEL_EXISTS.String() && e.Code == 400
}

// 镜像管理
func ErrorImageLabelExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_IMAGE_LABEL_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 无效的镜像ID
func IsImageInvalidArtifactId(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_IMAGE_INVALID_ARTIFACT_ID.String() && e.Code == 400
}

// 无效的镜像ID
func ErrorImageInvalidArtifactId(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_IMAGE_INVALID_ARTIFACT_ID.String(), fmt.Sprintf(format, args...))
}

// 无效的镜像的作者
func IsImageInvalidAuthor(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_IMAGE_INVALID_AUTHOR.String() && e.Code == 400
}

// 无效的镜像的作者
func ErrorImageInvalidAuthor(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_IMAGE_INVALID_AUTHOR.String(), fmt.Sprintf(format, args...))
}

// 上传中的状态不可删除
func IsImageStateIsUpload(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_IMAGE_STATE_IS_UPLOAD.String() && e.Code == 400
}

// 上传中的状态不可删除
func ErrorImageStateIsUpload(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_IMAGE_STATE_IS_UPLOAD.String(), fmt.Sprintf(format, args...))
}

// 无效的镜像名称
func IsImageInvalidArtifactName(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_IMAGE_INVALID_ARTIFACT_NAME.String() && e.Code == 400
}

// 无效的镜像名称
func ErrorImageInvalidArtifactName(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_IMAGE_INVALID_ARTIFACT_NAME.String(), fmt.Sprintf(format, args...))
}

// 数据集
func IsDatasetNameIsNull(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_NAME_IS_NULL.String() && e.Code == 400
}

// 数据集
func ErrorDatasetNameIsNull(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_NAME_IS_NULL.String(), fmt.Sprintf(format, args...))
}

// 仅支持.tar .zip .rar .tar.gz文件格式
func IsDatasetBadExtension(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_BAD_EXTENSION.String() && e.Code == 400
}

// 仅支持.tar .zip .rar .tar.gz文件格式
func ErrorDatasetBadExtension(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_BAD_EXTENSION.String(), fmt.Sprintf(format, args...))
}

// 数据集名称已存在
func IsDatasetNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_NAME_EXISTS.String() && e.Code == 400
}

// 数据集名称已存在
func ErrorDatasetNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 版本名称已存在
func IsDatasetVersionExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_VERSION_EXISTS.String() && e.Code == 400
}

// 版本名称已存在
func ErrorDatasetVersionExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_VERSION_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 版本目录为空
func IsDatasetVersionDirIsNil(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_VERSION_DIR_IS_NIL.String() && e.Code == 400
}

// 版本目录为空
func ErrorDatasetVersionDirIsNil(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_VERSION_DIR_IS_NIL.String(), fmt.Sprintf(format, args...))
}

// 数据集未找到
func IsDatasetNotFount(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_NOT_FOUNT.String() && e.Code == 404
}

// 数据集未找到
func ErrorDatasetNotFount(format string, args ...interface{}) *errors.Error {
	return errors.New(404, ErrorReason_DATASET_NOT_FOUNT.String(), fmt.Sprintf(format, args...))
}

// 数据集版本不能删除
func IsDatasetVersionCanNotDelete(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATASET_VERSION_CAN_NOT_DELETE.String() && e.Code == 400
}

// 数据集版本不能删除
func ErrorDatasetVersionCanNotDelete(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATASET_VERSION_CAN_NOT_DELETE.String(), fmt.Sprintf(format, args...))
}

// 模型
func IsModelNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MODEL_NOT_FOUND.String() && e.Code == 404
}

// 模型
func ErrorModelNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(404, ErrorReason_MODEL_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// 模型名称已存在
func IsModelNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MODEL_NAME_EXISTS.String() && e.Code == 400
}

// 模型名称已存在
func ErrorModelNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_MODEL_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 版本名称已存在
func IsModelVersionExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MODEL_VERSION_EXISTS.String() && e.Code == 400
}

// 版本名称已存在
func ErrorModelVersionExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_MODEL_VERSION_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 模型版本未找到
func IsModelVersionNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MODEL_VERSION_NOT_FOUND.String() && e.Code == 400
}

// 模型版本未找到
func ErrorModelVersionNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_MODEL_VERSION_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// 仅支持.pt .pth .pkl .ckpt .tar .pth.tar .pdparams .pdopt .pdmodel .index .meta .pb .h5 .pbtxt .zip .rar文件格式
func IsModelBadExtension(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_MODEL_BAD_EXTENSION.String() && e.Code == 400
}

// 仅支持.pt .pth .pkl .ckpt .tar .pth.tar .pdparams .pdopt .pdmodel .index .meta .pb .h5 .pbtxt .zip .rar文件格式
func ErrorModelBadExtension(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_MODEL_BAD_EXTENSION.String(), fmt.Sprintf(format, args...))
}

// 公共数据服务
func IsDataManageInvalidRangeHeader(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_DATA_MANAGE_INVALID_RANGE_HEADER.String() && e.Code == 400
}

// 公共数据服务
func ErrorDataManageInvalidRangeHeader(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_DATA_MANAGE_INVALID_RANGE_HEADER.String(), fmt.Sprintf(format, args...))
}

// 推理服务
func IsInferenceNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_INFERENCE_NAME_EXISTS.String() && e.Code == 400
}

// 推理服务
func ErrorInferenceNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_INFERENCE_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 推理服务未找到
func IsInferenceNotFount(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_INFERENCE_NOT_FOUNT.String() && e.Code == 404
}

// 推理服务未找到
func ErrorInferenceNotFount(format string, args ...interface{}) *errors.Error {
	return errors.New(404, ErrorReason_INFERENCE_NOT_FOUNT.String(), fmt.Sprintf(format, args...))
}

// 存储管理
func IsBucketNotFound(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_BUCKET_NOT_FOUND.String() && e.Code == 404
}

// 存储管理
func ErrorBucketNotFound(format string, args ...interface{}) *errors.Error {
	return errors.New(404, ErrorReason_BUCKET_NOT_FOUND.String(), fmt.Sprintf(format, args...))
}

// bucket未授权
func IsBucketNotAuth(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_BUCKET_NOT_AUTH.String() && e.Code == 400
}

// bucket未授权
func ErrorBucketNotAuth(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_BUCKET_NOT_AUTH.String(), fmt.Sprintf(format, args...))
}

// 目录不符合规范
func IsBucketDirectoryInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_BUCKET_DIRECTORY_INVALID.String() && e.Code == 400
}

// 目录不符合规范
func ErrorBucketDirectoryInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_BUCKET_DIRECTORY_INVALID.String(), fmt.Sprintf(format, args...))
}

// 已存在同名目录
func IsBucketDirectoryExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_BUCKET_DIRECTORY_EXISTS.String() && e.Code == 400
}

// 已存在同名目录
func ErrorBucketDirectoryExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_BUCKET_DIRECTORY_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 存储桶名称已存在
func IsBucketNameExists(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_BUCKET_NAME_EXISTS.String() && e.Code == 400
}

// 存储桶名称已存在
func ErrorBucketNameExists(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_BUCKET_NAME_EXISTS.String(), fmt.Sprintf(format, args...))
}

// 分布式训练
func IsTrainDisplayNameExisted(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_DISPLAY_NAME_EXISTED.String() && e.Code == 409
}

// 分布式训练
func ErrorTrainDisplayNameExisted(format string, args ...interface{}) *errors.Error {
	return errors.New(409, ErrorReason_TRAIN_DISPLAY_NAME_EXISTED.String(), fmt.Sprintf(format, args...))
}

// 创建实验错误
func IsTrainCreateExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_CREATE_EXPERIMENT.String() && e.Code == 400
}

// 创建实验错误
func ErrorTrainCreateExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_CREATE_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 获取实验信息错误
func IsTrainGetExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_GET_EXPERIMENT.String() && e.Code == 400
}

// 获取实验信息错误
func ErrorTrainGetExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_GET_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 更新实验信息错误
func IsTrainUpdateExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_UPDATE_EXPERIMENT.String() && e.Code == 400
}

// 更新实验信息错误
func ErrorTrainUpdateExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_UPDATE_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 获取实验列表信息错误
func IsTrainGetListExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_GET_LIST_EXPERIMENT.String() && e.Code == 400
}

// 获取实验列表信息错误
func ErrorTrainGetListExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_GET_LIST_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 停止实验错误
func IsTrainPatchExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_PATCH_EXPERIMENT.String() && e.Code == 400
}

// 停止实验错误
func ErrorTrainPatchExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_PATCH_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 获取模型文件失败
func IsTrainListTrainOutputFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_LIST_TRAIN_OUTPUT_FILES.String() && e.Code == 400
}

// 获取模型文件失败
func ErrorTrainListTrainOutputFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_LIST_TRAIN_OUTPUT_FILES.String(), fmt.Sprintf(format, args...))
}

// 模型保存失败
func IsTrainSaveModelFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_SAVE_MODEL_FILES.String() && e.Code == 400
}

// 模型保存失败
func ErrorTrainSaveModelFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_SAVE_MODEL_FILES.String(), fmt.Sprintf(format, args...))
}

// 获取模型列表失败
func IsTrainListAllTrainOutputFiles(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_LIST_ALL_TRAIN_OUTPUT_FILES.String() && e.Code == 400
}

// 获取模型列表失败
func ErrorTrainListAllTrainOutputFiles(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_LIST_ALL_TRAIN_OUTPUT_FILES.String(), fmt.Sprintf(format, args...))
}

// 删除实验失败
func IsTrainDeleteExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_DELETE_EXPERIMENT.String() && e.Code == 400
}

// 删除实验失败
func ErrorTrainDeleteExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_DELETE_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 检查配额错误
func IsTrainCheckQuotas(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_CHECK_QUOTAS.String() && e.Code == 400
}

// 检查配额错误
func ErrorTrainCheckQuotas(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_CHECK_QUOTAS.String(), fmt.Sprintf(format, args...))
}

// 训练不存在
func IsTrainNotFount(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_NOT_FOUNT.String() && e.Code == 400
}

// 训练不存在
func ErrorTrainNotFount(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_NOT_FOUNT.String(), fmt.Sprintf(format, args...))
}

// 解析错误
func IsTrainHeaderAnalysis(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_HEADER_ANALYSIS.String() && e.Code == 400
}

// 解析错误
func ErrorTrainHeaderAnalysis(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_HEADER_ANALYSIS.String(), fmt.Sprintf(format, args...))
}

// 创事实验集合错误
func IsTrainCreateExperimentCollection(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_CREATE_EXPERIMENT_COLLECTION.String() && e.Code == 400
}

// 创事实验集合错误
func ErrorTrainCreateExperimentCollection(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_CREATE_EXPERIMENT_COLLECTION.String(), fmt.Sprintf(format, args...))
}

// 启动/停止可视化工具错误
func IsTrainPatchTensorboard(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_PATCH_TENSORBOARD.String() && e.Code == 400
}

// 启动/停止可视化工具错误
func ErrorTrainPatchTensorboard(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_PATCH_TENSORBOARD.String(), fmt.Sprintf(format, args...))
}

// 配置ssh错误
func IsTrainAddSshSecret(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_TRAIN_ADD_SSH_SECRET.String() && e.Code == 400
}

// 配置ssh错误
func ErrorTrainAddSshSecret(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_TRAIN_ADD_SSH_SECRET.String(), fmt.Sprintf(format, args...))
}

// OpenAPI
func IsOpenapiAuthInvalid(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_AUTH_INVALID.String() && e.Code == 400
}

// OpenAPI
func ErrorOpenapiAuthInvalid(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_AUTH_INVALID.String(), fmt.Sprintf(format, args...))
}

// gpu解析错误
func IsOpenapiTrainingGpuAnalysis(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_TRAINING_GPU_ANALYSIS.String() && e.Code == 400
}

// gpu解析错误
func ErrorOpenapiTrainingGpuAnalysis(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_TRAINING_GPU_ANALYSIS.String(), fmt.Sprintf(format, args...))
}

// 获取实验集合错误
func IsOpenapiTrainingGetEc(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_TRAINING_GET_EC.String() && e.Code == 400
}

// 获取实验集合错误
func ErrorOpenapiTrainingGetEc(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_TRAINING_GET_EC.String(), fmt.Sprintf(format, args...))
}

// 创建实验集合错误
func IsOpenapiTrainingCreateEc(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_TRAINING_CREATE_EC.String() && e.Code == 400
}

// 创建实验集合错误
func ErrorOpenapiTrainingCreateEc(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_TRAINING_CREATE_EC.String(), fmt.Sprintf(format, args...))
}

// 创建实验错误
func IsOpenapiTrainingCreateExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_TRAINING_CREATE_EXPERIMENT.String() && e.Code == 400
}

// 创建实验错误
func ErrorOpenapiTrainingCreateExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_TRAINING_CREATE_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}

// 获取实验错误2
func IsOpenapiTrainingGetExperiment(err error) bool {
	if err == nil {
		return false
	}
	e := errors.FromError(err)
	return e.Reason == ErrorReason_OPENAPI_TRAINING_GET_EXPERIMENT.String() && e.Code == 400
}

// 获取实验错误2
func ErrorOpenapiTrainingGetExperiment(format string, args ...interface{}) *errors.Error {
	return errors.New(400, ErrorReason_OPENAPI_TRAINING_GET_EXPERIMENT.String(), fmt.Sprintf(format, args...))
}