teak

type App struct {
	cli.App
	// contains filtered or unexported fields
}

type ArgGetter struct {
	Err error
	// contains filtered or unexported fields
}

type AsyncLogger struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type AuthLevel int

type Authenticator func(
	gtx context.Context, params map[string]interface{}) (*User, error)

type Authorizer func(gtx context.Context, userID string) (AuthLevel, error)

type BinderFunc func(ctx echo.Context) (interface{}, error)

type Client struct {
	http.Client
	Address    string
	VersionStr string
	BaseURL    string
	Token      string
	User       *User
}

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

type CountList struct {
	TotalCount int64       `json:"total" db:"total"`
	Data       interface{} `json:"data" db:"data"`
}

type DataStorage interface {
	Name() string
	Count(
		gtx context.Context,
		dtype string,
		filter *Filter) (count int64, err error)
	Create(
		gtx context.Context,
		dataType string,
		data interface{}) error
	Update(
		gtx context.Context,
		dataType string,
		keyField string,
		key interface{},
		data interface{}) error
	Delete(
		gtx context.Context,
		dataType string,
		keyField string,
		key interface{}) error
	RetrieveOne(
		gtx context.Context,
		dataType string,
		keyField string,
		key interface{},
		data interface{}) error
	Retrieve(
		gtx context.Context,
		dtype string,
		sortFiled string,
		offset int64,
		limit int64,
		filter *Filter,
		out interface{}) error
	RetrieveWithCount(
		gtx context.Context,
		dtype string,
		sortFiled string,
		offset int64,
		limit int64,
		filter *Filter,
		out interface{}) (count int64, err error)
	GetFilterValues(
		gtx context.Context,
		dtype string,
		specs FilterSpecList) (values M, err error)
	GetFilterValuesX(
		gtx context.Context,
		dtype string,
		field string,
		specs FilterSpecList,
		filter *Filter) (values M, err error)

	IsSetup(gtx context.Context) (yes bool, err error)
	Setup(gtx context.Context, admin *User, adminPass string, param M) error
	Init(gtx context.Context, params M) error
	Reset(gtx context.Context) error
	Destroy(gtx context.Context) error
	Wrap(cmd *cli.Command) *cli.Command
}

type DateRange struct {
	// Name string    `json:"name" bson:"name"`
	From time.Time `json:"from" db:"from"`
	To   time.Time `json:"to" db:"to"`
}

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

type EmailConfig struct {
	AppEMail         string `json:"appEMail"`
	AppEMailPassword string `json:"appEMailPassword"`
	SMTPHost         string `json:"smtpHost"`
	SMTPPort         int    `json:"smtpPort"`
}

type Endpoint struct {
	Method   string      `json:"method"`
	URL      string      `json:"url"`
	Access   AuthLevel   `json:"access"`
	Category string      `json:"cateogry"`
	Route    *echo.Route `json:"route"`
	Comment  string      `json:"Comment"`
	Func     echo.HandlerFunc
}

type Event struct {
	Op       string      `json:"op" db:"op"`
	UserID   string      `json:"userID" db:"user_id"`
	UserName string      `json:"userName" db:"user_name"`
	Success  bool        `json:"success" db:"success"`
	Error    string      `json:"error" db:"error"`
	Time     time.Time   `json:"time" db:"time"`
	Data     interface{} `json:"data" db:"data"`
}

type EventAuditor interface {
	//LogEvent - logs given event into storage
	LogEvent(event *Event)

	//GetEvents - retrieves event entries based on filters
	GetEvents(offset, limit int64,
		filter *Filter) (
		total int64,
		events []*Event,
		err error)

	//CreateIndices - creates mongoDB indeces for tables used for event logs
	CreateIndices() (err error)

	//CleanData - cleans event related data from database
	CleanData() (err error)
}

type FieldNameRetriever func(field *reflect.StructField) (name string)

