sgul

type AMQP struct {
	User        string
	Password    string
	Host        string
	Port        int
	VHost       string
	Exchanges   []Exchange
	Queues      []Queue
	Publishers  []Publisher
	Subscribers []Subscriber
}

type AMQPConnection struct {
	URI        string
	Connection *amqp.Connection
	Channel    *amqp.Channel

	// publishers to be send messages to the relative exchanges
	Publishers map[string]*AMQPPublisher

	// subscribers to start and listen for messages from relative queues
	Subscribers map[string]*AMQPSubscriber
	// contains filtered or unexported fields
}

type AMQPPublisher struct {
	Connection   *AMQPConnection
	Exchange     string
	ExchangeType string
	RoutingKey   string
	ContentType  string
	DeliveryMode uint8
}

type AMQPSubscriber struct {
	Connection *AMQPConnection
	Queue      string
	Consumer   string
	AutoAck    bool
	Exclusive  bool
	NoLocal    bool
	NoWait     bool
	Replies    <-chan amqp.Delivery
}

type API struct {
	Endpoint struct {
		Port            int
		BaseRoutingPath string
	}
	// Cors defines the cors allowed resources struct.
	Cors struct {
		Origin  []string
		Methods []string
		Headers []string
	}
	Security struct {
		Enabled bool
		Jwt     struct {
			Secret     string
			Expiration struct {
				Enabled bool
				Minutes int32
			}
		}
	}
}

type Balancer interface {
	Balance(endpoints []string) (int, string)
}

type BalancingStrategy struct {
	Strategy string
}

type CasbinEnforcer struct {
	// contains filtered or unexported fields
}

type ChiController interface {
	Router() chi.Router
}

type Client struct {
	// Timeout specifies a time limit for requests made by this
	// Client. The timeout includes connection time, any
	// redirects, and reading the response body. The timer remains
	// running after Get, Head, Post, or Do return and will
	// interrupt reading of the Response.Body.
	// A Timeout of zero means no timeout.
	Timeout time.Duration

	// Timeout is the maximum amount of time a dial will wait for
	// a connect to complete. If Deadline is also set, it may fail
	// earlier.
	// The default is no timeout.
	DialerTimeout time.Duration

	// TLSHandshakeTimeout specifies the maximum amount of time waiting to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration

	// ExpectContinueTimeout, if non-zero, specifies the amount of
	// time to wait for a server's first response headers after fully
	// writing the request headers if the request has an
	// "Expect: 100-continue" header. Zero means no timeout and
	// causes the body to be sent immediately, without
	// waiting for the server to approve.
	// This time does not include the time to send the request header.
	ExpectContinueTimeout time.Duration

	// ResponseHeaderTimeout, if non-zero, specifies the amount of
	// time to wait for a server's response headers after fully
	// writing the request (including its body, if any). This
	// time does not include the time to read the response body.
	ResponseHeaderTimeout time.Duration

	// ServiceRegistry is the service registry for this client.
	ServiceRegistry ServiceRegistry

	// Balancing is the load balancing strategy for this client.
	// Actually it can be one from "round-robin" or "random".
	Balancing BalancingStrategy
}

type ClientError interface {
	Error() string
	// ResponseBody returns response body.
	ResponseBody() ([]byte, error)
	// ResponseHeaders returns http status code and headers.
	ResponseHeaders() (int, map[string]string)
}

type Configuration struct {
	Service    Service
	API        API
	Client     Client
	DB         DB
	Management Management
	Log        Log
	Ldap       Ldap
	AMQP       AMQP
}

type Controller struct {
	// Path is the base routing path for each route of the controller
	Path string
}

type DB struct {
	Type       string
	Host       string
	Port       int
	User       string
	Password   string
	Database   string
	Log        bool
	Migrations struct {
		Enabled            bool
		Drop               bool
		SingularTableNames bool
	}
}

type Event struct {
	// Name is the global identifier for event. It MUST be
	// composed as "<action>_<resource>", a.e. "new_user", "upd_user", "del_user", ...
	Name string

	// Source is the global identifier for the client which push
	// the evt message. A.E. "uaa-servce", "acct-service", ...
	Source string

	// Payload is the struct containing all the event message information.
	// The AMQP Publisher will marshal it to json and the AMQP Subscriber
	// will unmarshal it into a specific request (something like a dto).
	Payload interface{}
}

type Exchange struct {
	Name       string
	Type       string
	AutoDelete bool
	Durable    bool
	Internal   bool
	NoWait     bool
}

type GormRepository struct {
	DB *gorm.DB
}

type GormRepositoryInterface interface {
	SetDB(db *gorm.DB)
}

type HTTPError struct {
	Code      int         `json:"code"`
	Err       string      `json:"error"`
	Detail    interface{} `json:"detail"`
	RequestID string      `json:"requestId"`
	Timestamp time.Time   `json:"timestamp"`
}

type InTransaction func(tx *gorm.DB) error

type Ldap struct {
	Base   string
	Host   string
	Port   int
	UseSSL bool
	Bind   struct {
		DN       string
		Password string
	}
	UserFilter  string
	GroupFilter string
	Attributes  []string
}

type Log struct {
	Path       string
	Filename   string
	Console    bool
	Level      string
	JSON       bool
	MaxSize    int
	MaxBackups int
	MaxAge     int
	Compress   bool
	Caller     bool
}

type Logger = zap.SugaredLogger

type Management struct {
	Endpoint struct {
		Port            int
		BaseRoutingPath string
	}
	Health struct {
		Path string
		Full bool
	}
}

type MatchAllEnforcer struct{}

type MatchRoleEnforcer struct {
	// contains filtered or unexported fields
}

type Page struct {
	Page int
	Size int
}

type Principal struct {
	Username string
	Role     string
}

type Publisher struct {
	Name        string
	Exchange    string
	RoutingKey  string
	ContentType string
	// 2: "persistent" or 1: "non-persistent"
	DeliveryMode uint8
}

type Queue struct {
	Name       string
	AutoDelete bool
	Durable    bool
	Internal   bool
	Exclusive  bool
	NoWait     bool
}

type REGAgent struct {
	// contains filtered or unexported fields
}

type RestController interface {
	BasePath() string
	Router() chi.Router
}

type RolesEnforcer interface {
	Enforce(ctx context.Context, role string, route string, method string) bool
}

type Service struct {
	Group   string
	Name    string
	Version string
}

type ServiceRegistry struct {
	// Type specify the service registry type. Actually only "sgulreg" is managed.
	Type string
	// URL is the http url for the service registry.
	// For a SuglREG registry it is in the form of http://<host>:<port>.
	// This URL must be without trailing slash.
	URL string
	// Fallback is the fallback service registry used in case of the service registry
	// does not respond at the client startup or respond with and empty list, so we have an
	// empty local registry.
	// So, if the client local registry is empty and the service registry is not reachable
	// at the client startup, the client will use this fallback endpoints list to balance
	// client requests.
	Fallback []string
	// WatchInterval specifies the duration of a single interval between
	// two service discovery invocations from a service registry watcher.
	WatchInterval time.Duration
}

type ShamClient struct {
	// contains filtered or unexported fields
}

type Subscriber struct {
	Name      string
	Queue     string
	NoAck     bool
	NoLocal   bool
	NoWait    bool
	Exclusive bool
}