zrok/rest_model_zrok/share_request.go

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

package rest_model_zrok

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

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

// ShareRequest share request
//
// swagger:model shareRequest
type ShareRequest struct {

	// access grants
	AccessGrants []string `json:"accessGrants"`

	// auth scheme
	AuthScheme string `json:"authScheme,omitempty"`

	// backend mode
	// Enum: ["proxy","web","tcpTunnel","udpTunnel","caddy","drive","socks"]
	BackendMode string `json:"backendMode,omitempty"`

	// basic auth users
	BasicAuthUsers []*AuthUser `json:"basicAuthUsers"`

	// env z Id
	EnvZID string `json:"envZId,omitempty"`

	// name selections
	NameSelections []*NameSelection `json:"nameSelections"`

	// oauth email domains
	OauthEmailDomains []string `json:"oauthEmailDomains"`

	// oauth provider
	OauthProvider string `json:"oauthProvider,omitempty"`

	// oauth refresh interval
	OauthRefreshInterval string `json:"oauthRefreshInterval,omitempty"`

	// permission mode
	// Enum: ["open","closed"]
	PermissionMode string `json:"permissionMode,omitempty"`

	// private share token
	PrivateShareToken string `json:"privateShareToken,omitempty"`

	// share mode
	// Enum: ["public","private"]
	ShareMode string `json:"shareMode,omitempty"`

	// target
	Target string `json:"target,omitempty"`
}

// Validate validates this share request
func (m *ShareRequest) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

var shareRequestTypeBackendModePropEnum []any

func init() {
	var res []string
	if err := json.Unmarshal([]byte(`["proxy","web","tcpTunnel","udpTunnel","caddy","drive","socks"]`), &res); err != nil {
		panic(err)
	}
	for _, v := range res {
		shareRequestTypeBackendModePropEnum = append(shareRequestTypeBackendModePropEnum, v)
	}
}

const (

	// ShareRequestBackendModeProxy captures enum value "proxy"
	ShareRequestBackendModeProxy string = "proxy"

	// ShareRequestBackendModeWeb captures enum value "web"
	ShareRequestBackendModeWeb string = "web"

	// ShareRequestBackendModeTCPTunnel captures enum value "tcpTunnel"
	ShareRequestBackendModeTCPTunnel string = "tcpTunnel"

	// ShareRequestBackendModeUDPTunnel captures enum value "udpTunnel"
	ShareRequestBackendModeUDPTunnel string = "udpTunnel"

	// ShareRequestBackendModeCaddy captures enum value "caddy"
	ShareRequestBackendModeCaddy string = "caddy"

	// ShareRequestBackendModeDrive captures enum value "drive"
	ShareRequestBackendModeDrive string = "drive"

	// ShareRequestBackendModeSocks captures enum value "socks"
	ShareRequestBackendModeSocks string = "socks"
)

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

func (m *ShareRequest) validateBackendMode(formats strfmt.Registry) error {
	if swag.IsZero(m.BackendMode) { // not required
		return nil
	}

	// value enum
	if err := m.validateBackendModeEnum("backendMode", "body", m.BackendMode); err != nil {
		return err
	}

	return nil
}

func (m *ShareRequest) validateBasicAuthUsers(formats strfmt.Registry) error {
	if swag.IsZero(m.BasicAuthUsers) { // not required
		return nil
	}

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

		if m.BasicAuthUsers[i] != nil {
			if err := m.BasicAuthUsers[i].Validate(formats); err != nil {
				ve := new(errors.Validation)
				if stderrors.As(err, &ve) {
					return ve.ValidateName("basicAuthUsers" + "." + strconv.Itoa(i))
				}
				ce := new(errors.CompositeError)
				if stderrors.As(err, &ce) {
					return ce.ValidateName("basicAuthUsers" + "." + strconv.Itoa(i))
				}

				return err
			}
		}

	}

	return nil
}

func (m *ShareRequest) validateNameSelections(formats strfmt.Registry) error {
	if swag.IsZero(m.NameSelections) { // not required
		return nil
	}

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

		if m.NameSelections[i] != nil {
			if err := m.NameSelections[i].Validate(formats); err != nil {
				ve := new(errors.Validation)
				if stderrors.As(err, &ve) {
					return ve.ValidateName("nameSelections" + "." + strconv.Itoa(i))
				}
				ce := new(errors.CompositeError)
				if stderrors.As(err, &ce) {
					return ce.ValidateName("nameSelections" + "." + strconv.Itoa(i))
				}

				return err
			}
		}

	}

	return nil
}

var shareRequestTypePermissionModePropEnum []any

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

const (

	// ShareRequestPermissionModeOpen captures enum value "open"
	ShareRequestPermissionModeOpen string = "open"

	// ShareRequestPermissionModeClosed captures enum value "closed"
	ShareRequestPermissionModeClosed string = "closed"
)

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

func (m *ShareRequest) validatePermissionMode(formats strfmt.Registry) error {
	if swag.IsZero(m.PermissionMode) { // not required
		return nil
	}

	// value enum
	if err := m.validatePermissionModeEnum("permissionMode", "body", m.PermissionMode); err != nil {
		return err
	}

	return nil
}

var shareRequestTypeShareModePropEnum []any

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

const (

	// ShareRequestShareModePublic captures enum value "public"
	ShareRequestShareModePublic string = "public"

	// ShareRequestShareModePrivate captures enum value "private"
	ShareRequestShareModePrivate string = "private"
)

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

func (m *ShareRequest) validateShareMode(formats strfmt.Registry) error {
	if swag.IsZero(m.ShareMode) { // not required
		return nil
	}

	// value enum
	if err := m.validateShareModeEnum("shareMode", "body", m.ShareMode); err != nil {
		return err
	}

	return nil
}

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

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

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

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

func (m *ShareRequest) contextValidateBasicAuthUsers(ctx context.Context, formats strfmt.Registry) error {

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

		if m.BasicAuthUsers[i] != nil {

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

			if err := m.BasicAuthUsers[i].ContextValidate(ctx, formats); err != nil {
				ve := new(errors.Validation)
				if stderrors.As(err, &ve) {
					return ve.ValidateName("basicAuthUsers" + "." + strconv.Itoa(i))
				}
				ce := new(errors.CompositeError)
				if stderrors.As(err, &ce) {
					return ce.ValidateName("basicAuthUsers" + "." + strconv.Itoa(i))
				}

				return err
			}
		}

	}

	return nil
}

func (m *ShareRequest) contextValidateNameSelections(ctx context.Context, formats strfmt.Registry) error {

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

		if m.NameSelections[i] != nil {

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

			if err := m.NameSelections[i].ContextValidate(ctx, formats); err != nil {
				ve := new(errors.Validation)
				if stderrors.As(err, &ve) {
					return ve.ValidateName("nameSelections" + "." + strconv.Itoa(i))
				}
				ce := new(errors.CompositeError)
				if stderrors.As(err, &ce) {
					return ce.ValidateName("nameSelections" + "." + strconv.Itoa(i))
				}

				return err
			}
		}

	}

	return nil
}

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

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