core

type AdminActionPlacement struct {
	DisplayOnEditPage bool
	//DisplayToTheTop bool
	//DisplayToTheBottom bool
	//DisplayToTheRight bool
	//DisplayToTheLeft bool
	ShowOnTheListPage bool
}

type AdminBreadCrumbsRegistry struct {
	BreadCrumbs []*AdminBreadcrumb
}

type AdminBreadcrumb struct {
	Name     string
	URL      string
	IsActive bool
	Icon     string
}

type AdminContext struct {
	Err                    string
	PageTitle              string
	ErrExists              bool
	SiteName               string
	Languages              []Language
	RootURL                string
	OTPRequired            bool
	Language               *Language
	Username               string
	Password               string
	Logo                   string
	FavIcon                string
	SessionKey             string
	RootAdminURL           string
	User                   string
	UserExists             bool
	UserObject             *User
	Demo                   bool
	UserPermissionRegistry *UserPermRegistry
	CurrentURL             string
	CurrentQuery           string
	FullURL                *url.URL
	Form                   IForm
	BreadCrumbs            *AdminBreadCrumbsRegistry
	ID                     uint
	FormD                  *multipart.Form
	Ctx                    *gin.Context
}

type AdminFilterObjects struct {
	InitialGormQuerySet   IPersistenceStorage
	GormQuerySet          IPersistenceStorage
	PaginatedGormQuerySet IPersistenceStorage
	Model                 interface{}
	UadminDatabase        *UadminDatabase
	GenerateModelI        func() (interface{}, interface{})
}

type AdminModelAction struct {
	ActionName              string
	Description             string
	ShowFutureChanges       bool
	RedirectToRootModelPage bool
	Placement               *AdminActionPlacement
	PermName                CustomPermission
	Handler                 func(adminPage *AdminPage, afo IAdminFilterObjects, ctx *gin.Context) (bool, int64)
	IsDisabled              func(afo IAdminFilterObjects, ctx *gin.Context) bool
	SlugifiedActionName     string
	RequestMethod           string
	RequiresExtraSteps      bool
}

type AdminModelActionRegistry struct {
	AdminModelActions map[string]*AdminModelAction
}

type AdminPage struct {
	Model                              interface{}                                               `json:"-"`
	GenerateModelI                     func() (interface{}, interface{})                         `json:"-"`
	GenerateForm                       func(modelI interface{}, ctx IAdminContext) *Form         `json:"-"`
	GetQueryset                        func(*AdminPage, *AdminRequestParams) IAdminFilterObjects `json:"-"`
	ModelActionsRegistry               *AdminModelActionRegistry                                 `json:"-"`
	FilterOptions                      *FilterOptionsRegistry                                    `json:"-"`
	ActionsSelectionCounter            bool                                                      `json:"-"`
	BlueprintName                      string
	EmptyValueDisplay                  string                   `json:"-"`
	ExcludeFields                      IFieldRegistry           `json:"-"`
	FieldsToShow                       IFieldRegistry           `json:"-"`
	Form                               *Form                    `json:"-"`
	ShowAllFields                      bool                     `json:"-"`
	Validators                         *ValidatorRegistry       `json:"-"`
	InlineRegistry                     *AdminPageInlineRegistry `json:"-"`
	ListDisplay                        *ListDisplayRegistry     `json:"-"`
	ListFilter                         *ListFilterRegistry      `json:"-"`
	MaxShowAll                         int                      `json:"-"`
	PreserveFilters                    bool                     `json:"-"`
	SaveAndContinue                    bool                     `json:"-"`
	SaveOnTop                          bool                     `json:"-"`
	SearchFields                       *SearchFieldRegistry     `json:"-"`
	ShowFullResultCount                bool                     `json:"-"`
	ViewOnSite                         bool                     `json:"-"`
	ListTemplate                       string                   `json:"-"`
	AddTemplate                        string                   `json:"-"`
	EditTemplate                       string                   `json:"-"`
	DeleteConfirmationTemplate         string                   `json:"-"`
	DeleteSelectedConfirmationTemplate string                   `json:"-"`
	ObjectHistoryTemplate              string                   `json:"-"`
	PopupResponseTemplate              string                   `json:"-"`
	Paginator                          *Paginator               `json:"-"`
	SubPages                           *AdminPageRegistry       `json:"-"`
	Ordering                           int
	PageName                           string
	ModelName                          string
	Slug                               string
	ToolTip                            string
	Icon                               string
	ListHandler                        func(ctx *gin.Context)                                                 `json:"-"`
	EditHandler                        func(ctx *gin.Context)                                                 `json:"-"`
	AddHandler                         func(ctx *gin.Context)                                                 `json:"-"`
	DeleteHandler                      func(ctx *gin.Context)                                                 `json:"-"`
	Router                             *gin.Engine                                                            `json:"-"`
	ParentPage                         *AdminPage                                                             `json:"-"`
	SaveModel                          func(modelI interface{}, ID uint, afo IAdminFilterObjects) interface{} `json:"-"`
	RegisteredHTTPHandlers             bool
	NoPermissionToAddNew               bool
	NoPermissionToEdit                 bool
}

