property_rule.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"

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

// PropertyRule property rule
//
// swagger:model PropertyRule
type PropertyRule struct {

	// The property rule applies to
	// Read Only: true
	AppliesTo string `json:"appliesTo,omitempty"`

	// The property rule auditVersion
	// Read Only: true
	AuditVersion int64 `json:"auditVersion,omitempty"`

	// LM module checksum
	// Read Only: true
	Checksum string `json:"checksum,omitempty"`

	// The data type of property source, default is 0. The values can be
	//
	// 0: property source
	//
	// 1: raw ERI
	//
	//
	// Read Only: true
	DataType int32 `json:"dataType,omitempty"`

	// The property rule description
	// Read Only: true
	Description string `json:"description,omitempty"`

	// groovy script
	GroovyScript string `json:"groovyScript,omitempty"`

	// The property rule group name
	// Read Only: true
	Group string `json:"group,omitempty"`

	// id
	ID int32 `json:"id,omitempty"`

	// The local module's IntegrationMetadata, readable for troubleshooting purposes
	// Read Only: true
	InstallationMetadata *IntegrationMetadata `json:"installationMetadata,omitempty"`

	// The collect interval of raw ERI
	// Read Only: true
	Interval int32 `json:"interval,omitempty"`

	// LM module lineageId
	// Read Only: true
	LineageID string `json:"lineageId,omitempty"`

	// external linux script args
	LinuxCmdline string `json:"linuxCmdline,omitempty"`

	// external linux script name
	LinuxScript string `json:"linuxScript,omitempty"`

	// The property rule name
	// Read Only: true
	Name string `json:"name,omitempty"`

	// The property rule schedule option. The values can be onAP|onAPpropertyChanges
	// Read Only: true
	ScheduleOption string `json:"scheduleOption,omitempty"`

	// script type: embed | powershell | external
	ScriptType string `json:"scriptType,omitempty"`

	// The property rule tags
	// Read Only: true
	Tags string `json:"tags,omitempty"`

	// The technology notes
	// Read Only: true
	Technology string `json:"technology,omitempty"`

	// The property rule version
	// Read Only: true
	Version int64 `json:"version,omitempty"`

	// external windows script args
	WindowsCmdline string `json:"windowsCmdline,omitempty"`

	// external windows script name
	WindowsScript string `json:"windowsScript,omitempty"`
}

// Validate validates this property rule
func (m *PropertyRule) Validate(formats strfmt.Registry) error {
	var res []error

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

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

func (m *PropertyRule) validateInstallationMetadata(formats strfmt.Registry) error {
	if swag.IsZero(m.InstallationMetadata) { // not required
		return nil
	}

	if m.InstallationMetadata != nil {
		if err := m.InstallationMetadata.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("installationMetadata")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this property rule based on the context it is used
func (m *PropertyRule) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *PropertyRule) contextValidateAppliesTo(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateAuditVersion(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "auditVersion", "body", int64(m.AuditVersion)); err != nil {
		return err
	}

	return nil
}

func (m *PropertyRule) contextValidateChecksum(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateDataType(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateDescription(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateGroup(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateInstallationMetadata(ctx context.Context, formats strfmt.Registry) error {

	if m.InstallationMetadata != nil {
		if err := m.InstallationMetadata.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("installationMetadata")
			}
			return err
		}
	}

	return nil
}

func (m *PropertyRule) contextValidateInterval(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateLineageID(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateName(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateScheduleOption(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateTags(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateTechnology(ctx context.Context, formats strfmt.Registry) error {

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

	return nil
}

func (m *PropertyRule) contextValidateVersion(ctx context.Context, formats strfmt.Registry) error {

	if err := validate.ReadOnly(ctx, "version", "body", int64(m.Version)); err != nil {
		return err
	}

	return nil
}

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

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