models

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 3, 2022 License: Apache-2.0 Imports: 29 Imported by: 8

Documentation

Index

Constants

View Source 
const (
	ExprSep = "."

	ContextSep = "|"
)

Expression separation symbols

View Source 
const DBSerializationMaxRetries uint8 = 5

DBSerializationMaxRetries defines the number of time a transaction that failed due to serialization error should be retried.

Variables

View Source 
var (
	// Testing is true if we are testing the framework
	Testing bool
	// ID is a FieldName that represents the PK of a model
	ID = fieldName{/* contains filtered or unexported fields */}
	// Name is a fieldName that represents the Name field of a model
	Name = fieldName{/* contains filtered or unexported fields */}
)
View Source 
var Registry *modelCollection

Registry is the registry of all Model instances.

View Source 
var (

	// Views is a map to store views created automatically.
	// It will be processed by the views package and added to the views registry.
	Views map[*Model][]string
)

Functions

func BootStrap 

func BootStrap()

BootStrap freezes model, fields and method caches and syncs the database structure with the declared data.

func BootStrapped 

func BootStrapped() bool

BootStrapped returns true if the models have been bootstrapped

func ConvertLimitToInt 

func ConvertLimitToInt(limit interface{}) int

ConvertLimitToInt converts the given limit as interface{} to an int

func CreateM2MRelModelInfo 

func CreateM2MRelModelInfo(relModelName, model1, model2, field1, field2 string, mixin bool) (*Model, *Field, *Field)

CreateM2MRelModelInfo creates a Model relModelName (if it does not exist) for the m2m relation defined between model1 and model2. It returns the Model of the intermediate model, the Field of that model pointing to our model, and the Field pointing to the other model.

If mixin is true, the created M2M model is created as a mixin model.

func DBClose 

func DBClose()

DBClose is a wrapper around sqlx.Close It closes the connection to the database

func DBConnect 

func DBConnect(params ConnectionParams)

DBConnect connects to a database using the given driver and arguments.

func DefaultValue 

func DefaultValue(value interface{}) func(env Environment) interface{}

DefaultValue returns a function that is suitable for the Default parameter of model fields and that simply returns value.

func ExecuteInNewEnvironment 

func ExecuteInNewEnvironment(uid int64, fnct func(Environment)) error

ExecuteInNewEnvironment executes the given fnct in a new Environment within a new transaction.

This function commits the transaction if everything went right or rolls it back otherwise, returning an arror. Database serialization errors are automatically retried several times before returning an error if they still occur.

func FreeTransientModels 

func FreeTransientModels()

FreeTransientModels remove transient models records from database which are older than the given timeout.

func LoadCSVDataFile 

func LoadCSVDataFile(fileName string)

LoadCSVDataFile loads the data of the given file into the database.

func RegisterModelDataWrapper 

func RegisterModelDataWrapper(modelName string, obj interface{})

RegisterModelDataWrapper registers the object passed as obj as the ModelData type for the given model.

- typ must be a struct that embeds ModelData - modelName must be the name of a model that exists in the registry

func RegisterRecordSetWrapper 

func RegisterRecordSetWrapper(modelName string, obj interface{})

RegisterRecordSetWrapper registers the object passed as obj as the RecordSet type for the given model.

- typ must be a struct that embeds *RecordCollection - modelName must be the name of a model that exists in the registry

func RegisterWorker 

func RegisterWorker(wf WorkerFunction)

RegisterWorker registers a WorkerFunction so that it will be called by the core loop.

func RunWorkerLoop 

func RunWorkerLoop()

RunWorkerLoop launches the hexya core worker loop.

This function must be called only once or it will panic

func SimulateInNewEnvironment 

func SimulateInNewEnvironment(uid int64, fnct func(Environment)) error

SimulateInNewEnvironment executes the given fnct in a new Environment within a new transaction and rolls back the transaction at the end.

This function always rolls back the transaction but returns an error only if fnct panicked during its execution.

func SnakeCaseFieldName 

func SnakeCaseFieldName(fName string, typ fieldtype.Type) string

SnakeCaseFieldName returns a snake cased field name, adding '_id' on x2one relation fields and '_ids' to x2many relation fields.

func StopWorkerLoop 

func StopWorkerLoop()

StopWorkerLoop stops the hexya core worker loop.

Calling this method if the core worker loop is not running will cause panic.

func SyncDatabase 

func SyncDatabase()

SyncDatabase creates or updates database tables with the data in the model registry

Types

type ClientEvaluatedString 

type ClientEvaluatedString string

A ClientEvaluatedString is a string that contains code that will be evaluated by the client

type ColumnData 

type ColumnData struct {
	ColumnName    string
	DataType      string
	IsNullable    string
	ColumnDefault sql.NullString
}

A ColumnData holds information from the db schema about one column

type Condition 

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

A Condition represents a WHERE clause of an SQL query.

func (Condition) And 

func (c Condition) And() *ConditionStart

And completes the current condition with a simple AND clause : c.And().nextCond => c AND nextCond.

No brackets are added so AND precedence over OR applies.

func (Condition) AndCond 

func (c Condition) AndCond(cond *Condition) *Condition

AndCond completes the current condition with the given cond as an AND clause between brackets : c.And(cond) => (c) AND (cond)

func (Condition) AndNot 

func (c Condition) AndNot() *ConditionStart

AndNot completes the current condition with a simple AND NOT clause : c.AndNot().nextCond => c AND NOT nextCond

No brackets are added so AND precedence over OR applies.

func (Condition) AndNotCond 

func (c Condition) AndNotCond(cond *Condition) *Condition

AndNotCond completes the current condition with an AND NOT clause between brackets : c.AndNot(cond) => (c) AND NOT (cond)

func (Condition) HasField 

func (c Condition) HasField(f *Field) bool

HasField returns true if the given field is in at least one of the the predicates of this condition or of one of its nested conditions.

func (*Condition) IsEmpty 

func (c *Condition) IsEmpty() bool

IsEmpty check the condition arguments are empty or not.

func (Condition) Or 

func (c Condition) Or() *ConditionStart

Or completes the current condition both with a simple OR clause : c.Or().nextCond => c OR nextCond

No brackets are added so AND precedence over OR applies.

func (Condition) OrCond 

func (c Condition) OrCond(cond *Condition) *Condition

OrCond completes the current condition both with an OR clause between brackets : c.Or(cond) => (c) OR (cond)

func (Condition) OrNot 

func (c Condition) OrNot() *ConditionStart

OrNot completes the current condition both with a simple OR NOT clause : c.OrNot().nextCond => c OR NOT nextCond

No brackets are added so AND precedence over OR applies.

func (Condition) OrNotCond 

func (c Condition) OrNotCond(cond *Condition) *Condition

OrNotCond completes the current condition both with an OR NOT clause between brackets : c.OrNot(cond) => (c) OR NOT (cond)

func (Condition) PredicatesWithField 

func (c Condition) PredicatesWithField(f *Field) []*predicate

PredicatesWithField returns all predicates of this condition (including nested conditions) that concern the given field.

