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

package ops

// 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"
)

// EntityIncident entity incident
//
// swagger:model entity.Incident
type EntityIncident struct {

	// biz regions
	BizRegions string `json:"biz_regions,omitempty"`

	// components
	Components string `json:"components,omitempty"`

	// created at
	CreatedAt string `json:"created_at,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// fbowners
	Fbowners []*EntityUser `json:"fbowners"`

	// feishu channel msg
	FeishuChannelMsg string `json:"feishu_channel_msg,omitempty"`

	// feishu url
	FeishuURL string `json:"feishu_url,omitempty"`

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

	// incident resolve time
	IncidentResolveTime string `json:"incident_resolve_time,omitempty"`

	// incident start time
	IncidentStartTime string `json:"incident_start_time,omitempty"`

	// jira issues
	JiraIssues string `json:"jira_issues,omitempty"`

	// leaders
	Leaders []*EntityUser `json:"leaders"`

	// log items
	LogItems []*EntityIncidentLogItem `json:"log_items"`

	// name
	Name string `json:"name,omitempty"`

	// oncallers
	Oncallers []*EntityUser `json:"oncallers"`

	// postmortem available
	PostmortemAvailable bool `json:"postmortem_available,omitempty"`

	// status
	Status EntityIncidentStatus `json:"status,omitempty"`

	// tier
	Tier EntityIncidentTier `json:"tier,omitempty"`
}

// Validate validates this entity incident
func (m *EntityIncident) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

func (m *EntityIncident) validateFbowners(formats strfmt.Registry) error {
	if swag.IsZero(m.Fbowners) { // not required
		return nil
	}

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

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

	}

	return nil
}

func (m *EntityIncident) validateLeaders(formats strfmt.Registry) error {
	if swag.IsZero(m.Leaders) { // not required
		return nil
	}

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

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

	}

	return nil
}

func (m *EntityIncident) validateLogItems(formats strfmt.Registry) error {
	if swag.IsZero(m.LogItems) { // not required
		return nil
	}

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

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

	}

	return nil
}

func (m *EntityIncident) validateOncallers(formats strfmt.Registry) error {
	if swag.IsZero(m.Oncallers) { // not required
		return nil
	}

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

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

	}

	return nil
}

func (m *EntityIncident) 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 *EntityIncident) validateTier(formats strfmt.Registry) error {
	if swag.IsZero(m.Tier) { // not required
		return nil
	}

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

	return nil
}

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

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

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

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

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

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

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

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

func (m *EntityIncident) contextValidateFbowners(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Fbowners[i] != nil {

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

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

	}

	return nil
}

func (m *EntityIncident) contextValidateLeaders(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Leaders[i] != nil {

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

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

	}

	return nil
}

func (m *EntityIncident) contextValidateLogItems(ctx context.Context, formats strfmt.Registry) error {

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

		if m.LogItems[i] != nil {

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

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

	}

	return nil
}

func (m *EntityIncident) contextValidateOncallers(ctx context.Context, formats strfmt.Registry) error {

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

		if m.Oncallers[i] != nil {

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

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

	}

	return nil
}

func (m *EntityIncident) 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
}

func (m *EntityIncident) contextValidateTier(ctx context.Context, formats strfmt.Registry) error {

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

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

	return nil
}

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

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