type Filter struct {
	Props    map[string]Matcher     `json:"props" db:"props"`
	Bools    map[string]interface{} `json:"bools" db:"bools"`
	Dates    map[string]DateRange   `json:"dates" db:"dates"`
	Lists    map[string]Matcher     `json:"lists" db:"lists"`
	Searches map[string]Matcher     `json:"searches" db:"searches"`
}

type FilterSpec struct {
	Field string     `json:"field" db:"field"`
	Name  string     `json:"name" db:"name"`
	Type  FilterType `json:"type" db:"type"`
}

type FilterSpecList []*FilterSpec

type FilterType string

type FilterVal struct {
	Name  string `json:"name" db:"name"`
	Count int    `json:"count" db:"count"`
}

type Group struct {
	Name  string   `json:"name" db:"name"`
	Users []string `json:"users" db:"users"`
}

type Level int

type Logger interface {
	//Log - logs a message with given level and module
	Log(level Level,
		module string,
		fmtstr string,
		args ...interface{})

	//RegisterWriter - registers a writer
	RegisterWriter(writer Writer)

	//RemoveWriter - removes a writer with given ID
	RemoveWriter(uniqueID string)

	//GetWriter - gives the writer with given ID
	GetWriter(uniqueID string) (writer Writer)
}

type LoggerConfig struct {
	Logger      Logger
	LogConsole  bool
	FilterLevel Level
}

type M map[string]interface{}

type MatchStrategy string

type Matcher struct {
	Strategy MatchStrategy `json:"strategy" db:"strategy"`
	Fields   []interface{} `json:"fields" db:"fields"`
}

type Module struct {
	Name         string              `json:"name" db:"name"`
	Description  string              `json:"desc" db:"desc"`
	Endpoints    []*Endpoint         `json:"endpoints" db:"endpoints"`
	ItemHandlers []StoredItemHandler `json:"itemHandlers" db:"item_handlers"`
	Commands     []*cli.Command
	Initialize   ModuleConfigFunc
	Setup        ModuleConfigFunc
	Reset        ModuleConfigFunc
}

type ModuleConfigFunc func(gtx context.Context, app *App) (err error)

type NoOpAuditor struct{}

type Pair struct {
	Key   string `json:"key" db:"key"`
	Value string `json:"value" db:"value"`
}

type Param struct {
	Name    string      `json:"name" db:"name"`
	Type    ParamType   `json:"type" db:"type"`
	Desc    string      `json:"desc" db:"desc"`
	Range   Range       `json:"range" db:"range"`
	Choices []Pair      `json:"choices" db:"choices"`
	Default interface{} `json:"def" db:"def"`
}

type ParamType int

type PropMatcher []interface{}

type Range struct {
	Min int `json:"min" db:"min"`
	Max int `json:"max" db:"max"`
}

type Result struct {
	Status int         `json:"status"`
	Op     string      `json:"op"`
	Msg    string      `json:"msg"`
	OK     bool        `json:"ok"`
	Err    string      `json:"error"`
	Data   interface{} `json:"data"`
}

type ResultReader struct {
	RawData []byte
	Err     error
	Res     Result
}

type SM map[string]string

type Session struct {
	UserID   string    `json:"userID"`
	UserName string    `json:"userName"`
	UserType string    `json:"userType"`
	Valid    bool      `json:"valid"`
	Role     AuthLevel `json:"role"`
}

type StoredItemHandler interface {
	DataType() string
	UniqueKeyField() string
	GetKey(item interface{}) interface{}
	SetModInfo(item interface{}, at time.Time, by string)
	CreateInstance(by string) interface{}
	PropNames() []string
}