func (Condition) Serialize 

func (c Condition) Serialize() []interface{}

Serialize returns the condition as a list which mimics Odoo domains.

func (Condition) String 

func (c Condition) String() string

String method for the Condition. Recursively print all predicates.

func (Condition) Underlying 

func (c Condition) Underlying() *Condition

Underlying returns the underlying Condition (i.e. itself)

type ConditionField 

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

A ConditionField is a partial Condition when we have set a field name in a predicate and are about to add an operator.

func (ConditionField) AddOperator 

func (c ConditionField) AddOperator(op operator.Operator, data interface{}) *Condition

AddOperator adds a condition value to the condition with the given operator and data If multi is true, a recordset will be converted into a slice of int64 otherwise, it will return an int64 and panic if the recordset is not a singleton.

This method is low level and should be avoided. Use operator methods such as Equals() instead.

func (ConditionField) ChildOf 

func (c ConditionField) ChildOf(data interface{}) *Condition

ChildOf appends the 'child of' operator to the current Condition

func (ConditionField) Contains 

func (c ConditionField) Contains(data interface{}) *Condition

Contains appends the 'LIKE %%' operator to the current Condition

func (ConditionField) Equals 

func (c ConditionField) Equals(data interface{}) *Condition

Equals appends the '=' operator to the current Condition

func (ConditionField) Greater 

func (c ConditionField) Greater(data interface{}) *Condition

Greater appends the '>' operator to the current Condition

func (ConditionField) GreaterOrEqual 

func (c ConditionField) GreaterOrEqual(data interface{}) *Condition

GreaterOrEqual appends the '>=' operator to the current Condition

func (ConditionField) IContains 

func (c ConditionField) IContains(data interface{}) *Condition

IContains appends the 'ILIKE %%' operator to the current Condition

func (ConditionField) ILike 

func (c ConditionField) ILike(data interface{}) *Condition

ILike appends the 'ILIKE' operator to the current Condition

func (ConditionField) In 

func (c ConditionField) In(data interface{}) *Condition

In appends the 'IN' operator to the current Condition

func (ConditionField) IsNotNull 

func (c ConditionField) IsNotNull() *Condition

IsNotNull checks if the current condition field is not null

func (ConditionField) IsNull 

func (c ConditionField) IsNull() *Condition

IsNull checks if the current condition field is null

func (ConditionField) JSON 

func (c ConditionField) JSON() string

JSON returns the json field name of this ConditionField

func (ConditionField) Like 

func (c ConditionField) Like(data interface{}) *Condition

Like appends the 'LIKE' operator to the current Condition

func (ConditionField) Lower 

func (c ConditionField) Lower(data interface{}) *Condition

Lower appends the '<' operator to the current Condition

func (ConditionField) LowerOrEqual 

func (c ConditionField) LowerOrEqual(data interface{}) *Condition

LowerOrEqual appends the '<=' operator to the current Condition

func (ConditionField) Name 

func (c ConditionField) Name() string

Name method for ConditionField

func (ConditionField) NotContains 

func (c ConditionField) NotContains(data interface{}) *Condition

NotContains appends the 'NOT LIKE %%' operator to the current Condition

func (ConditionField) NotEquals 

func (c ConditionField) NotEquals(data interface{}) *Condition

NotEquals appends the '!=' operator to the current Condition

func (ConditionField) NotIContains 

func (c ConditionField) NotIContains(data interface{}) *Condition

NotIContains appends the 'NOT ILIKE %%' operator to the current Condition

func (ConditionField) NotIn 

func (c ConditionField) NotIn(data interface{}) *Condition

NotIn appends the 'NOT IN' operator to the current Condition

type ConditionStart 

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

A ConditionStart is an object representing a Condition when we just added a logical operator (AND, OR, ...) and we are about to add a predicate.

func (ConditionStart) Field 

func (cs ConditionStart) Field(name FieldName) *ConditionField

Field adds a field path (dot separated) to this condition

func (ConditionStart) FilteredOn 

func (cs ConditionStart) FilteredOn(field FieldName, condition *Condition) *Condition

FilteredOn adds a condition with a table join on the given field and filters the result with the given condition

type Conditioner 

type Conditioner interface {
	Underlying() *Condition
}

A Conditioner can return a Condition object through its Underlying() method

type ConnectionParams 

type ConnectionParams struct {
	Driver   string
	Host     string
	Port     string
	User     string
	Password string
	DBName   string
	SSLMode  string
	SSLCert  string
	SSLKey   string
	SSLCA    string
}

ConnectionParams are the database agnostic parameters to connect to the database

func DBParams 

func DBParams() ConnectionParams

DBParams returns the DB connection parameters currently in use

func (ConnectionParams) ConnectionString 

func (cp ConnectionParams) ConnectionString() string

ConnectionString returns the connection string for these connection params

type Cursor 

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

Cursor is a wrapper around a database transaction

func (*Cursor) Execute 

func (c *Cursor) Execute(query string, args ...interface{}) sql.Result

Execute a query without returning any rows. It panics in case of error. The args are for any placeholder parameters in the query.

func (*Cursor) Get 

func (c *Cursor) Get(dest interface{}, query string, args ...interface{})

Get queries a row into the database and maps the result into dest. The query must return only one row. Get panics on errors

func (*Cursor) Select 

func (c *Cursor) Select(dest interface{}, query string, args ...interface{})

Select queries multiple rows and map the result into dest which must be a slice. Select panics on errors.

type DummyField 

type DummyField struct{}

DummyField is used internally to inflate mixins. It should not be used.

func (DummyField) DeclareField 

func (df DummyField) DeclareField(fc *FieldsCollection, name string) *Field

DeclareField creates a dummy field for the given FieldsCollection with the given name.

type Environment 

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

An Environment stores various contextual data used by the models: - the database cursor (current open transaction), - the current user ID (for access rights checking) - the current context (for storing arbitrary metadata). The Environment also stores caches.

func (Environment) Context 

func (env Environment) Context() *types.Context

Context returns the Context of the Environment

func (Environment) Cr 

func (env Environment) Cr() *Cursor

Cr returns a pointer to the Cursor of the Environment

func (Environment) DumpCache 

func (env Environment) DumpCache() string

DumpCache returns a human readable string of this Environment's cache for debugging purposes.

func (Environment) Pool 

func (env Environment) Pool(modelName string) *RecordCollection

Pool returns an empty RecordCollection for the given modelName

func (Environment) Uid 

func (env Environment) Uid() int64

Uid returns the user id of the Environment

type Field 

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

Field holds the meta information about a field

func CreateFieldFromStruct 

func CreateFieldFromStruct(fc *FieldsCollection, fStruct interface{}, name string, fieldType fieldtype.Type, goType interface{}) *Field

CreateFieldFromStruct creates a generic Field with the data from the given fStruct

fStruct must be a pointer to a struct and goType a pointer to a type instance

func (*Field) AddContexts 

func (f *Field) AddContexts(value FieldContexts) *Field