type AdminPageInline struct {
	Ordering          int
	GenerateModelI    func(m interface{}) (interface{}, interface{})
	GetQueryset       func(afo IAdminFilterObjects, model interface{}, rp *AdminRequestParams) IAdminFilterObjects
	Actions           *AdminModelActionRegistry
	EmptyValueDisplay string
	ExcludeFields     IFieldRegistry
	FieldsToShow      IFieldRegistry
	ShowAllFields     bool
	Validators        *ValidatorRegistry
	Classes           []string
	Extra             int
	MaxNum            int
	MinNum            int
	VerboseName       string
	VerboseNamePlural string
	ShowChangeLink    bool
	Template          string
	ContentType       *ContentType
	Permission        CustomPermission
	InlineType        InlineType
	Prefix            string
	ListDisplay       *ListDisplayRegistry `json:"-"`
}

type AdminPageInlineRegistry struct {
	Inlines []*AdminPageInline
}

type AdminPageRegistry struct {
	AdminPages map[string]*AdminPage
}

type AdminPagesList []*AdminPage

type AdminRequestPaginator struct {
	PerPage int
	Offset  int
}

type AdminRequestParams struct {
	CreateSession     bool
	GenerateCSRFToken bool
	NeedAllLanguages  bool
	Paginator         *AdminRequestPaginator
	RequestURL        string
	Search            string
	Ordering          []string
}

type Blueprint struct {
	Name              string
	Description       string
	MigrationRegistry IMigrationRegistry
}

type BlueprintRegistry struct {
	RegisteredBlueprints map[string]IBlueprint
	MigrationTree        IMigrationTree
}

type CheckboxSelectMultipleWidget struct {
	Widget
	OptGroups map[string][]*RadioOptGroup
	ID        string
	WrapLabel bool
}

type CheckboxWidget struct {
	Widget
}

type ChooseFromSelectWidget struct {
	Widget
	PopulateLeftSide      func() []*SelectOptGroup
	PopulateRightSide     func() []*SelectOptGroup
	LeftSelectTitle       string
	LeftSelectHelp        string
	LeftHelpChooseAll     string
	LeftSearchSelectHelp  string
	LeftChooseAllText     string
	RightSelectTitle      string
	RightSelectHelp       string
	RightHelpChooseAll    string
	RightSearchSelectHelp string
	RightChooseAllText    string
	AddNewLink            string
	AddNewTitle           string
}

type ClearableFileWidget struct {
	Widget
	InitialText        string
	CurrentValue       *URLValue
	Required           bool
	ID                 string
	ClearCheckboxLabel string
	InputText          string
	Storage            IStorageInterface
	UploadPath         string
	Multiple           bool
}

type ColumnSchema struct {
	ShowLabel bool
	Fields    []*Field
}

type ConnectionToParentModel struct {
	FieldNameToValue map[string]interface{}
}

type ContainsGormOperator struct {
}

type ContentType struct {
	Model
	BlueprintName string `sql:"unique_index:idx_contenttype_content_type"`
	ModelName     string `sql:"unique_index:idx_contenttype_content_type"`
}

