c_d_r_arrangement.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"
	"encoding/json"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// CDRArrangement c d r arrangement
//
// swagger:model CDRArrangement
type CDRArrangement struct {

	// List of accounts.
	//
	// It can refer to user's bank accounts that can be accessed by your client application in order to provide consumer
	// services.
	AccountIds []string `json:"account_ids" yaml:"account_ids"`

	// amending arrangement id
	AmendingArrangementID CDRArrangementID `json:"amending_arrangement_id,omitempty" yaml:"amending_arrangement_id,omitempty"`

	// Workspace identifier
	// Example: server
	AuthorizationServerID string `json:"authorization_server_id,omitempty" yaml:"authorization_server_id,omitempty"`

	// cdr arrangement id
	CdrArrangementID CDRArrangementID `json:"cdr_arrangement_id,omitempty" yaml:"cdr_arrangement_id,omitempty"`

	// cdr arrangement metadata
	CdrArrangementMetadata *CDRArrangementMetadata `json:"cdr_arrangement_metadata,omitempty" yaml:"cdr_arrangement_metadata,omitempty"`

	// Client application identifier
	// Example: bugkgm23g9kregtu051g
	ClientID string `json:"client_id,omitempty" yaml:"client_id,omitempty"`

	// Arrangement creation date
	// Example: 2022-07-01T08:52:27.127932Z
	// Format: date-time
	CreatedAt strfmt.DateTime `json:"created_at,omitempty" yaml:"created_at,omitempty"`

	// customer id
	CustomerID CDRCustomerID `json:"customer_id,omitempty" yaml:"customer_id,omitempty"`

	// Arrangement expiration date
	// Example: 2023-03-01T09:02:27.127932Z
	// Format: date-time
	Expiry strfmt.DateTime `json:"expiry,omitempty" yaml:"expiry,omitempty"`

	// The detailed list of scopes voluntarily granted by the user for the client application to access user data.
	ScopeGrants []*ScopeGrant `json:"scope_grants" yaml:"scope_grants"`

	// The rule on how a user shares their data: reuse with a token or without it, or the user allows one-time access.
	// Example: one_time
	// Enum: [one_time one_time_with_refresh_token reusable]
	SharingType string `json:"sharing_type,omitempty" yaml:"sharing_type,omitempty"`

	// Arrangement version.
	// Currently, the version parameter is not used.
	// Example: v1
	// Enum: [v1]
	SpecVersion string `json:"spec_version,omitempty" yaml:"spec_version,omitempty"`

	// status
	Status ConsentStatus `json:"status,omitempty" yaml:"status,omitempty"`

	// Subject identifies an authenticated user.
	// Depending on the workspace configuration, the value can be hashed.
	// Example: 377eb000a87a471291b5a9869930a2422c670b7b6a06f74143eb74a01ed2fbe1
	Subject string `json:"subject,omitempty" yaml:"subject,omitempty"`

	// Tenant identifier
	// Example: my-company
	TenantID string `json:"tenant_id,omitempty" yaml:"tenant_id,omitempty"`

	// Arrangement last update date
	// Example: 2022-10-01T08:52:27.127932Z
	// Format: date-time
	UpdatedAt strfmt.DateTime `json:"updated_at,omitempty" yaml:"updated_at,omitempty"`
}