AddContexts adds the given contexts to the Contexts parameter of this Field

func (*Field) JSON 

func (f *Field) JSON() string

JSON returns this field name as FieldName type

func (*Field) Name 

func (f *Field) Name() string

Name returns the field's name.

func (*Field) SetCompute 

func (f *Field) SetCompute(value Methoder) *Field

SetCompute overrides the value of the Compute parameter of this Field

func (*Field) SetConstraint 

func (f *Field) SetConstraint(value Methoder) *Field

SetConstraint overrides the value of the Constraint parameter of this Field

func (*Field) SetContexts 

func (f *Field) SetContexts(value FieldContexts) *Field

SetContexts overrides the value of the Contexts parameter of this Field

func (*Field) SetDefault 

func (f *Field) SetDefault(value func(Environment) interface{}) *Field

SetDefault overrides the value of the Default parameter of this Field

func (*Field) SetDepends 

func (f *Field) SetDepends(value []string) *Field

SetDepends overrides the value of the Depends parameter of this Field

func (*Field) SetDigits 

func (f *Field) SetDigits(value nbutils.Digits) *Field

SetDigits overrides the value of the Digits parameter of this Field

func (*Field) SetEmbed 

func (f *Field) SetEmbed(value bool) *Field

SetEmbed overrides the value of the Embed parameter of this Field

func (*Field) SetFieldType 

func (f *Field) SetFieldType(value fieldtype.Type) *Field

SetFieldType overrides the type of Field. This may fail at database sync if the table already has values and the old type cannot be casted into the new type by the database.

func (*Field) SetFilter 

func (f *Field) SetFilter(value Conditioner) *Field

SetFilter overrides the value of the Filter parameter of this Field

func (*Field) SetGroupOperator 

func (f *Field) SetGroupOperator(value string) *Field

SetGroupOperator overrides the value of the GroupOperator parameter of this Field

func (*Field) SetHelp 

func (f *Field) SetHelp(value string) *Field

SetHelp overrides the value of the Help parameter of this Field

func (*Field) SetIndex 

func (f *Field) SetIndex(value bool) *Field

SetIndex overrides the value of the Index parameter of this Field

func (*Field) SetInverse 

func (f *Field) SetInverse(value Methoder) *Field

SetInverse overrides the value of the Inverse parameter of this Field

func (*Field) SetInvisibleFunc 

func (f *Field) SetInvisibleFunc(value func(Environment) (bool, Conditioner)) *Field

SetInvisibleFunc overrides the value of the InvisibleFunc parameter of this Field

func (*Field) SetM2MOurField 

func (f *Field) SetM2MOurField(value *Field) *Field

SetM2MOurField sets the field of the M2MRelModel pointing to this model.

func (*Field) SetM2MRelModel 

func (f *Field) SetM2MRelModel(value Modeler) *Field

SetM2MRelModel sets the relation model between this model and the target model.

func (*Field) SetM2MTheirField 

func (f *Field) SetM2MTheirField(value *Field) *Field

SetM2MTheirField sets the field of the M2MRelModel pointing to the other model.

func (*Field) SetNoCopy 

func (f *Field) SetNoCopy(value bool) *Field

SetNoCopy overrides the value of the NoCopy parameter of this Field

func (*Field) SetOnDelete 

func (f *Field) SetOnDelete(value OnDeleteAction) *Field

SetOnDelete overrides the value of the OnDelete parameter of this Field

func (*Field) SetOnchange 

func (f *Field) SetOnchange(value Methoder) *Field

SetOnchange overrides the value of the Onchange parameter of this Field

func (*Field) SetOnchangeFilters 

func (f *Field) SetOnchangeFilters(value Methoder) *Field

SetOnchangeFilters overrides the value of the OnChangeFilters parameter of this Field

func (*Field) SetOnchangeWarning 

func (f *Field) SetOnchangeWarning(value Methoder) *Field

SetOnchangeWarning overrides the value of the OnChangeWarning parameter of this Field

func (*Field) SetProperty 

func (f *Field) SetProperty(property string, value interface{})

SetProperty sets the given property value in this field This method uses switch as they are unexported struct fields

func (*Field) SetReadOnly 

func (f *Field) SetReadOnly(value bool) *Field

SetReadOnly overrides the value of the ReadOnly parameter of this Field

func (*Field) SetReadOnlyFunc 

func (f *Field) SetReadOnlyFunc(value func(Environment) (bool, Conditioner)) *Field

SetReadOnlyFunc overrides the value of the ReadOnlyFunc parameter of this Field

func (*Field) SetRelated 

func (f *Field) SetRelated(value string) *Field

SetRelated overrides the value of the Related parameter of this Field

func (*Field) SetRelationModel 

func (f *Field) SetRelationModel(value Modeler) *Field

SetRelationModel overrides the value of the Filter parameter of this Field

func (*Field) SetRequired 

func (f *Field) SetRequired(value bool) *Field

SetRequired overrides the value of the Required parameter of this Field

func (*Field) SetRequiredFunc 

func (f *Field) SetRequiredFunc(value func(Environment) (bool, Conditioner)) *Field

SetRequiredFunc overrides the value of the RequiredFunc parameter of this Field

func (*Field) SetReverseFK 

func (f *Field) SetReverseFK(value string) *Field

SetReverseFK sets the name of the FK pointing to this model in a O2M or R2O relation

func (*Field) SetSelection 

func (f *Field) SetSelection(value types.Selection) *Field

SetSelection overrides the value of the Selection parameter of this Field

func (*Field) SetSelectionFunc 

func (f *Field) SetSelectionFunc(value func() types.Selection) *Field

SetSelectionFunc defines the function that will return the selection of this field

func (*Field) SetSize 

func (f *Field) SetSize(value int) *Field

SetSize overrides the value of the Size parameter of this Field

func (*Field) SetStored 

func (f *Field) SetStored(value bool) *Field

SetStored overrides the value of the Stored parameter of this Field

func (*Field) SetString 

func (f *Field) SetString(value string) *Field

SetString overrides the value of the String parameter of this Field

func (*Field) SetTranslate 

func (f *Field) SetTranslate(value bool) *Field

SetTranslate overrides the value of the Translate parameter of this Field

func (*Field) SetUnique 

func (f *Field) SetUnique(value bool) *Field

SetUnique overrides the value of the Unique parameter of this Field

func (*Field) UpdateSelection 

func (f *Field) UpdateSelection(value types.Selection) *Field

UpdateSelection updates the value of the Selection parameter of this Field with the given value. Existing keys are overridden.

type FieldContexts 

type FieldContexts map[string]func(RecordSet) string

FieldContexts define the different contexts for a field, that will define different values for this field.

The key is a context name and the value is a function that returns the context value for the given recordset.

type FieldDefinition 

type FieldDefinition interface {
	// DeclareField creates a field for the given FieldsCollection with the given name and returns the created field.
	DeclareField(*FieldsCollection, string) *Field
}

A FieldDefinition is a struct that declares a new field in a fields collection;

type FieldInfo 