type ContentTypeSelectorWidget struct {
	Widget
	OptGroups             map[string][]*SelectOptGroup
	LoadFieldsOfAllModels bool
}

type CustomPermission string

type DBSettings struct {
	Type     string `json:"type"` // sqlite, mysql
	Name     string `json:"name"` // File/DB name
	User     string `json:"user"`
	Password string `json:"password"`
	Host     string `json:"host"`
	Port     int    `json:"port"`
}

type DashboardAdminPanel struct {
	AdminPages  *AdminPageRegistry
	ListHandler func(ctx *gin.Context)
}

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

type DatabaseSettings struct {
	Default *DBSettings
}

type DateGormOperator struct {
}

type DateTimeWidget struct {
	Widget
	DateTimeValue string
}

type DateWidget struct {
	Widget
	DateValue string
}

type DayGormOperator struct {
}

type DeleteRowStructure struct {
	SQL         string
	Values      []interface{}
	Explanation string
	Table       string
	Cond        string
}

type DisplayFilterOption struct {
	FilterField string
	FilterValue string
	DisplayAs   string
}

type DynamicWidget struct {
	Widget
	GetRealWidget                  func(formRenderContext *FormRenderContext, currentField *Field) IWidget
	GetRealWidgetForFormProceeding func(form *multipart.Form, afo IAdminFilterObjects) IWidget
}

type EmailWidget struct {
	Widget
}

type EndsWithGormOperator struct {
}

type ExactGormOperator struct {
}

type Field struct {
	schema.Field
	ReadOnly        bool
	UadminFieldType UadminFieldType
	FieldConfig     *FieldConfig
	Required        bool
	DisplayName     string
	HelpText        string
	Choices         *FieldChoiceRegistry
	Validators      *ValidatorRegistry
	SortingDisabled bool
	Populate        func(field *Field, m interface{}) interface{}
	Initial         interface{}
	WidgetType      string
	SetUpField      func(w IWidget, modelI interface{}, v interface{}, afo IAdminFilterObjects) error
	Ordering        int
}

type FieldChoice struct {
	DisplayAs string
	Value     interface{}
}

type FieldChoiceRegistry struct {
	Choices []*FieldChoice
}

type FieldConfig struct {
	Widget                 IWidget
	AutocompleteURL        string
	DependsOnAnotherFields []string
}

type FieldFormOptions struct {
	Name           string
	Initial        interface{}
	DisplayName    string
	Validators     *ValidatorRegistry
	Choices        *FieldChoiceRegistry
	HelpText       string
	WidgetType     string
	ReadOnly       bool
	Required       bool
	WidgetPopulate func(renderContext *FormRenderContext, currentField *Field) interface{}
	IsFk           bool
}

type FieldRegistry struct {
	Fields      map[string]*Field
	MaxOrdering int
}

type FileForStorage struct {
	Content           []byte
	PatternForTheFile string
	Filename          string
}

type FileWidget struct {
	Widget
	Storage    IStorageInterface
	UploadPath string
	Multiple   bool
}

type FilterOption struct {
	FieldName    string
	FetchOptions func(afo IAdminFilterObjects) []*DisplayFilterOption
}

type FilterOptionsRegistry struct {
	FilterOption []*FilterOption
}

type FkLinkWidget struct {
	Widget
}

type ForeignKeyWidget struct {
	Widget
	OptGroups                map[string][]*SelectOptGroup
	DontValidateForExistence bool
	AddNewLink               string
	GetQuerySet              func(formRenderContext *FormRenderContext) IPersistenceStorage
	GenerateModelInterface   func() (interface{}, interface{})
}

type Form struct {
	ExcludeFields       IFieldRegistry
	FieldsToShow        IFieldRegistry
	FieldRegistry       IFieldRegistry
	GroupsOfTheFields   *GrouppedFieldsRegistry
	TemplateName        string
	FormTitle           string
	Renderer            ITemplateRenderer
	RequestContext      map[string]interface{}
	ErrorMessage        string
	ExtraStatic         *StaticFiles `json:"-"`
	ForAdminPanel       bool
	FormError           *FormError
	DontGenerateFormTag bool
	Prefix              string
	RenderContext       *FormRenderContext
}