type User struct {
	UserID     string      `json:"userID" db:"userID"`
	Email      string      `json:"email" db:"email"`
	Auth       AuthLevel   `json:"auth" db:"auth"`
	FirstName  string      `json:"firstName" db:"first_name"`
	LastName   string      `json:"lastName" db:"last_name"`
	Title      string      `json:"title" db:"title"`
	FullName   string      `json:"fullName" db:"full_name"`
	State      UserState   `json:"state" db:"state"`
	VerID      string      `json:"ver_id" db:"ver_id"`
	PwdExpiry  time.Time   `json:"pwdExpiry" db:"pwd_expiry"`
	CreatedAt  time.Time   `json:"createdAt" db:"created_at"`
	CreatedBy  string      `json:"createdBy" db:"created_by"`
	ModifiedAt time.Time   `json:"modifiedAt" db:"modified_at"`
	ModifiedBy string      `json:"modifiedBy" db:"modified_by"`
	VerfiedAt  time.Time   `json:"verifiedAt" db:"verified_at"`
	Props      interface{} `json:"props,omitempty" db:"props,omitempty"`
}

type UserHandler struct{}

type UserState string

type UserStorage interface {
	//CreateUser - creates user in database, returns the has of the user ID
	// This returns hash of the user ID which should be used for subsequent
	// uses
	CreateUser(gtx context.Context, user *User) (idHash string, err error)

	//UpdateUser - updates user in database
	UpdateUser(gtx context.Context, user *User) (err error)

	//DeleteUser - deletes user with given user ID
	DeleteUser(gtx context.Context, userID string) (err error)

	//GetUser - gets details of the user corresponding to ID
	GetUser(gtx context.Context, userID string) (user *User, err error)

	//GetAllUsers - gets all users based on offset and limit
	GetUsers(
		gtx context.Context,
		offset,
		limit int64,
		filter *Filter) (users []*User, err error)

	//GetCount - gives the number of user selected by given filter
	GetCount(gtx context.Context, filter *Filter) (count int64, err error)

	//GetUsersWithCount - gives a list of users paged with total count
	GetUsersWithCount(
		gtx context.Context,
		offset,
		limit int64,
		filter *Filter) (total int64, users []*User, err error)

	//ResetPassword - sets password of a unauthenticated user
	ResetPassword(
		gtx context.Context, userID, oldPwd, newPwd string) (err error)

	//SetPassword - sets password of a already authenticated user, old password
	//is not required
	SetPassword(gtx context.Context, userID, newPwd string) (err error)

	//ValidateUser - validates user ID and password
	ValidateUser(gtx context.Context, userID, password string) (err error)

	//GetUserAuthLevel - gets user authorization level
	GetUserAuthLevel(gtx context.Context, userID string) (
		level AuthLevel, err error)

	//SetAuthLevel - sets the auth level for the user
	SetAuthLevel(gtx context.Context, userID string, authLevel AuthLevel) (err error)

	//SetUserState - sets state of an user account
	SetUserState(gtx context.Context, userID string, state UserState) (err error)

	//VerifyUser - sets state of an user account to verified based on userID
	//and verification ID
	VerifyUser(gtx context.Context, userID, verID string) (err error)

	//UpdateProfile - updates user details - this should be used when user
	//logged in is updating own user account
	UpdateProfile(gtx context.Context, user *User) (err error)
}

type Version struct {
	Major int `json:"major" db:"major"`
	Minor int `json:"minor" db:"minor"`
	Patch int `json:"patch" db:"patch"`
}

type VisitorFunc func(state *WalkerState) (cont bool)

type WalkConfig struct {
	Visitor            VisitorFunc        //visitor function
	FieldNameRetriever FieldNameRetriever //func to get name from struct field
	MaxDepth           int                //Stop walk at this depth
	IgnoreContainers   bool               //Ignore slice and map parent objects
	VisitPrivate       bool               //Visit private fields
	VisitRootStruct    bool               //Visit the root struct thats passed
}

type WalkerState struct {
	Depth   int
	Field   *reflect.StructField
	Path    string
	Parent  *reflect.Value
	Current *reflect.Value
}

type Writer interface {
	UniqueID() string
	Write(message string)
	Enable(value bool)
	IsEnabled() (value bool)
}