type FieldInfo struct {
	ChangeDefault    bool                                  `json:"change_default"`
	Help             string                                `json:"help"`
	Searchable       bool                                  `json:"searchable"`
	Views            map[string]interface{}                `json:"views"`
	Required         bool                                  `json:"required"`
	Manual           bool                                  `json:"manual"`
	ReadOnly         bool                                  `json:"readonly"`
	Depends          []string                              `json:"depends"`
	CompanyDependent bool                                  `json:"company_dependent"`
	Sortable         bool                                  `json:"sortable"`
	Translate        bool                                  `json:"translate"`
	Type             fieldtype.Type                        `json:"type"`
	Store            bool                                  `json:"store"`
	String           string                                `json:"string"`
	Relation         string                                `json:"relation"`
	Selection        types.Selection                       `json:"selection"`
	Domain           interface{}                           `json:"domain"`
	OnChange         bool                                  `json:"-"`
	ReverseFK        string                                `json:"-"`
	Name             string                                `json:"-"`
	JSON             string                                `json:"-"`
	ReadOnlyFunc     func(Environment) (bool, Conditioner) `json:"-"`
	RequiredFunc     func(Environment) (bool, Conditioner) `json:"-"`
	InvisibleFunc    func(Environment) (bool, Conditioner) `json:"-"`
	DefaultFunc      func(Environment) interface{}         `json:"-"`
	GoType           reflect.Type                          `json:"-"`
	Index            bool                                  `json:"-"`
}

FieldInfo is the exportable field information struct

type FieldMap 

type FieldMap map[string]interface{}

FieldMap is a map of interface{} specifically used for holding model fields values.

func (FieldMap) Copy 

func (fm FieldMap) Copy() FieldMap

Copy returns a shallow copy of this FieldMap

func (*FieldMap) Delete 

func (fm *FieldMap) Delete(field FieldName)

Delete removes the given field from this FieldMap. Calling Del on a non existent field is a no op.

func (FieldMap) FieldNames 

func (fm FieldMap) FieldNames(model *Model) FieldNames

FieldNames returns the keys of this FieldMap as FieldNames of the given model

func (FieldMap) Get 

func (fm FieldMap) Get(field FieldName) (interface{}, bool)

Get returns the value of the given field referring to the given model. field can be either a field name (or path) or a field JSON name (or path). The second returned value is true if the field has been found in the FieldMap

func (FieldMap) Keys 

func (fm FieldMap) Keys() (res []string)

Keys returns the FieldMap keys as a slice of strings

func (*FieldMap) MergeWith 

func (fm *FieldMap) MergeWith(other FieldMap, model *Model)

MergeWith updates this FieldMap with the given other FieldMap If a key of the other FieldMap already exists here, the value is overridden, otherwise, the key is inserted with its json name.

func (FieldMap) MustGet 

func (fm FieldMap) MustGet(field FieldName) interface{}

MustGet returns the value of the given field referring to the given model. field can be either a field name (or path) or a field JSON name (or path). It panics if the field is not found.

func (FieldMap) OrderedKeys 

func (fm FieldMap) OrderedKeys() []string

OrderedKeys returns the keys of this FieldMap ordered.

This has the convenient side effect of having shorter paths come before longer paths, which is particularly useful when creating or updating related records.

func (*FieldMap) RemovePK 

func (fm *FieldMap) RemovePK()

RemovePK removes the entries of our FieldMap which references the ID field.

func (*FieldMap) RemovePKIfZero 

func (fm *FieldMap) RemovePKIfZero()

RemovePKIfZero removes the entries of our FieldMap which references the ID field if the referenced id is 0.

func (*FieldMap) Set 

func (fm *FieldMap) Set(field FieldName, value interface{})

Set sets the given field with the given value. If the field already exists, then it is updated with value. Otherwise, a new entry is inserted in the FieldMap with the JSON name of the field.

func (FieldMap) Underlying 

func (fm FieldMap) Underlying() FieldMap

Underlying returns the object converted to a FieldMap i.e. itself

func (FieldMap) Values 

func (fm FieldMap) Values() (res []interface{})

Values returns the FieldMap values as a slice of interface{}

type FieldMapper 

type FieldMapper interface {
	// Underlying returns the object converted to a FieldMap.
	Underlying() FieldMap
}

A FieldMapper is an object that can convert itself into a FieldMap

type FieldName 

type FieldName interface {
	Name() string
	JSON() string
}

A FieldName is a type that can represents a field in a model. It can yield the field name or the field's JSON name as a string

func NewFieldName 

func NewFieldName(name, json string) FieldName

NewFieldName returns a fieldName instance with the given name and json

type FieldNames 

type FieldNames []FieldName

FieldNames is a slice of FieldName that can be sorted

func (FieldNames) JSON 

func (f FieldNames) JSON() []string

JSON returns a slice with the JSON names of each field

func (FieldNames) Len 

func (f FieldNames) Len() int

Len returns the length of the FieldName slice

func (FieldNames) Less 

func (f FieldNames) Less(i, j int) bool

Less returns true if f[i] < f[j]. FieldNames are ordered by JSON names

func (FieldNames) Names 

func (f FieldNames) Names() []string

Names returns a slice with the names of each field

func (FieldNames) Swap 

func (f FieldNames) Swap(i, j int)

Swap i and j indexes

func (*FieldNames) UnmarshalJSON 

func (f *FieldNames) UnmarshalJSON(data []byte) error

UnmarshalJSON for the FieldNames type

type FieldsCollection 

type FieldsCollection struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

FieldsCollection is a collection of Field instances in a model.

func (*FieldsCollection) Get 

func (fc *FieldsCollection) Get(name string) (fi *Field, ok bool)

Get returns the Field of the field with the given name. name can be either the name of the field or its JSON name.

func (*FieldsCollection) Model 

func (fc *FieldsCollection) Model() *Model

Model returns this FieldsCollection Model

func (*FieldsCollection) MustGet 

func (fc *FieldsCollection) MustGet(name string) *Field

MustGet returns the Field of the field with the given name or panics name can be either the name of the field or its JSON name.

type FieldsGetArgs 

type FieldsGetArgs struct {
	// Fields is a list of fields to document, all if empty or not provided
	Fields FieldNames `json:"allfields"`
}

FieldsGetArgs is the args struct for the FieldsGet method

type GroupAggregateRow 

type GroupAggregateRow struct {
	Values    *ModelData
	Count     int
	Condition *Condition
}

A GroupAggregateRow holds a row of results of a query with a group by clause - Values holds the values of the actual query - Count is the number of lines aggregated into this one - Condition can be used to query the aggregated rows separately if needed

type Method 

type Method struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

A Method is a definition of a model's method

func (*Method) AllowGroup 

func (m *Method) AllowGroup(group *security.Group, callers ...Methoder) *Method

AllowGroup grants the execution permission on this method to the given group If callers are defined, then the permission is granted only when this method is called from one of the callers, otherwise it is granted from any caller.

func (*Method) Call 

func (m *Method) Call(rc *RecordCollection, params ...interface{}) interface{}

