create_transaction_batch_response_model.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"
)

// CreateTransactionBatchResponseModel Represents a create transaction batch response model.
// Example: {"files":[{"contentLength":2393,"contentType":"application/json","fileExtension":"JSON","filePath":"Input.json","name":"Input"}],"name":"TestBatch"}
//
// swagger:model CreateTransactionBatchResponseModel
type CreateTransactionBatchResponseModel struct {

	// The Account ID number of the account that owns this batch.
	AccountID int32 `json:"accountId,omitempty"`

	// The Company ID number of the company that owns this batch.
	CompanyID int32 `json:"companyId,omitempty"`

	// The date/time when this batch was completely processed
	// Read Only: true
	// Format: date-time
	CompletedDate strfmt.DateTime `json:"completedDate,omitempty"`

	// The date when this record was created.
	// Read Only: true
	// Format: date-time
	CreatedDate strfmt.DateTime `json:"createdDate,omitempty"`

	// The User ID of the user who created this record.
	// Read Only: true
	CreatedUserID int32 `json:"createdUserId,omitempty"`

	// The current record being processed
	// Read Only: true
	CurrentRecord int32 `json:"currentRecord,omitempty"`

	// The list of files contained in this batch.
	// Example: [{"contentLength":2393,"contentType":"application/json","fileExtension":"JSON","filePath":"Input.json","name":"Input"}]
	Files []*BatchFileModel `json:"files"`

	// The unique ID number of this batch.
	// Read Only: true
	ID int32 `json:"id,omitempty"`

	// The date/time when this record was last modified.
	// Read Only: true
	// Format: date-time
	ModifiedDate strfmt.DateTime `json:"modifiedDate,omitempty"`

	// The user ID of the user who last modified this record.
	// Read Only: true
	ModifiedUserID int32 `json:"modifiedUserId,omitempty"`

	// The user-friendly readable name for this batch.
	// Example: TestBatch
	// Required: true
	// Max Length: 194
	// Min Length: 0
	Name *string `json:"name"`

	// The number of records in this batch; determined by the server
	// Read Only: true
	RecordCount int32 `json:"recordCount,omitempty"`

	// The date/time when this batch started processing
	// Read Only: true
	// Format: date-time
	StartedDate strfmt.DateTime `json:"startedDate,omitempty"`

	// This batch's current processing status
	// Example: Waiting
	// Read Only: true
	// Enum: [Waiting SystemErrors Cancelled Completed Creating Deleted Errors Paused Processing Cancelling]
	Status string `json:"status,omitempty"`
}

// Validate validates this create transaction batch response model
func (m *CreateTransactionBatchResponseModel) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

func (m *CreateTransactionBatchResponseModel) validateCompletedDate(formats strfmt.Registry) error {
	if swag.IsZero(m.CompletedDate) { // not required
		return nil
	}

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

	return nil
}

func (m *CreateTransactionBatchResponseModel) validateCreatedDate(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatedDate) { // not required
		return nil
	}

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

	return nil
}

func (m *CreateTransactionBatchResponseModel) validateFiles(formats strfmt.Registry) error {
	if swag.IsZero(m.Files) { // not required
		return nil
	}

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

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

	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) validateModifiedDate(formats strfmt.Registry) error {
	if swag.IsZero(m.ModifiedDate) { // not required
		return nil
	}

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

	return nil
}

func (m *CreateTransactionBatchResponseModel) validateName(formats strfmt.Registry) error {

	if err := validate.Required("name", "body", m.Name); err != nil {
		return err
	}

	if err := validate.MinLength("name", "body", *m.Name, 0); err != nil {
		return err
	}

	if err := validate.MaxLength("name", "body", *m.Name, 194); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) validateStartedDate(formats strfmt.Registry) error {
	if swag.IsZero(m.StartedDate) { // not required
		return nil
	}

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

	return nil
}

var createTransactionBatchResponseModelTypeStatusPropEnum []interface{}

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["Waiting","SystemErrors","Cancelled","Completed","Creating","Deleted","Errors","Paused","Processing","Cancelling"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		createTransactionBatchResponseModelTypeStatusPropEnum = append(createTransactionBatchResponseModelTypeStatusPropEnum, v)
	}
}

const (

	// CreateTransactionBatchResponseModelStatusWaiting captures enum value "Waiting"
	CreateTransactionBatchResponseModelStatusWaiting string = "Waiting"

	// CreateTransactionBatchResponseModelStatusSystemErrors captures enum value "SystemErrors"
	CreateTransactionBatchResponseModelStatusSystemErrors string = "SystemErrors"

	// CreateTransactionBatchResponseModelStatusCancelled captures enum value "Cancelled"
	CreateTransactionBatchResponseModelStatusCancelled string = "Cancelled"

	// CreateTransactionBatchResponseModelStatusCompleted captures enum value "Completed"
	CreateTransactionBatchResponseModelStatusCompleted string = "Completed"

	// CreateTransactionBatchResponseModelStatusCreating captures enum value "Creating"
	CreateTransactionBatchResponseModelStatusCreating string = "Creating"

	// CreateTransactionBatchResponseModelStatusDeleted captures enum value "Deleted"
	CreateTransactionBatchResponseModelStatusDeleted string = "Deleted"

	// CreateTransactionBatchResponseModelStatusErrors captures enum value "Errors"
	CreateTransactionBatchResponseModelStatusErrors string = "Errors"

	// CreateTransactionBatchResponseModelStatusPaused captures enum value "Paused"
	CreateTransactionBatchResponseModelStatusPaused string = "Paused"

	// CreateTransactionBatchResponseModelStatusProcessing captures enum value "Processing"
	CreateTransactionBatchResponseModelStatusProcessing string = "Processing"

	// CreateTransactionBatchResponseModelStatusCancelling captures enum value "Cancelling"
	CreateTransactionBatchResponseModelStatusCancelling string = "Cancelling"
)

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

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

	// value enum
	if err := m.validateStatusEnum("status", "body", m.Status); err != nil {
		return err
	}

	return nil
}

// ContextValidate validate this create transaction batch response model based on the context it is used
func (m *CreateTransactionBatchResponseModel) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

	if err := m.contextValidateStartedDate(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 *CreateTransactionBatchResponseModel) contextValidateCompletedDate(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "completedDate", "body", strfmt.DateTime(m.CompletedDate)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateCreatedDate(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "createdDate", "body", strfmt.DateTime(m.CreatedDate)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateCreatedUserID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "createdUserId", "body", int32(m.CreatedUserID)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateCurrentRecord(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "currentRecord", "body", int32(m.CurrentRecord)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateFiles(ctx context.Context, formats strfmt.Registry) error {

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

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

	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "id", "body", int32(m.ID)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateModifiedDate(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "modifiedDate", "body", strfmt.DateTime(m.ModifiedDate)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateModifiedUserID(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "modifiedUserId", "body", int32(m.ModifiedUserID)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateRecordCount(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "recordCount", "body", int32(m.RecordCount)); err != nil {
		return err
	}

	return nil
}

func (m *CreateTransactionBatchResponseModel) contextValidateStartedDate(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "startedDate", "body", strfmt.DateTime(m.StartedDate)); err != nil {
		return err
	}

	return nil
}

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

	if err := validate.ReadOnly(ctx, "status", "body", string(m.Status)); err != nil {
		return err
	}

	return nil
}

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

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