github.com/qiniu/go-sdk/v7@v7.27.0/iam/apis/create_policy/api.go

// THIS FILE IS GENERATED BY api-generator, DO NOT EDIT DIRECTLY!

// 新建授权策略
package create_policy

import (
	"encoding/json"

	credentials "github.com/qiniu/go-sdk/v7/storagev2/credentials"
	errors "github.com/qiniu/go-sdk/v7/storagev2/errors"
)

// 调用 API 所用的请求
type Request struct {
	Credentials credentials.CredentialsProvider // 鉴权参数，用于生成鉴权凭证，如果为空，则使用 HTTPClientOptions 中的 CredentialsProvider
	Alias       string                          // 授权策略别名，由 `A-Za-z0-9` 组成
	EditType    int64                           // 1：是通过自定义 JSON 编辑的策略 2：是通过 UI 编辑的策略
	Description string                          // 授权策略描述
	Statement   CreateStatements                // 授权策略规则集合
}

// 授权策略规则的操作集合
type CreateActions = []string

// 授权策略规则的资源集合
type CreateResources = []string

// 授权策略规则
type CreateStatement struct {
	Actions   CreateActions   // 授权策略规则的操作集合，action 查询参考 action 接口，格式为 service/action_alias
	Resources CreateResources // 授权策略规则的资源集合，格式为 qrn:product:region:uid:[resource-type/]resource-id ；可以简写为 qrn:product:::resource-id
	Effect    string          // 授权策略规则的生效类型，允许访问或拒绝访问
}
type jsonCreateStatement struct {
	Actions   CreateActions   `json:"action"`   // 授权策略规则的操作集合，action 查询参考 action 接口，格式为 service/action_alias
	Resources CreateResources `json:"resource"` // 授权策略规则的资源集合，格式为 qrn:product:region:uid:[resource-type/]resource-id ；可以简写为 qrn:product:::resource-id
	Effect    string          `json:"effect"`   // 授权策略规则的生效类型，允许访问或拒绝访问
}

func (j *CreateStatement) MarshalJSON() ([]byte, error) {
	if err := j.validate(); err != nil {
		return nil, err
	}
	return json.Marshal(&jsonCreateStatement{Actions: j.Actions, Resources: j.Resources, Effect: j.Effect})
}

func (j *CreateStatement) UnmarshalJSON(data []byte) error {
	var nj jsonCreateStatement
	if err := json.Unmarshal(data, &nj); err != nil {
		return err
	}
	j.Actions = nj.Actions
	j.Resources = nj.Resources
	j.Effect = nj.Effect
	return nil
}

func (j *CreateStatement) validate() error {
	if len(j.Actions) == 0 {
		return errors.MissingRequiredFieldError{Name: "Actions"}
	}
	if len(j.Resources) == 0 {
		return errors.MissingRequiredFieldError{Name: "Resources"}
	}
	if j.Effect == "" {
		return errors.MissingRequiredFieldError{Name: "Effect"}
	}
	return nil
}

// 授权策略规则集合
type CreateStatements = []CreateStatement

// 创建授权策略参数
type (
	CreatePolicyParam = Request
	jsonRequest       struct {
		Alias       string           `json:"alias,omitempty"`       // 授权策略别名，由 `A-Za-z0-9` 组成
		EditType    int64            `json:"edit_type,omitempty"`   // 1：是通过自定义 JSON 编辑的策略 2：是通过 UI 编辑的策略
		Description string           `json:"description,omitempty"` // 授权策略描述
		Statement   CreateStatements `json:"statement"`             // 授权策略规则集合
	}
)

func (j *Request) MarshalJSON() ([]byte, error) {
	if err := j.validate(); err != nil {
		return nil, err
	}
	return json.Marshal(&jsonRequest{Alias: j.Alias, EditType: j.EditType, Description: j.Description, Statement: j.Statement})
}

func (j *Request) UnmarshalJSON(data []byte) error {
	var nj jsonRequest
	if err := json.Unmarshal(data, &nj); err != nil {
		return err
	}
	j.Alias = nj.Alias
	j.EditType = nj.EditType
	j.Description = nj.Description
	j.Statement = nj.Statement
	return nil
}

func (j *Request) validate() error {
	if len(j.Statement) == 0 {
		return errors.MissingRequiredFieldError{Name: "Statement"}
	}
	for _, value := range j.Statement {
		if err := value.validate(); err != nil {
			return err
		}
	}
	return nil
}

// 获取 API 所用的响应
type Response struct {
	Data CreatedPolicyData // 授权策略信息
}

// 授权策略规则的操作集合
type CreatedActions = []string

// 授权策略规则的资源集合
type CreatedResources = []string

// 授权策略规则
type CreatedStatement struct {
	Actions   CreatedActions   // 授权策略规则的操作集合
	Resources CreatedResources // 授权策略规则的资源集合
	Effect    string           // 授权策略规则的生效类型，允许访问或拒绝访问
}
type jsonCreatedStatement struct {
	Actions   CreatedActions   `json:"action"`   // 授权策略规则的操作集合
	Resources CreatedResources `json:"resource"` // 授权策略规则的资源集合
	Effect    string           `json:"effect"`   // 授权策略规则的生效类型，允许访问或拒绝访问
}

