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

package model

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

import (
	"context"
	"strconv"

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

// DataflowBackupSettingResp dataflow backup setting resp
//
// swagger:model dataflowBackupSettingResp
type DataflowBackupSettingResp struct {

	// backup schedule
	BackupSchedule *DataflowBackupScheduleSetting `json:"backup_schedule,omitempty"`

	// cluster id
	// Required: true
	ClusterID *string `json:"cluster_id"`

	// description
	// Required: true
	Description *string `json:"description"`

	// pitr
	Pitr *DataflowPiTRSetting `json:"pitr,omitempty"`

	// provider
	// Required: true
	Provider *string `json:"provider"`

	// regions
	// Required: true
	Regions []*DataflowRegionInfo `json:"regions"`

	// restore regions
	RestoreRegions []*DataflowRegionInfo `json:"restore_regions"`

	// status
	Status *DataflowBackupSettingStatus `json:"status,omitempty"`

	// volume backup
	VolumeBackup *DataflowVolumeBackupSetting `json:"volume_backup,omitempty"`
}

// Validate validates this dataflow backup setting resp
func (m *DataflowBackupSettingResp) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

func (m *DataflowBackupSettingResp) validateBackupSchedule(formats strfmt.Registry) error {
	if swag.IsZero(m.BackupSchedule) { // not required
		return nil
	}

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

	return nil
}

func (m *DataflowBackupSettingResp) validateClusterID(formats strfmt.Registry) error {

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

	return nil
}

func (m *DataflowBackupSettingResp) validateDescription(formats strfmt.Registry) error {

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

	return nil
}

func (m *DataflowBackupSettingResp) validatePitr(formats strfmt.Registry) error {
	if swag.IsZero(m.Pitr) { // not required
		return nil
	}

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

	return nil
}

func (m *DataflowBackupSettingResp) validateProvider(formats strfmt.Registry) error {

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

	return nil
}

func (m *DataflowBackupSettingResp) validateRegions(formats strfmt.Registry) error {

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

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

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

	}

	return nil
}

func (m *DataflowBackupSettingResp) validateRestoreRegions(formats strfmt.Registry) error {
	if swag.IsZero(m.RestoreRegions) { // not required
		return nil
	}

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

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

	}

	return nil
}

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

	if m.Status != 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 *DataflowBackupSettingResp) validateVolumeBackup(formats strfmt.Registry) error {
	if swag.IsZero(m.VolumeBackup) { // not required
		return nil
	}

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

	return nil
}

// ContextValidate validate this dataflow backup setting resp based on the context it is used
func (m *DataflowBackupSettingResp) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

func (m *DataflowBackupSettingResp) contextValidateBackupSchedule(ctx context.Context, formats strfmt.Registry) error {

	if m.BackupSchedule != nil {

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

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

	return nil
}

func (m *DataflowBackupSettingResp) contextValidatePitr(ctx context.Context, formats strfmt.Registry) error {

	if m.Pitr != nil {

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

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

	return nil
}

func (m *DataflowBackupSettingResp) contextValidateRegions(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Regions[i] != nil {

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

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

	}

	return nil
}

func (m *DataflowBackupSettingResp) contextValidateRestoreRegions(ctx context.Context, formats strfmt.Registry) error {

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

		if m.RestoreRegions[i] != nil {

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

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

	}

	return nil
}

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

	if m.Status != nil {

		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
}

func (m *DataflowBackupSettingResp) contextValidateVolumeBackup(ctx context.Context, formats strfmt.Registry) error {

	if m.VolumeBackup != nil {

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

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

	return nil
}

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

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