// Validate validates this c d r arrangement
func (m *CDRArrangement) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAmendingArrangementID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCdrArrangementID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCdrArrangementMetadata(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCreatedAt(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCustomerID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExpiry(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateScopeGrants(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSharingType(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateSpecVersion(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStatus(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUpdatedAt(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *CDRArrangement) validateAmendingArrangementID(formats strfmt.Registry) error {
	if swag.IsZero(m.AmendingArrangementID) { // not required
		return nil
	}

	if err := m.AmendingArrangementID.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("amending_arrangement_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("amending_arrangement_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) validateCdrArrangementID(formats strfmt.Registry) error {
	if swag.IsZero(m.CdrArrangementID) { // not required
		return nil
	}

	if err := m.CdrArrangementID.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("cdr_arrangement_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("cdr_arrangement_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) validateCdrArrangementMetadata(formats strfmt.Registry) error {
	if swag.IsZero(m.CdrArrangementMetadata) { // not required
		return nil
	}

	if m.CdrArrangementMetadata != nil {
		if err := m.CdrArrangementMetadata.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("cdr_arrangement_metadata")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("cdr_arrangement_metadata")
			}
			return err
		}
	}

	return nil
}

func (m *CDRArrangement) validateCreatedAt(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatedAt) { // not required
		return nil
	}

	if err := validate.FormatOf("created_at", "body", "date-time", m.CreatedAt.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *CDRArrangement) validateCustomerID(formats strfmt.Registry) error {
	if swag.IsZero(m.CustomerID) { // not required
		return nil
	}

	if err := m.CustomerID.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("customer_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("customer_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) validateExpiry(formats strfmt.Registry) error {
	if swag.IsZero(m.Expiry) { // not required
		return nil
	}

	if err := validate.FormatOf("expiry", "body", "date-time", m.Expiry.String(), formats); err != nil {
		return err
	}

	return nil
}

func (m *CDRArrangement) validateScopeGrants(formats strfmt.Registry) error {
	if swag.IsZero(m.ScopeGrants) { // not required
		return nil
	}

	for i := 0; i < len(m.ScopeGrants); i++ {
		if swag.IsZero(m.ScopeGrants[i]) { // not required
			continue
		}

		if m.ScopeGrants[i] != nil {
			if err := m.ScopeGrants[i].Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("scope_grants" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("scope_grants" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

var cDRArrangementTypeSharingTypePropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["one_time","one_time_with_refresh_token","reusable"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		cDRArrangementTypeSharingTypePropEnum = append(cDRArrangementTypeSharingTypePropEnum, v)
	}
}

const (

	// CDRArrangementSharingTypeOneTime captures enum value "one_time"
	CDRArrangementSharingTypeOneTime string = "one_time"

	// CDRArrangementSharingTypeOneTimeWithRefreshToken captures enum value "one_time_with_refresh_token"
	CDRArrangementSharingTypeOneTimeWithRefreshToken string = "one_time_with_refresh_token"

	// CDRArrangementSharingTypeReusable captures enum value "reusable"
	CDRArrangementSharingTypeReusable string = "reusable"
)

// prop value enum
func (m *CDRArrangement) validateSharingTypeEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, cDRArrangementTypeSharingTypePropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *CDRArrangement) validateSharingType(formats strfmt.Registry) error {
	if swag.IsZero(m.SharingType) { // not required
		return nil
	}

	// value enum
	if err := m.validateSharingTypeEnum("sharing_type", "body", m.SharingType); err != nil {
		return err
	}

	return nil
}

var cDRArrangementTypeSpecVersionPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["v1"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		cDRArrangementTypeSpecVersionPropEnum = append(cDRArrangementTypeSpecVersionPropEnum, v)
	}
}

const (

	// CDRArrangementSpecVersionV1 captures enum value "v1"
	CDRArrangementSpecVersionV1 string = "v1"
)

// prop value enum
func (m *CDRArrangement) validateSpecVersionEnum(path, location string, value string) error {
	if err := validate.EnumCase(path, location, value, cDRArrangementTypeSpecVersionPropEnum, true); err != nil {
		return err
	}
	return nil
}

func (m *CDRArrangement) validateSpecVersion(formats strfmt.Registry) error {
	if swag.IsZero(m.SpecVersion) { // not required
		return nil
	}

	// value enum
	if err := m.validateSpecVersionEnum("spec_version", "body", m.SpecVersion); err != nil {
		return err
	}

	return nil
}

func (m *CDRArrangement) validateStatus(formats strfmt.Registry) error {
	if swag.IsZero(m.Status) { // not required
		return nil
	}

	if err := m.Status.Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("status")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("status")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) validateUpdatedAt(formats strfmt.Registry) error {
	if swag.IsZero(m.UpdatedAt) { // not required
		return nil
	}

	if err := validate.FormatOf("updated_at", "body", "date-time", m.UpdatedAt.String(), formats); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this c d r arrangement based on the context it is used
func (m *CDRArrangement) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateAmendingArrangementID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCdrArrangementID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCdrArrangementMetadata(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCustomerID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateScopeGrants(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateStatus(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *CDRArrangement) contextValidateAmendingArrangementID(ctx context.Context, formats strfmt.Registry) error {

	if swag.IsZero(m.AmendingArrangementID) { // not required
		return nil
	}

	if err := m.AmendingArrangementID.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("amending_arrangement_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("amending_arrangement_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) contextValidateCdrArrangementID(ctx context.Context, formats strfmt.Registry) error {

	if swag.IsZero(m.CdrArrangementID) { // not required
		return nil
	}

	if err := m.CdrArrangementID.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("cdr_arrangement_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("cdr_arrangement_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) contextValidateCdrArrangementMetadata(ctx context.Context, formats strfmt.Registry) error {

	if m.CdrArrangementMetadata != nil {

		if swag.IsZero(m.CdrArrangementMetadata) { // not required
			return nil
		}

		if err := m.CdrArrangementMetadata.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("cdr_arrangement_metadata")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("cdr_arrangement_metadata")
			}
			return err
		}
	}

	return nil
}

func (m *CDRArrangement) contextValidateCustomerID(ctx context.Context, formats strfmt.Registry) error {

	if swag.IsZero(m.CustomerID) { // not required
		return nil
	}

	if err := m.CustomerID.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("customer_id")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("customer_id")
		}
		return err
	}

	return nil
}

func (m *CDRArrangement) contextValidateScopeGrants(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.ScopeGrants); i++ {

		if m.ScopeGrants[i] != nil {

			if swag.IsZero(m.ScopeGrants[i]) { // not required
				return nil
			}

			if err := m.ScopeGrants[i].ContextValidate(ctx, formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("scope_grants" + "." + strconv.Itoa(i))
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("scope_grants" + "." + strconv.Itoa(i))
				}
				return err
			}
		}

	}

	return nil
}

func (m *CDRArrangement) contextValidateStatus(ctx context.Context, formats strfmt.Registry) error {

	if swag.IsZero(m.Status) { // not required
		return nil
	}

	if err := m.Status.ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("status")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("status")
		}
		return err
	}

	return nil
}

// MarshalBinary interface implementation
func (m *CDRArrangement) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *CDRArrangement) UnmarshalBinary(b []byte) error {
	var res CDRArrangement
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}