func (j *CreatedStatement) MarshalJSON() ([]byte, error) {
	if err := j.validate(); err != nil {
		return nil, err
	}
	return json.Marshal(&jsonCreatedStatement{Actions: j.Actions, Resources: j.Resources, Effect: j.Effect})
}

func (j *CreatedStatement) UnmarshalJSON(data []byte) error {
	var nj jsonCreatedStatement
	if err := json.Unmarshal(data, &nj); err != nil {
		return err
	}
	j.Actions = nj.Actions
	j.Resources = nj.Resources
	j.Effect = nj.Effect
	return nil
}

func (j *CreatedStatement) validate() error {
	if len(j.Actions) == 0 {
		return errors.MissingRequiredFieldError{Name: "Actions"}
	}
	if len(j.Resources) == 0 {
		return errors.MissingRequiredFieldError{Name: "Resources"}
	}
	if j.Effect == "" {
		return errors.MissingRequiredFieldError{Name: "Effect"}
	}
	return nil
}

// 授权策略规则集合
type CreatedStatements = []CreatedStatement

// 授权策略信息
type Data struct {
	Id          string            // 记录 ID
	RootUid     int64             // 根用户 uid
	Alias       string            // 授权策略别名
	Description string            // 授权策略描述
	Enabled     bool              // 授权策略是否启用
	CreatedAt   string            // 授权策略创建时间
	UpdatedAt   string            // 授权策略上次更新时间
	Statement   CreatedStatements // 授权策略规则集合
}

// 返回的授权策略信息
type (
	CreatedPolicyData = Data
	jsonData          struct {
		Id          string            `json:"id"`          // 记录 ID
		RootUid     int64             `json:"root_uid"`    // 根用户 uid
		Alias       string            `json:"alias"`       // 授权策略别名
		Description string            `json:"description"` // 授权策略描述
		Enabled     bool              `json:"enabled"`     // 授权策略是否启用
		CreatedAt   string            `json:"created_at"`  // 授权策略创建时间
		UpdatedAt   string            `json:"updated_at"`  // 授权策略上次更新时间
		Statement   CreatedStatements `json:"statement"`   // 授权策略规则集合
	}
)

func (j *Data) MarshalJSON() ([]byte, error) {
	if err := j.validate(); err != nil {
		return nil, err
	}
	return json.Marshal(&jsonData{Id: j.Id, RootUid: j.RootUid, Alias: j.Alias, Description: j.Description, Enabled: j.Enabled, CreatedAt: j.CreatedAt, UpdatedAt: j.UpdatedAt, Statement: j.Statement})
}

func (j *Data) UnmarshalJSON(data []byte) error {
	var nj jsonData
	if err := json.Unmarshal(data, &nj); err != nil {
		return err
	}
	j.Id = nj.Id
	j.RootUid = nj.RootUid
	j.Alias = nj.Alias
	j.Description = nj.Description
	j.Enabled = nj.Enabled
	j.CreatedAt = nj.CreatedAt
	j.UpdatedAt = nj.UpdatedAt
	j.Statement = nj.Statement
	return nil
}

func (j *Data) validate() error {
	if j.Id == "" {
		return errors.MissingRequiredFieldError{Name: "Id"}
	}
	if j.RootUid == 0 {
		return errors.MissingRequiredFieldError{Name: "RootUid"}
	}
	if j.Alias == "" {
		return errors.MissingRequiredFieldError{Name: "Alias"}
	}
	if j.Description == "" {
		return errors.MissingRequiredFieldError{Name: "Description"}
	}
	if j.CreatedAt == "" {
		return errors.MissingRequiredFieldError{Name: "CreatedAt"}
	}
	if j.UpdatedAt == "" {
		return errors.MissingRequiredFieldError{Name: "UpdatedAt"}
	}
	if len(j.Statement) == 0 {
		return errors.MissingRequiredFieldError{Name: "Statement"}
	}
	for _, value := range j.Statement {
		if err := value.validate(); err != nil {
			return err
		}
	}
	return nil
}

// 返回的授权策略响应
type (
	CreatedPolicyResp = Response
	jsonResponse      struct {
		Data CreatedPolicyData `json:"data"` // 授权策略信息
	}
)

func (j *Response) MarshalJSON() ([]byte, error) {
	if err := j.validate(); err != nil {
		return nil, err
	}
	return json.Marshal(&jsonResponse{Data: j.Data})
}

func (j *Response) UnmarshalJSON(data []byte) error {
	var nj jsonResponse
	if err := json.Unmarshal(data, &nj); err != nil {
		return err
	}
	j.Data = nj.Data
	return nil
}

func (j *Response) validate() error {
	if err := j.Data.validate(); err != nil {
		return err
	}
	return nil
}