Call executes the given method with the given parameters and returns (only) the first returned value

func (*Method) CallMulti 

func (m *Method) CallMulti(rc *RecordCollection, params ...interface{}) []interface{}

CallMulti executes the given method with the given parameters and returns all returned value as []interface{}.

func (*Method) Extend 

func (m *Method) Extend(fnct interface{}) *Method

Extend adds the given fnct function as a new layer on this method. fnct must be of the same signature as the first layer of this method.

func (*Method) MethodType 

func (m *Method) MethodType() reflect.Type

MethodType returns the methodType of a Method

func (*Method) Name 

func (m *Method) Name() string

Name returns the name of the method

func (*Method) RevokeGroup 

func (m *Method) RevokeGroup(group *security.Group) *Method

RevokeGroup revokes the execution permission on the method to the given group if it has been given previously, otherwise does nothing. Note that this methods revokes all permissions, whatever the caller.

func (*Method) Underlying 

func (m *Method) Underlying() *Method

Underlying returns the underlysing method data object

type Methoder 

type Methoder interface {
	Underlying() *Method
}

A Methoder can return a Method data object through its Underlying() method

type MethodsCollection 

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

A MethodsCollection is a collection of methods for use in a model

func (*MethodsCollection) AllowAllToGroup 

func (mc *MethodsCollection) AllowAllToGroup(group *security.Group)

AllowAllToGroup grants the given group access to all the CRUD methods of this collection

func (*MethodsCollection) Get 

func (mc *MethodsCollection) Get(methodName string) (*Method, bool)

Get returns the Method with the given method name.

The second return value is true if a method has been found.

func (*MethodsCollection) MustGet 

func (mc *MethodsCollection) MustGet(methodName string) *Method

MustGet returns the Method of the given method. It panics if the method is not found.

func (*MethodsCollection) RevokeAllFromGroup 

func (mc *MethodsCollection) RevokeAllFromGroup(group *security.Group)

RevokeAllFromGroup revokes permissions on all CRUD methods given by AllowAllToGroup

type Model 

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

A Model is the definition of a business object (e.g. a partner, a sale order, etc.) including fields and methods.

func CreateModel 

func CreateModel(name string, options Option) *Model

CreateModel creates a new Model with the given name and options. You should not use this function directly. Use NewModel instead.

func NewManualModel 

func NewManualModel(name string) *Model

NewManualModel creates a model whose table is not automatically generated in the database. This is particularly useful for SQL view models.

func NewMixinModel 

func NewMixinModel(name string) *Model

NewMixinModel creates a new mixin model with the given name.

func NewModel 

func NewModel(name string) *Model

NewModel creates a new model with the given name.

func NewTransientModel 

func NewTransientModel(name string) *Model

NewTransientModel creates a new mixin model with the given name.

func (*Model) AddEmptyMethod 

func (m *Model) AddEmptyMethod(methodName string) *Method

AddEmptyMethod creates a new method without function layer The resulting method cannot be called until finalize is called

func (*Model) AddFields 

func (m *Model) AddFields(fields map[string]FieldDefinition)

AddFields adds the given fields to the model.

func (*Model) AddRecordRule 

func (m *Model) AddRecordRule(rule *RecordRule)

AddRecordRule registers the given RecordRule to the registry for the given model with the given name.

func (*Model) AddSQLConstraint 

func (m *Model) AddSQLConstraint(name, sql, errorString string)

AddSQLConstraint adds a table constraint in the database.

  • name is an arbitrary name to reference this constraint. It will be appended by the table name in the database, so there is only need to ensure that it is unique in this model.
  • sql is constraint definition to pass to the database.
  • errorString is the text to display to the user when the constraint is violated

func (*Model) Browse 

func (m *Model) Browse(env Environment, ids []int64) *RecordCollection

Browse returns a new RecordSet with the records with the given ids. Note that this function is just a shorcut for Search on a list of ids.

func (*Model) BrowseOne 

func (m *Model) BrowseOne(env Environment, id int64) *RecordCollection

BrowseOne returns a new RecordSet with the record with the given id. Note that this function is just a shorcut for Search the given id.

func (*Model) Create 

func (m *Model) Create(env Environment, data interface{}) *RecordCollection

Create creates a new record in this model with the given data.

func (*Model) Field 

func (m *Model) Field(name FieldName) *ConditionField

Field starts a condition on this model

func (*Model) FieldName 

func (m *Model) FieldName(name string) FieldName

FieldName returns a FieldName for the field with the given name. name may be a dot separated path from this model. It returns nil if the name is empty and panics if the path is invalid.

func (*Model) FieldNames 

func (m *Model) FieldNames() FieldNames

FieldNames returns the slice of all field's names for this model

func (*Model) Fields 

func (m *Model) Fields() *FieldsCollection

Fields returns the fields collection of this model

func (*Model) FieldsGet 

func (m *Model) FieldsGet(fields ...FieldName) map[string]*FieldInfo

FieldsGet returns the definition of each field. The embedded fields are included.

If no fields are given, then all fields are returned.

The result map is indexed by the fields JSON names.

func (*Model) FilteredOn 

func (m *Model) FilteredOn(field FieldName, condition *Condition) *Condition

FilteredOn adds a condition with a table join on the given field and filters the result with the given condition

func (*Model) InheritModel 

func (m *Model) InheritModel(mixInModel Modeler)

InheritModel extends this Model by importing all fields and methods of mixInModel. MixIn methods and fields have a lower priority than those of the model and are overridden by the them when applicable. 

func (m *Model) IsM2MLink() bool

IsM2MLink returns true if this is an M2M Link model.

func (*Model) IsManual 

func (m *Model) IsManual() bool

IsManual returns true if this is a manual model.

func (*Model) IsMixin 

func (m *Model) IsMixin() bool

IsMixin returns true if this is a mixin model.

func (*Model) IsTransient 

func (m *Model) IsTransient() bool

IsTransient returns true if this Model is transient

func (*Model) JSONizeFieldName 

func (m *Model) JSONizeFieldName(fieldName string) string

JSONizeFieldName returns the json name of the given fieldName If fieldName is already the json name, returns it without modifying it. fieldName may be a dot separated path from this model. It panics if the path is invalid.

func (*Model) Methods 

func (m *Model) Methods() *MethodsCollection

Methods returns the methods collection of this model

func (*Model) Name 

func (m *Model) Name() string

Name returns the name of this model

func (*Model) NewMethod 

func (m *Model) NewMethod(methodName string, fnct interface{}) *Method

NewMethod is used in modules to declare a new method for this model.

func (*Model) RemoveRecordRule 

func (m *Model) RemoveRecordRule(name string)

RemoveRecordRule removes the Record Rule with the given name from the rule registry of the given model.

func (*Model) RemoveSQLConstraint 

func (m *Model) RemoveSQLConstraint(name string)

RemoveSQLConstraint removes the sql constraint with the given name from the database.

func (*Model) Search 

func (m *Model) Search(env Environment, cond Conditioner) *RecordCollection