type FormError struct {
	FieldError    map[string]ValidationError
	GeneralErrors ValidationError
}

type FormListEditable struct {
	FieldRegistry     IFieldRegistry
	Prefix            string
	FormRenderContext *FormRenderContext
	FormError         *FormError
}

type FormListEditableCollection struct {
	InlineCollection map[string]InlineFormListEditableCollection
}

type FormRenderContext struct {
	Model interface{}
	Ctx   *gin.Context
}

type FormRow struct {
	Columns []*ColumnSchema
}

type FsStorage struct {
	UploadPath string
	URLPath    string
}

type GormOperatorContext struct {
	TableName string
	Tx        IPersistenceStorage
	Statement *gorm.Statement
}

type GormOperatorRegistry struct {
	Operators map[string]IGormOperator
}

type GormPersistenceStorage struct {
	Db *gorm.DB
}

type GormQueryBuilder struct {
	FilterString     []string
	OperatorRegistry *GormOperatorRegistry
	Model            interface{}
}

type GrouppedFields struct {
	Rows            []*FormRow
	ExtraCSSClasses []string
	Description     string
	Name            string
}

type GrouppedFieldsRegistry struct {
	GrouppedFields map[string]*GrouppedFields
}

type GtGormOperator struct {
}

type GteGormOperator struct {
}

type HiddenWidget struct {
	Widget
}

type HourGormOperator struct {
}

type IAdminContext interface {
	SetSiteName(siteName string)
	SetCurrentURL(currentURL string)
	SetFullURL(fullURL *url.URL)
	SetRootAdminURL(rootAdminURL string)
	SetSessionKey(sessionKey string)
	SetRootURL(rootURL string)
	SetLanguage(language *Language)
	SetLogo(logo string)
	SetFavIcon(favicon string)
	SetLanguages(langs []Language)
	SetPageTitle(pageTitle string)
	SetUser(user string)
	SetUserExists(userExists bool)
	SetDemo()
	SetError(err string)
	SetErrorExists()
	GetLanguage() *Language
	GetRootURL() string
	SetUserPermissionRegistry(permRegistry *UserPermRegistry)
	SetForm(form IForm)
	SetCurrentQuery(currentQuery string)
	SetBreadCrumbs(breadcrumbs *AdminBreadCrumbsRegistry)
	GetSessionKey() string
	SetID(ID uint)
	GetID() uint
	SetUserObject(u *User)
	GetUserObject() *User
	SetPostForm(formD *multipart.Form)
	GetPostForm() *multipart.Form
	GetCtx() *gin.Context
	SetCtx(ctx *gin.Context)
}

type IAdminFilterObjects interface {
	WithTransaction(handler func(afo1 IAdminFilterObjects) error)
	LoadDataForModelByID(ID interface{}, model interface{})
	SaveModel(model interface{}) error
	CreateNew(model interface{}) error
	GetPaginated() <-chan *IterateAdminObjects
	IterateThroughWholeQuerySet() <-chan *IterateAdminObjects
	GetPaginatedQuerySet() IPersistenceStorage
	GetFullQuerySet() IPersistenceStorage
	SetFullQuerySet(IPersistenceStorage)
	SetPaginatedQuerySet(IPersistenceStorage)
	GetUadminDatabase() *UadminDatabase
	GetCurrentModel() interface{}
	GetInitialQuerySet() IPersistenceStorage
	SetInitialQuerySet(IPersistenceStorage)
	GenerateModelInterface() (interface{}, interface{})
	RemoveModelPermanently(model interface{}) error
}

type IAdminModelActionInterface interface {
}

type IBlueprint interface {
	GetName() string
	GetDescription() string
	GetMigrationRegistry() IMigrationRegistry
	InitRouter(mainRouter *gin.Engine, group *gin.RouterGroup)
	Init()
}

