lib/api/research/research_models/portfolio_enrichment_coverage.go

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

// (c) 2012-2020 by Taxnexus, Inc.
// All rights reserved worldwide.
// Proprietary product; unlicensed use is not allowed

package research_models

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

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

// PortfolioEnrichmentCoverage Research-derived completeness statement for one bounded portfolio research result
//
// swagger:model PortfolioEnrichmentCoverage
type PortfolioEnrichmentCoverage struct {

	// omitted reasons
	// Required: true
	// Max Items: 100
	OmittedReasons []string `json:"OmittedReasons"`

	// policy version
	// Required: true
	// Enum: ["portfolio_coverage.v1"]
	PolicyVersion *string `json:"PolicyVersion"`

	// product count
	// Required: true
	// Maximum: 10000
	// Minimum: 0
	ProductCount *int64 `json:"ProductCount"`

	// query count
	// Required: true
	// Maximum: 10000
	// Minimum: 0
	QueryCount *int64 `json:"QueryCount"`

	// service count
	// Required: true
	// Maximum: 10000
	// Minimum: 0
	ServiceCount *int64 `json:"ServiceCount"`

	// source count
	// Required: true
	// Maximum: 10000
	// Minimum: 0
	SourceCount *int64 `json:"SourceCount"`

	// status
	// Required: true
	// Enum: ["complete","partial","insufficient_evidence","truncated"]
	Status *string `json:"Status"`

	// unique host count
	// Required: true
	// Maximum: 10000
	// Minimum: 0
	UniqueHostCount *int64 `json:"UniqueHostCount"`
}

// Validate validates this portfolio enrichment coverage
func (m *PortfolioEnrichmentCoverage) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

func (m *PortfolioEnrichmentCoverage) validateOmittedReasons(formats strfmt.Registry) error {

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

	iOmittedReasonsSize := int64(len(m.OmittedReasons))

	if err := validate.MaxItems("OmittedReasons", "body", iOmittedReasonsSize, 100); err != nil {
		return err
	}

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

		if err := validate.MinLength("OmittedReasons"+"."+strconv.Itoa(i), "body", m.OmittedReasons[i], 1); err != nil {
			return err
		}

		if err := validate.MaxLength("OmittedReasons"+"."+strconv.Itoa(i), "body", m.OmittedReasons[i], 1000); err != nil {
			return err
		}

	}

	return nil
}

var portfolioEnrichmentCoverageTypePolicyVersionPropEnum []any

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

const (

	// PortfolioEnrichmentCoveragePolicyVersionPortfolioCoverageDotV1 captures enum value "portfolio_coverage.v1"
	PortfolioEnrichmentCoveragePolicyVersionPortfolioCoverageDotV1 string = "portfolio_coverage.v1"
)

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

func (m *PortfolioEnrichmentCoverage) validatePolicyVersion(formats strfmt.Registry) error {

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

	// value enum
	if err := m.validatePolicyVersionEnum("PolicyVersion", "body", *m.PolicyVersion); err != nil {
		return err
	}

	return nil
}

func (m *PortfolioEnrichmentCoverage) validateProductCount(formats strfmt.Registry) error {

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

	if err := validate.MinimumInt("ProductCount", "body", *m.ProductCount, 0, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("ProductCount", "body", *m.ProductCount, 10000, false); err != nil {
		return err
	}

	return nil
}

func (m *PortfolioEnrichmentCoverage) validateQueryCount(formats strfmt.Registry) error {

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

	if err := validate.MinimumInt("QueryCount", "body", *m.QueryCount, 0, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("QueryCount", "body", *m.QueryCount, 10000, false); err != nil {
		return err
	}

	return nil
}

func (m *PortfolioEnrichmentCoverage) validateServiceCount(formats strfmt.Registry) error {

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

	if err := validate.MinimumInt("ServiceCount", "body", *m.ServiceCount, 0, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("ServiceCount", "body", *m.ServiceCount, 10000, false); err != nil {
		return err
	}

	return nil
}

func (m *PortfolioEnrichmentCoverage) validateSourceCount(formats strfmt.Registry) error {

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

	if err := validate.MinimumInt("SourceCount", "body", *m.SourceCount, 0, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("SourceCount", "body", *m.SourceCount, 10000, false); err != nil {
		return err
	}

	return nil
}

var portfolioEnrichmentCoverageTypeStatusPropEnum []any

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

const (

	// PortfolioEnrichmentCoverageStatusComplete captures enum value "complete"
	PortfolioEnrichmentCoverageStatusComplete string = "complete"

	// PortfolioEnrichmentCoverageStatusPartial captures enum value "partial"
	PortfolioEnrichmentCoverageStatusPartial string = "partial"

	// PortfolioEnrichmentCoverageStatusInsufficientEvidence captures enum value "insufficient_evidence"
	PortfolioEnrichmentCoverageStatusInsufficientEvidence string = "insufficient_evidence"

	// PortfolioEnrichmentCoverageStatusTruncated captures enum value "truncated"
	PortfolioEnrichmentCoverageStatusTruncated string = "truncated"
)

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

func (m *PortfolioEnrichmentCoverage) validateStatus(formats strfmt.Registry) error {

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

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

	return nil
}

func (m *PortfolioEnrichmentCoverage) validateUniqueHostCount(formats strfmt.Registry) error {

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

	if err := validate.MinimumInt("UniqueHostCount", "body", *m.UniqueHostCount, 0, false); err != nil {
		return err
	}

	if err := validate.MaximumInt("UniqueHostCount", "body", *m.UniqueHostCount, 10000, false); err != nil {
		return err
	}

	return nil
}

// ContextValidate validates this portfolio enrichment coverage based on context it is used
func (m *PortfolioEnrichmentCoverage) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

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

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