Search searches the database and returns records matching the given condition.

func (*Model) SetDefaultOrder 

func (m *Model) SetDefaultOrder(orders ...string)

SetDefaultOrder sets the default order used by this model when no OrderBy() is specified in a query. When unspecified, default order is 'id asc'.

Give the order fields in separate strings, such as model.SetDefaultOrder("Name desc", "date asc", "id")

func (*Model) TableName 

func (m *Model) TableName() string

TableName return the db table name

func (*Model) Underlying 

func (m *Model) Underlying() *Model

Underlying returns the underlying Model data object, i.e. itself

type ModelData 

type ModelData struct {
	FieldMap
	ToCreate map[string][]*ModelData
	Model    *Model
}

A ModelData is used to hold values of an object instance for creating or updating a RecordSet. It is mainly designed to be embedded in a type-safe struct.

func NewModelData 

func NewModelData(model Modeler, fm ...FieldMap) *ModelData

NewModelData returns a pointer to a new instance of ModelData for the given model. If FieldMaps are given they are added to the ModelData.

func NewModelDataFromRS 

func NewModelDataFromRS(rs RecordSet, fm ...FieldMap) *ModelData

NewModelDataFromRS creates a pointer to a new instance of ModelData. If FieldMaps are given they are added to the ModelData.

Unlike NewModelData, this method translates relation fields in64 and []int64 values as RecordSets

func (*ModelData) Copy 

func (md *ModelData) Copy() *ModelData

Copy returns a copy of this ModelData

func (*ModelData) Create 

func (md *ModelData) Create(field FieldName, related *ModelData) *ModelData

Create stores the related ModelData to be used to create a related record on the fly and link it to this field.

This method can be called multiple times to create multiple records

func (*ModelData) FieldNames 

func (md *ModelData) FieldNames() FieldNames

FieldNames returns the ModelData keys as a slice of FieldNames.

func (*ModelData) Get 

func (md *ModelData) Get(field FieldName) interface{}

Get returns the value of the given field.

The field can be either its name or is JSON name.

func (*ModelData) Has 

func (md *ModelData) Has(field FieldName) bool

Has returns true if this ModelData has values for the given field.

The field can be either its name or is JSON name.

func (*ModelData) MarshalJSON 

func (md *ModelData) MarshalJSON() ([]byte, error)

MarshalJSON function for ModelData. Returns the FieldMap.

func (*ModelData) MergeWith 

func (md *ModelData) MergeWith(other *ModelData)

MergeWith updates this ModelData with the given other ModelData. If a key of the other ModelData already exists here, the value is overridden, otherwise, the key is inserted with its json name.

func (*ModelData) Scan 

func (md *ModelData) Scan(src interface{}) error

Scan implements sql.Scanner

func (*ModelData) Set 

func (md *ModelData) Set(field FieldName, value interface{}) *ModelData

Set sets the given field with the given value. If the field already exists, then it is updated with value. Otherwise, a new entry is inserted.

It returns the given ModelData so that calls can be chained

func (*ModelData) Underlying 

func (md *ModelData) Underlying() *ModelData

Underlying returns the ModelData

func (*ModelData) Unset 

func (md *ModelData) Unset(field FieldName) *ModelData

Unset removes the value of the given field if it exists.

It returns the given ModelData so that calls can be chained

func (ModelData) Wrap 

func (md ModelData) Wrap() interface{}

Wrap returns the given ModelData embedded into a RecordSet Wrapper type. This method returns a pointer.

type Modeler 

type Modeler interface {
	Underlying() *Model
}

A Modeler can return a Model data object through its Underlying() method

type OnDeleteAction 

type OnDeleteAction string

An OnDeleteAction defines what to be done with this record when the target record is deleted. 

const (
	// SetNull sets the foreign key to null in referencing records. This is the default
	SetNull OnDeleteAction = "set null"
	// Restrict throws an error if there are record referencing the deleted one.
	Restrict OnDeleteAction = "restrict"
	// Cascade deletes all referencing records.
	Cascade OnDeleteAction = "cascade"
)

type OnchangeParams 

type OnchangeParams struct {
	Values   RecordData        `json:"values"`
	Fields   FieldNames        `json:"field_name"`
	Onchange map[string]string `json:"field_onchange"`
}

OnchangeParams is the args struct of the Onchange function

type OnchangeResult 

type OnchangeResult struct {
	Value   RecordData                `json:"value"`
	Warning string                    `json:"warning"`
	Filters map[FieldName]Conditioner `json:"domain"`
}

OnchangeResult is the result struct type of the Onchange function

type Option 

type Option int

Option describes a optional feature of a model 

const (
	// TransientModel means that the records of this model will be automatically
	// removed periodically. Transient models are mainly used for wizards.
	TransientModel Option = 1 << iota
	// MixinModel means that this model will not be accessible like a regular model
	// but is meant to be mixed in other models.
	MixinModel
	// Many2ManyLinkModel is a model that abstracts the link
	// table of a many2many relationship
	Many2ManyLinkModel
	// ContextsModel is a model for holding fields values that depend on contexts
	ContextsModel
	// ManualModel is a model whose table is not automatically generated in the
	// database. Such models include SQL views and materialized SQL views.
	ManualModel
	// SystemModel is a model that is used internally by the Hexya Framework
	SystemModel
)

type Query 

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

A Query defines the common part an SQL Query, i.e. all that come after the FROM keyword.

type RecordCollection 

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

RecordCollection is a generic struct representing several records of a model.

func InvalidRecordCollection 

func InvalidRecordCollection(modelName string) *RecordCollection

InvalidRecordCollection returns an invalid RecordCollection without an environment.

You should really not use this function, but use env.Pool("ModelName") instead.

func (*RecordCollection) Aggregates 

func (rc *RecordCollection) Aggregates(fieldNames ...FieldName) []GroupAggregateRow

Aggregates returns the result of this RecordCollection query, which must by a grouped query.

func (*RecordCollection) All 

func (rc *RecordCollection) All() []*ModelData

All returns the values of all records of the RecordCollection as a slice of ModelData.

func (*RecordCollection) Call 

func (rc *RecordCollection) Call(methName string, args ...interface{}) interface{}

Call calls the given method name methName on the given RecordCollection with the given arguments and returns (only) the first result as interface{}.

func (*RecordCollection) CallMulti 

func (rc *RecordCollection) CallMulti(methName string, args ...interface{}) []interface{}

CallMulti calls the given method name methName on the given RecordCollection with the given arguments and return the result as []interface{}.

func (*RecordCollection) CartesianProduct 

func (rc *RecordCollection) CartesianProduct(records ...RecordSet) []*RecordCollection

CartesianProduct returns the cartesian product of this RecordCollection with others.

This function panics if all records are not pf the same model

func (*RecordCollection) CheckConstraints 

func (rc *RecordCollection) CheckConstraints(fields FieldNames)

CheckConstraints executes the constraint method for each field defined in the given FieldNames. Each method is only executed once, even if it is called by several fields. It panics as soon as one constraint fails.