type IBlueprintRegistry interface {
	Iterate() <-chan IBlueprint
	GetByName(name string) (IBlueprint, error)
	Register(blueprint IBlueprint)
	GetMigrationTree() IMigrationTree
	TraverseMigrations() <-chan *TraverseMigrationResult
	TraverseMigrationsDownTo(downToMigration int64) <-chan *TraverseMigrationResult
	InitializeRouting(router *gin.Engine)
	Initialize()
	ResetMigrationTree()
}

type ICommand interface {
	Proceed(subaction string, args []string) error
	GetHelpText() string
}

type IContainsGormOperator struct {
}

type IDbAdapter interface {
	Equals(name interface{}, args ...interface{})
	Quote(name interface{}) string
	LikeOperator() string
	ToString() string
	GetLastInsertID()

	QuoteTableName(tableName string) string
	Delete(db *gorm.DB, model reflect.Value, query interface{}, args ...interface{}) *gorm.DB
	ReadRows(db *gorm.DB, customSchema bool, SQL string, m interface{}, args ...interface{}) (*sql.Rows, error)
	GetSQLDialectStrings() map[string]string
	GetDb(alias string, dryRun bool) (*gorm.DB, error)
	CreateDb() error
	Transaction(handler func()) error
	GetStringToExtractYearFromField(filterOptionField string) string
	GetStringToExtractMonthFromField(filterOptionField string) string
	Exact(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IExact(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Contains(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IContains(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	In(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Gt(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Gte(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Lt(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Lte(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	StartsWith(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IStartsWith(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	EndsWith(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IEndsWith(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Range(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Date(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Year(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Month(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Day(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Week(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	WeekDay(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Quarter(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Time(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Hour(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Minute(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Second(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IsNull(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	Regex(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	IRegex(operatorContext *GormOperatorContext, field *Field, value interface{}, forSearching bool)
	BuildDeleteString(table string, cond string, values ...interface{}) *DeleteRowStructure
	// contains filtered or unexported methods
}

type IEndsWithGormOperator struct {
}

type IExactGormOperator struct {
}

type IFieldChoiceRegistryInterface interface {
	IsValidChoice(v interface{}) bool
}

type IFieldFormOptions interface {
	GetName() string
	GetInitial() interface{}
	GetDisplayName() string
	GetValidators() *ValidatorRegistry
	GetChoices() *FieldChoiceRegistry
	GetHelpText() string
	GetWidgetType() string
	GetReadOnly() bool
	GetIsRequired() bool
	GetWidgetPopulate() func(renderContext *FormRenderContext, currentField *Field) interface{}
	IsItFk() bool
}

type IFieldRegistry interface {
	GetByName(name string) (*Field, error)
	AddField(field *Field)
	GetAllFields() map[string]*Field
	GetAllFieldsWithOrdering() []*Field
	GetPrimaryKey() (*Field, error)
}

type IForm interface {
}

type IGormOperator interface {
	Build(adapter IDbAdapter, context *GormOperatorContext, field *Field, value interface{}, forSearching bool) *GormOperatorContext
	GetName() string
	RegisterDbHandlers(registerDbHandler IRegisterDbHandler) error
	TransformValue(value string) interface{}
}

type IGrouppedFieldsRegistry interface {
	AddGroup(grouppedFields *GrouppedFields)
	GetGroupByName(name string) *GrouppedFields
}

type IListDisplayInterface interface {
	GetValue(m interface{}) string
}

type IListFilterInterface interface {
	FilterQs(afo IAdminFilterObjects, filterString string)
}

type IMigration interface {
	Up(uadminDatabase *UadminDatabase) error
	Down(uadminDatabase *UadminDatabase) error
	GetName() string
	GetID() int64
	Deps() []string
}

type IMigrationNode interface {
	IsApplied() bool
	GetMigration() IMigration
	SetItAsRoot()
	IsRoot() bool
	AddChild(node IMigrationNode)
	AddDep(node IMigrationNode)
	GetChildrenCount() int
	GetChildren() *list.List
	GetDeps() *list.List
	TraverseDeps(migrationList []int64, depList MigrationDepList) MigrationDepList
	TraverseChildren(migrationList []int64) []int64
	IsDummy() bool
	Downgrade(uadminDatabase *UadminDatabase) error
	Apply(uadminDatabase *UadminDatabase) error
}