func (*RecordCollection) CheckExecutionPermission 

func (rc *RecordCollection) CheckExecutionPermission(method *Method, dontPanic ...bool) bool

CheckExecutionPermission panics if the current user is not allowed to execute the given method.

If dontPanic is false, this function will panic, otherwise it returns true if the user has the execution permission and false otherwise.

func (*RecordCollection) Collection 

func (rc *RecordCollection) Collection() *RecordCollection

Collection returns the underlying RecordCollection instance i.e. itself

func (*RecordCollection) Condition 

func (rc *RecordCollection) Condition() *Condition

Condition returns the query condition associated with this RecordSet.

func (*RecordCollection) EnsureOne 

func (rc *RecordCollection) EnsureOne()

EnsureOne panics if rc is not a singleton

func (*RecordCollection) Env 

func (rc *RecordCollection) Env() Environment

Env returns the RecordSet's Environment

func (*RecordCollection) Equals 

func (rc *RecordCollection) Equals(other RecordSet) bool

Equals returns true if this RecordCollection is the same as other i.e. they are of the same model and have the same ids

func (*RecordCollection) Fetch 

func (rc *RecordCollection) Fetch() *RecordCollection

Fetch query the database with the current filter and returns a RecordSet with the queries ids.

Fetch is lazy and only return ids. Use Load() instead if you want to fetch all fields.

func (*RecordCollection) Filtered 

func (rc *RecordCollection) Filtered(test func(rs RecordSet) bool) *RecordCollection

Filtered returns a new record set with only the elements of this record set for which test is true.

Note that if this record set is not fully loaded, this function will call the database to load the fields before doing the filtering. In this case, it might be more efficient to search the database directly with the filter condition.

func (*RecordCollection) First 

func (rc *RecordCollection) First() *ModelData

First returns the values of the first Record of the RecordCollection as a ModelData.

If this RecordCollection is empty, it returns an empty ModelData.

func (*RecordCollection) ForceLoad 

func (rc *RecordCollection) ForceLoad(fieldNames ...FieldName) *RecordCollection

ForceLoad query all data of the RecordCollection and store in cache. fields are the fields to retrieve in the path format, i.e. "User.Profile.Age" or "user_id.profile_id.age".

If no fields are given, all DB columns of the RecordCollection's model are retrieved as well as related fields. Non-DB fields must be explicitly given in fields to be retrieved.

func (*RecordCollection) Get 

func (rc *RecordCollection) Get(fieldName FieldName) interface{}

Get returns the value of the given fieldName for the first record of this RecordCollection. It returns the type's zero value if the RecordCollection is empty.

func (*RecordCollection) GetRecord 

func (rc *RecordCollection) GetRecord(externalID string) *RecordCollection

GetRecord returns the Recordset with the given externalID. It panics if the externalID does not exist.

func (*RecordCollection) GroupBy 

func (rc *RecordCollection) GroupBy(fields ...FieldName) *RecordCollection

GroupBy returns a new RecordSet grouped with the given GROUP BY expressions

func (*RecordCollection) Ids 

func (rc *RecordCollection) Ids() []int64

Ids returns the ids of the RecordSet, fetching from db if necessary.

func (*RecordCollection) Intersect 

func (rc *RecordCollection) Intersect(other RecordSet) *RecordCollection

Intersect returns a new RecordCollection with only the records that are both in this RecordCollection and in the other RecordSet.

func (*RecordCollection) InvalidateCache 

func (rc *RecordCollection) InvalidateCache()

InvalidateCache clears the cache for this RecordSet data, and immediately reloads the data from the DB.

func (*RecordCollection) IsEmpty 

func (rc *RecordCollection) IsEmpty() bool

IsEmpty returns true if rc is an empty RecordCollection

func (*RecordCollection) IsNotEmpty 

func (rc *RecordCollection) IsNotEmpty() bool

IsNotEmpty returns true if rc is not an empty RecordCollection

func (*RecordCollection) IsValid 

func (rc *RecordCollection) IsValid() bool

IsValid returns true if this RecordSet has been initialized.

func (*RecordCollection) Len 

func (rc *RecordCollection) Len() int

Len returns the number of records in this RecordCollection

func (*RecordCollection) Limit 

func (rc *RecordCollection) Limit(limit int) *RecordCollection

Limit returns a new RecordSet with only the first 'limit' records.

func (*RecordCollection) Load 

func (rc *RecordCollection) Load(fields ...FieldName) *RecordCollection

Load look up fields of the RecordCollection in cache and query the database for missing values which are then stored in cache.

func (*RecordCollection) MethodType 

func (rc *RecordCollection) MethodType(methName string) reflect.Type

MethodType returns the type of the method given by methName

func (*RecordCollection) Model 

func (rc *RecordCollection) Model() *Model

Model returns the Model instance of this RecordCollection

func (*RecordCollection) ModelName 

func (rc *RecordCollection) ModelName() string

ModelName returns the model name of the RecordSet

func (*RecordCollection) Offset 

func (rc *RecordCollection) Offset(offset int) *RecordCollection

Offset returns a new RecordSet with only the records starting at offset

func (*RecordCollection) OrderBy 

func (rc *RecordCollection) OrderBy(exprs ...string) *RecordCollection

OrderBy returns a new RecordSet ordered by the given ORDER BY expressions

func (*RecordCollection) Records 

func (rc *RecordCollection) Records() []*RecordCollection

Records returns the slice of RecordCollection singletons that constitute this RecordCollection.

func (*RecordCollection) SQLFromCondition 

func (rc *RecordCollection) SQLFromCondition(c *Condition) (string, SQLParams)

SQLFromCondition returns the WHERE clause sql and arguments corresponding to the given condition.

func (*RecordCollection) Scan 

func (rc *RecordCollection) Scan(src interface{}) error

Scan implements sql.Scanner

func (*RecordCollection) Search 

func (rc *RecordCollection) Search(cond *Condition) *RecordCollection

Search returns a new RecordSet filtering on the current one with the additional given Condition

func (*RecordCollection) SearchAll 

func (rc *RecordCollection) SearchAll() *RecordCollection

SearchAll returns a new RecordSet with all items of the table, regardless of the current RecordSet query. It is mainly meant to be used on an empty RecordSet

func (*RecordCollection) SearchCount 

func (rc *RecordCollection) SearchCount() int

SearchCount fetch from the database the number of records that match the RecordSet conditions It panics in case of error

func (*RecordCollection) Set 

func (rc *RecordCollection) Set(fieldName FieldName, value interface{})

Set sets field given by fieldName to the given value. If the RecordSet has several Records, all of them will be updated. Each call to Set makes an update query in the database. It panics if it is called on an empty RecordSet.

func (*RecordCollection) Sorted 

func (rc *RecordCollection) Sorted(less func(rs1 RecordSet, rs2 RecordSet) bool) *RecordCollection

Sorted returns a new RecordCollection sorted according to the given less function.

The less function should return true if rs1 < rs2

func (*RecordCollection) SortedByField 

func (rc *RecordCollection) SortedByField(name FieldName, reverse bool) *RecordCollection

SortedByField returns a new record set with the same records as rc but sorted by the given field. If reverse is true, the sort is done in reversed order

func (*RecordCollection) SortedDefault 

func (rc *RecordCollection) SortedDefault() *RecordCollection

SortedDefault returns a new record set with the same records as rc but sorted according to the default order of this model

func (*RecordCollection) String 

func (rc *RecordCollection) String() string

String returns the string representation of a RecordSet

func (*RecordCollection) Subtract 

func (rc *RecordCollection) Subtract(other RecordSet) *RecordCollection

Subtract returns a RecordSet with the Records that are in this RecordCollection but not in the given 'other' one. The result is guaranteed to be a set of unique records.

func (*RecordCollection) Sudo 

func (rc *RecordCollection) Sudo(userId ...int64) *RecordCollection

Sudo returns a new RecordCollection with the given userId or the superuser id if not specified

func (*RecordCollection) Super 

func (rc *RecordCollection) Super() *RecordCollection

Super returns a RecordSet with a modified callstack so that call to the current method will execute the next method layer.

This method is meant to be used inside a method layer function to call its parent, such as: 

func (rs models.RecordCollection) MyMethod() string {
    res := rs.Super().MyMethod()
    res += " ok!"
    return res
}

Calls to a different method than the current method will call its next layer only if the current method has been called from a layer of the other method. Otherwise, it will be the same as calling the other method directly.

func (*RecordCollection) T 

func (rc *RecordCollection) T(src string, args ...interface{}) string

T translates the given string to the language specified by the 'lang' key of rc.Env().Context(). If for any reason the string cannot be translated, then src is returned.

You MUST pass a string literal as src to have it extracted automatically

The translated string will be passed to fmt.Sprintf with the optional args before being returned.

func (*RecordCollection) Union 

func (rc *RecordCollection) Union(other RecordSet) *RecordCollection

Union returns a new RecordCollection that is the union of this RecordCollection and the given `other` RecordCollection. The result is guaranteed to be a set of unique records. The order of the records is kept.

func (*RecordCollection) WithContext 

func (rc *RecordCollection) WithContext(key string, value interface{}) *RecordCollection

WithContext returns a copy of the current RecordCollection with its context extended by the given key and value.

func (*RecordCollection) WithEnv 

func (rc *RecordCollection) WithEnv(env Environment) *RecordCollection

WithEnv returns a copy of the current RecordCollection with the given Environment.

func (*RecordCollection) WithNewContext 

func (rc *RecordCollection) WithNewContext(context *types.Context) *RecordCollection

WithNewContext returns a copy of the current RecordCollection with its context replaced by the given one.

func (*RecordCollection) Wrap 

func (rc *RecordCollection) Wrap(modelName ...string) interface{}

Wrap returns the given RecordCollection embedded into a RecordSet Wrapper type

If modelName is defined, wrap in a modelName Wrapper type instead (use for mixins).

type RecordData 

type RecordData interface {
	sql.Scanner
	Underlying() *ModelData
}

A RecordData can return a ModelData object through its Underlying() method

type RecordRef 

type RecordRef struct {
	ModelName string
	ID        int64
}

A RecordRef uniquely identifies a Record by giving its model and ID.

type RecordRule 

type RecordRule struct {
	Name      string
	Global    bool
	Group     *security.Group
	Condition *Condition
	Perms     security.Permission
}

A RecordRule allow to grant a group some permissions on a selection of records. - If Global is true, then the RecordRule applies to all groups - Condition is the filter to apply on the model to retrieve the records on which to allow the Perms permission.

type RecordSet 

type RecordSet interface {
	sql.Scanner
	fmt.Stringer
	// ModelName returns the name of the model of this RecordSet
	ModelName() string
	// Ids returns the ids in this set of Records
	Ids() []int64
	// Env returns the current Environment of this RecordSet
	Env() Environment
	// Len returns the number of records in this RecordSet
	Len() int
	// IsValid returns true if this RecordSet has been initialized.
	IsValid() bool
	// IsEmpty returns true if this RecordSet has no records
	IsEmpty() bool
	// IsNotEmpty returns true if this RecordSet has at least one record
	IsNotEmpty() bool
	// Call executes the given method (as string) with the given arguments
	Call(string, ...interface{}) interface{}
	// Collection returns the underlying RecordCollection instance
	Collection() *RecordCollection
	// Get returns the value of the given fieldName for the first record of this RecordCollection.
	// It returns the type's zero value if the RecordCollection is empty.
	Get(FieldName) interface{}
	// Set sets field given by fieldName to the given value. If the RecordSet has several
	// Records, all of them will be updated. Each call to Set makes an update query in the
	// database. It panics if it is called on an empty RecordSet.
	Set(FieldName, interface{})
	// T translates the given string to the language specified by
	// the 'lang' key of rc.Env().Context(). If for any reason the
	// string cannot be translated, then src is returned.
	//
	// You MUST pass a string literal as src to have it extracted automatically (and not a variable)
	//
	// The translated string will be passed to fmt.Sprintf with the optional args
	// before being returned.
	T(string, ...interface{}) string
	// EnsureOne panics if this Recordset is not a singleton
	EnsureOne()
}

RecordSet identifies a type that holds a set of records of a given model.

type SQLParams 

type SQLParams []interface{}

An SQLParams is a list of parameters that are passed to the DB server with the query string and that will be used in the placeholders.

func (SQLParams) Extend 

func (p SQLParams) Extend(p2 SQLParams) SQLParams

Extend returns a new SQLParams with both params of this SQLParams and of p2 SQLParams.

type Sequence 

type Sequence struct {
	JSON      string
	Increment int64
	Start     int64
	// contains filtered or unexported fields
}

A Sequence holds the metadata of a DB sequence

There are two types of sequences: those created before bootstrap and those created after. The former will be created and updated at bootstrap and cannot be modified afterwards. The latter will be created, updated or dropped immediately.

func CreateSequence 

func CreateSequence(name string, increment, start int64) *Sequence

CreateSequence creates a new Sequence in the database and returns a pointer to it

func (*Sequence) Alter 

func (s *Sequence) Alter(increment, restart int64)

Alter alters this sequence by changing next number and/or increment. Set a parameter to 0 to leave it unchanged.

func (*Sequence) Drop 

func (s *Sequence) Drop()

Drop this sequence and removes it from the database

func (*Sequence) NextValue 

func (s *Sequence) NextValue() int64

NextValue returns the next value of this Sequence

type WorkerFunction 

type WorkerFunction interface {
	// Run the worker function
	Run()
	// LoopPeriod is the time between each run of the worker function
	LoopPeriod() time.Duration
}

A WorkerFunction can be executed in a loop in background every given LoopPeriod.

func NewWorkerFunction 

func NewWorkerFunction(fnct func(), period time.Duration) WorkerFunction

NewWorkerFunction returns a WorkerFunction from the given fnct and period

Source Files

View all Source files

Directories

Path Synopsis
dates

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.