diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..5c6ddc4 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,16 @@ +{ + // Use IntelliSense to learn about possible attributes. + // Hover to view descriptions of existing attributes. + // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "Launch Package", + "type": "go", + "request": "launch", + "mode": "auto", + "program": "${fileDirname}", + "envFile": "/home/kocoder/src/js/golang/.env" + } + ] +} \ No newline at end of file diff --git a/cmd/api/main.go b/cmd/api/main.go index 15a6932..8867bf0 100644 --- a/cmd/api/main.go +++ b/cmd/api/main.go @@ -5,6 +5,7 @@ import ( "log" "log/slog" "os" + "time" "git.kocoder.xyz/kocoded/vt/routers" "git.kocoder.xyz/kocoded/vt/utils" @@ -14,7 +15,6 @@ import ( ) func main() { - logger := slog.New(slog.NewTextHandler(os.Stdout, nil)) err := godotenv.Load() @@ -23,8 +23,12 @@ func main() { } db := utils.SetupDatabase(os.Getenv("DB_DSN"), logger) + cache, ok := utils.SetupCache(os.Getenv("VALKEY_HOST"), os.Getenv("VALKEY_PORT"), os.Getenv("VALKEY_USER"), os.Getenv("VALKEY_PASS")) + if !ok { + logger.Error("Configuring and connecting to Valkey failed!") + } - appCtx := utils.Application{Logger: logger, DB: db} + appCtx := utils.Application{Logger: logger, DB: db, Client: cache} app := fiber.New() @@ -35,6 +39,8 @@ func main() { routers.RegisterMandantRouter(app.Group("/v1/mandant"), appCtx) routers.RegisterAnsprechpartnerRouter(app.Group("/v1/ansprechpartner"), appCtx) routers.RegisterFirmaRouter(app.Group("/v1/firma"), appCtx) + routers.RegisterProjectRouter(app.Group("/v1/projects"), appCtx) + routers.RegisterUserRouter(app.Group("/v1/users"), appCtx) app.Use("/ws", func(c *fiber.Ctx) error { if websocket.IsWebSocketUpgrade(c) { @@ -44,30 +50,13 @@ func main() { return fiber.ErrUpgradeRequired }) - app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) { - log.Println(c.Locals("allowed")) // true - log.Println(c.Params("id")) // 123 - log.Println(c.Query("v")) // 1.0 - log.Println(c.Cookies("session")) // "" + app.Get("/ws", websocket.New(func(c *websocket.Conn) { + go func() { + time.Sleep(time.Second) + }() - var ( - mt int - msg []byte - err error - ) - for { - if mt, msg, err = c.ReadMessage(); err != nil { - slog.Info("read", "error", err) - break - } + utils.MessageBus.AddConn(1, c) - slog.Info("recv:", "messageType", mt, "bytes", msg) - - if err = c.WriteMessage(mt, msg); err != nil { - slog.Info("write", "error", err) - break - } - } })) log.Fatalln(app.Listen(":3000")) diff --git a/cmd/api/query/ansprechpartners.gen.go b/cmd/api/query/ansprechpartners.gen.go new file mode 100644 index 0000000..ba155b4 --- /dev/null +++ b/cmd/api/query/ansprechpartners.gen.go @@ -0,0 +1,562 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) ansprechpartner { + _ansprechpartner := ansprechpartner{} + + _ansprechpartner.ansprechpartnerDo.UseDB(db, opts...) + _ansprechpartner.ansprechpartnerDo.UseModel(&model.Ansprechpartner{}) + + tableName := _ansprechpartner.ansprechpartnerDo.TableName() + _ansprechpartner.ALL = field.NewAsterisk(tableName) + _ansprechpartner.ID = field.NewUint(tableName, "id") + _ansprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _ansprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _ansprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _ansprechpartner.ImageURL = field.NewString(tableName, "image_url") + _ansprechpartner.Title = field.NewString(tableName, "title") + _ansprechpartner.FirstName = field.NewString(tableName, "first_name") + _ansprechpartner.LastName = field.NewString(tableName, "last_name") + _ansprechpartner.LastTitle = field.NewString(tableName, "last_title") + _ansprechpartner.EMail = field.NewString(tableName, "e_mail") + _ansprechpartner.Phone = field.NewString(tableName, "phone") + _ansprechpartner.Mobile = field.NewString(tableName, "mobile") + _ansprechpartner.Notes = field.NewString(tableName, "notes") + _ansprechpartner.Description = field.NewString(tableName, "description") + _ansprechpartner.Active = field.NewBool(tableName, "active") + _ansprechpartner.Gender = field.NewInt(tableName, "gender") + _ansprechpartner.Firmen = ansprechpartnerManyToManyFirmen{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Firmen", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _ansprechpartner.fillFieldMap() + + return _ansprechpartner +} + +type ansprechpartner struct { + ansprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + ImageURL field.String + Title field.String + FirstName field.String + LastName field.String + LastTitle field.String + EMail field.String + Phone field.String + Mobile field.String + Notes field.String + Description field.String + Active field.Bool + Gender field.Int + Firmen ansprechpartnerManyToManyFirmen + + fieldMap map[string]field.Expr +} + +func (a ansprechpartner) Table(newTableName string) *ansprechpartner { + a.ansprechpartnerDo.UseTable(newTableName) + return a.updateTableName(newTableName) +} + +func (a ansprechpartner) As(alias string) *ansprechpartner { + a.ansprechpartnerDo.DO = *(a.ansprechpartnerDo.As(alias).(*gen.DO)) + return a.updateTableName(alias) +} + +func (a *ansprechpartner) updateTableName(table string) *ansprechpartner { + a.ALL = field.NewAsterisk(table) + a.ID = field.NewUint(table, "id") + a.CreatedAt = field.NewTime(table, "created_at") + a.UpdatedAt = field.NewTime(table, "updated_at") + a.DeletedAt = field.NewField(table, "deleted_at") + a.ImageURL = field.NewString(table, "image_url") + a.Title = field.NewString(table, "title") + a.FirstName = field.NewString(table, "first_name") + a.LastName = field.NewString(table, "last_name") + a.LastTitle = field.NewString(table, "last_title") + a.EMail = field.NewString(table, "e_mail") + a.Phone = field.NewString(table, "phone") + a.Mobile = field.NewString(table, "mobile") + a.Notes = field.NewString(table, "notes") + a.Description = field.NewString(table, "description") + a.Active = field.NewBool(table, "active") + a.Gender = field.NewInt(table, "gender") + + a.fillFieldMap() + + return a +} + +func (a *ansprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := a.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (a *ansprechpartner) fillFieldMap() { + a.fieldMap = make(map[string]field.Expr, 17) + a.fieldMap["id"] = a.ID + a.fieldMap["created_at"] = a.CreatedAt + a.fieldMap["updated_at"] = a.UpdatedAt + a.fieldMap["deleted_at"] = a.DeletedAt + a.fieldMap["image_url"] = a.ImageURL + a.fieldMap["title"] = a.Title + a.fieldMap["first_name"] = a.FirstName + a.fieldMap["last_name"] = a.LastName + a.fieldMap["last_title"] = a.LastTitle + a.fieldMap["e_mail"] = a.EMail + a.fieldMap["phone"] = a.Phone + a.fieldMap["mobile"] = a.Mobile + a.fieldMap["notes"] = a.Notes + a.fieldMap["description"] = a.Description + a.fieldMap["active"] = a.Active + a.fieldMap["gender"] = a.Gender + +} + +func (a ansprechpartner) clone(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + a.Firmen.db = db.Session(&gorm.Session{Initialized: true}) + a.Firmen.db.Statement.ConnPool = db.Statement.ConnPool + return a +} + +func (a ansprechpartner) replaceDB(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceDB(db) + a.Firmen.db = db.Session(&gorm.Session{}) + return a +} + +type ansprechpartnerManyToManyFirmen struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a ansprechpartnerManyToManyFirmen) Where(conds ...field.Expr) *ansprechpartnerManyToManyFirmen { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) WithContext(ctx context.Context) *ansprechpartnerManyToManyFirmen { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Session(session *gorm.Session) *ansprechpartnerManyToManyFirmen { + a.db = a.db.Session(session) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Model(m *model.Ansprechpartner) *ansprechpartnerManyToManyFirmenTx { + return &ansprechpartnerManyToManyFirmenTx{a.db.Model(m).Association(a.Name())} +} + +func (a ansprechpartnerManyToManyFirmen) Unscoped() *ansprechpartnerManyToManyFirmen { + a.db = a.db.Unscoped() + return &a +} + +type ansprechpartnerManyToManyFirmenTx struct{ tx *gorm.Association } + +func (a ansprechpartnerManyToManyFirmenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a ansprechpartnerManyToManyFirmenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Clear() error { + return a.tx.Clear() +} + +func (a ansprechpartnerManyToManyFirmenTx) Count() int64 { + return a.tx.Count() +} + +func (a ansprechpartnerManyToManyFirmenTx) Unscoped() *ansprechpartnerManyToManyFirmenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type ansprechpartnerDo struct{ gen.DO } + +type IAnsprechpartnerDo interface { + gen.SubQuery + Debug() IAnsprechpartnerDo + WithContext(ctx context.Context) IAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IAnsprechpartnerDo + WriteDB() IAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IAnsprechpartnerDo + Not(conds ...gen.Condition) IAnsprechpartnerDo + Or(conds ...gen.Condition) IAnsprechpartnerDo + Select(conds ...field.Expr) IAnsprechpartnerDo + Where(conds ...gen.Condition) IAnsprechpartnerDo + Order(conds ...field.Expr) IAnsprechpartnerDo + Distinct(cols ...field.Expr) IAnsprechpartnerDo + Omit(cols ...field.Expr) IAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + Group(cols ...field.Expr) IAnsprechpartnerDo + Having(conds ...gen.Condition) IAnsprechpartnerDo + Limit(limit int) IAnsprechpartnerDo + Offset(offset int) IAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo + Unscoped() IAnsprechpartnerDo + Create(values ...*model.Ansprechpartner) error + CreateInBatches(values []*model.Ansprechpartner, batchSize int) error + Save(values ...*model.Ansprechpartner) error + First() (*model.Ansprechpartner, error) + Take() (*model.Ansprechpartner, error) + Last() (*model.Ansprechpartner, error) + Find() ([]*model.Ansprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) + FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Ansprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo + Joins(fields ...field.RelationField) IAnsprechpartnerDo + Preload(fields ...field.RelationField) IAnsprechpartnerDo + FirstOrInit() (*model.Ansprechpartner, error) + FirstOrCreate() (*model.Ansprechpartner, error) + FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (a ansprechpartnerDo) Debug() IAnsprechpartnerDo { + return a.withDO(a.DO.Debug()) +} + +func (a ansprechpartnerDo) WithContext(ctx context.Context) IAnsprechpartnerDo { + return a.withDO(a.DO.WithContext(ctx)) +} + +func (a ansprechpartnerDo) ReadDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Read) +} + +func (a ansprechpartnerDo) WriteDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Write) +} + +func (a ansprechpartnerDo) Session(config *gorm.Session) IAnsprechpartnerDo { + return a.withDO(a.DO.Session(config)) +} + +func (a ansprechpartnerDo) Clauses(conds ...clause.Expression) IAnsprechpartnerDo { + return a.withDO(a.DO.Clauses(conds...)) +} + +func (a ansprechpartnerDo) Returning(value interface{}, columns ...string) IAnsprechpartnerDo { + return a.withDO(a.DO.Returning(value, columns...)) +} + +func (a ansprechpartnerDo) Not(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Not(conds...)) +} + +func (a ansprechpartnerDo) Or(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Or(conds...)) +} + +func (a ansprechpartnerDo) Select(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Select(conds...)) +} + +func (a ansprechpartnerDo) Where(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Where(conds...)) +} + +func (a ansprechpartnerDo) Order(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Order(conds...)) +} + +func (a ansprechpartnerDo) Distinct(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Distinct(cols...)) +} + +func (a ansprechpartnerDo) Omit(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Omit(cols...)) +} + +func (a ansprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Join(table, on...)) +} + +func (a ansprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.LeftJoin(table, on...)) +} + +func (a ansprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.RightJoin(table, on...)) +} + +func (a ansprechpartnerDo) Group(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Group(cols...)) +} + +func (a ansprechpartnerDo) Having(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Having(conds...)) +} + +func (a ansprechpartnerDo) Limit(limit int) IAnsprechpartnerDo { + return a.withDO(a.DO.Limit(limit)) +} + +func (a ansprechpartnerDo) Offset(offset int) IAnsprechpartnerDo { + return a.withDO(a.DO.Offset(offset)) +} + +func (a ansprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo { + return a.withDO(a.DO.Scopes(funcs...)) +} + +func (a ansprechpartnerDo) Unscoped() IAnsprechpartnerDo { + return a.withDO(a.DO.Unscoped()) +} + +func (a ansprechpartnerDo) Create(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Create(values) +} + +func (a ansprechpartnerDo) CreateInBatches(values []*model.Ansprechpartner, batchSize int) error { + return a.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (a ansprechpartnerDo) Save(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Save(values) +} + +func (a ansprechpartnerDo) First() (*model.Ansprechpartner, error) { + if result, err := a.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Take() (*model.Ansprechpartner, error) { + if result, err := a.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Last() (*model.Ansprechpartner, error) { + if result, err := a.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Find() ([]*model.Ansprechpartner, error) { + result, err := a.DO.Find() + return result.([]*model.Ansprechpartner), err +} + +func (a ansprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) { + buf := make([]*model.Ansprechpartner, 0, batchSize) + err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (a ansprechpartnerDo) FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return a.DO.FindInBatches(result, batchSize, fc) +} + +func (a ansprechpartnerDo) Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Attrs(attrs...)) +} + +func (a ansprechpartnerDo) Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Assign(attrs...)) +} + +func (a ansprechpartnerDo) Joins(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Joins(_f)) + } + return &a +} + +func (a ansprechpartnerDo) Preload(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Preload(_f)) + } + return &a +} + +func (a ansprechpartnerDo) FirstOrInit() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FirstOrCreate() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) { + result, err = a.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = a.Offset(-1).Limit(-1).Count() + return +} + +func (a ansprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = a.Count() + if err != nil { + return + } + + err = a.Offset(offset).Limit(limit).Scan(result) + return +} + +func (a ansprechpartnerDo) Scan(result interface{}) (err error) { + return a.DO.Scan(result) +} + +func (a ansprechpartnerDo) Delete(models ...*model.Ansprechpartner) (result gen.ResultInfo, err error) { + return a.DO.Delete(models) +} + +func (a *ansprechpartnerDo) withDO(do gen.Dao) *ansprechpartnerDo { + a.DO = *do.(*gen.DO) + return a +} diff --git a/cmd/api/query/dokuments.gen.go b/cmd/api/query/dokuments.gen.go new file mode 100644 index 0000000..ac04910 --- /dev/null +++ b/cmd/api/query/dokuments.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newDokument(db *gorm.DB, opts ...gen.DOOption) dokument { + _dokument := dokument{} + + _dokument.dokumentDo.UseDB(db, opts...) + _dokument.dokumentDo.UseModel(&model.Dokument{}) + + tableName := _dokument.dokumentDo.TableName() + _dokument.ALL = field.NewAsterisk(tableName) + _dokument.ID = field.NewUint(tableName, "id") + _dokument.CreatedAt = field.NewTime(tableName, "created_at") + _dokument.UpdatedAt = field.NewTime(tableName, "updated_at") + _dokument.DeletedAt = field.NewField(tableName, "deleted_at") + + _dokument.fillFieldMap() + + return _dokument +} + +type dokument struct { + dokumentDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (d dokument) Table(newTableName string) *dokument { + d.dokumentDo.UseTable(newTableName) + return d.updateTableName(newTableName) +} + +func (d dokument) As(alias string) *dokument { + d.dokumentDo.DO = *(d.dokumentDo.As(alias).(*gen.DO)) + return d.updateTableName(alias) +} + +func (d *dokument) updateTableName(table string) *dokument { + d.ALL = field.NewAsterisk(table) + d.ID = field.NewUint(table, "id") + d.CreatedAt = field.NewTime(table, "created_at") + d.UpdatedAt = field.NewTime(table, "updated_at") + d.DeletedAt = field.NewField(table, "deleted_at") + + d.fillFieldMap() + + return d +} + +func (d *dokument) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := d.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (d *dokument) fillFieldMap() { + d.fieldMap = make(map[string]field.Expr, 4) + d.fieldMap["id"] = d.ID + d.fieldMap["created_at"] = d.CreatedAt + d.fieldMap["updated_at"] = d.UpdatedAt + d.fieldMap["deleted_at"] = d.DeletedAt +} + +func (d dokument) clone(db *gorm.DB) dokument { + d.dokumentDo.ReplaceConnPool(db.Statement.ConnPool) + return d +} + +func (d dokument) replaceDB(db *gorm.DB) dokument { + d.dokumentDo.ReplaceDB(db) + return d +} + +type dokumentDo struct{ gen.DO } + +type IDokumentDo interface { + gen.SubQuery + Debug() IDokumentDo + WithContext(ctx context.Context) IDokumentDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IDokumentDo + WriteDB() IDokumentDo + As(alias string) gen.Dao + Session(config *gorm.Session) IDokumentDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IDokumentDo + Not(conds ...gen.Condition) IDokumentDo + Or(conds ...gen.Condition) IDokumentDo + Select(conds ...field.Expr) IDokumentDo + Where(conds ...gen.Condition) IDokumentDo + Order(conds ...field.Expr) IDokumentDo + Distinct(cols ...field.Expr) IDokumentDo + Omit(cols ...field.Expr) IDokumentDo + Join(table schema.Tabler, on ...field.Expr) IDokumentDo + LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + Group(cols ...field.Expr) IDokumentDo + Having(conds ...gen.Condition) IDokumentDo + Limit(limit int) IDokumentDo + Offset(offset int) IDokumentDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo + Unscoped() IDokumentDo + Create(values ...*model.Dokument) error + CreateInBatches(values []*model.Dokument, batchSize int) error + Save(values ...*model.Dokument) error + First() (*model.Dokument, error) + Take() (*model.Dokument, error) + Last() (*model.Dokument, error) + Find() ([]*model.Dokument, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) + FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Dokument) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IDokumentDo + Assign(attrs ...field.AssignExpr) IDokumentDo + Joins(fields ...field.RelationField) IDokumentDo + Preload(fields ...field.RelationField) IDokumentDo + FirstOrInit() (*model.Dokument, error) + FirstOrCreate() (*model.Dokument, error) + FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IDokumentDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (d dokumentDo) Debug() IDokumentDo { + return d.withDO(d.DO.Debug()) +} + +func (d dokumentDo) WithContext(ctx context.Context) IDokumentDo { + return d.withDO(d.DO.WithContext(ctx)) +} + +func (d dokumentDo) ReadDB() IDokumentDo { + return d.Clauses(dbresolver.Read) +} + +func (d dokumentDo) WriteDB() IDokumentDo { + return d.Clauses(dbresolver.Write) +} + +func (d dokumentDo) Session(config *gorm.Session) IDokumentDo { + return d.withDO(d.DO.Session(config)) +} + +func (d dokumentDo) Clauses(conds ...clause.Expression) IDokumentDo { + return d.withDO(d.DO.Clauses(conds...)) +} + +func (d dokumentDo) Returning(value interface{}, columns ...string) IDokumentDo { + return d.withDO(d.DO.Returning(value, columns...)) +} + +func (d dokumentDo) Not(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Not(conds...)) +} + +func (d dokumentDo) Or(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Or(conds...)) +} + +func (d dokumentDo) Select(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Select(conds...)) +} + +func (d dokumentDo) Where(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Where(conds...)) +} + +func (d dokumentDo) Order(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Order(conds...)) +} + +func (d dokumentDo) Distinct(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Distinct(cols...)) +} + +func (d dokumentDo) Omit(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Omit(cols...)) +} + +func (d dokumentDo) Join(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Join(table, on...)) +} + +func (d dokumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.LeftJoin(table, on...)) +} + +func (d dokumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.RightJoin(table, on...)) +} + +func (d dokumentDo) Group(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Group(cols...)) +} + +func (d dokumentDo) Having(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Having(conds...)) +} + +func (d dokumentDo) Limit(limit int) IDokumentDo { + return d.withDO(d.DO.Limit(limit)) +} + +func (d dokumentDo) Offset(offset int) IDokumentDo { + return d.withDO(d.DO.Offset(offset)) +} + +func (d dokumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo { + return d.withDO(d.DO.Scopes(funcs...)) +} + +func (d dokumentDo) Unscoped() IDokumentDo { + return d.withDO(d.DO.Unscoped()) +} + +func (d dokumentDo) Create(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Create(values) +} + +func (d dokumentDo) CreateInBatches(values []*model.Dokument, batchSize int) error { + return d.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (d dokumentDo) Save(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Save(values) +} + +func (d dokumentDo) First() (*model.Dokument, error) { + if result, err := d.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Take() (*model.Dokument, error) { + if result, err := d.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Last() (*model.Dokument, error) { + if result, err := d.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Find() ([]*model.Dokument, error) { + result, err := d.DO.Find() + return result.([]*model.Dokument), err +} + +func (d dokumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) { + buf := make([]*model.Dokument, 0, batchSize) + err = d.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (d dokumentDo) FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return d.DO.FindInBatches(result, batchSize, fc) +} + +func (d dokumentDo) Attrs(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Attrs(attrs...)) +} + +func (d dokumentDo) Assign(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Assign(attrs...)) +} + +func (d dokumentDo) Joins(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Joins(_f)) + } + return &d +} + +func (d dokumentDo) Preload(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Preload(_f)) + } + return &d +} + +func (d dokumentDo) FirstOrInit() (*model.Dokument, error) { + if result, err := d.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FirstOrCreate() (*model.Dokument, error) { + if result, err := d.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) { + result, err = d.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = d.Offset(-1).Limit(-1).Count() + return +} + +func (d dokumentDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = d.Count() + if err != nil { + return + } + + err = d.Offset(offset).Limit(limit).Scan(result) + return +} + +func (d dokumentDo) Scan(result interface{}) (err error) { + return d.DO.Scan(result) +} + +func (d dokumentDo) Delete(models ...*model.Dokument) (result gen.ResultInfo, err error) { + return d.DO.Delete(models) +} + +func (d *dokumentDo) withDO(do gen.Dao) *dokumentDo { + d.DO = *do.(*gen.DO) + return d +} diff --git a/cmd/api/query/firma_ansprechpartner.gen.go b/cmd/api/query/firma_ansprechpartner.gen.go new file mode 100644 index 0000000..c8a5461 --- /dev/null +++ b/cmd/api/query/firma_ansprechpartner.gen.go @@ -0,0 +1,407 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirmaAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) firmaAnsprechpartner { + _firmaAnsprechpartner := firmaAnsprechpartner{} + + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseDB(db, opts...) + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseModel(&model.FirmaAnsprechpartner{}) + + tableName := _firmaAnsprechpartner.firmaAnsprechpartnerDo.TableName() + _firmaAnsprechpartner.ALL = field.NewAsterisk(tableName) + _firmaAnsprechpartner.ID = field.NewUint(tableName, "id") + _firmaAnsprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _firmaAnsprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _firmaAnsprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _firmaAnsprechpartner.AnsprechpartnerId = field.NewUint(tableName, "ansprechpartner_id") + _firmaAnsprechpartner.FirmaId = field.NewUint(tableName, "firma_id") + _firmaAnsprechpartner.Role = field.NewString(tableName, "role") + + _firmaAnsprechpartner.fillFieldMap() + + return _firmaAnsprechpartner +} + +type firmaAnsprechpartner struct { + firmaAnsprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + AnsprechpartnerId field.Uint + FirmaId field.Uint + Role field.String + + fieldMap map[string]field.Expr +} + +func (f firmaAnsprechpartner) Table(newTableName string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firmaAnsprechpartner) As(alias string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.DO = *(f.firmaAnsprechpartnerDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firmaAnsprechpartner) updateTableName(table string) *firmaAnsprechpartner { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.AnsprechpartnerId = field.NewUint(table, "ansprechpartner_id") + f.FirmaId = field.NewUint(table, "firma_id") + f.Role = field.NewString(table, "role") + + f.fillFieldMap() + + return f +} + +func (f *firmaAnsprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firmaAnsprechpartner) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 7) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["ansprechpartner_id"] = f.AnsprechpartnerId + f.fieldMap["firma_id"] = f.FirmaId + f.fieldMap["role"] = f.Role +} + +func (f firmaAnsprechpartner) clone(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + return f +} + +func (f firmaAnsprechpartner) replaceDB(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceDB(db) + return f +} + +type firmaAnsprechpartnerDo struct{ gen.DO } + +type IFirmaAnsprechpartnerDo interface { + gen.SubQuery + Debug() IFirmaAnsprechpartnerDo + WithContext(ctx context.Context) IFirmaAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaAnsprechpartnerDo + WriteDB() IFirmaAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo + Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Select(conds ...field.Expr) IFirmaAnsprechpartnerDo + Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Order(conds ...field.Expr) IFirmaAnsprechpartnerDo + Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo + Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + Group(cols ...field.Expr) IFirmaAnsprechpartnerDo + Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Limit(limit int) IFirmaAnsprechpartnerDo + Offset(offset int) IFirmaAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo + Unscoped() IFirmaAnsprechpartnerDo + Create(values ...*model.FirmaAnsprechpartner) error + CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error + Save(values ...*model.FirmaAnsprechpartner) error + First() (*model.FirmaAnsprechpartner, error) + Take() (*model.FirmaAnsprechpartner, error) + Last() (*model.FirmaAnsprechpartner, error) + Find() ([]*model.FirmaAnsprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) + FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.FirmaAnsprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo + Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo + FirstOrInit() (*model.FirmaAnsprechpartner, error) + FirstOrCreate() (*model.FirmaAnsprechpartner, error) + FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaAnsprechpartnerDo) Debug() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaAnsprechpartnerDo) WithContext(ctx context.Context) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaAnsprechpartnerDo) ReadDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaAnsprechpartnerDo) WriteDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaAnsprechpartnerDo) Session(config *gorm.Session) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaAnsprechpartnerDo) Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaAnsprechpartnerDo) Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaAnsprechpartnerDo) Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaAnsprechpartnerDo) Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaAnsprechpartnerDo) Select(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaAnsprechpartnerDo) Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaAnsprechpartnerDo) Order(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaAnsprechpartnerDo) Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaAnsprechpartnerDo) Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaAnsprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaAnsprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) Group(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaAnsprechpartnerDo) Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaAnsprechpartnerDo) Limit(limit int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaAnsprechpartnerDo) Offset(offset int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaAnsprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaAnsprechpartnerDo) Unscoped() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaAnsprechpartnerDo) Create(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaAnsprechpartnerDo) CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaAnsprechpartnerDo) Save(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaAnsprechpartnerDo) First() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Take() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Last() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Find() ([]*model.FirmaAnsprechpartner, error) { + result, err := f.DO.Find() + return result.([]*model.FirmaAnsprechpartner), err +} + +func (f firmaAnsprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) { + buf := make([]*model.FirmaAnsprechpartner, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaAnsprechpartnerDo) FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaAnsprechpartnerDo) Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) FirstOrInit() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FirstOrCreate() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaAnsprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaAnsprechpartnerDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaAnsprechpartnerDo) Delete(models ...*model.FirmaAnsprechpartner) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaAnsprechpartnerDo) withDO(do gen.Dao) *firmaAnsprechpartnerDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/cmd/api/query/firmas.gen.go b/cmd/api/query/firmas.gen.go new file mode 100644 index 0000000..5177cf1 --- /dev/null +++ b/cmd/api/query/firmas.gen.go @@ -0,0 +1,630 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirma(db *gorm.DB, opts ...gen.DOOption) firma { + _firma := firma{} + + _firma.firmaDo.UseDB(db, opts...) + _firma.firmaDo.UseModel(&model.Firma{}) + + tableName := _firma.firmaDo.TableName() + _firma.ALL = field.NewAsterisk(tableName) + _firma.ID = field.NewUint(tableName, "id") + _firma.CreatedAt = field.NewTime(tableName, "created_at") + _firma.UpdatedAt = field.NewTime(tableName, "updated_at") + _firma.DeletedAt = field.NewField(tableName, "deleted_at") + _firma.FirmaTyp = field.NewInt(tableName, "firma_typ") + _firma.Name = field.NewString(tableName, "name") + _firma.InternerName = field.NewString(tableName, "interner_name") + _firma.Slug = field.NewString(tableName, "slug") + _firma.Branche = field.NewString(tableName, "branche") + _firma.ParentCompany = field.NewUint(tableName, "parent_company") + _firma.Tochergesellschaften = firmaHasManyTochergesellschaften{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Tochergesellschaften", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _firma.Ansprechpartner = firmaManyToManyAnsprechpartner{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Ansprechpartner", "model.Ansprechpartner"), + } + + _firma.fillFieldMap() + + return _firma +} + +type firma struct { + firmaDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + FirmaTyp field.Int + Name field.String + InternerName field.String + Slug field.String + Branche field.String + ParentCompany field.Uint + Tochergesellschaften firmaHasManyTochergesellschaften + + Ansprechpartner firmaManyToManyAnsprechpartner + + fieldMap map[string]field.Expr +} + +func (f firma) Table(newTableName string) *firma { + f.firmaDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firma) As(alias string) *firma { + f.firmaDo.DO = *(f.firmaDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firma) updateTableName(table string) *firma { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.FirmaTyp = field.NewInt(table, "firma_typ") + f.Name = field.NewString(table, "name") + f.InternerName = field.NewString(table, "interner_name") + f.Slug = field.NewString(table, "slug") + f.Branche = field.NewString(table, "branche") + f.ParentCompany = field.NewUint(table, "parent_company") + + f.fillFieldMap() + + return f +} + +func (f *firma) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firma) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 12) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["firma_typ"] = f.FirmaTyp + f.fieldMap["name"] = f.Name + f.fieldMap["interner_name"] = f.InternerName + f.fieldMap["slug"] = f.Slug + f.fieldMap["branche"] = f.Branche + f.fieldMap["parent_company"] = f.ParentCompany + +} + +func (f firma) clone(db *gorm.DB) firma { + f.firmaDo.ReplaceConnPool(db.Statement.ConnPool) + f.Tochergesellschaften.db = db.Session(&gorm.Session{Initialized: true}) + f.Tochergesellschaften.db.Statement.ConnPool = db.Statement.ConnPool + f.Ansprechpartner.db = db.Session(&gorm.Session{Initialized: true}) + f.Ansprechpartner.db.Statement.ConnPool = db.Statement.ConnPool + return f +} + +func (f firma) replaceDB(db *gorm.DB) firma { + f.firmaDo.ReplaceDB(db) + f.Tochergesellschaften.db = db.Session(&gorm.Session{}) + f.Ansprechpartner.db = db.Session(&gorm.Session{}) + return f +} + +type firmaHasManyTochergesellschaften struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a firmaHasManyTochergesellschaften) Where(conds ...field.Expr) *firmaHasManyTochergesellschaften { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaHasManyTochergesellschaften) WithContext(ctx context.Context) *firmaHasManyTochergesellschaften { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaHasManyTochergesellschaften) Session(session *gorm.Session) *firmaHasManyTochergesellschaften { + a.db = a.db.Session(session) + return &a +} + +func (a firmaHasManyTochergesellschaften) Model(m *model.Firma) *firmaHasManyTochergesellschaftenTx { + return &firmaHasManyTochergesellschaftenTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaHasManyTochergesellschaften) Unscoped() *firmaHasManyTochergesellschaften { + a.db = a.db.Unscoped() + return &a +} + +type firmaHasManyTochergesellschaftenTx struct{ tx *gorm.Association } + +func (a firmaHasManyTochergesellschaftenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaHasManyTochergesellschaftenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaHasManyTochergesellschaftenTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaHasManyTochergesellschaftenTx) Unscoped() *firmaHasManyTochergesellschaftenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartner struct { + db *gorm.DB + + field.RelationField +} + +func (a firmaManyToManyAnsprechpartner) Where(conds ...field.Expr) *firmaManyToManyAnsprechpartner { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaManyToManyAnsprechpartner) WithContext(ctx context.Context) *firmaManyToManyAnsprechpartner { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Session(session *gorm.Session) *firmaManyToManyAnsprechpartner { + a.db = a.db.Session(session) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Model(m *model.Firma) *firmaManyToManyAnsprechpartnerTx { + return &firmaManyToManyAnsprechpartnerTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaManyToManyAnsprechpartner) Unscoped() *firmaManyToManyAnsprechpartner { + a.db = a.db.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartnerTx struct{ tx *gorm.Association } + +func (a firmaManyToManyAnsprechpartnerTx) Find() (result []*model.Ansprechpartner, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaManyToManyAnsprechpartnerTx) Append(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Replace(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Delete(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaManyToManyAnsprechpartnerTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaManyToManyAnsprechpartnerTx) Unscoped() *firmaManyToManyAnsprechpartnerTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaDo struct{ gen.DO } + +type IFirmaDo interface { + gen.SubQuery + Debug() IFirmaDo + WithContext(ctx context.Context) IFirmaDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaDo + WriteDB() IFirmaDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaDo + Not(conds ...gen.Condition) IFirmaDo + Or(conds ...gen.Condition) IFirmaDo + Select(conds ...field.Expr) IFirmaDo + Where(conds ...gen.Condition) IFirmaDo + Order(conds ...field.Expr) IFirmaDo + Distinct(cols ...field.Expr) IFirmaDo + Omit(cols ...field.Expr) IFirmaDo + Join(table schema.Tabler, on ...field.Expr) IFirmaDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + Group(cols ...field.Expr) IFirmaDo + Having(conds ...gen.Condition) IFirmaDo + Limit(limit int) IFirmaDo + Offset(offset int) IFirmaDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo + Unscoped() IFirmaDo + Create(values ...*model.Firma) error + CreateInBatches(values []*model.Firma, batchSize int) error + Save(values ...*model.Firma) error + First() (*model.Firma, error) + Take() (*model.Firma, error) + Last() (*model.Firma, error) + Find() ([]*model.Firma, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) + FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Firma) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaDo + Assign(attrs ...field.AssignExpr) IFirmaDo + Joins(fields ...field.RelationField) IFirmaDo + Preload(fields ...field.RelationField) IFirmaDo + FirstOrInit() (*model.Firma, error) + FirstOrCreate() (*model.Firma, error) + FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaDo) Debug() IFirmaDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaDo) WithContext(ctx context.Context) IFirmaDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaDo) ReadDB() IFirmaDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaDo) WriteDB() IFirmaDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaDo) Session(config *gorm.Session) IFirmaDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaDo) Clauses(conds ...clause.Expression) IFirmaDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaDo) Returning(value interface{}, columns ...string) IFirmaDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaDo) Not(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaDo) Or(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaDo) Select(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaDo) Where(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaDo) Order(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaDo) Distinct(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaDo) Omit(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaDo) Join(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaDo) Group(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaDo) Having(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaDo) Limit(limit int) IFirmaDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaDo) Offset(offset int) IFirmaDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaDo) Unscoped() IFirmaDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaDo) Create(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaDo) CreateInBatches(values []*model.Firma, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaDo) Save(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaDo) First() (*model.Firma, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Take() (*model.Firma, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Last() (*model.Firma, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Find() ([]*model.Firma, error) { + result, err := f.DO.Find() + return result.([]*model.Firma), err +} + +func (f firmaDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) { + buf := make([]*model.Firma, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaDo) FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaDo) Attrs(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaDo) Assign(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaDo) Joins(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaDo) Preload(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaDo) FirstOrInit() (*model.Firma, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FirstOrCreate() (*model.Firma, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaDo) Delete(models ...*model.Firma) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaDo) withDO(do gen.Dao) *firmaDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/cmd/api/query/gen.go b/cmd/api/query/gen.go new file mode 100644 index 0000000..e61b305 --- /dev/null +++ b/cmd/api/query/gen.go @@ -0,0 +1,239 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + + "gorm.io/gen" + + "gorm.io/plugin/dbresolver" +) + +var ( + Q = new(Query) + Ansprechpartner *ansprechpartner + Dokument *dokument + Firma *firma + FirmaAnsprechpartner *firmaAnsprechpartner + Kalender *kalender + Kalendereintrag *kalendereintrag + Kostenstelle *kostenstelle + Lager *lager + Lagerplatz *lagerplatz + Mandant *mandant + Material *material + Nachricht *nachricht + Projekt *projekt + Rechnung *rechnung + Rechnungsposition *rechnungsposition + Scanobject *scanobject + User *user + Zahlung *zahlung +) + +func SetDefault(db *gorm.DB, opts ...gen.DOOption) { + *Q = *Use(db, opts...) + Ansprechpartner = &Q.Ansprechpartner + Dokument = &Q.Dokument + Firma = &Q.Firma + FirmaAnsprechpartner = &Q.FirmaAnsprechpartner + Kalender = &Q.Kalender + Kalendereintrag = &Q.Kalendereintrag + Kostenstelle = &Q.Kostenstelle + Lager = &Q.Lager + Lagerplatz = &Q.Lagerplatz + Mandant = &Q.Mandant + Material = &Q.Material + Nachricht = &Q.Nachricht + Projekt = &Q.Projekt + Rechnung = &Q.Rechnung + Rechnungsposition = &Q.Rechnungsposition + Scanobject = &Q.Scanobject + User = &Q.User + Zahlung = &Q.Zahlung +} + +func Use(db *gorm.DB, opts ...gen.DOOption) *Query { + return &Query{ + db: db, + Ansprechpartner: newAnsprechpartner(db, opts...), + Dokument: newDokument(db, opts...), + Firma: newFirma(db, opts...), + FirmaAnsprechpartner: newFirmaAnsprechpartner(db, opts...), + Kalender: newKalender(db, opts...), + Kalendereintrag: newKalendereintrag(db, opts...), + Kostenstelle: newKostenstelle(db, opts...), + Lager: newLager(db, opts...), + Lagerplatz: newLagerplatz(db, opts...), + Mandant: newMandant(db, opts...), + Material: newMaterial(db, opts...), + Nachricht: newNachricht(db, opts...), + Projekt: newProjekt(db, opts...), + Rechnung: newRechnung(db, opts...), + Rechnungsposition: newRechnungsposition(db, opts...), + Scanobject: newScanobject(db, opts...), + User: newUser(db, opts...), + Zahlung: newZahlung(db, opts...), + } +} + +type Query struct { + db *gorm.DB + + Ansprechpartner ansprechpartner + Dokument dokument + Firma firma + FirmaAnsprechpartner firmaAnsprechpartner + Kalender kalender + Kalendereintrag kalendereintrag + Kostenstelle kostenstelle + Lager lager + Lagerplatz lagerplatz + Mandant mandant + Material material + Nachricht nachricht + Projekt projekt + Rechnung rechnung + Rechnungsposition rechnungsposition + Scanobject scanobject + User user + Zahlung zahlung +} + +func (q *Query) Available() bool { return q.db != nil } + +func (q *Query) clone(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.clone(db), + Dokument: q.Dokument.clone(db), + Firma: q.Firma.clone(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.clone(db), + Kalender: q.Kalender.clone(db), + Kalendereintrag: q.Kalendereintrag.clone(db), + Kostenstelle: q.Kostenstelle.clone(db), + Lager: q.Lager.clone(db), + Lagerplatz: q.Lagerplatz.clone(db), + Mandant: q.Mandant.clone(db), + Material: q.Material.clone(db), + Nachricht: q.Nachricht.clone(db), + Projekt: q.Projekt.clone(db), + Rechnung: q.Rechnung.clone(db), + Rechnungsposition: q.Rechnungsposition.clone(db), + Scanobject: q.Scanobject.clone(db), + User: q.User.clone(db), + Zahlung: q.Zahlung.clone(db), + } +} + +func (q *Query) ReadDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Read)) +} + +func (q *Query) WriteDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Write)) +} + +func (q *Query) ReplaceDB(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.replaceDB(db), + Dokument: q.Dokument.replaceDB(db), + Firma: q.Firma.replaceDB(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.replaceDB(db), + Kalender: q.Kalender.replaceDB(db), + Kalendereintrag: q.Kalendereintrag.replaceDB(db), + Kostenstelle: q.Kostenstelle.replaceDB(db), + Lager: q.Lager.replaceDB(db), + Lagerplatz: q.Lagerplatz.replaceDB(db), + Mandant: q.Mandant.replaceDB(db), + Material: q.Material.replaceDB(db), + Nachricht: q.Nachricht.replaceDB(db), + Projekt: q.Projekt.replaceDB(db), + Rechnung: q.Rechnung.replaceDB(db), + Rechnungsposition: q.Rechnungsposition.replaceDB(db), + Scanobject: q.Scanobject.replaceDB(db), + User: q.User.replaceDB(db), + Zahlung: q.Zahlung.replaceDB(db), + } +} + +type queryCtx struct { + Ansprechpartner IAnsprechpartnerDo + Dokument IDokumentDo + Firma IFirmaDo + FirmaAnsprechpartner IFirmaAnsprechpartnerDo + Kalender IKalenderDo + Kalendereintrag IKalendereintragDo + Kostenstelle IKostenstelleDo + Lager ILagerDo + Lagerplatz ILagerplatzDo + Mandant IMandantDo + Material IMaterialDo + Nachricht INachrichtDo + Projekt IProjektDo + Rechnung IRechnungDo + Rechnungsposition IRechnungspositionDo + Scanobject IScanobjectDo + User IUserDo + Zahlung IZahlungDo +} + +func (q *Query) WithContext(ctx context.Context) *queryCtx { + return &queryCtx{ + Ansprechpartner: q.Ansprechpartner.WithContext(ctx), + Dokument: q.Dokument.WithContext(ctx), + Firma: q.Firma.WithContext(ctx), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.WithContext(ctx), + Kalender: q.Kalender.WithContext(ctx), + Kalendereintrag: q.Kalendereintrag.WithContext(ctx), + Kostenstelle: q.Kostenstelle.WithContext(ctx), + Lager: q.Lager.WithContext(ctx), + Lagerplatz: q.Lagerplatz.WithContext(ctx), + Mandant: q.Mandant.WithContext(ctx), + Material: q.Material.WithContext(ctx), + Nachricht: q.Nachricht.WithContext(ctx), + Projekt: q.Projekt.WithContext(ctx), + Rechnung: q.Rechnung.WithContext(ctx), + Rechnungsposition: q.Rechnungsposition.WithContext(ctx), + Scanobject: q.Scanobject.WithContext(ctx), + User: q.User.WithContext(ctx), + Zahlung: q.Zahlung.WithContext(ctx), + } +} + +func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { + return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...) +} + +func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { + tx := q.db.Begin(opts...) + return &QueryTx{Query: q.clone(tx), Error: tx.Error} +} + +type QueryTx struct { + *Query + Error error +} + +func (q *QueryTx) Commit() error { + return q.db.Commit().Error +} + +func (q *QueryTx) Rollback() error { + return q.db.Rollback().Error +} + +func (q *QueryTx) SavePoint(name string) error { + return q.db.SavePoint(name).Error +} + +func (q *QueryTx) RollbackTo(name string) error { + return q.db.RollbackTo(name).Error +} diff --git a/cmd/api/query/kalendereintrags.gen.go b/cmd/api/query/kalendereintrags.gen.go new file mode 100644 index 0000000..dd5ea58 --- /dev/null +++ b/cmd/api/query/kalendereintrags.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalendereintrag(db *gorm.DB, opts ...gen.DOOption) kalendereintrag { + _kalendereintrag := kalendereintrag{} + + _kalendereintrag.kalendereintragDo.UseDB(db, opts...) + _kalendereintrag.kalendereintragDo.UseModel(&model.Kalendereintrag{}) + + tableName := _kalendereintrag.kalendereintragDo.TableName() + _kalendereintrag.ALL = field.NewAsterisk(tableName) + _kalendereintrag.ID = field.NewUint(tableName, "id") + _kalendereintrag.CreatedAt = field.NewTime(tableName, "created_at") + _kalendereintrag.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalendereintrag.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalendereintrag.fillFieldMap() + + return _kalendereintrag +} + +type kalendereintrag struct { + kalendereintragDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalendereintrag) Table(newTableName string) *kalendereintrag { + k.kalendereintragDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalendereintrag) As(alias string) *kalendereintrag { + k.kalendereintragDo.DO = *(k.kalendereintragDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalendereintrag) updateTableName(table string) *kalendereintrag { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalendereintrag) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalendereintrag) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalendereintrag) clone(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalendereintrag) replaceDB(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceDB(db) + return k +} + +type kalendereintragDo struct{ gen.DO } + +type IKalendereintragDo interface { + gen.SubQuery + Debug() IKalendereintragDo + WithContext(ctx context.Context) IKalendereintragDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalendereintragDo + WriteDB() IKalendereintragDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalendereintragDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalendereintragDo + Not(conds ...gen.Condition) IKalendereintragDo + Or(conds ...gen.Condition) IKalendereintragDo + Select(conds ...field.Expr) IKalendereintragDo + Where(conds ...gen.Condition) IKalendereintragDo + Order(conds ...field.Expr) IKalendereintragDo + Distinct(cols ...field.Expr) IKalendereintragDo + Omit(cols ...field.Expr) IKalendereintragDo + Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + Group(cols ...field.Expr) IKalendereintragDo + Having(conds ...gen.Condition) IKalendereintragDo + Limit(limit int) IKalendereintragDo + Offset(offset int) IKalendereintragDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo + Unscoped() IKalendereintragDo + Create(values ...*model.Kalendereintrag) error + CreateInBatches(values []*model.Kalendereintrag, batchSize int) error + Save(values ...*model.Kalendereintrag) error + First() (*model.Kalendereintrag, error) + Take() (*model.Kalendereintrag, error) + Last() (*model.Kalendereintrag, error) + Find() ([]*model.Kalendereintrag, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) + FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalendereintrag) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalendereintragDo + Assign(attrs ...field.AssignExpr) IKalendereintragDo + Joins(fields ...field.RelationField) IKalendereintragDo + Preload(fields ...field.RelationField) IKalendereintragDo + FirstOrInit() (*model.Kalendereintrag, error) + FirstOrCreate() (*model.Kalendereintrag, error) + FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalendereintragDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalendereintragDo) Debug() IKalendereintragDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalendereintragDo) WithContext(ctx context.Context) IKalendereintragDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalendereintragDo) ReadDB() IKalendereintragDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalendereintragDo) WriteDB() IKalendereintragDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalendereintragDo) Session(config *gorm.Session) IKalendereintragDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalendereintragDo) Clauses(conds ...clause.Expression) IKalendereintragDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalendereintragDo) Returning(value interface{}, columns ...string) IKalendereintragDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalendereintragDo) Not(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalendereintragDo) Or(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalendereintragDo) Select(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalendereintragDo) Where(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalendereintragDo) Order(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalendereintragDo) Distinct(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalendereintragDo) Omit(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalendereintragDo) Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalendereintragDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalendereintragDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalendereintragDo) Group(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalendereintragDo) Having(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalendereintragDo) Limit(limit int) IKalendereintragDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalendereintragDo) Offset(offset int) IKalendereintragDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalendereintragDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalendereintragDo) Unscoped() IKalendereintragDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalendereintragDo) Create(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalendereintragDo) CreateInBatches(values []*model.Kalendereintrag, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalendereintragDo) Save(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalendereintragDo) First() (*model.Kalendereintrag, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Take() (*model.Kalendereintrag, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Last() (*model.Kalendereintrag, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Find() ([]*model.Kalendereintrag, error) { + result, err := k.DO.Find() + return result.([]*model.Kalendereintrag), err +} + +func (k kalendereintragDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) { + buf := make([]*model.Kalendereintrag, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalendereintragDo) FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalendereintragDo) Attrs(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalendereintragDo) Assign(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalendereintragDo) Joins(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalendereintragDo) Preload(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalendereintragDo) FirstOrInit() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FirstOrCreate() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalendereintragDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalendereintragDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalendereintragDo) Delete(models ...*model.Kalendereintrag) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalendereintragDo) withDO(do gen.Dao) *kalendereintragDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/api/query/kalenders.gen.go b/cmd/api/query/kalenders.gen.go new file mode 100644 index 0000000..2993174 --- /dev/null +++ b/cmd/api/query/kalenders.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalender(db *gorm.DB, opts ...gen.DOOption) kalender { + _kalender := kalender{} + + _kalender.kalenderDo.UseDB(db, opts...) + _kalender.kalenderDo.UseModel(&model.Kalender{}) + + tableName := _kalender.kalenderDo.TableName() + _kalender.ALL = field.NewAsterisk(tableName) + _kalender.ID = field.NewUint(tableName, "id") + _kalender.CreatedAt = field.NewTime(tableName, "created_at") + _kalender.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalender.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalender.fillFieldMap() + + return _kalender +} + +type kalender struct { + kalenderDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalender) Table(newTableName string) *kalender { + k.kalenderDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalender) As(alias string) *kalender { + k.kalenderDo.DO = *(k.kalenderDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalender) updateTableName(table string) *kalender { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalender) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalender) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalender) clone(db *gorm.DB) kalender { + k.kalenderDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalender) replaceDB(db *gorm.DB) kalender { + k.kalenderDo.ReplaceDB(db) + return k +} + +type kalenderDo struct{ gen.DO } + +type IKalenderDo interface { + gen.SubQuery + Debug() IKalenderDo + WithContext(ctx context.Context) IKalenderDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalenderDo + WriteDB() IKalenderDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalenderDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalenderDo + Not(conds ...gen.Condition) IKalenderDo + Or(conds ...gen.Condition) IKalenderDo + Select(conds ...field.Expr) IKalenderDo + Where(conds ...gen.Condition) IKalenderDo + Order(conds ...field.Expr) IKalenderDo + Distinct(cols ...field.Expr) IKalenderDo + Omit(cols ...field.Expr) IKalenderDo + Join(table schema.Tabler, on ...field.Expr) IKalenderDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + Group(cols ...field.Expr) IKalenderDo + Having(conds ...gen.Condition) IKalenderDo + Limit(limit int) IKalenderDo + Offset(offset int) IKalenderDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo + Unscoped() IKalenderDo + Create(values ...*model.Kalender) error + CreateInBatches(values []*model.Kalender, batchSize int) error + Save(values ...*model.Kalender) error + First() (*model.Kalender, error) + Take() (*model.Kalender, error) + Last() (*model.Kalender, error) + Find() ([]*model.Kalender, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) + FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalender) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalenderDo + Assign(attrs ...field.AssignExpr) IKalenderDo + Joins(fields ...field.RelationField) IKalenderDo + Preload(fields ...field.RelationField) IKalenderDo + FirstOrInit() (*model.Kalender, error) + FirstOrCreate() (*model.Kalender, error) + FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalenderDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalenderDo) Debug() IKalenderDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalenderDo) WithContext(ctx context.Context) IKalenderDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalenderDo) ReadDB() IKalenderDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalenderDo) WriteDB() IKalenderDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalenderDo) Session(config *gorm.Session) IKalenderDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalenderDo) Clauses(conds ...clause.Expression) IKalenderDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalenderDo) Returning(value interface{}, columns ...string) IKalenderDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalenderDo) Not(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalenderDo) Or(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalenderDo) Select(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalenderDo) Where(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalenderDo) Order(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalenderDo) Distinct(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalenderDo) Omit(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalenderDo) Join(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalenderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalenderDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalenderDo) Group(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalenderDo) Having(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalenderDo) Limit(limit int) IKalenderDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalenderDo) Offset(offset int) IKalenderDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalenderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalenderDo) Unscoped() IKalenderDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalenderDo) Create(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalenderDo) CreateInBatches(values []*model.Kalender, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalenderDo) Save(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalenderDo) First() (*model.Kalender, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Take() (*model.Kalender, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Last() (*model.Kalender, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Find() ([]*model.Kalender, error) { + result, err := k.DO.Find() + return result.([]*model.Kalender), err +} + +func (k kalenderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) { + buf := make([]*model.Kalender, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalenderDo) FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalenderDo) Attrs(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalenderDo) Assign(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalenderDo) Joins(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalenderDo) Preload(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalenderDo) FirstOrInit() (*model.Kalender, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FirstOrCreate() (*model.Kalender, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalenderDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalenderDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalenderDo) Delete(models ...*model.Kalender) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalenderDo) withDO(do gen.Dao) *kalenderDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/api/query/kostenstelles.gen.go b/cmd/api/query/kostenstelles.gen.go new file mode 100644 index 0000000..ffbbbae --- /dev/null +++ b/cmd/api/query/kostenstelles.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKostenstelle(db *gorm.DB, opts ...gen.DOOption) kostenstelle { + _kostenstelle := kostenstelle{} + + _kostenstelle.kostenstelleDo.UseDB(db, opts...) + _kostenstelle.kostenstelleDo.UseModel(&model.Kostenstelle{}) + + tableName := _kostenstelle.kostenstelleDo.TableName() + _kostenstelle.ALL = field.NewAsterisk(tableName) + _kostenstelle.ID = field.NewUint(tableName, "id") + _kostenstelle.CreatedAt = field.NewTime(tableName, "created_at") + _kostenstelle.UpdatedAt = field.NewTime(tableName, "updated_at") + _kostenstelle.DeletedAt = field.NewField(tableName, "deleted_at") + + _kostenstelle.fillFieldMap() + + return _kostenstelle +} + +type kostenstelle struct { + kostenstelleDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kostenstelle) Table(newTableName string) *kostenstelle { + k.kostenstelleDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kostenstelle) As(alias string) *kostenstelle { + k.kostenstelleDo.DO = *(k.kostenstelleDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kostenstelle) updateTableName(table string) *kostenstelle { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kostenstelle) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kostenstelle) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kostenstelle) clone(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kostenstelle) replaceDB(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceDB(db) + return k +} + +type kostenstelleDo struct{ gen.DO } + +type IKostenstelleDo interface { + gen.SubQuery + Debug() IKostenstelleDo + WithContext(ctx context.Context) IKostenstelleDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKostenstelleDo + WriteDB() IKostenstelleDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKostenstelleDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKostenstelleDo + Not(conds ...gen.Condition) IKostenstelleDo + Or(conds ...gen.Condition) IKostenstelleDo + Select(conds ...field.Expr) IKostenstelleDo + Where(conds ...gen.Condition) IKostenstelleDo + Order(conds ...field.Expr) IKostenstelleDo + Distinct(cols ...field.Expr) IKostenstelleDo + Omit(cols ...field.Expr) IKostenstelleDo + Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + Group(cols ...field.Expr) IKostenstelleDo + Having(conds ...gen.Condition) IKostenstelleDo + Limit(limit int) IKostenstelleDo + Offset(offset int) IKostenstelleDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo + Unscoped() IKostenstelleDo + Create(values ...*model.Kostenstelle) error + CreateInBatches(values []*model.Kostenstelle, batchSize int) error + Save(values ...*model.Kostenstelle) error + First() (*model.Kostenstelle, error) + Take() (*model.Kostenstelle, error) + Last() (*model.Kostenstelle, error) + Find() ([]*model.Kostenstelle, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) + FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kostenstelle) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKostenstelleDo + Assign(attrs ...field.AssignExpr) IKostenstelleDo + Joins(fields ...field.RelationField) IKostenstelleDo + Preload(fields ...field.RelationField) IKostenstelleDo + FirstOrInit() (*model.Kostenstelle, error) + FirstOrCreate() (*model.Kostenstelle, error) + FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKostenstelleDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kostenstelleDo) Debug() IKostenstelleDo { + return k.withDO(k.DO.Debug()) +} + +func (k kostenstelleDo) WithContext(ctx context.Context) IKostenstelleDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kostenstelleDo) ReadDB() IKostenstelleDo { + return k.Clauses(dbresolver.Read) +} + +func (k kostenstelleDo) WriteDB() IKostenstelleDo { + return k.Clauses(dbresolver.Write) +} + +func (k kostenstelleDo) Session(config *gorm.Session) IKostenstelleDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kostenstelleDo) Clauses(conds ...clause.Expression) IKostenstelleDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kostenstelleDo) Returning(value interface{}, columns ...string) IKostenstelleDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kostenstelleDo) Not(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kostenstelleDo) Or(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kostenstelleDo) Select(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kostenstelleDo) Where(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kostenstelleDo) Order(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kostenstelleDo) Distinct(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kostenstelleDo) Omit(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kostenstelleDo) Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kostenstelleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kostenstelleDo) RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kostenstelleDo) Group(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kostenstelleDo) Having(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kostenstelleDo) Limit(limit int) IKostenstelleDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kostenstelleDo) Offset(offset int) IKostenstelleDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kostenstelleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kostenstelleDo) Unscoped() IKostenstelleDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kostenstelleDo) Create(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kostenstelleDo) CreateInBatches(values []*model.Kostenstelle, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kostenstelleDo) Save(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kostenstelleDo) First() (*model.Kostenstelle, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Take() (*model.Kostenstelle, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Last() (*model.Kostenstelle, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Find() ([]*model.Kostenstelle, error) { + result, err := k.DO.Find() + return result.([]*model.Kostenstelle), err +} + +func (k kostenstelleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) { + buf := make([]*model.Kostenstelle, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kostenstelleDo) FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kostenstelleDo) Attrs(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kostenstelleDo) Assign(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kostenstelleDo) Joins(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kostenstelleDo) Preload(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kostenstelleDo) FirstOrInit() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FirstOrCreate() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kostenstelleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kostenstelleDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kostenstelleDo) Delete(models ...*model.Kostenstelle) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kostenstelleDo) withDO(do gen.Dao) *kostenstelleDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/api/query/lagerplatzs.gen.go b/cmd/api/query/lagerplatzs.gen.go new file mode 100644 index 0000000..e83e134 --- /dev/null +++ b/cmd/api/query/lagerplatzs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLagerplatz(db *gorm.DB, opts ...gen.DOOption) lagerplatz { + _lagerplatz := lagerplatz{} + + _lagerplatz.lagerplatzDo.UseDB(db, opts...) + _lagerplatz.lagerplatzDo.UseModel(&model.Lagerplatz{}) + + tableName := _lagerplatz.lagerplatzDo.TableName() + _lagerplatz.ALL = field.NewAsterisk(tableName) + _lagerplatz.ID = field.NewUint(tableName, "id") + _lagerplatz.CreatedAt = field.NewTime(tableName, "created_at") + _lagerplatz.UpdatedAt = field.NewTime(tableName, "updated_at") + _lagerplatz.DeletedAt = field.NewField(tableName, "deleted_at") + + _lagerplatz.fillFieldMap() + + return _lagerplatz +} + +type lagerplatz struct { + lagerplatzDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lagerplatz) Table(newTableName string) *lagerplatz { + l.lagerplatzDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lagerplatz) As(alias string) *lagerplatz { + l.lagerplatzDo.DO = *(l.lagerplatzDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lagerplatz) updateTableName(table string) *lagerplatz { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lagerplatz) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lagerplatz) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lagerplatz) clone(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lagerplatz) replaceDB(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceDB(db) + return l +} + +type lagerplatzDo struct{ gen.DO } + +type ILagerplatzDo interface { + gen.SubQuery + Debug() ILagerplatzDo + WithContext(ctx context.Context) ILagerplatzDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerplatzDo + WriteDB() ILagerplatzDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerplatzDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerplatzDo + Not(conds ...gen.Condition) ILagerplatzDo + Or(conds ...gen.Condition) ILagerplatzDo + Select(conds ...field.Expr) ILagerplatzDo + Where(conds ...gen.Condition) ILagerplatzDo + Order(conds ...field.Expr) ILagerplatzDo + Distinct(cols ...field.Expr) ILagerplatzDo + Omit(cols ...field.Expr) ILagerplatzDo + Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + Group(cols ...field.Expr) ILagerplatzDo + Having(conds ...gen.Condition) ILagerplatzDo + Limit(limit int) ILagerplatzDo + Offset(offset int) ILagerplatzDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo + Unscoped() ILagerplatzDo + Create(values ...*model.Lagerplatz) error + CreateInBatches(values []*model.Lagerplatz, batchSize int) error + Save(values ...*model.Lagerplatz) error + First() (*model.Lagerplatz, error) + Take() (*model.Lagerplatz, error) + Last() (*model.Lagerplatz, error) + Find() ([]*model.Lagerplatz, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) + FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lagerplatz) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerplatzDo + Assign(attrs ...field.AssignExpr) ILagerplatzDo + Joins(fields ...field.RelationField) ILagerplatzDo + Preload(fields ...field.RelationField) ILagerplatzDo + FirstOrInit() (*model.Lagerplatz, error) + FirstOrCreate() (*model.Lagerplatz, error) + FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerplatzDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerplatzDo) Debug() ILagerplatzDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerplatzDo) WithContext(ctx context.Context) ILagerplatzDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerplatzDo) ReadDB() ILagerplatzDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerplatzDo) WriteDB() ILagerplatzDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerplatzDo) Session(config *gorm.Session) ILagerplatzDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerplatzDo) Clauses(conds ...clause.Expression) ILagerplatzDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerplatzDo) Returning(value interface{}, columns ...string) ILagerplatzDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerplatzDo) Not(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerplatzDo) Or(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerplatzDo) Select(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerplatzDo) Where(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerplatzDo) Order(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerplatzDo) Distinct(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerplatzDo) Omit(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerplatzDo) Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerplatzDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerplatzDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerplatzDo) Group(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerplatzDo) Having(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerplatzDo) Limit(limit int) ILagerplatzDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerplatzDo) Offset(offset int) ILagerplatzDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerplatzDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerplatzDo) Unscoped() ILagerplatzDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerplatzDo) Create(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerplatzDo) CreateInBatches(values []*model.Lagerplatz, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerplatzDo) Save(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerplatzDo) First() (*model.Lagerplatz, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Take() (*model.Lagerplatz, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Last() (*model.Lagerplatz, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Find() ([]*model.Lagerplatz, error) { + result, err := l.DO.Find() + return result.([]*model.Lagerplatz), err +} + +func (l lagerplatzDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) { + buf := make([]*model.Lagerplatz, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerplatzDo) FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerplatzDo) Attrs(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerplatzDo) Assign(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerplatzDo) Joins(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerplatzDo) Preload(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerplatzDo) FirstOrInit() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FirstOrCreate() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerplatzDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerplatzDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerplatzDo) Delete(models ...*model.Lagerplatz) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerplatzDo) withDO(do gen.Dao) *lagerplatzDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/cmd/api/query/lagers.gen.go b/cmd/api/query/lagers.gen.go new file mode 100644 index 0000000..20a3da0 --- /dev/null +++ b/cmd/api/query/lagers.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLager(db *gorm.DB, opts ...gen.DOOption) lager { + _lager := lager{} + + _lager.lagerDo.UseDB(db, opts...) + _lager.lagerDo.UseModel(&model.Lager{}) + + tableName := _lager.lagerDo.TableName() + _lager.ALL = field.NewAsterisk(tableName) + _lager.ID = field.NewUint(tableName, "id") + _lager.CreatedAt = field.NewTime(tableName, "created_at") + _lager.UpdatedAt = field.NewTime(tableName, "updated_at") + _lager.DeletedAt = field.NewField(tableName, "deleted_at") + + _lager.fillFieldMap() + + return _lager +} + +type lager struct { + lagerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lager) Table(newTableName string) *lager { + l.lagerDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lager) As(alias string) *lager { + l.lagerDo.DO = *(l.lagerDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lager) updateTableName(table string) *lager { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lager) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lager) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lager) clone(db *gorm.DB) lager { + l.lagerDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lager) replaceDB(db *gorm.DB) lager { + l.lagerDo.ReplaceDB(db) + return l +} + +type lagerDo struct{ gen.DO } + +type ILagerDo interface { + gen.SubQuery + Debug() ILagerDo + WithContext(ctx context.Context) ILagerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerDo + WriteDB() ILagerDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerDo + Not(conds ...gen.Condition) ILagerDo + Or(conds ...gen.Condition) ILagerDo + Select(conds ...field.Expr) ILagerDo + Where(conds ...gen.Condition) ILagerDo + Order(conds ...field.Expr) ILagerDo + Distinct(cols ...field.Expr) ILagerDo + Omit(cols ...field.Expr) ILagerDo + Join(table schema.Tabler, on ...field.Expr) ILagerDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo + Group(cols ...field.Expr) ILagerDo + Having(conds ...gen.Condition) ILagerDo + Limit(limit int) ILagerDo + Offset(offset int) ILagerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo + Unscoped() ILagerDo + Create(values ...*model.Lager) error + CreateInBatches(values []*model.Lager, batchSize int) error + Save(values ...*model.Lager) error + First() (*model.Lager, error) + Take() (*model.Lager, error) + Last() (*model.Lager, error) + Find() ([]*model.Lager, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) + FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lager) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerDo + Assign(attrs ...field.AssignExpr) ILagerDo + Joins(fields ...field.RelationField) ILagerDo + Preload(fields ...field.RelationField) ILagerDo + FirstOrInit() (*model.Lager, error) + FirstOrCreate() (*model.Lager, error) + FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerDo) Debug() ILagerDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerDo) WithContext(ctx context.Context) ILagerDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerDo) ReadDB() ILagerDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerDo) WriteDB() ILagerDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerDo) Session(config *gorm.Session) ILagerDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerDo) Clauses(conds ...clause.Expression) ILagerDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerDo) Returning(value interface{}, columns ...string) ILagerDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerDo) Not(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerDo) Or(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerDo) Select(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerDo) Where(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerDo) Order(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerDo) Distinct(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerDo) Omit(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerDo) Join(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerDo) Group(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerDo) Having(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerDo) Limit(limit int) ILagerDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerDo) Offset(offset int) ILagerDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerDo) Unscoped() ILagerDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerDo) Create(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerDo) CreateInBatches(values []*model.Lager, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerDo) Save(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerDo) First() (*model.Lager, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Take() (*model.Lager, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Last() (*model.Lager, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Find() ([]*model.Lager, error) { + result, err := l.DO.Find() + return result.([]*model.Lager), err +} + +func (l lagerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) { + buf := make([]*model.Lager, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerDo) FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerDo) Attrs(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerDo) Assign(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerDo) Joins(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerDo) Preload(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerDo) FirstOrInit() (*model.Lager, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FirstOrCreate() (*model.Lager, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerDo) Delete(models ...*model.Lager) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerDo) withDO(do gen.Dao) *lagerDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/cmd/api/query/mandants.gen.go b/cmd/api/query/mandants.gen.go new file mode 100644 index 0000000..e806c6a --- /dev/null +++ b/cmd/api/query/mandants.gen.go @@ -0,0 +1,411 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newMandant(db *gorm.DB, opts ...gen.DOOption) mandant { + _mandant := mandant{} + + _mandant.mandantDo.UseDB(db, opts...) + _mandant.mandantDo.UseModel(&model.Mandant{}) + + tableName := _mandant.mandantDo.TableName() + _mandant.ALL = field.NewAsterisk(tableName) + _mandant.ID = field.NewUint(tableName, "id") + _mandant.CreatedAt = field.NewTime(tableName, "created_at") + _mandant.UpdatedAt = field.NewTime(tableName, "updated_at") + _mandant.DeletedAt = field.NewField(tableName, "deleted_at") + _mandant.Name = field.NewString(tableName, "name") + _mandant.Logo = field.NewString(tableName, "logo") + _mandant.Plan = field.NewString(tableName, "plan") + _mandant.Color = field.NewString(tableName, "color") + + _mandant.fillFieldMap() + + return _mandant +} + +type mandant struct { + mandantDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Name field.String + Logo field.String + Plan field.String + Color field.String + + fieldMap map[string]field.Expr +} + +func (m mandant) Table(newTableName string) *mandant { + m.mandantDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m mandant) As(alias string) *mandant { + m.mandantDo.DO = *(m.mandantDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *mandant) updateTableName(table string) *mandant { + m.ALL = field.NewAsterisk(table) + m.ID = field.NewUint(table, "id") + m.CreatedAt = field.NewTime(table, "created_at") + m.UpdatedAt = field.NewTime(table, "updated_at") + m.DeletedAt = field.NewField(table, "deleted_at") + m.Name = field.NewString(table, "name") + m.Logo = field.NewString(table, "logo") + m.Plan = field.NewString(table, "plan") + m.Color = field.NewString(table, "color") + + m.fillFieldMap() + + return m +} + +func (m *mandant) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *mandant) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 8) + m.fieldMap["id"] = m.ID + m.fieldMap["created_at"] = m.CreatedAt + m.fieldMap["updated_at"] = m.UpdatedAt + m.fieldMap["deleted_at"] = m.DeletedAt + m.fieldMap["name"] = m.Name + m.fieldMap["logo"] = m.Logo + m.fieldMap["plan"] = m.Plan + m.fieldMap["color"] = m.Color +} + +func (m mandant) clone(db *gorm.DB) mandant { + m.mandantDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m mandant) replaceDB(db *gorm.DB) mandant { + m.mandantDo.ReplaceDB(db) + return m +} + +type mandantDo struct{ gen.DO } + +type IMandantDo interface { + gen.SubQuery + Debug() IMandantDo + WithContext(ctx context.Context) IMandantDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IMandantDo + WriteDB() IMandantDo + As(alias string) gen.Dao + Session(config *gorm.Session) IMandantDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IMandantDo + Not(conds ...gen.Condition) IMandantDo + Or(conds ...gen.Condition) IMandantDo + Select(conds ...field.Expr) IMandantDo + Where(conds ...gen.Condition) IMandantDo + Order(conds ...field.Expr) IMandantDo + Distinct(cols ...field.Expr) IMandantDo + Omit(cols ...field.Expr) IMandantDo + Join(table schema.Tabler, on ...field.Expr) IMandantDo + LeftJoin(table schema.Tabler, on ...field.Expr) IMandantDo + RightJoin(table schema.Tabler, on ...field.Expr) IMandantDo + Group(cols ...field.Expr) IMandantDo + Having(conds ...gen.Condition) IMandantDo + Limit(limit int) IMandantDo + Offset(offset int) IMandantDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IMandantDo + Unscoped() IMandantDo + Create(values ...*model.Mandant) error + CreateInBatches(values []*model.Mandant, batchSize int) error + Save(values ...*model.Mandant) error + First() (*model.Mandant, error) + Take() (*model.Mandant, error) + Last() (*model.Mandant, error) + Find() ([]*model.Mandant, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Mandant, err error) + FindInBatches(result *[]*model.Mandant, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Mandant) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IMandantDo + Assign(attrs ...field.AssignExpr) IMandantDo + Joins(fields ...field.RelationField) IMandantDo + Preload(fields ...field.RelationField) IMandantDo + FirstOrInit() (*model.Mandant, error) + FirstOrCreate() (*model.Mandant, error) + FindByPage(offset int, limit int) (result []*model.Mandant, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IMandantDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (m mandantDo) Debug() IMandantDo { + return m.withDO(m.DO.Debug()) +} + +func (m mandantDo) WithContext(ctx context.Context) IMandantDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m mandantDo) ReadDB() IMandantDo { + return m.Clauses(dbresolver.Read) +} + +func (m mandantDo) WriteDB() IMandantDo { + return m.Clauses(dbresolver.Write) +} + +func (m mandantDo) Session(config *gorm.Session) IMandantDo { + return m.withDO(m.DO.Session(config)) +} + +func (m mandantDo) Clauses(conds ...clause.Expression) IMandantDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m mandantDo) Returning(value interface{}, columns ...string) IMandantDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m mandantDo) Not(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m mandantDo) Or(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m mandantDo) Select(conds ...field.Expr) IMandantDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m mandantDo) Where(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m mandantDo) Order(conds ...field.Expr) IMandantDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m mandantDo) Distinct(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m mandantDo) Omit(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m mandantDo) Join(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m mandantDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m mandantDo) RightJoin(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m mandantDo) Group(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m mandantDo) Having(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m mandantDo) Limit(limit int) IMandantDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m mandantDo) Offset(offset int) IMandantDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m mandantDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMandantDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m mandantDo) Unscoped() IMandantDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m mandantDo) Create(values ...*model.Mandant) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m mandantDo) CreateInBatches(values []*model.Mandant, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m mandantDo) Save(values ...*model.Mandant) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m mandantDo) First() (*model.Mandant, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Take() (*model.Mandant, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Last() (*model.Mandant, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Find() ([]*model.Mandant, error) { + result, err := m.DO.Find() + return result.([]*model.Mandant), err +} + +func (m mandantDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Mandant, err error) { + buf := make([]*model.Mandant, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m mandantDo) FindInBatches(result *[]*model.Mandant, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m mandantDo) Attrs(attrs ...field.AssignExpr) IMandantDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m mandantDo) Assign(attrs ...field.AssignExpr) IMandantDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m mandantDo) Joins(fields ...field.RelationField) IMandantDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m mandantDo) Preload(fields ...field.RelationField) IMandantDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m mandantDo) FirstOrInit() (*model.Mandant, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) FirstOrCreate() (*model.Mandant, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) FindByPage(offset int, limit int) (result []*model.Mandant, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m mandantDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m mandantDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m mandantDo) Delete(models ...*model.Mandant) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *mandantDo) withDO(do gen.Dao) *mandantDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/cmd/api/query/materials.gen.go b/cmd/api/query/materials.gen.go new file mode 100644 index 0000000..1f6c21e --- /dev/null +++ b/cmd/api/query/materials.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newMaterial(db *gorm.DB, opts ...gen.DOOption) material { + _material := material{} + + _material.materialDo.UseDB(db, opts...) + _material.materialDo.UseModel(&model.Material{}) + + tableName := _material.materialDo.TableName() + _material.ALL = field.NewAsterisk(tableName) + _material.ID = field.NewUint(tableName, "id") + _material.CreatedAt = field.NewTime(tableName, "created_at") + _material.UpdatedAt = field.NewTime(tableName, "updated_at") + _material.DeletedAt = field.NewField(tableName, "deleted_at") + + _material.fillFieldMap() + + return _material +} + +type material struct { + materialDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (m material) Table(newTableName string) *material { + m.materialDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m material) As(alias string) *material { + m.materialDo.DO = *(m.materialDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *material) updateTableName(table string) *material { + m.ALL = field.NewAsterisk(table) + m.ID = field.NewUint(table, "id") + m.CreatedAt = field.NewTime(table, "created_at") + m.UpdatedAt = field.NewTime(table, "updated_at") + m.DeletedAt = field.NewField(table, "deleted_at") + + m.fillFieldMap() + + return m +} + +func (m *material) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *material) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 4) + m.fieldMap["id"] = m.ID + m.fieldMap["created_at"] = m.CreatedAt + m.fieldMap["updated_at"] = m.UpdatedAt + m.fieldMap["deleted_at"] = m.DeletedAt +} + +func (m material) clone(db *gorm.DB) material { + m.materialDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m material) replaceDB(db *gorm.DB) material { + m.materialDo.ReplaceDB(db) + return m +} + +type materialDo struct{ gen.DO } + +type IMaterialDo interface { + gen.SubQuery + Debug() IMaterialDo + WithContext(ctx context.Context) IMaterialDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IMaterialDo + WriteDB() IMaterialDo + As(alias string) gen.Dao + Session(config *gorm.Session) IMaterialDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IMaterialDo + Not(conds ...gen.Condition) IMaterialDo + Or(conds ...gen.Condition) IMaterialDo + Select(conds ...field.Expr) IMaterialDo + Where(conds ...gen.Condition) IMaterialDo + Order(conds ...field.Expr) IMaterialDo + Distinct(cols ...field.Expr) IMaterialDo + Omit(cols ...field.Expr) IMaterialDo + Join(table schema.Tabler, on ...field.Expr) IMaterialDo + LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + Group(cols ...field.Expr) IMaterialDo + Having(conds ...gen.Condition) IMaterialDo + Limit(limit int) IMaterialDo + Offset(offset int) IMaterialDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo + Unscoped() IMaterialDo + Create(values ...*model.Material) error + CreateInBatches(values []*model.Material, batchSize int) error + Save(values ...*model.Material) error + First() (*model.Material, error) + Take() (*model.Material, error) + Last() (*model.Material, error) + Find() ([]*model.Material, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) + FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Material) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IMaterialDo + Assign(attrs ...field.AssignExpr) IMaterialDo + Joins(fields ...field.RelationField) IMaterialDo + Preload(fields ...field.RelationField) IMaterialDo + FirstOrInit() (*model.Material, error) + FirstOrCreate() (*model.Material, error) + FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IMaterialDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (m materialDo) Debug() IMaterialDo { + return m.withDO(m.DO.Debug()) +} + +func (m materialDo) WithContext(ctx context.Context) IMaterialDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m materialDo) ReadDB() IMaterialDo { + return m.Clauses(dbresolver.Read) +} + +func (m materialDo) WriteDB() IMaterialDo { + return m.Clauses(dbresolver.Write) +} + +func (m materialDo) Session(config *gorm.Session) IMaterialDo { + return m.withDO(m.DO.Session(config)) +} + +func (m materialDo) Clauses(conds ...clause.Expression) IMaterialDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m materialDo) Returning(value interface{}, columns ...string) IMaterialDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m materialDo) Not(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m materialDo) Or(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m materialDo) Select(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m materialDo) Where(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m materialDo) Order(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m materialDo) Distinct(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m materialDo) Omit(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m materialDo) Join(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m materialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m materialDo) RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m materialDo) Group(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m materialDo) Having(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m materialDo) Limit(limit int) IMaterialDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m materialDo) Offset(offset int) IMaterialDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m materialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m materialDo) Unscoped() IMaterialDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m materialDo) Create(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m materialDo) CreateInBatches(values []*model.Material, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m materialDo) Save(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m materialDo) First() (*model.Material, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Take() (*model.Material, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Last() (*model.Material, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Find() ([]*model.Material, error) { + result, err := m.DO.Find() + return result.([]*model.Material), err +} + +func (m materialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) { + buf := make([]*model.Material, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m materialDo) FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m materialDo) Attrs(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m materialDo) Assign(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m materialDo) Joins(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m materialDo) Preload(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m materialDo) FirstOrInit() (*model.Material, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FirstOrCreate() (*model.Material, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m materialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m materialDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m materialDo) Delete(models ...*model.Material) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *materialDo) withDO(do gen.Dao) *materialDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/cmd/api/query/nachrichts.gen.go b/cmd/api/query/nachrichts.gen.go new file mode 100644 index 0000000..19de00c --- /dev/null +++ b/cmd/api/query/nachrichts.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newNachricht(db *gorm.DB, opts ...gen.DOOption) nachricht { + _nachricht := nachricht{} + + _nachricht.nachrichtDo.UseDB(db, opts...) + _nachricht.nachrichtDo.UseModel(&model.Nachricht{}) + + tableName := _nachricht.nachrichtDo.TableName() + _nachricht.ALL = field.NewAsterisk(tableName) + _nachricht.ID = field.NewUint(tableName, "id") + _nachricht.CreatedAt = field.NewTime(tableName, "created_at") + _nachricht.UpdatedAt = field.NewTime(tableName, "updated_at") + _nachricht.DeletedAt = field.NewField(tableName, "deleted_at") + + _nachricht.fillFieldMap() + + return _nachricht +} + +type nachricht struct { + nachrichtDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (n nachricht) Table(newTableName string) *nachricht { + n.nachrichtDo.UseTable(newTableName) + return n.updateTableName(newTableName) +} + +func (n nachricht) As(alias string) *nachricht { + n.nachrichtDo.DO = *(n.nachrichtDo.As(alias).(*gen.DO)) + return n.updateTableName(alias) +} + +func (n *nachricht) updateTableName(table string) *nachricht { + n.ALL = field.NewAsterisk(table) + n.ID = field.NewUint(table, "id") + n.CreatedAt = field.NewTime(table, "created_at") + n.UpdatedAt = field.NewTime(table, "updated_at") + n.DeletedAt = field.NewField(table, "deleted_at") + + n.fillFieldMap() + + return n +} + +func (n *nachricht) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := n.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (n *nachricht) fillFieldMap() { + n.fieldMap = make(map[string]field.Expr, 4) + n.fieldMap["id"] = n.ID + n.fieldMap["created_at"] = n.CreatedAt + n.fieldMap["updated_at"] = n.UpdatedAt + n.fieldMap["deleted_at"] = n.DeletedAt +} + +func (n nachricht) clone(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceConnPool(db.Statement.ConnPool) + return n +} + +func (n nachricht) replaceDB(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceDB(db) + return n +} + +type nachrichtDo struct{ gen.DO } + +type INachrichtDo interface { + gen.SubQuery + Debug() INachrichtDo + WithContext(ctx context.Context) INachrichtDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() INachrichtDo + WriteDB() INachrichtDo + As(alias string) gen.Dao + Session(config *gorm.Session) INachrichtDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) INachrichtDo + Not(conds ...gen.Condition) INachrichtDo + Or(conds ...gen.Condition) INachrichtDo + Select(conds ...field.Expr) INachrichtDo + Where(conds ...gen.Condition) INachrichtDo + Order(conds ...field.Expr) INachrichtDo + Distinct(cols ...field.Expr) INachrichtDo + Omit(cols ...field.Expr) INachrichtDo + Join(table schema.Tabler, on ...field.Expr) INachrichtDo + LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + Group(cols ...field.Expr) INachrichtDo + Having(conds ...gen.Condition) INachrichtDo + Limit(limit int) INachrichtDo + Offset(offset int) INachrichtDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo + Unscoped() INachrichtDo + Create(values ...*model.Nachricht) error + CreateInBatches(values []*model.Nachricht, batchSize int) error + Save(values ...*model.Nachricht) error + First() (*model.Nachricht, error) + Take() (*model.Nachricht, error) + Last() (*model.Nachricht, error) + Find() ([]*model.Nachricht, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) + FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Nachricht) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) INachrichtDo + Assign(attrs ...field.AssignExpr) INachrichtDo + Joins(fields ...field.RelationField) INachrichtDo + Preload(fields ...field.RelationField) INachrichtDo + FirstOrInit() (*model.Nachricht, error) + FirstOrCreate() (*model.Nachricht, error) + FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) INachrichtDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (n nachrichtDo) Debug() INachrichtDo { + return n.withDO(n.DO.Debug()) +} + +func (n nachrichtDo) WithContext(ctx context.Context) INachrichtDo { + return n.withDO(n.DO.WithContext(ctx)) +} + +func (n nachrichtDo) ReadDB() INachrichtDo { + return n.Clauses(dbresolver.Read) +} + +func (n nachrichtDo) WriteDB() INachrichtDo { + return n.Clauses(dbresolver.Write) +} + +func (n nachrichtDo) Session(config *gorm.Session) INachrichtDo { + return n.withDO(n.DO.Session(config)) +} + +func (n nachrichtDo) Clauses(conds ...clause.Expression) INachrichtDo { + return n.withDO(n.DO.Clauses(conds...)) +} + +func (n nachrichtDo) Returning(value interface{}, columns ...string) INachrichtDo { + return n.withDO(n.DO.Returning(value, columns...)) +} + +func (n nachrichtDo) Not(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Not(conds...)) +} + +func (n nachrichtDo) Or(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Or(conds...)) +} + +func (n nachrichtDo) Select(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Select(conds...)) +} + +func (n nachrichtDo) Where(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Where(conds...)) +} + +func (n nachrichtDo) Order(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Order(conds...)) +} + +func (n nachrichtDo) Distinct(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Distinct(cols...)) +} + +func (n nachrichtDo) Omit(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Omit(cols...)) +} + +func (n nachrichtDo) Join(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Join(table, on...)) +} + +func (n nachrichtDo) LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.LeftJoin(table, on...)) +} + +func (n nachrichtDo) RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.RightJoin(table, on...)) +} + +func (n nachrichtDo) Group(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Group(cols...)) +} + +func (n nachrichtDo) Having(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Having(conds...)) +} + +func (n nachrichtDo) Limit(limit int) INachrichtDo { + return n.withDO(n.DO.Limit(limit)) +} + +func (n nachrichtDo) Offset(offset int) INachrichtDo { + return n.withDO(n.DO.Offset(offset)) +} + +func (n nachrichtDo) Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo { + return n.withDO(n.DO.Scopes(funcs...)) +} + +func (n nachrichtDo) Unscoped() INachrichtDo { + return n.withDO(n.DO.Unscoped()) +} + +func (n nachrichtDo) Create(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Create(values) +} + +func (n nachrichtDo) CreateInBatches(values []*model.Nachricht, batchSize int) error { + return n.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (n nachrichtDo) Save(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Save(values) +} + +func (n nachrichtDo) First() (*model.Nachricht, error) { + if result, err := n.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Take() (*model.Nachricht, error) { + if result, err := n.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Last() (*model.Nachricht, error) { + if result, err := n.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Find() ([]*model.Nachricht, error) { + result, err := n.DO.Find() + return result.([]*model.Nachricht), err +} + +func (n nachrichtDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) { + buf := make([]*model.Nachricht, 0, batchSize) + err = n.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (n nachrichtDo) FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return n.DO.FindInBatches(result, batchSize, fc) +} + +func (n nachrichtDo) Attrs(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Attrs(attrs...)) +} + +func (n nachrichtDo) Assign(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Assign(attrs...)) +} + +func (n nachrichtDo) Joins(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Joins(_f)) + } + return &n +} + +func (n nachrichtDo) Preload(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Preload(_f)) + } + return &n +} + +func (n nachrichtDo) FirstOrInit() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FirstOrCreate() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) { + result, err = n.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = n.Offset(-1).Limit(-1).Count() + return +} + +func (n nachrichtDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = n.Count() + if err != nil { + return + } + + err = n.Offset(offset).Limit(limit).Scan(result) + return +} + +func (n nachrichtDo) Scan(result interface{}) (err error) { + return n.DO.Scan(result) +} + +func (n nachrichtDo) Delete(models ...*model.Nachricht) (result gen.ResultInfo, err error) { + return n.DO.Delete(models) +} + +func (n *nachrichtDo) withDO(do gen.Dao) *nachrichtDo { + n.DO = *do.(*gen.DO) + return n +} diff --git a/cmd/api/query/projekts.gen.go b/cmd/api/query/projekts.gen.go new file mode 100644 index 0000000..bd4e4a1 --- /dev/null +++ b/cmd/api/query/projekts.gen.go @@ -0,0 +1,502 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt { + _projekt := projekt{} + + _projekt.projektDo.UseDB(db, opts...) + _projekt.projektDo.UseModel(&model.Projekt{}) + + tableName := _projekt.projektDo.TableName() + _projekt.ALL = field.NewAsterisk(tableName) + _projekt.ID = field.NewUint(tableName, "id") + _projekt.CreatedAt = field.NewTime(tableName, "created_at") + _projekt.UpdatedAt = field.NewTime(tableName, "updated_at") + _projekt.DeletedAt = field.NewField(tableName, "deleted_at") + _projekt.Name = field.NewString(tableName, "name") + _projekt.Description = field.NewString(tableName, "description") + _projekt.Icon = field.NewString(tableName, "icon") + _projekt.MandantID = field.NewUint(tableName, "mandant_id") + _projekt.Mandant = projektBelongsToMandant{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Mandant", "model.Mandant"), + } + + _projekt.fillFieldMap() + + return _projekt +} + +type projekt struct { + projektDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Name field.String + Description field.String + Icon field.String + MandantID field.Uint + Mandant projektBelongsToMandant + + fieldMap map[string]field.Expr +} + +func (p projekt) Table(newTableName string) *projekt { + p.projektDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p projekt) As(alias string) *projekt { + p.projektDo.DO = *(p.projektDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *projekt) updateTableName(table string) *projekt { + p.ALL = field.NewAsterisk(table) + p.ID = field.NewUint(table, "id") + p.CreatedAt = field.NewTime(table, "created_at") + p.UpdatedAt = field.NewTime(table, "updated_at") + p.DeletedAt = field.NewField(table, "deleted_at") + p.Name = field.NewString(table, "name") + p.Description = field.NewString(table, "description") + p.Icon = field.NewString(table, "icon") + p.MandantID = field.NewUint(table, "mandant_id") + + p.fillFieldMap() + + return p +} + +func (p *projekt) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *projekt) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 9) + p.fieldMap["id"] = p.ID + p.fieldMap["created_at"] = p.CreatedAt + p.fieldMap["updated_at"] = p.UpdatedAt + p.fieldMap["deleted_at"] = p.DeletedAt + p.fieldMap["name"] = p.Name + p.fieldMap["description"] = p.Description + p.fieldMap["icon"] = p.Icon + p.fieldMap["mandant_id"] = p.MandantID + +} + +func (p projekt) clone(db *gorm.DB) projekt { + p.projektDo.ReplaceConnPool(db.Statement.ConnPool) + p.Mandant.db = db.Session(&gorm.Session{Initialized: true}) + p.Mandant.db.Statement.ConnPool = db.Statement.ConnPool + return p +} + +func (p projekt) replaceDB(db *gorm.DB) projekt { + p.projektDo.ReplaceDB(db) + p.Mandant.db = db.Session(&gorm.Session{}) + return p +} + +type projektBelongsToMandant struct { + db *gorm.DB + + field.RelationField +} + +func (a projektBelongsToMandant) Where(conds ...field.Expr) *projektBelongsToMandant { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a projektBelongsToMandant) WithContext(ctx context.Context) *projektBelongsToMandant { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a projektBelongsToMandant) Session(session *gorm.Session) *projektBelongsToMandant { + a.db = a.db.Session(session) + return &a +} + +func (a projektBelongsToMandant) Model(m *model.Projekt) *projektBelongsToMandantTx { + return &projektBelongsToMandantTx{a.db.Model(m).Association(a.Name())} +} + +func (a projektBelongsToMandant) Unscoped() *projektBelongsToMandant { + a.db = a.db.Unscoped() + return &a +} + +type projektBelongsToMandantTx struct{ tx *gorm.Association } + +func (a projektBelongsToMandantTx) Find() (result *model.Mandant, err error) { + return result, a.tx.Find(&result) +} + +func (a projektBelongsToMandantTx) Append(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a projektBelongsToMandantTx) Replace(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a projektBelongsToMandantTx) Delete(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a projektBelongsToMandantTx) Clear() error { + return a.tx.Clear() +} + +func (a projektBelongsToMandantTx) Count() int64 { + return a.tx.Count() +} + +func (a projektBelongsToMandantTx) Unscoped() *projektBelongsToMandantTx { + a.tx = a.tx.Unscoped() + return &a +} + +type projektDo struct{ gen.DO } + +type IProjektDo interface { + gen.SubQuery + Debug() IProjektDo + WithContext(ctx context.Context) IProjektDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IProjektDo + WriteDB() IProjektDo + As(alias string) gen.Dao + Session(config *gorm.Session) IProjektDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IProjektDo + Not(conds ...gen.Condition) IProjektDo + Or(conds ...gen.Condition) IProjektDo + Select(conds ...field.Expr) IProjektDo + Where(conds ...gen.Condition) IProjektDo + Order(conds ...field.Expr) IProjektDo + Distinct(cols ...field.Expr) IProjektDo + Omit(cols ...field.Expr) IProjektDo + Join(table schema.Tabler, on ...field.Expr) IProjektDo + LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo + RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo + Group(cols ...field.Expr) IProjektDo + Having(conds ...gen.Condition) IProjektDo + Limit(limit int) IProjektDo + Offset(offset int) IProjektDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo + Unscoped() IProjektDo + Create(values ...*model.Projekt) error + CreateInBatches(values []*model.Projekt, batchSize int) error + Save(values ...*model.Projekt) error + First() (*model.Projekt, error) + Take() (*model.Projekt, error) + Last() (*model.Projekt, error) + Find() ([]*model.Projekt, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) + FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Projekt) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IProjektDo + Assign(attrs ...field.AssignExpr) IProjektDo + Joins(fields ...field.RelationField) IProjektDo + Preload(fields ...field.RelationField) IProjektDo + FirstOrInit() (*model.Projekt, error) + FirstOrCreate() (*model.Projekt, error) + FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IProjektDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p projektDo) Debug() IProjektDo { + return p.withDO(p.DO.Debug()) +} + +func (p projektDo) WithContext(ctx context.Context) IProjektDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p projektDo) ReadDB() IProjektDo { + return p.Clauses(dbresolver.Read) +} + +func (p projektDo) WriteDB() IProjektDo { + return p.Clauses(dbresolver.Write) +} + +func (p projektDo) Session(config *gorm.Session) IProjektDo { + return p.withDO(p.DO.Session(config)) +} + +func (p projektDo) Clauses(conds ...clause.Expression) IProjektDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p projektDo) Returning(value interface{}, columns ...string) IProjektDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p projektDo) Not(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p projektDo) Or(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p projektDo) Select(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p projektDo) Where(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p projektDo) Order(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p projektDo) Distinct(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p projektDo) Omit(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p projektDo) Join(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p projektDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p projektDo) RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p projektDo) Group(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p projektDo) Having(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p projektDo) Limit(limit int) IProjektDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p projektDo) Offset(offset int) IProjektDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p projektDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p projektDo) Unscoped() IProjektDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p projektDo) Create(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p projektDo) CreateInBatches(values []*model.Projekt, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p projektDo) Save(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p projektDo) First() (*model.Projekt, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Take() (*model.Projekt, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Last() (*model.Projekt, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Find() ([]*model.Projekt, error) { + result, err := p.DO.Find() + return result.([]*model.Projekt), err +} + +func (p projektDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) { + buf := make([]*model.Projekt, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p projektDo) FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p projektDo) Attrs(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p projektDo) Assign(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p projektDo) Joins(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p projektDo) Preload(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p projektDo) FirstOrInit() (*model.Projekt, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FirstOrCreate() (*model.Projekt, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p projektDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p projektDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p projektDo) Delete(models ...*model.Projekt) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *projektDo) withDO(do gen.Dao) *projektDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/cmd/api/query/rechnungs.gen.go b/cmd/api/query/rechnungs.gen.go new file mode 100644 index 0000000..c3e25ed --- /dev/null +++ b/cmd/api/query/rechnungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnung(db *gorm.DB, opts ...gen.DOOption) rechnung { + _rechnung := rechnung{} + + _rechnung.rechnungDo.UseDB(db, opts...) + _rechnung.rechnungDo.UseModel(&model.Rechnung{}) + + tableName := _rechnung.rechnungDo.TableName() + _rechnung.ALL = field.NewAsterisk(tableName) + _rechnung.ID = field.NewUint(tableName, "id") + _rechnung.CreatedAt = field.NewTime(tableName, "created_at") + _rechnung.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnung.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnung.fillFieldMap() + + return _rechnung +} + +type rechnung struct { + rechnungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnung) Table(newTableName string) *rechnung { + r.rechnungDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnung) As(alias string) *rechnung { + r.rechnungDo.DO = *(r.rechnungDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnung) updateTableName(table string) *rechnung { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnung) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnung) clone(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnung) replaceDB(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceDB(db) + return r +} + +type rechnungDo struct{ gen.DO } + +type IRechnungDo interface { + gen.SubQuery + Debug() IRechnungDo + WithContext(ctx context.Context) IRechnungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungDo + WriteDB() IRechnungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungDo + Not(conds ...gen.Condition) IRechnungDo + Or(conds ...gen.Condition) IRechnungDo + Select(conds ...field.Expr) IRechnungDo + Where(conds ...gen.Condition) IRechnungDo + Order(conds ...field.Expr) IRechnungDo + Distinct(cols ...field.Expr) IRechnungDo + Omit(cols ...field.Expr) IRechnungDo + Join(table schema.Tabler, on ...field.Expr) IRechnungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + Group(cols ...field.Expr) IRechnungDo + Having(conds ...gen.Condition) IRechnungDo + Limit(limit int) IRechnungDo + Offset(offset int) IRechnungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo + Unscoped() IRechnungDo + Create(values ...*model.Rechnung) error + CreateInBatches(values []*model.Rechnung, batchSize int) error + Save(values ...*model.Rechnung) error + First() (*model.Rechnung, error) + Take() (*model.Rechnung, error) + Last() (*model.Rechnung, error) + Find() ([]*model.Rechnung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) + FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungDo + Assign(attrs ...field.AssignExpr) IRechnungDo + Joins(fields ...field.RelationField) IRechnungDo + Preload(fields ...field.RelationField) IRechnungDo + FirstOrInit() (*model.Rechnung, error) + FirstOrCreate() (*model.Rechnung, error) + FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungDo) Debug() IRechnungDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungDo) WithContext(ctx context.Context) IRechnungDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungDo) ReadDB() IRechnungDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungDo) WriteDB() IRechnungDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungDo) Session(config *gorm.Session) IRechnungDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungDo) Clauses(conds ...clause.Expression) IRechnungDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungDo) Returning(value interface{}, columns ...string) IRechnungDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungDo) Not(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungDo) Or(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungDo) Select(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungDo) Where(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungDo) Order(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungDo) Distinct(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungDo) Omit(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungDo) Join(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungDo) Group(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungDo) Having(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungDo) Limit(limit int) IRechnungDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungDo) Offset(offset int) IRechnungDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungDo) Unscoped() IRechnungDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungDo) Create(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungDo) CreateInBatches(values []*model.Rechnung, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungDo) Save(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungDo) First() (*model.Rechnung, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Take() (*model.Rechnung, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Last() (*model.Rechnung, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Find() ([]*model.Rechnung, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnung), err +} + +func (r rechnungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) { + buf := make([]*model.Rechnung, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungDo) FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungDo) Attrs(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungDo) Assign(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungDo) Joins(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungDo) Preload(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungDo) FirstOrInit() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FirstOrCreate() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungDo) Delete(models ...*model.Rechnung) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungDo) withDO(do gen.Dao) *rechnungDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/cmd/api/query/rechnungspositions.gen.go b/cmd/api/query/rechnungspositions.gen.go new file mode 100644 index 0000000..de07dec --- /dev/null +++ b/cmd/api/query/rechnungspositions.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnungsposition(db *gorm.DB, opts ...gen.DOOption) rechnungsposition { + _rechnungsposition := rechnungsposition{} + + _rechnungsposition.rechnungspositionDo.UseDB(db, opts...) + _rechnungsposition.rechnungspositionDo.UseModel(&model.Rechnungsposition{}) + + tableName := _rechnungsposition.rechnungspositionDo.TableName() + _rechnungsposition.ALL = field.NewAsterisk(tableName) + _rechnungsposition.ID = field.NewUint(tableName, "id") + _rechnungsposition.CreatedAt = field.NewTime(tableName, "created_at") + _rechnungsposition.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnungsposition.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnungsposition.fillFieldMap() + + return _rechnungsposition +} + +type rechnungsposition struct { + rechnungspositionDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnungsposition) Table(newTableName string) *rechnungsposition { + r.rechnungspositionDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnungsposition) As(alias string) *rechnungsposition { + r.rechnungspositionDo.DO = *(r.rechnungspositionDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnungsposition) updateTableName(table string) *rechnungsposition { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnungsposition) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnungsposition) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnungsposition) clone(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnungsposition) replaceDB(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceDB(db) + return r +} + +type rechnungspositionDo struct{ gen.DO } + +type IRechnungspositionDo interface { + gen.SubQuery + Debug() IRechnungspositionDo + WithContext(ctx context.Context) IRechnungspositionDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungspositionDo + WriteDB() IRechnungspositionDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungspositionDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungspositionDo + Not(conds ...gen.Condition) IRechnungspositionDo + Or(conds ...gen.Condition) IRechnungspositionDo + Select(conds ...field.Expr) IRechnungspositionDo + Where(conds ...gen.Condition) IRechnungspositionDo + Order(conds ...field.Expr) IRechnungspositionDo + Distinct(cols ...field.Expr) IRechnungspositionDo + Omit(cols ...field.Expr) IRechnungspositionDo + Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + Group(cols ...field.Expr) IRechnungspositionDo + Having(conds ...gen.Condition) IRechnungspositionDo + Limit(limit int) IRechnungspositionDo + Offset(offset int) IRechnungspositionDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo + Unscoped() IRechnungspositionDo + Create(values ...*model.Rechnungsposition) error + CreateInBatches(values []*model.Rechnungsposition, batchSize int) error + Save(values ...*model.Rechnungsposition) error + First() (*model.Rechnungsposition, error) + Take() (*model.Rechnungsposition, error) + Last() (*model.Rechnungsposition, error) + Find() ([]*model.Rechnungsposition, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) + FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnungsposition) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungspositionDo + Assign(attrs ...field.AssignExpr) IRechnungspositionDo + Joins(fields ...field.RelationField) IRechnungspositionDo + Preload(fields ...field.RelationField) IRechnungspositionDo + FirstOrInit() (*model.Rechnungsposition, error) + FirstOrCreate() (*model.Rechnungsposition, error) + FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungspositionDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungspositionDo) Debug() IRechnungspositionDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungspositionDo) WithContext(ctx context.Context) IRechnungspositionDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungspositionDo) ReadDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungspositionDo) WriteDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungspositionDo) Session(config *gorm.Session) IRechnungspositionDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungspositionDo) Clauses(conds ...clause.Expression) IRechnungspositionDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungspositionDo) Returning(value interface{}, columns ...string) IRechnungspositionDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungspositionDo) Not(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungspositionDo) Or(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungspositionDo) Select(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungspositionDo) Where(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungspositionDo) Order(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungspositionDo) Distinct(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungspositionDo) Omit(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungspositionDo) Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungspositionDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungspositionDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungspositionDo) Group(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungspositionDo) Having(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungspositionDo) Limit(limit int) IRechnungspositionDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungspositionDo) Offset(offset int) IRechnungspositionDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungspositionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungspositionDo) Unscoped() IRechnungspositionDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungspositionDo) Create(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungspositionDo) CreateInBatches(values []*model.Rechnungsposition, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungspositionDo) Save(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungspositionDo) First() (*model.Rechnungsposition, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Take() (*model.Rechnungsposition, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Last() (*model.Rechnungsposition, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Find() ([]*model.Rechnungsposition, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnungsposition), err +} + +func (r rechnungspositionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) { + buf := make([]*model.Rechnungsposition, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungspositionDo) FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungspositionDo) Attrs(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungspositionDo) Assign(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungspositionDo) Joins(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungspositionDo) Preload(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungspositionDo) FirstOrInit() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FirstOrCreate() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungspositionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungspositionDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungspositionDo) Delete(models ...*model.Rechnungsposition) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungspositionDo) withDO(do gen.Dao) *rechnungspositionDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/cmd/api/query/scanobjects.gen.go b/cmd/api/query/scanobjects.gen.go new file mode 100644 index 0000000..661b4e9 --- /dev/null +++ b/cmd/api/query/scanobjects.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newScanobject(db *gorm.DB, opts ...gen.DOOption) scanobject { + _scanobject := scanobject{} + + _scanobject.scanobjectDo.UseDB(db, opts...) + _scanobject.scanobjectDo.UseModel(&model.Scanobject{}) + + tableName := _scanobject.scanobjectDo.TableName() + _scanobject.ALL = field.NewAsterisk(tableName) + _scanobject.ID = field.NewUint(tableName, "id") + _scanobject.CreatedAt = field.NewTime(tableName, "created_at") + _scanobject.UpdatedAt = field.NewTime(tableName, "updated_at") + _scanobject.DeletedAt = field.NewField(tableName, "deleted_at") + + _scanobject.fillFieldMap() + + return _scanobject +} + +type scanobject struct { + scanobjectDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (s scanobject) Table(newTableName string) *scanobject { + s.scanobjectDo.UseTable(newTableName) + return s.updateTableName(newTableName) +} + +func (s scanobject) As(alias string) *scanobject { + s.scanobjectDo.DO = *(s.scanobjectDo.As(alias).(*gen.DO)) + return s.updateTableName(alias) +} + +func (s *scanobject) updateTableName(table string) *scanobject { + s.ALL = field.NewAsterisk(table) + s.ID = field.NewUint(table, "id") + s.CreatedAt = field.NewTime(table, "created_at") + s.UpdatedAt = field.NewTime(table, "updated_at") + s.DeletedAt = field.NewField(table, "deleted_at") + + s.fillFieldMap() + + return s +} + +func (s *scanobject) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := s.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (s *scanobject) fillFieldMap() { + s.fieldMap = make(map[string]field.Expr, 4) + s.fieldMap["id"] = s.ID + s.fieldMap["created_at"] = s.CreatedAt + s.fieldMap["updated_at"] = s.UpdatedAt + s.fieldMap["deleted_at"] = s.DeletedAt +} + +func (s scanobject) clone(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceConnPool(db.Statement.ConnPool) + return s +} + +func (s scanobject) replaceDB(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceDB(db) + return s +} + +type scanobjectDo struct{ gen.DO } + +type IScanobjectDo interface { + gen.SubQuery + Debug() IScanobjectDo + WithContext(ctx context.Context) IScanobjectDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IScanobjectDo + WriteDB() IScanobjectDo + As(alias string) gen.Dao + Session(config *gorm.Session) IScanobjectDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IScanobjectDo + Not(conds ...gen.Condition) IScanobjectDo + Or(conds ...gen.Condition) IScanobjectDo + Select(conds ...field.Expr) IScanobjectDo + Where(conds ...gen.Condition) IScanobjectDo + Order(conds ...field.Expr) IScanobjectDo + Distinct(cols ...field.Expr) IScanobjectDo + Omit(cols ...field.Expr) IScanobjectDo + Join(table schema.Tabler, on ...field.Expr) IScanobjectDo + LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + Group(cols ...field.Expr) IScanobjectDo + Having(conds ...gen.Condition) IScanobjectDo + Limit(limit int) IScanobjectDo + Offset(offset int) IScanobjectDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo + Unscoped() IScanobjectDo + Create(values ...*model.Scanobject) error + CreateInBatches(values []*model.Scanobject, batchSize int) error + Save(values ...*model.Scanobject) error + First() (*model.Scanobject, error) + Take() (*model.Scanobject, error) + Last() (*model.Scanobject, error) + Find() ([]*model.Scanobject, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) + FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Scanobject) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IScanobjectDo + Assign(attrs ...field.AssignExpr) IScanobjectDo + Joins(fields ...field.RelationField) IScanobjectDo + Preload(fields ...field.RelationField) IScanobjectDo + FirstOrInit() (*model.Scanobject, error) + FirstOrCreate() (*model.Scanobject, error) + FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IScanobjectDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (s scanobjectDo) Debug() IScanobjectDo { + return s.withDO(s.DO.Debug()) +} + +func (s scanobjectDo) WithContext(ctx context.Context) IScanobjectDo { + return s.withDO(s.DO.WithContext(ctx)) +} + +func (s scanobjectDo) ReadDB() IScanobjectDo { + return s.Clauses(dbresolver.Read) +} + +func (s scanobjectDo) WriteDB() IScanobjectDo { + return s.Clauses(dbresolver.Write) +} + +func (s scanobjectDo) Session(config *gorm.Session) IScanobjectDo { + return s.withDO(s.DO.Session(config)) +} + +func (s scanobjectDo) Clauses(conds ...clause.Expression) IScanobjectDo { + return s.withDO(s.DO.Clauses(conds...)) +} + +func (s scanobjectDo) Returning(value interface{}, columns ...string) IScanobjectDo { + return s.withDO(s.DO.Returning(value, columns...)) +} + +func (s scanobjectDo) Not(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Not(conds...)) +} + +func (s scanobjectDo) Or(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Or(conds...)) +} + +func (s scanobjectDo) Select(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Select(conds...)) +} + +func (s scanobjectDo) Where(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Where(conds...)) +} + +func (s scanobjectDo) Order(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Order(conds...)) +} + +func (s scanobjectDo) Distinct(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Distinct(cols...)) +} + +func (s scanobjectDo) Omit(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Omit(cols...)) +} + +func (s scanobjectDo) Join(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Join(table, on...)) +} + +func (s scanobjectDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.LeftJoin(table, on...)) +} + +func (s scanobjectDo) RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.RightJoin(table, on...)) +} + +func (s scanobjectDo) Group(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Group(cols...)) +} + +func (s scanobjectDo) Having(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Having(conds...)) +} + +func (s scanobjectDo) Limit(limit int) IScanobjectDo { + return s.withDO(s.DO.Limit(limit)) +} + +func (s scanobjectDo) Offset(offset int) IScanobjectDo { + return s.withDO(s.DO.Offset(offset)) +} + +func (s scanobjectDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo { + return s.withDO(s.DO.Scopes(funcs...)) +} + +func (s scanobjectDo) Unscoped() IScanobjectDo { + return s.withDO(s.DO.Unscoped()) +} + +func (s scanobjectDo) Create(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Create(values) +} + +func (s scanobjectDo) CreateInBatches(values []*model.Scanobject, batchSize int) error { + return s.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (s scanobjectDo) Save(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Save(values) +} + +func (s scanobjectDo) First() (*model.Scanobject, error) { + if result, err := s.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Take() (*model.Scanobject, error) { + if result, err := s.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Last() (*model.Scanobject, error) { + if result, err := s.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Find() ([]*model.Scanobject, error) { + result, err := s.DO.Find() + return result.([]*model.Scanobject), err +} + +func (s scanobjectDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) { + buf := make([]*model.Scanobject, 0, batchSize) + err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (s scanobjectDo) FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return s.DO.FindInBatches(result, batchSize, fc) +} + +func (s scanobjectDo) Attrs(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Attrs(attrs...)) +} + +func (s scanobjectDo) Assign(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Assign(attrs...)) +} + +func (s scanobjectDo) Joins(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Joins(_f)) + } + return &s +} + +func (s scanobjectDo) Preload(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Preload(_f)) + } + return &s +} + +func (s scanobjectDo) FirstOrInit() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FirstOrCreate() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) { + result, err = s.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = s.Offset(-1).Limit(-1).Count() + return +} + +func (s scanobjectDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = s.Count() + if err != nil { + return + } + + err = s.Offset(offset).Limit(limit).Scan(result) + return +} + +func (s scanobjectDo) Scan(result interface{}) (err error) { + return s.DO.Scan(result) +} + +func (s scanobjectDo) Delete(models ...*model.Scanobject) (result gen.ResultInfo, err error) { + return s.DO.Delete(models) +} + +func (s *scanobjectDo) withDO(do gen.Dao) *scanobjectDo { + s.DO = *do.(*gen.DO) + return s +} diff --git a/cmd/api/query/users.gen.go b/cmd/api/query/users.gen.go new file mode 100644 index 0000000..c0b3e51 --- /dev/null +++ b/cmd/api/query/users.gen.go @@ -0,0 +1,403 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newUser(db *gorm.DB, opts ...gen.DOOption) user { + _user := user{} + + _user.userDo.UseDB(db, opts...) + _user.userDo.UseModel(&model.User{}) + + tableName := _user.userDo.TableName() + _user.ALL = field.NewAsterisk(tableName) + _user.ID = field.NewUint(tableName, "id") + _user.CreatedAt = field.NewTime(tableName, "created_at") + _user.UpdatedAt = field.NewTime(tableName, "updated_at") + _user.DeletedAt = field.NewField(tableName, "deleted_at") + _user.Sub = field.NewString(tableName, "sub") + _user.Email = field.NewString(tableName, "email") + + _user.fillFieldMap() + + return _user +} + +type user struct { + userDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Sub field.String + Email field.String + + fieldMap map[string]field.Expr +} + +func (u user) Table(newTableName string) *user { + u.userDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u user) As(alias string) *user { + u.userDo.DO = *(u.userDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *user) updateTableName(table string) *user { + u.ALL = field.NewAsterisk(table) + u.ID = field.NewUint(table, "id") + u.CreatedAt = field.NewTime(table, "created_at") + u.UpdatedAt = field.NewTime(table, "updated_at") + u.DeletedAt = field.NewField(table, "deleted_at") + u.Sub = field.NewString(table, "sub") + u.Email = field.NewString(table, "email") + + u.fillFieldMap() + + return u +} + +func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *user) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 6) + u.fieldMap["id"] = u.ID + u.fieldMap["created_at"] = u.CreatedAt + u.fieldMap["updated_at"] = u.UpdatedAt + u.fieldMap["deleted_at"] = u.DeletedAt + u.fieldMap["sub"] = u.Sub + u.fieldMap["email"] = u.Email +} + +func (u user) clone(db *gorm.DB) user { + u.userDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u user) replaceDB(db *gorm.DB) user { + u.userDo.ReplaceDB(db) + return u +} + +type userDo struct{ gen.DO } + +type IUserDo interface { + gen.SubQuery + Debug() IUserDo + WithContext(ctx context.Context) IUserDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUserDo + WriteDB() IUserDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUserDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUserDo + Not(conds ...gen.Condition) IUserDo + Or(conds ...gen.Condition) IUserDo + Select(conds ...field.Expr) IUserDo + Where(conds ...gen.Condition) IUserDo + Order(conds ...field.Expr) IUserDo + Distinct(cols ...field.Expr) IUserDo + Omit(cols ...field.Expr) IUserDo + Join(table schema.Tabler, on ...field.Expr) IUserDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo + RightJoin(table schema.Tabler, on ...field.Expr) IUserDo + Group(cols ...field.Expr) IUserDo + Having(conds ...gen.Condition) IUserDo + Limit(limit int) IUserDo + Offset(offset int) IUserDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo + Unscoped() IUserDo + Create(values ...*model.User) error + CreateInBatches(values []*model.User, batchSize int) error + Save(values ...*model.User) error + First() (*model.User, error) + Take() (*model.User, error) + Last() (*model.User, error) + Find() ([]*model.User, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) + FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.User) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUserDo + Assign(attrs ...field.AssignExpr) IUserDo + Joins(fields ...field.RelationField) IUserDo + Preload(fields ...field.RelationField) IUserDo + FirstOrInit() (*model.User, error) + FirstOrCreate() (*model.User, error) + FindByPage(offset int, limit int) (result []*model.User, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUserDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u userDo) Debug() IUserDo { + return u.withDO(u.DO.Debug()) +} + +func (u userDo) WithContext(ctx context.Context) IUserDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u userDo) ReadDB() IUserDo { + return u.Clauses(dbresolver.Read) +} + +func (u userDo) WriteDB() IUserDo { + return u.Clauses(dbresolver.Write) +} + +func (u userDo) Session(config *gorm.Session) IUserDo { + return u.withDO(u.DO.Session(config)) +} + +func (u userDo) Clauses(conds ...clause.Expression) IUserDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u userDo) Returning(value interface{}, columns ...string) IUserDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u userDo) Not(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u userDo) Or(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u userDo) Select(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u userDo) Where(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u userDo) Order(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u userDo) Distinct(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u userDo) Omit(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u userDo) Group(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u userDo) Having(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u userDo) Limit(limit int) IUserDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u userDo) Offset(offset int) IUserDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u userDo) Unscoped() IUserDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u userDo) Create(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u userDo) CreateInBatches(values []*model.User, batchSize int) error { + return u.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (u userDo) Save(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u userDo) First() (*model.User, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Take() (*model.User, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Last() (*model.User, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Find() ([]*model.User, error) { + result, err := u.DO.Find() + return result.([]*model.User), err +} + +func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) { + buf := make([]*model.User, 0, batchSize) + err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u userDo) Joins(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u userDo) Preload(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u userDo) FirstOrInit() (*model.User, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FirstOrCreate() (*model.User, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FindByPage(offset int, limit int) (result []*model.User, count int64, err error) { + result, err = u.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = u.Offset(-1).Limit(-1).Count() + return +} + +func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u userDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u userDo) Delete(models ...*model.User) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *userDo) withDO(do gen.Dao) *userDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/cmd/api/query/zahlungs.gen.go b/cmd/api/query/zahlungs.gen.go new file mode 100644 index 0000000..9526702 --- /dev/null +++ b/cmd/api/query/zahlungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newZahlung(db *gorm.DB, opts ...gen.DOOption) zahlung { + _zahlung := zahlung{} + + _zahlung.zahlungDo.UseDB(db, opts...) + _zahlung.zahlungDo.UseModel(&model.Zahlung{}) + + tableName := _zahlung.zahlungDo.TableName() + _zahlung.ALL = field.NewAsterisk(tableName) + _zahlung.ID = field.NewUint(tableName, "id") + _zahlung.CreatedAt = field.NewTime(tableName, "created_at") + _zahlung.UpdatedAt = field.NewTime(tableName, "updated_at") + _zahlung.DeletedAt = field.NewField(tableName, "deleted_at") + + _zahlung.fillFieldMap() + + return _zahlung +} + +type zahlung struct { + zahlungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (z zahlung) Table(newTableName string) *zahlung { + z.zahlungDo.UseTable(newTableName) + return z.updateTableName(newTableName) +} + +func (z zahlung) As(alias string) *zahlung { + z.zahlungDo.DO = *(z.zahlungDo.As(alias).(*gen.DO)) + return z.updateTableName(alias) +} + +func (z *zahlung) updateTableName(table string) *zahlung { + z.ALL = field.NewAsterisk(table) + z.ID = field.NewUint(table, "id") + z.CreatedAt = field.NewTime(table, "created_at") + z.UpdatedAt = field.NewTime(table, "updated_at") + z.DeletedAt = field.NewField(table, "deleted_at") + + z.fillFieldMap() + + return z +} + +func (z *zahlung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := z.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (z *zahlung) fillFieldMap() { + z.fieldMap = make(map[string]field.Expr, 4) + z.fieldMap["id"] = z.ID + z.fieldMap["created_at"] = z.CreatedAt + z.fieldMap["updated_at"] = z.UpdatedAt + z.fieldMap["deleted_at"] = z.DeletedAt +} + +func (z zahlung) clone(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceConnPool(db.Statement.ConnPool) + return z +} + +func (z zahlung) replaceDB(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceDB(db) + return z +} + +type zahlungDo struct{ gen.DO } + +type IZahlungDo interface { + gen.SubQuery + Debug() IZahlungDo + WithContext(ctx context.Context) IZahlungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IZahlungDo + WriteDB() IZahlungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IZahlungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IZahlungDo + Not(conds ...gen.Condition) IZahlungDo + Or(conds ...gen.Condition) IZahlungDo + Select(conds ...field.Expr) IZahlungDo + Where(conds ...gen.Condition) IZahlungDo + Order(conds ...field.Expr) IZahlungDo + Distinct(cols ...field.Expr) IZahlungDo + Omit(cols ...field.Expr) IZahlungDo + Join(table schema.Tabler, on ...field.Expr) IZahlungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + Group(cols ...field.Expr) IZahlungDo + Having(conds ...gen.Condition) IZahlungDo + Limit(limit int) IZahlungDo + Offset(offset int) IZahlungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo + Unscoped() IZahlungDo + Create(values ...*model.Zahlung) error + CreateInBatches(values []*model.Zahlung, batchSize int) error + Save(values ...*model.Zahlung) error + First() (*model.Zahlung, error) + Take() (*model.Zahlung, error) + Last() (*model.Zahlung, error) + Find() ([]*model.Zahlung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) + FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Zahlung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IZahlungDo + Assign(attrs ...field.AssignExpr) IZahlungDo + Joins(fields ...field.RelationField) IZahlungDo + Preload(fields ...field.RelationField) IZahlungDo + FirstOrInit() (*model.Zahlung, error) + FirstOrCreate() (*model.Zahlung, error) + FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IZahlungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (z zahlungDo) Debug() IZahlungDo { + return z.withDO(z.DO.Debug()) +} + +func (z zahlungDo) WithContext(ctx context.Context) IZahlungDo { + return z.withDO(z.DO.WithContext(ctx)) +} + +func (z zahlungDo) ReadDB() IZahlungDo { + return z.Clauses(dbresolver.Read) +} + +func (z zahlungDo) WriteDB() IZahlungDo { + return z.Clauses(dbresolver.Write) +} + +func (z zahlungDo) Session(config *gorm.Session) IZahlungDo { + return z.withDO(z.DO.Session(config)) +} + +func (z zahlungDo) Clauses(conds ...clause.Expression) IZahlungDo { + return z.withDO(z.DO.Clauses(conds...)) +} + +func (z zahlungDo) Returning(value interface{}, columns ...string) IZahlungDo { + return z.withDO(z.DO.Returning(value, columns...)) +} + +func (z zahlungDo) Not(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Not(conds...)) +} + +func (z zahlungDo) Or(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Or(conds...)) +} + +func (z zahlungDo) Select(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Select(conds...)) +} + +func (z zahlungDo) Where(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Where(conds...)) +} + +func (z zahlungDo) Order(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Order(conds...)) +} + +func (z zahlungDo) Distinct(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Distinct(cols...)) +} + +func (z zahlungDo) Omit(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Omit(cols...)) +} + +func (z zahlungDo) Join(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Join(table, on...)) +} + +func (z zahlungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.LeftJoin(table, on...)) +} + +func (z zahlungDo) RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.RightJoin(table, on...)) +} + +func (z zahlungDo) Group(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Group(cols...)) +} + +func (z zahlungDo) Having(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Having(conds...)) +} + +func (z zahlungDo) Limit(limit int) IZahlungDo { + return z.withDO(z.DO.Limit(limit)) +} + +func (z zahlungDo) Offset(offset int) IZahlungDo { + return z.withDO(z.DO.Offset(offset)) +} + +func (z zahlungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo { + return z.withDO(z.DO.Scopes(funcs...)) +} + +func (z zahlungDo) Unscoped() IZahlungDo { + return z.withDO(z.DO.Unscoped()) +} + +func (z zahlungDo) Create(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Create(values) +} + +func (z zahlungDo) CreateInBatches(values []*model.Zahlung, batchSize int) error { + return z.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (z zahlungDo) Save(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Save(values) +} + +func (z zahlungDo) First() (*model.Zahlung, error) { + if result, err := z.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Take() (*model.Zahlung, error) { + if result, err := z.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Last() (*model.Zahlung, error) { + if result, err := z.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Find() ([]*model.Zahlung, error) { + result, err := z.DO.Find() + return result.([]*model.Zahlung), err +} + +func (z zahlungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) { + buf := make([]*model.Zahlung, 0, batchSize) + err = z.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (z zahlungDo) FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return z.DO.FindInBatches(result, batchSize, fc) +} + +func (z zahlungDo) Attrs(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Attrs(attrs...)) +} + +func (z zahlungDo) Assign(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Assign(attrs...)) +} + +func (z zahlungDo) Joins(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Joins(_f)) + } + return &z +} + +func (z zahlungDo) Preload(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Preload(_f)) + } + return &z +} + +func (z zahlungDo) FirstOrInit() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FirstOrCreate() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) { + result, err = z.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = z.Offset(-1).Limit(-1).Count() + return +} + +func (z zahlungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = z.Count() + if err != nil { + return + } + + err = z.Offset(offset).Limit(limit).Scan(result) + return +} + +func (z zahlungDo) Scan(result interface{}) (err error) { + return z.DO.Scan(result) +} + +func (z zahlungDo) Delete(models ...*model.Zahlung) (result gen.ResultInfo, err error) { + return z.DO.Delete(models) +} + +func (z *zahlungDo) withDO(do gen.Dao) *zahlungDo { + z.DO = *do.(*gen.DO) + return z +} diff --git a/cmd/mailingest/.air.toml b/cmd/mailingest/.air.toml new file mode 100644 index 0000000..b6e034f --- /dev/null +++ b/cmd/mailingest/.air.toml @@ -0,0 +1,52 @@ +root = "." +testdata_dir = "testdata" +tmp_dir = "tmp" + +[build] + args_bin = [] + bin = "./tmp/main" + cmd = "go build -o ./tmp/main ." + delay = 1000 + exclude_dir = ["assets", "tmp", "vendor", "testdata", "query"] + exclude_file = [] + exclude_regex = ["_test.go"] + exclude_unchanged = false + follow_symlink = false + full_bin = "" + include_dir = [] + include_ext = ["go", "tpl", "tmpl", "html"] + include_file = [] + kill_delay = "0s" + log = "build-errors.log" + poll = false + poll_interval = 0 + post_cmd = [] + pre_cmd = [] + rerun = false + rerun_delay = 500 + send_interrupt = false + stop_on_error = false + +[color] + app = "" + build = "yellow" + main = "magenta" + runner = "green" + watcher = "cyan" + +[log] + main_only = false + silent = false + time = false + +[misc] + clean_on_exit = false + +[proxy] + app_port = 0 + enabled = false + proxy_port = 0 + +[screen] + clear_on_rebuild = false + keep_scroll = true diff --git a/cmd/mailingest/main.go b/cmd/mailingest/main.go new file mode 100644 index 0000000..eefb9d5 --- /dev/null +++ b/cmd/mailingest/main.go @@ -0,0 +1,161 @@ +package main + +import ( + "crypto/tls" + "io" + "log" + "log/slog" + "os" + + "github.com/emersion/go-imap/v2" + "github.com/emersion/go-imap/v2/imapclient" + "github.com/emersion/go-message/mail" +) + +func main() { + logger := slog.New(slog.NewTextHandler(os.Stdout, nil)) + + // err := godotenv.Load() + // if err != nil { + // logger.Error("Error Loading Environment variables! ", "error", err) + // } + + // logger.Info("Setting up DB") + // db := utils.SetupDatabase(os.Getenv("DB_DSN"), logger) + // logger.Info("Done setting up DB") + + // appCtx := utils.Application{Logger: logger, DB: db} + + // Register to jobs. + + // auth := smtp.PlainAuth("", "me@kocoder.xyz", "&,25,upMeddeEnTYPTifaccEptIonaAlErGiE", "mx.kocoder.xyz") + + // logger.Info("Before sending Email") + // err := smtp.SendMail("mx.kocoder.xyz:587", auth, "me@kocoder.xyz", []string{"oss@kocoder.xyz"}, []byte( + // "From: Konstantin Hintermayer \r\n"+ + // "To: oss@kocoder.xyz\r\n"+ + // "Subject: discount Gophers!\r\n"+ + // "\r\n"+ + // "This is the email body lel.\r\n")) + // if err != nil { + // logger.Error("Unable to send EMail", "err", err) + // } else { + // logger.Info("Successfully sent Email") + // } + + c, err := imapclient.DialTLS("10.1.0.2:993", &imapclient.Options{TLSConfig: &tls.Config{ServerName: "mx.kocoder.xyz"}}) + if err != nil { + log.Fatalf("failed to dial IMAP server: %v", err) + } + defer c.Close() + + if err := c.Login("me@kocoder.xyz", "&,25,upMeddeEnTYPTifaccEptIonaAlErGiE").Wait(); err != nil { + log.Fatalf("failed to login: %v", err) + } + log.Print("Connected") + + mailboxes, err := c.List("", "%", nil).Collect() + if err != nil { + log.Fatalf("failed to list mailboxes: %v", err) + } + log.Printf("Found %v mailboxes", len(mailboxes)) + for _, mbox := range mailboxes { + log.Printf(" - %v", mbox.Mailbox) + } + + selectedMbox, err := c.Select("INBOX", nil).Wait() + if err != nil { + log.Fatalf("failed to select INBOX: %v", err) + } + log.Printf("INBOX contains %v messages", selectedMbox.NumMessages) + + i := 0 + + for { + // Send a FETCH command to fetch the message body + seqSet := imap.SeqSetNum(uint32(i)) + + bodySection := &imap.FetchItemBodySection{} + fetchOptions := &imap.FetchOptions{ + BodySection: []*imap.FetchItemBodySection{bodySection}, + } + fetchCmd := c.Fetch(seqSet, fetchOptions) + defer fetchCmd.Close() + + msg := fetchCmd.Next() + for msg != nil { + // Find the body section in the response + var bodySectionData imapclient.FetchItemDataBodySection + ok := false + for { + item := msg.Next() + if item == nil { + break + } + bodySectionData, ok = item.(imapclient.FetchItemDataBodySection) + if ok { + break + } + } + if !ok { + log.Fatalf("FETCH command did not return body section") + } + + // Read the message via the go-message library + mr, err := mail.CreateReader(bodySectionData.Literal) + if err != nil { + log.Fatalf("failed to create mail reader: %v", err) + } + + // Print a few header fields + h := mr.Header + if date, err := h.Date(); err != nil { + log.Printf("failed to parse Date header field: %v", err) + } else { + log.Printf("Date: %v", date) + } + if to, err := h.AddressList("To"); err != nil { + log.Printf("failed to parse To header field: %v", err) + } else { + log.Printf("To: %v", to) + } + if subject, err := h.Text("Subject"); err != nil { + log.Printf("failed to parse Subject header field: %v", err) + } else { + log.Printf("Subject: %v", subject) + } + + if err := fetchCmd.Close(); err != nil { + logger.Error("FETCH command failed", "err", err) + } + + // Process the message's parts + for { + p, err := mr.NextPart() + if err == io.EOF { + break + } else if err != nil { + log.Fatalf("failed to read message part: %v", err) + } + + switch h := p.Header.(type) { + case *mail.InlineHeader: + // This is the message's text (can be plain-text or HTML) + b, _ := io.ReadAll(p.Body) + log.Printf("Inline text: %v", string(b)) + case *mail.AttachmentHeader: + // This is an attachment + filename, _ := h.Filename() + log.Printf("Attachment: %v", filename) + } + } + + msg = fetchCmd.Next() + } + + i++ + if i > 10 { + break + } + } +} diff --git a/cmd/mailingest/query/ansprechpartners.gen.go b/cmd/mailingest/query/ansprechpartners.gen.go new file mode 100644 index 0000000..ba155b4 --- /dev/null +++ b/cmd/mailingest/query/ansprechpartners.gen.go @@ -0,0 +1,562 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) ansprechpartner { + _ansprechpartner := ansprechpartner{} + + _ansprechpartner.ansprechpartnerDo.UseDB(db, opts...) + _ansprechpartner.ansprechpartnerDo.UseModel(&model.Ansprechpartner{}) + + tableName := _ansprechpartner.ansprechpartnerDo.TableName() + _ansprechpartner.ALL = field.NewAsterisk(tableName) + _ansprechpartner.ID = field.NewUint(tableName, "id") + _ansprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _ansprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _ansprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _ansprechpartner.ImageURL = field.NewString(tableName, "image_url") + _ansprechpartner.Title = field.NewString(tableName, "title") + _ansprechpartner.FirstName = field.NewString(tableName, "first_name") + _ansprechpartner.LastName = field.NewString(tableName, "last_name") + _ansprechpartner.LastTitle = field.NewString(tableName, "last_title") + _ansprechpartner.EMail = field.NewString(tableName, "e_mail") + _ansprechpartner.Phone = field.NewString(tableName, "phone") + _ansprechpartner.Mobile = field.NewString(tableName, "mobile") + _ansprechpartner.Notes = field.NewString(tableName, "notes") + _ansprechpartner.Description = field.NewString(tableName, "description") + _ansprechpartner.Active = field.NewBool(tableName, "active") + _ansprechpartner.Gender = field.NewInt(tableName, "gender") + _ansprechpartner.Firmen = ansprechpartnerManyToManyFirmen{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Firmen", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Firmen.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _ansprechpartner.fillFieldMap() + + return _ansprechpartner +} + +type ansprechpartner struct { + ansprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + ImageURL field.String + Title field.String + FirstName field.String + LastName field.String + LastTitle field.String + EMail field.String + Phone field.String + Mobile field.String + Notes field.String + Description field.String + Active field.Bool + Gender field.Int + Firmen ansprechpartnerManyToManyFirmen + + fieldMap map[string]field.Expr +} + +func (a ansprechpartner) Table(newTableName string) *ansprechpartner { + a.ansprechpartnerDo.UseTable(newTableName) + return a.updateTableName(newTableName) +} + +func (a ansprechpartner) As(alias string) *ansprechpartner { + a.ansprechpartnerDo.DO = *(a.ansprechpartnerDo.As(alias).(*gen.DO)) + return a.updateTableName(alias) +} + +func (a *ansprechpartner) updateTableName(table string) *ansprechpartner { + a.ALL = field.NewAsterisk(table) + a.ID = field.NewUint(table, "id") + a.CreatedAt = field.NewTime(table, "created_at") + a.UpdatedAt = field.NewTime(table, "updated_at") + a.DeletedAt = field.NewField(table, "deleted_at") + a.ImageURL = field.NewString(table, "image_url") + a.Title = field.NewString(table, "title") + a.FirstName = field.NewString(table, "first_name") + a.LastName = field.NewString(table, "last_name") + a.LastTitle = field.NewString(table, "last_title") + a.EMail = field.NewString(table, "e_mail") + a.Phone = field.NewString(table, "phone") + a.Mobile = field.NewString(table, "mobile") + a.Notes = field.NewString(table, "notes") + a.Description = field.NewString(table, "description") + a.Active = field.NewBool(table, "active") + a.Gender = field.NewInt(table, "gender") + + a.fillFieldMap() + + return a +} + +func (a *ansprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := a.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (a *ansprechpartner) fillFieldMap() { + a.fieldMap = make(map[string]field.Expr, 17) + a.fieldMap["id"] = a.ID + a.fieldMap["created_at"] = a.CreatedAt + a.fieldMap["updated_at"] = a.UpdatedAt + a.fieldMap["deleted_at"] = a.DeletedAt + a.fieldMap["image_url"] = a.ImageURL + a.fieldMap["title"] = a.Title + a.fieldMap["first_name"] = a.FirstName + a.fieldMap["last_name"] = a.LastName + a.fieldMap["last_title"] = a.LastTitle + a.fieldMap["e_mail"] = a.EMail + a.fieldMap["phone"] = a.Phone + a.fieldMap["mobile"] = a.Mobile + a.fieldMap["notes"] = a.Notes + a.fieldMap["description"] = a.Description + a.fieldMap["active"] = a.Active + a.fieldMap["gender"] = a.Gender + +} + +func (a ansprechpartner) clone(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + a.Firmen.db = db.Session(&gorm.Session{Initialized: true}) + a.Firmen.db.Statement.ConnPool = db.Statement.ConnPool + return a +} + +func (a ansprechpartner) replaceDB(db *gorm.DB) ansprechpartner { + a.ansprechpartnerDo.ReplaceDB(db) + a.Firmen.db = db.Session(&gorm.Session{}) + return a +} + +type ansprechpartnerManyToManyFirmen struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a ansprechpartnerManyToManyFirmen) Where(conds ...field.Expr) *ansprechpartnerManyToManyFirmen { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) WithContext(ctx context.Context) *ansprechpartnerManyToManyFirmen { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Session(session *gorm.Session) *ansprechpartnerManyToManyFirmen { + a.db = a.db.Session(session) + return &a +} + +func (a ansprechpartnerManyToManyFirmen) Model(m *model.Ansprechpartner) *ansprechpartnerManyToManyFirmenTx { + return &ansprechpartnerManyToManyFirmenTx{a.db.Model(m).Association(a.Name())} +} + +func (a ansprechpartnerManyToManyFirmen) Unscoped() *ansprechpartnerManyToManyFirmen { + a.db = a.db.Unscoped() + return &a +} + +type ansprechpartnerManyToManyFirmenTx struct{ tx *gorm.Association } + +func (a ansprechpartnerManyToManyFirmenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a ansprechpartnerManyToManyFirmenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a ansprechpartnerManyToManyFirmenTx) Clear() error { + return a.tx.Clear() +} + +func (a ansprechpartnerManyToManyFirmenTx) Count() int64 { + return a.tx.Count() +} + +func (a ansprechpartnerManyToManyFirmenTx) Unscoped() *ansprechpartnerManyToManyFirmenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type ansprechpartnerDo struct{ gen.DO } + +type IAnsprechpartnerDo interface { + gen.SubQuery + Debug() IAnsprechpartnerDo + WithContext(ctx context.Context) IAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IAnsprechpartnerDo + WriteDB() IAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IAnsprechpartnerDo + Not(conds ...gen.Condition) IAnsprechpartnerDo + Or(conds ...gen.Condition) IAnsprechpartnerDo + Select(conds ...field.Expr) IAnsprechpartnerDo + Where(conds ...gen.Condition) IAnsprechpartnerDo + Order(conds ...field.Expr) IAnsprechpartnerDo + Distinct(cols ...field.Expr) IAnsprechpartnerDo + Omit(cols ...field.Expr) IAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo + Group(cols ...field.Expr) IAnsprechpartnerDo + Having(conds ...gen.Condition) IAnsprechpartnerDo + Limit(limit int) IAnsprechpartnerDo + Offset(offset int) IAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo + Unscoped() IAnsprechpartnerDo + Create(values ...*model.Ansprechpartner) error + CreateInBatches(values []*model.Ansprechpartner, batchSize int) error + Save(values ...*model.Ansprechpartner) error + First() (*model.Ansprechpartner, error) + Take() (*model.Ansprechpartner, error) + Last() (*model.Ansprechpartner, error) + Find() ([]*model.Ansprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) + FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Ansprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo + Joins(fields ...field.RelationField) IAnsprechpartnerDo + Preload(fields ...field.RelationField) IAnsprechpartnerDo + FirstOrInit() (*model.Ansprechpartner, error) + FirstOrCreate() (*model.Ansprechpartner, error) + FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (a ansprechpartnerDo) Debug() IAnsprechpartnerDo { + return a.withDO(a.DO.Debug()) +} + +func (a ansprechpartnerDo) WithContext(ctx context.Context) IAnsprechpartnerDo { + return a.withDO(a.DO.WithContext(ctx)) +} + +func (a ansprechpartnerDo) ReadDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Read) +} + +func (a ansprechpartnerDo) WriteDB() IAnsprechpartnerDo { + return a.Clauses(dbresolver.Write) +} + +func (a ansprechpartnerDo) Session(config *gorm.Session) IAnsprechpartnerDo { + return a.withDO(a.DO.Session(config)) +} + +func (a ansprechpartnerDo) Clauses(conds ...clause.Expression) IAnsprechpartnerDo { + return a.withDO(a.DO.Clauses(conds...)) +} + +func (a ansprechpartnerDo) Returning(value interface{}, columns ...string) IAnsprechpartnerDo { + return a.withDO(a.DO.Returning(value, columns...)) +} + +func (a ansprechpartnerDo) Not(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Not(conds...)) +} + +func (a ansprechpartnerDo) Or(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Or(conds...)) +} + +func (a ansprechpartnerDo) Select(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Select(conds...)) +} + +func (a ansprechpartnerDo) Where(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Where(conds...)) +} + +func (a ansprechpartnerDo) Order(conds ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Order(conds...)) +} + +func (a ansprechpartnerDo) Distinct(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Distinct(cols...)) +} + +func (a ansprechpartnerDo) Omit(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Omit(cols...)) +} + +func (a ansprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Join(table, on...)) +} + +func (a ansprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.LeftJoin(table, on...)) +} + +func (a ansprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.RightJoin(table, on...)) +} + +func (a ansprechpartnerDo) Group(cols ...field.Expr) IAnsprechpartnerDo { + return a.withDO(a.DO.Group(cols...)) +} + +func (a ansprechpartnerDo) Having(conds ...gen.Condition) IAnsprechpartnerDo { + return a.withDO(a.DO.Having(conds...)) +} + +func (a ansprechpartnerDo) Limit(limit int) IAnsprechpartnerDo { + return a.withDO(a.DO.Limit(limit)) +} + +func (a ansprechpartnerDo) Offset(offset int) IAnsprechpartnerDo { + return a.withDO(a.DO.Offset(offset)) +} + +func (a ansprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo { + return a.withDO(a.DO.Scopes(funcs...)) +} + +func (a ansprechpartnerDo) Unscoped() IAnsprechpartnerDo { + return a.withDO(a.DO.Unscoped()) +} + +func (a ansprechpartnerDo) Create(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Create(values) +} + +func (a ansprechpartnerDo) CreateInBatches(values []*model.Ansprechpartner, batchSize int) error { + return a.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (a ansprechpartnerDo) Save(values ...*model.Ansprechpartner) error { + if len(values) == 0 { + return nil + } + return a.DO.Save(values) +} + +func (a ansprechpartnerDo) First() (*model.Ansprechpartner, error) { + if result, err := a.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Take() (*model.Ansprechpartner, error) { + if result, err := a.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Last() (*model.Ansprechpartner, error) { + if result, err := a.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) Find() ([]*model.Ansprechpartner, error) { + result, err := a.DO.Find() + return result.([]*model.Ansprechpartner), err +} + +func (a ansprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) { + buf := make([]*model.Ansprechpartner, 0, batchSize) + err = a.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (a ansprechpartnerDo) FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return a.DO.FindInBatches(result, batchSize, fc) +} + +func (a ansprechpartnerDo) Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Attrs(attrs...)) +} + +func (a ansprechpartnerDo) Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo { + return a.withDO(a.DO.Assign(attrs...)) +} + +func (a ansprechpartnerDo) Joins(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Joins(_f)) + } + return &a +} + +func (a ansprechpartnerDo) Preload(fields ...field.RelationField) IAnsprechpartnerDo { + for _, _f := range fields { + a = *a.withDO(a.DO.Preload(_f)) + } + return &a +} + +func (a ansprechpartnerDo) FirstOrInit() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FirstOrCreate() (*model.Ansprechpartner, error) { + if result, err := a.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Ansprechpartner), nil + } +} + +func (a ansprechpartnerDo) FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error) { + result, err = a.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = a.Offset(-1).Limit(-1).Count() + return +} + +func (a ansprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = a.Count() + if err != nil { + return + } + + err = a.Offset(offset).Limit(limit).Scan(result) + return +} + +func (a ansprechpartnerDo) Scan(result interface{}) (err error) { + return a.DO.Scan(result) +} + +func (a ansprechpartnerDo) Delete(models ...*model.Ansprechpartner) (result gen.ResultInfo, err error) { + return a.DO.Delete(models) +} + +func (a *ansprechpartnerDo) withDO(do gen.Dao) *ansprechpartnerDo { + a.DO = *do.(*gen.DO) + return a +} diff --git a/cmd/mailingest/query/dokuments.gen.go b/cmd/mailingest/query/dokuments.gen.go new file mode 100644 index 0000000..ac04910 --- /dev/null +++ b/cmd/mailingest/query/dokuments.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newDokument(db *gorm.DB, opts ...gen.DOOption) dokument { + _dokument := dokument{} + + _dokument.dokumentDo.UseDB(db, opts...) + _dokument.dokumentDo.UseModel(&model.Dokument{}) + + tableName := _dokument.dokumentDo.TableName() + _dokument.ALL = field.NewAsterisk(tableName) + _dokument.ID = field.NewUint(tableName, "id") + _dokument.CreatedAt = field.NewTime(tableName, "created_at") + _dokument.UpdatedAt = field.NewTime(tableName, "updated_at") + _dokument.DeletedAt = field.NewField(tableName, "deleted_at") + + _dokument.fillFieldMap() + + return _dokument +} + +type dokument struct { + dokumentDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (d dokument) Table(newTableName string) *dokument { + d.dokumentDo.UseTable(newTableName) + return d.updateTableName(newTableName) +} + +func (d dokument) As(alias string) *dokument { + d.dokumentDo.DO = *(d.dokumentDo.As(alias).(*gen.DO)) + return d.updateTableName(alias) +} + +func (d *dokument) updateTableName(table string) *dokument { + d.ALL = field.NewAsterisk(table) + d.ID = field.NewUint(table, "id") + d.CreatedAt = field.NewTime(table, "created_at") + d.UpdatedAt = field.NewTime(table, "updated_at") + d.DeletedAt = field.NewField(table, "deleted_at") + + d.fillFieldMap() + + return d +} + +func (d *dokument) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := d.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (d *dokument) fillFieldMap() { + d.fieldMap = make(map[string]field.Expr, 4) + d.fieldMap["id"] = d.ID + d.fieldMap["created_at"] = d.CreatedAt + d.fieldMap["updated_at"] = d.UpdatedAt + d.fieldMap["deleted_at"] = d.DeletedAt +} + +func (d dokument) clone(db *gorm.DB) dokument { + d.dokumentDo.ReplaceConnPool(db.Statement.ConnPool) + return d +} + +func (d dokument) replaceDB(db *gorm.DB) dokument { + d.dokumentDo.ReplaceDB(db) + return d +} + +type dokumentDo struct{ gen.DO } + +type IDokumentDo interface { + gen.SubQuery + Debug() IDokumentDo + WithContext(ctx context.Context) IDokumentDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IDokumentDo + WriteDB() IDokumentDo + As(alias string) gen.Dao + Session(config *gorm.Session) IDokumentDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IDokumentDo + Not(conds ...gen.Condition) IDokumentDo + Or(conds ...gen.Condition) IDokumentDo + Select(conds ...field.Expr) IDokumentDo + Where(conds ...gen.Condition) IDokumentDo + Order(conds ...field.Expr) IDokumentDo + Distinct(cols ...field.Expr) IDokumentDo + Omit(cols ...field.Expr) IDokumentDo + Join(table schema.Tabler, on ...field.Expr) IDokumentDo + LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo + Group(cols ...field.Expr) IDokumentDo + Having(conds ...gen.Condition) IDokumentDo + Limit(limit int) IDokumentDo + Offset(offset int) IDokumentDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo + Unscoped() IDokumentDo + Create(values ...*model.Dokument) error + CreateInBatches(values []*model.Dokument, batchSize int) error + Save(values ...*model.Dokument) error + First() (*model.Dokument, error) + Take() (*model.Dokument, error) + Last() (*model.Dokument, error) + Find() ([]*model.Dokument, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) + FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Dokument) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IDokumentDo + Assign(attrs ...field.AssignExpr) IDokumentDo + Joins(fields ...field.RelationField) IDokumentDo + Preload(fields ...field.RelationField) IDokumentDo + FirstOrInit() (*model.Dokument, error) + FirstOrCreate() (*model.Dokument, error) + FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IDokumentDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (d dokumentDo) Debug() IDokumentDo { + return d.withDO(d.DO.Debug()) +} + +func (d dokumentDo) WithContext(ctx context.Context) IDokumentDo { + return d.withDO(d.DO.WithContext(ctx)) +} + +func (d dokumentDo) ReadDB() IDokumentDo { + return d.Clauses(dbresolver.Read) +} + +func (d dokumentDo) WriteDB() IDokumentDo { + return d.Clauses(dbresolver.Write) +} + +func (d dokumentDo) Session(config *gorm.Session) IDokumentDo { + return d.withDO(d.DO.Session(config)) +} + +func (d dokumentDo) Clauses(conds ...clause.Expression) IDokumentDo { + return d.withDO(d.DO.Clauses(conds...)) +} + +func (d dokumentDo) Returning(value interface{}, columns ...string) IDokumentDo { + return d.withDO(d.DO.Returning(value, columns...)) +} + +func (d dokumentDo) Not(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Not(conds...)) +} + +func (d dokumentDo) Or(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Or(conds...)) +} + +func (d dokumentDo) Select(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Select(conds...)) +} + +func (d dokumentDo) Where(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Where(conds...)) +} + +func (d dokumentDo) Order(conds ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Order(conds...)) +} + +func (d dokumentDo) Distinct(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Distinct(cols...)) +} + +func (d dokumentDo) Omit(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Omit(cols...)) +} + +func (d dokumentDo) Join(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Join(table, on...)) +} + +func (d dokumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.LeftJoin(table, on...)) +} + +func (d dokumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo { + return d.withDO(d.DO.RightJoin(table, on...)) +} + +func (d dokumentDo) Group(cols ...field.Expr) IDokumentDo { + return d.withDO(d.DO.Group(cols...)) +} + +func (d dokumentDo) Having(conds ...gen.Condition) IDokumentDo { + return d.withDO(d.DO.Having(conds...)) +} + +func (d dokumentDo) Limit(limit int) IDokumentDo { + return d.withDO(d.DO.Limit(limit)) +} + +func (d dokumentDo) Offset(offset int) IDokumentDo { + return d.withDO(d.DO.Offset(offset)) +} + +func (d dokumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo { + return d.withDO(d.DO.Scopes(funcs...)) +} + +func (d dokumentDo) Unscoped() IDokumentDo { + return d.withDO(d.DO.Unscoped()) +} + +func (d dokumentDo) Create(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Create(values) +} + +func (d dokumentDo) CreateInBatches(values []*model.Dokument, batchSize int) error { + return d.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (d dokumentDo) Save(values ...*model.Dokument) error { + if len(values) == 0 { + return nil + } + return d.DO.Save(values) +} + +func (d dokumentDo) First() (*model.Dokument, error) { + if result, err := d.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Take() (*model.Dokument, error) { + if result, err := d.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Last() (*model.Dokument, error) { + if result, err := d.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) Find() ([]*model.Dokument, error) { + result, err := d.DO.Find() + return result.([]*model.Dokument), err +} + +func (d dokumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) { + buf := make([]*model.Dokument, 0, batchSize) + err = d.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (d dokumentDo) FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return d.DO.FindInBatches(result, batchSize, fc) +} + +func (d dokumentDo) Attrs(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Attrs(attrs...)) +} + +func (d dokumentDo) Assign(attrs ...field.AssignExpr) IDokumentDo { + return d.withDO(d.DO.Assign(attrs...)) +} + +func (d dokumentDo) Joins(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Joins(_f)) + } + return &d +} + +func (d dokumentDo) Preload(fields ...field.RelationField) IDokumentDo { + for _, _f := range fields { + d = *d.withDO(d.DO.Preload(_f)) + } + return &d +} + +func (d dokumentDo) FirstOrInit() (*model.Dokument, error) { + if result, err := d.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FirstOrCreate() (*model.Dokument, error) { + if result, err := d.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Dokument), nil + } +} + +func (d dokumentDo) FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error) { + result, err = d.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = d.Offset(-1).Limit(-1).Count() + return +} + +func (d dokumentDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = d.Count() + if err != nil { + return + } + + err = d.Offset(offset).Limit(limit).Scan(result) + return +} + +func (d dokumentDo) Scan(result interface{}) (err error) { + return d.DO.Scan(result) +} + +func (d dokumentDo) Delete(models ...*model.Dokument) (result gen.ResultInfo, err error) { + return d.DO.Delete(models) +} + +func (d *dokumentDo) withDO(do gen.Dao) *dokumentDo { + d.DO = *do.(*gen.DO) + return d +} diff --git a/cmd/mailingest/query/firma_ansprechpartner.gen.go b/cmd/mailingest/query/firma_ansprechpartner.gen.go new file mode 100644 index 0000000..c8a5461 --- /dev/null +++ b/cmd/mailingest/query/firma_ansprechpartner.gen.go @@ -0,0 +1,407 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirmaAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) firmaAnsprechpartner { + _firmaAnsprechpartner := firmaAnsprechpartner{} + + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseDB(db, opts...) + _firmaAnsprechpartner.firmaAnsprechpartnerDo.UseModel(&model.FirmaAnsprechpartner{}) + + tableName := _firmaAnsprechpartner.firmaAnsprechpartnerDo.TableName() + _firmaAnsprechpartner.ALL = field.NewAsterisk(tableName) + _firmaAnsprechpartner.ID = field.NewUint(tableName, "id") + _firmaAnsprechpartner.CreatedAt = field.NewTime(tableName, "created_at") + _firmaAnsprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at") + _firmaAnsprechpartner.DeletedAt = field.NewField(tableName, "deleted_at") + _firmaAnsprechpartner.AnsprechpartnerId = field.NewUint(tableName, "ansprechpartner_id") + _firmaAnsprechpartner.FirmaId = field.NewUint(tableName, "firma_id") + _firmaAnsprechpartner.Role = field.NewString(tableName, "role") + + _firmaAnsprechpartner.fillFieldMap() + + return _firmaAnsprechpartner +} + +type firmaAnsprechpartner struct { + firmaAnsprechpartnerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + AnsprechpartnerId field.Uint + FirmaId field.Uint + Role field.String + + fieldMap map[string]field.Expr +} + +func (f firmaAnsprechpartner) Table(newTableName string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firmaAnsprechpartner) As(alias string) *firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.DO = *(f.firmaAnsprechpartnerDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firmaAnsprechpartner) updateTableName(table string) *firmaAnsprechpartner { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.AnsprechpartnerId = field.NewUint(table, "ansprechpartner_id") + f.FirmaId = field.NewUint(table, "firma_id") + f.Role = field.NewString(table, "role") + + f.fillFieldMap() + + return f +} + +func (f *firmaAnsprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firmaAnsprechpartner) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 7) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["ansprechpartner_id"] = f.AnsprechpartnerId + f.fieldMap["firma_id"] = f.FirmaId + f.fieldMap["role"] = f.Role +} + +func (f firmaAnsprechpartner) clone(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool) + return f +} + +func (f firmaAnsprechpartner) replaceDB(db *gorm.DB) firmaAnsprechpartner { + f.firmaAnsprechpartnerDo.ReplaceDB(db) + return f +} + +type firmaAnsprechpartnerDo struct{ gen.DO } + +type IFirmaAnsprechpartnerDo interface { + gen.SubQuery + Debug() IFirmaAnsprechpartnerDo + WithContext(ctx context.Context) IFirmaAnsprechpartnerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaAnsprechpartnerDo + WriteDB() IFirmaAnsprechpartnerDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaAnsprechpartnerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo + Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Select(conds ...field.Expr) IFirmaAnsprechpartnerDo + Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Order(conds ...field.Expr) IFirmaAnsprechpartnerDo + Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo + Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo + Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo + Group(cols ...field.Expr) IFirmaAnsprechpartnerDo + Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo + Limit(limit int) IFirmaAnsprechpartnerDo + Offset(offset int) IFirmaAnsprechpartnerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo + Unscoped() IFirmaAnsprechpartnerDo + Create(values ...*model.FirmaAnsprechpartner) error + CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error + Save(values ...*model.FirmaAnsprechpartner) error + First() (*model.FirmaAnsprechpartner, error) + Take() (*model.FirmaAnsprechpartner, error) + Last() (*model.FirmaAnsprechpartner, error) + Find() ([]*model.FirmaAnsprechpartner, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) + FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.FirmaAnsprechpartner) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo + Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo + Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo + FirstOrInit() (*model.FirmaAnsprechpartner, error) + FirstOrCreate() (*model.FirmaAnsprechpartner, error) + FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaAnsprechpartnerDo) Debug() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaAnsprechpartnerDo) WithContext(ctx context.Context) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaAnsprechpartnerDo) ReadDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaAnsprechpartnerDo) WriteDB() IFirmaAnsprechpartnerDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaAnsprechpartnerDo) Session(config *gorm.Session) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaAnsprechpartnerDo) Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaAnsprechpartnerDo) Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaAnsprechpartnerDo) Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaAnsprechpartnerDo) Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaAnsprechpartnerDo) Select(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaAnsprechpartnerDo) Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaAnsprechpartnerDo) Order(conds ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaAnsprechpartnerDo) Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaAnsprechpartnerDo) Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaAnsprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaAnsprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaAnsprechpartnerDo) Group(cols ...field.Expr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaAnsprechpartnerDo) Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaAnsprechpartnerDo) Limit(limit int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaAnsprechpartnerDo) Offset(offset int) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaAnsprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaAnsprechpartnerDo) Unscoped() IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaAnsprechpartnerDo) Create(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaAnsprechpartnerDo) CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaAnsprechpartnerDo) Save(values ...*model.FirmaAnsprechpartner) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaAnsprechpartnerDo) First() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Take() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Last() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) Find() ([]*model.FirmaAnsprechpartner, error) { + result, err := f.DO.Find() + return result.([]*model.FirmaAnsprechpartner), err +} + +func (f firmaAnsprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) { + buf := make([]*model.FirmaAnsprechpartner, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaAnsprechpartnerDo) FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaAnsprechpartnerDo) Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaAnsprechpartnerDo) Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaAnsprechpartnerDo) FirstOrInit() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FirstOrCreate() (*model.FirmaAnsprechpartner, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.FirmaAnsprechpartner), nil + } +} + +func (f firmaAnsprechpartnerDo) FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaAnsprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaAnsprechpartnerDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaAnsprechpartnerDo) Delete(models ...*model.FirmaAnsprechpartner) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaAnsprechpartnerDo) withDO(do gen.Dao) *firmaAnsprechpartnerDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/cmd/mailingest/query/firmas.gen.go b/cmd/mailingest/query/firmas.gen.go new file mode 100644 index 0000000..5177cf1 --- /dev/null +++ b/cmd/mailingest/query/firmas.gen.go @@ -0,0 +1,630 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newFirma(db *gorm.DB, opts ...gen.DOOption) firma { + _firma := firma{} + + _firma.firmaDo.UseDB(db, opts...) + _firma.firmaDo.UseModel(&model.Firma{}) + + tableName := _firma.firmaDo.TableName() + _firma.ALL = field.NewAsterisk(tableName) + _firma.ID = field.NewUint(tableName, "id") + _firma.CreatedAt = field.NewTime(tableName, "created_at") + _firma.UpdatedAt = field.NewTime(tableName, "updated_at") + _firma.DeletedAt = field.NewField(tableName, "deleted_at") + _firma.FirmaTyp = field.NewInt(tableName, "firma_typ") + _firma.Name = field.NewString(tableName, "name") + _firma.InternerName = field.NewString(tableName, "interner_name") + _firma.Slug = field.NewString(tableName, "slug") + _firma.Branche = field.NewString(tableName, "branche") + _firma.ParentCompany = field.NewUint(tableName, "parent_company") + _firma.Tochergesellschaften = firmaHasManyTochergesellschaften{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Tochergesellschaften", "model.Firma"), + Tochergesellschaften: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Tochergesellschaften", "model.Firma"), + }, + Ansprechpartner: struct { + field.RelationField + Firmen struct { + field.RelationField + } + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner", "model.Ansprechpartner"), + Firmen: struct { + field.RelationField + }{ + RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner.Firmen", "model.Firma"), + }, + }, + } + + _firma.Ansprechpartner = firmaManyToManyAnsprechpartner{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Ansprechpartner", "model.Ansprechpartner"), + } + + _firma.fillFieldMap() + + return _firma +} + +type firma struct { + firmaDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + FirmaTyp field.Int + Name field.String + InternerName field.String + Slug field.String + Branche field.String + ParentCompany field.Uint + Tochergesellschaften firmaHasManyTochergesellschaften + + Ansprechpartner firmaManyToManyAnsprechpartner + + fieldMap map[string]field.Expr +} + +func (f firma) Table(newTableName string) *firma { + f.firmaDo.UseTable(newTableName) + return f.updateTableName(newTableName) +} + +func (f firma) As(alias string) *firma { + f.firmaDo.DO = *(f.firmaDo.As(alias).(*gen.DO)) + return f.updateTableName(alias) +} + +func (f *firma) updateTableName(table string) *firma { + f.ALL = field.NewAsterisk(table) + f.ID = field.NewUint(table, "id") + f.CreatedAt = field.NewTime(table, "created_at") + f.UpdatedAt = field.NewTime(table, "updated_at") + f.DeletedAt = field.NewField(table, "deleted_at") + f.FirmaTyp = field.NewInt(table, "firma_typ") + f.Name = field.NewString(table, "name") + f.InternerName = field.NewString(table, "interner_name") + f.Slug = field.NewString(table, "slug") + f.Branche = field.NewString(table, "branche") + f.ParentCompany = field.NewUint(table, "parent_company") + + f.fillFieldMap() + + return f +} + +func (f *firma) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := f.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (f *firma) fillFieldMap() { + f.fieldMap = make(map[string]field.Expr, 12) + f.fieldMap["id"] = f.ID + f.fieldMap["created_at"] = f.CreatedAt + f.fieldMap["updated_at"] = f.UpdatedAt + f.fieldMap["deleted_at"] = f.DeletedAt + f.fieldMap["firma_typ"] = f.FirmaTyp + f.fieldMap["name"] = f.Name + f.fieldMap["interner_name"] = f.InternerName + f.fieldMap["slug"] = f.Slug + f.fieldMap["branche"] = f.Branche + f.fieldMap["parent_company"] = f.ParentCompany + +} + +func (f firma) clone(db *gorm.DB) firma { + f.firmaDo.ReplaceConnPool(db.Statement.ConnPool) + f.Tochergesellschaften.db = db.Session(&gorm.Session{Initialized: true}) + f.Tochergesellschaften.db.Statement.ConnPool = db.Statement.ConnPool + f.Ansprechpartner.db = db.Session(&gorm.Session{Initialized: true}) + f.Ansprechpartner.db.Statement.ConnPool = db.Statement.ConnPool + return f +} + +func (f firma) replaceDB(db *gorm.DB) firma { + f.firmaDo.ReplaceDB(db) + f.Tochergesellschaften.db = db.Session(&gorm.Session{}) + f.Ansprechpartner.db = db.Session(&gorm.Session{}) + return f +} + +type firmaHasManyTochergesellschaften struct { + db *gorm.DB + + field.RelationField + + Tochergesellschaften struct { + field.RelationField + } + Ansprechpartner struct { + field.RelationField + Firmen struct { + field.RelationField + } + } +} + +func (a firmaHasManyTochergesellschaften) Where(conds ...field.Expr) *firmaHasManyTochergesellschaften { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaHasManyTochergesellschaften) WithContext(ctx context.Context) *firmaHasManyTochergesellschaften { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaHasManyTochergesellschaften) Session(session *gorm.Session) *firmaHasManyTochergesellschaften { + a.db = a.db.Session(session) + return &a +} + +func (a firmaHasManyTochergesellschaften) Model(m *model.Firma) *firmaHasManyTochergesellschaftenTx { + return &firmaHasManyTochergesellschaftenTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaHasManyTochergesellschaften) Unscoped() *firmaHasManyTochergesellschaften { + a.db = a.db.Unscoped() + return &a +} + +type firmaHasManyTochergesellschaftenTx struct{ tx *gorm.Association } + +func (a firmaHasManyTochergesellschaftenTx) Find() (result []*model.Firma, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaHasManyTochergesellschaftenTx) Append(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Replace(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Delete(values ...*model.Firma) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaHasManyTochergesellschaftenTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaHasManyTochergesellschaftenTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaHasManyTochergesellschaftenTx) Unscoped() *firmaHasManyTochergesellschaftenTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartner struct { + db *gorm.DB + + field.RelationField +} + +func (a firmaManyToManyAnsprechpartner) Where(conds ...field.Expr) *firmaManyToManyAnsprechpartner { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a firmaManyToManyAnsprechpartner) WithContext(ctx context.Context) *firmaManyToManyAnsprechpartner { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Session(session *gorm.Session) *firmaManyToManyAnsprechpartner { + a.db = a.db.Session(session) + return &a +} + +func (a firmaManyToManyAnsprechpartner) Model(m *model.Firma) *firmaManyToManyAnsprechpartnerTx { + return &firmaManyToManyAnsprechpartnerTx{a.db.Model(m).Association(a.Name())} +} + +func (a firmaManyToManyAnsprechpartner) Unscoped() *firmaManyToManyAnsprechpartner { + a.db = a.db.Unscoped() + return &a +} + +type firmaManyToManyAnsprechpartnerTx struct{ tx *gorm.Association } + +func (a firmaManyToManyAnsprechpartnerTx) Find() (result []*model.Ansprechpartner, err error) { + return result, a.tx.Find(&result) +} + +func (a firmaManyToManyAnsprechpartnerTx) Append(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Replace(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Delete(values ...*model.Ansprechpartner) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a firmaManyToManyAnsprechpartnerTx) Clear() error { + return a.tx.Clear() +} + +func (a firmaManyToManyAnsprechpartnerTx) Count() int64 { + return a.tx.Count() +} + +func (a firmaManyToManyAnsprechpartnerTx) Unscoped() *firmaManyToManyAnsprechpartnerTx { + a.tx = a.tx.Unscoped() + return &a +} + +type firmaDo struct{ gen.DO } + +type IFirmaDo interface { + gen.SubQuery + Debug() IFirmaDo + WithContext(ctx context.Context) IFirmaDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IFirmaDo + WriteDB() IFirmaDo + As(alias string) gen.Dao + Session(config *gorm.Session) IFirmaDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IFirmaDo + Not(conds ...gen.Condition) IFirmaDo + Or(conds ...gen.Condition) IFirmaDo + Select(conds ...field.Expr) IFirmaDo + Where(conds ...gen.Condition) IFirmaDo + Order(conds ...field.Expr) IFirmaDo + Distinct(cols ...field.Expr) IFirmaDo + Omit(cols ...field.Expr) IFirmaDo + Join(table schema.Tabler, on ...field.Expr) IFirmaDo + LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo + Group(cols ...field.Expr) IFirmaDo + Having(conds ...gen.Condition) IFirmaDo + Limit(limit int) IFirmaDo + Offset(offset int) IFirmaDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo + Unscoped() IFirmaDo + Create(values ...*model.Firma) error + CreateInBatches(values []*model.Firma, batchSize int) error + Save(values ...*model.Firma) error + First() (*model.Firma, error) + Take() (*model.Firma, error) + Last() (*model.Firma, error) + Find() ([]*model.Firma, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) + FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Firma) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IFirmaDo + Assign(attrs ...field.AssignExpr) IFirmaDo + Joins(fields ...field.RelationField) IFirmaDo + Preload(fields ...field.RelationField) IFirmaDo + FirstOrInit() (*model.Firma, error) + FirstOrCreate() (*model.Firma, error) + FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IFirmaDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (f firmaDo) Debug() IFirmaDo { + return f.withDO(f.DO.Debug()) +} + +func (f firmaDo) WithContext(ctx context.Context) IFirmaDo { + return f.withDO(f.DO.WithContext(ctx)) +} + +func (f firmaDo) ReadDB() IFirmaDo { + return f.Clauses(dbresolver.Read) +} + +func (f firmaDo) WriteDB() IFirmaDo { + return f.Clauses(dbresolver.Write) +} + +func (f firmaDo) Session(config *gorm.Session) IFirmaDo { + return f.withDO(f.DO.Session(config)) +} + +func (f firmaDo) Clauses(conds ...clause.Expression) IFirmaDo { + return f.withDO(f.DO.Clauses(conds...)) +} + +func (f firmaDo) Returning(value interface{}, columns ...string) IFirmaDo { + return f.withDO(f.DO.Returning(value, columns...)) +} + +func (f firmaDo) Not(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Not(conds...)) +} + +func (f firmaDo) Or(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Or(conds...)) +} + +func (f firmaDo) Select(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Select(conds...)) +} + +func (f firmaDo) Where(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Where(conds...)) +} + +func (f firmaDo) Order(conds ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Order(conds...)) +} + +func (f firmaDo) Distinct(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Distinct(cols...)) +} + +func (f firmaDo) Omit(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Omit(cols...)) +} + +func (f firmaDo) Join(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Join(table, on...)) +} + +func (f firmaDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.LeftJoin(table, on...)) +} + +func (f firmaDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo { + return f.withDO(f.DO.RightJoin(table, on...)) +} + +func (f firmaDo) Group(cols ...field.Expr) IFirmaDo { + return f.withDO(f.DO.Group(cols...)) +} + +func (f firmaDo) Having(conds ...gen.Condition) IFirmaDo { + return f.withDO(f.DO.Having(conds...)) +} + +func (f firmaDo) Limit(limit int) IFirmaDo { + return f.withDO(f.DO.Limit(limit)) +} + +func (f firmaDo) Offset(offset int) IFirmaDo { + return f.withDO(f.DO.Offset(offset)) +} + +func (f firmaDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo { + return f.withDO(f.DO.Scopes(funcs...)) +} + +func (f firmaDo) Unscoped() IFirmaDo { + return f.withDO(f.DO.Unscoped()) +} + +func (f firmaDo) Create(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Create(values) +} + +func (f firmaDo) CreateInBatches(values []*model.Firma, batchSize int) error { + return f.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (f firmaDo) Save(values ...*model.Firma) error { + if len(values) == 0 { + return nil + } + return f.DO.Save(values) +} + +func (f firmaDo) First() (*model.Firma, error) { + if result, err := f.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Take() (*model.Firma, error) { + if result, err := f.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Last() (*model.Firma, error) { + if result, err := f.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) Find() ([]*model.Firma, error) { + result, err := f.DO.Find() + return result.([]*model.Firma), err +} + +func (f firmaDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) { + buf := make([]*model.Firma, 0, batchSize) + err = f.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (f firmaDo) FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return f.DO.FindInBatches(result, batchSize, fc) +} + +func (f firmaDo) Attrs(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Attrs(attrs...)) +} + +func (f firmaDo) Assign(attrs ...field.AssignExpr) IFirmaDo { + return f.withDO(f.DO.Assign(attrs...)) +} + +func (f firmaDo) Joins(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Joins(_f)) + } + return &f +} + +func (f firmaDo) Preload(fields ...field.RelationField) IFirmaDo { + for _, _f := range fields { + f = *f.withDO(f.DO.Preload(_f)) + } + return &f +} + +func (f firmaDo) FirstOrInit() (*model.Firma, error) { + if result, err := f.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FirstOrCreate() (*model.Firma, error) { + if result, err := f.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Firma), nil + } +} + +func (f firmaDo) FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) { + result, err = f.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = f.Offset(-1).Limit(-1).Count() + return +} + +func (f firmaDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = f.Count() + if err != nil { + return + } + + err = f.Offset(offset).Limit(limit).Scan(result) + return +} + +func (f firmaDo) Scan(result interface{}) (err error) { + return f.DO.Scan(result) +} + +func (f firmaDo) Delete(models ...*model.Firma) (result gen.ResultInfo, err error) { + return f.DO.Delete(models) +} + +func (f *firmaDo) withDO(do gen.Dao) *firmaDo { + f.DO = *do.(*gen.DO) + return f +} diff --git a/cmd/mailingest/query/gen.go b/cmd/mailingest/query/gen.go new file mode 100644 index 0000000..e61b305 --- /dev/null +++ b/cmd/mailingest/query/gen.go @@ -0,0 +1,239 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + + "gorm.io/gen" + + "gorm.io/plugin/dbresolver" +) + +var ( + Q = new(Query) + Ansprechpartner *ansprechpartner + Dokument *dokument + Firma *firma + FirmaAnsprechpartner *firmaAnsprechpartner + Kalender *kalender + Kalendereintrag *kalendereintrag + Kostenstelle *kostenstelle + Lager *lager + Lagerplatz *lagerplatz + Mandant *mandant + Material *material + Nachricht *nachricht + Projekt *projekt + Rechnung *rechnung + Rechnungsposition *rechnungsposition + Scanobject *scanobject + User *user + Zahlung *zahlung +) + +func SetDefault(db *gorm.DB, opts ...gen.DOOption) { + *Q = *Use(db, opts...) + Ansprechpartner = &Q.Ansprechpartner + Dokument = &Q.Dokument + Firma = &Q.Firma + FirmaAnsprechpartner = &Q.FirmaAnsprechpartner + Kalender = &Q.Kalender + Kalendereintrag = &Q.Kalendereintrag + Kostenstelle = &Q.Kostenstelle + Lager = &Q.Lager + Lagerplatz = &Q.Lagerplatz + Mandant = &Q.Mandant + Material = &Q.Material + Nachricht = &Q.Nachricht + Projekt = &Q.Projekt + Rechnung = &Q.Rechnung + Rechnungsposition = &Q.Rechnungsposition + Scanobject = &Q.Scanobject + User = &Q.User + Zahlung = &Q.Zahlung +} + +func Use(db *gorm.DB, opts ...gen.DOOption) *Query { + return &Query{ + db: db, + Ansprechpartner: newAnsprechpartner(db, opts...), + Dokument: newDokument(db, opts...), + Firma: newFirma(db, opts...), + FirmaAnsprechpartner: newFirmaAnsprechpartner(db, opts...), + Kalender: newKalender(db, opts...), + Kalendereintrag: newKalendereintrag(db, opts...), + Kostenstelle: newKostenstelle(db, opts...), + Lager: newLager(db, opts...), + Lagerplatz: newLagerplatz(db, opts...), + Mandant: newMandant(db, opts...), + Material: newMaterial(db, opts...), + Nachricht: newNachricht(db, opts...), + Projekt: newProjekt(db, opts...), + Rechnung: newRechnung(db, opts...), + Rechnungsposition: newRechnungsposition(db, opts...), + Scanobject: newScanobject(db, opts...), + User: newUser(db, opts...), + Zahlung: newZahlung(db, opts...), + } +} + +type Query struct { + db *gorm.DB + + Ansprechpartner ansprechpartner + Dokument dokument + Firma firma + FirmaAnsprechpartner firmaAnsprechpartner + Kalender kalender + Kalendereintrag kalendereintrag + Kostenstelle kostenstelle + Lager lager + Lagerplatz lagerplatz + Mandant mandant + Material material + Nachricht nachricht + Projekt projekt + Rechnung rechnung + Rechnungsposition rechnungsposition + Scanobject scanobject + User user + Zahlung zahlung +} + +func (q *Query) Available() bool { return q.db != nil } + +func (q *Query) clone(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.clone(db), + Dokument: q.Dokument.clone(db), + Firma: q.Firma.clone(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.clone(db), + Kalender: q.Kalender.clone(db), + Kalendereintrag: q.Kalendereintrag.clone(db), + Kostenstelle: q.Kostenstelle.clone(db), + Lager: q.Lager.clone(db), + Lagerplatz: q.Lagerplatz.clone(db), + Mandant: q.Mandant.clone(db), + Material: q.Material.clone(db), + Nachricht: q.Nachricht.clone(db), + Projekt: q.Projekt.clone(db), + Rechnung: q.Rechnung.clone(db), + Rechnungsposition: q.Rechnungsposition.clone(db), + Scanobject: q.Scanobject.clone(db), + User: q.User.clone(db), + Zahlung: q.Zahlung.clone(db), + } +} + +func (q *Query) ReadDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Read)) +} + +func (q *Query) WriteDB() *Query { + return q.ReplaceDB(q.db.Clauses(dbresolver.Write)) +} + +func (q *Query) ReplaceDB(db *gorm.DB) *Query { + return &Query{ + db: db, + Ansprechpartner: q.Ansprechpartner.replaceDB(db), + Dokument: q.Dokument.replaceDB(db), + Firma: q.Firma.replaceDB(db), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.replaceDB(db), + Kalender: q.Kalender.replaceDB(db), + Kalendereintrag: q.Kalendereintrag.replaceDB(db), + Kostenstelle: q.Kostenstelle.replaceDB(db), + Lager: q.Lager.replaceDB(db), + Lagerplatz: q.Lagerplatz.replaceDB(db), + Mandant: q.Mandant.replaceDB(db), + Material: q.Material.replaceDB(db), + Nachricht: q.Nachricht.replaceDB(db), + Projekt: q.Projekt.replaceDB(db), + Rechnung: q.Rechnung.replaceDB(db), + Rechnungsposition: q.Rechnungsposition.replaceDB(db), + Scanobject: q.Scanobject.replaceDB(db), + User: q.User.replaceDB(db), + Zahlung: q.Zahlung.replaceDB(db), + } +} + +type queryCtx struct { + Ansprechpartner IAnsprechpartnerDo + Dokument IDokumentDo + Firma IFirmaDo + FirmaAnsprechpartner IFirmaAnsprechpartnerDo + Kalender IKalenderDo + Kalendereintrag IKalendereintragDo + Kostenstelle IKostenstelleDo + Lager ILagerDo + Lagerplatz ILagerplatzDo + Mandant IMandantDo + Material IMaterialDo + Nachricht INachrichtDo + Projekt IProjektDo + Rechnung IRechnungDo + Rechnungsposition IRechnungspositionDo + Scanobject IScanobjectDo + User IUserDo + Zahlung IZahlungDo +} + +func (q *Query) WithContext(ctx context.Context) *queryCtx { + return &queryCtx{ + Ansprechpartner: q.Ansprechpartner.WithContext(ctx), + Dokument: q.Dokument.WithContext(ctx), + Firma: q.Firma.WithContext(ctx), + FirmaAnsprechpartner: q.FirmaAnsprechpartner.WithContext(ctx), + Kalender: q.Kalender.WithContext(ctx), + Kalendereintrag: q.Kalendereintrag.WithContext(ctx), + Kostenstelle: q.Kostenstelle.WithContext(ctx), + Lager: q.Lager.WithContext(ctx), + Lagerplatz: q.Lagerplatz.WithContext(ctx), + Mandant: q.Mandant.WithContext(ctx), + Material: q.Material.WithContext(ctx), + Nachricht: q.Nachricht.WithContext(ctx), + Projekt: q.Projekt.WithContext(ctx), + Rechnung: q.Rechnung.WithContext(ctx), + Rechnungsposition: q.Rechnungsposition.WithContext(ctx), + Scanobject: q.Scanobject.WithContext(ctx), + User: q.User.WithContext(ctx), + Zahlung: q.Zahlung.WithContext(ctx), + } +} + +func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error { + return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...) +} + +func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx { + tx := q.db.Begin(opts...) + return &QueryTx{Query: q.clone(tx), Error: tx.Error} +} + +type QueryTx struct { + *Query + Error error +} + +func (q *QueryTx) Commit() error { + return q.db.Commit().Error +} + +func (q *QueryTx) Rollback() error { + return q.db.Rollback().Error +} + +func (q *QueryTx) SavePoint(name string) error { + return q.db.SavePoint(name).Error +} + +func (q *QueryTx) RollbackTo(name string) error { + return q.db.RollbackTo(name).Error +} diff --git a/cmd/mailingest/query/kalendereintrags.gen.go b/cmd/mailingest/query/kalendereintrags.gen.go new file mode 100644 index 0000000..dd5ea58 --- /dev/null +++ b/cmd/mailingest/query/kalendereintrags.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalendereintrag(db *gorm.DB, opts ...gen.DOOption) kalendereintrag { + _kalendereintrag := kalendereintrag{} + + _kalendereintrag.kalendereintragDo.UseDB(db, opts...) + _kalendereintrag.kalendereintragDo.UseModel(&model.Kalendereintrag{}) + + tableName := _kalendereintrag.kalendereintragDo.TableName() + _kalendereintrag.ALL = field.NewAsterisk(tableName) + _kalendereintrag.ID = field.NewUint(tableName, "id") + _kalendereintrag.CreatedAt = field.NewTime(tableName, "created_at") + _kalendereintrag.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalendereintrag.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalendereintrag.fillFieldMap() + + return _kalendereintrag +} + +type kalendereintrag struct { + kalendereintragDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalendereintrag) Table(newTableName string) *kalendereintrag { + k.kalendereintragDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalendereintrag) As(alias string) *kalendereintrag { + k.kalendereintragDo.DO = *(k.kalendereintragDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalendereintrag) updateTableName(table string) *kalendereintrag { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalendereintrag) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalendereintrag) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalendereintrag) clone(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalendereintrag) replaceDB(db *gorm.DB) kalendereintrag { + k.kalendereintragDo.ReplaceDB(db) + return k +} + +type kalendereintragDo struct{ gen.DO } + +type IKalendereintragDo interface { + gen.SubQuery + Debug() IKalendereintragDo + WithContext(ctx context.Context) IKalendereintragDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalendereintragDo + WriteDB() IKalendereintragDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalendereintragDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalendereintragDo + Not(conds ...gen.Condition) IKalendereintragDo + Or(conds ...gen.Condition) IKalendereintragDo + Select(conds ...field.Expr) IKalendereintragDo + Where(conds ...gen.Condition) IKalendereintragDo + Order(conds ...field.Expr) IKalendereintragDo + Distinct(cols ...field.Expr) IKalendereintragDo + Omit(cols ...field.Expr) IKalendereintragDo + Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo + Group(cols ...field.Expr) IKalendereintragDo + Having(conds ...gen.Condition) IKalendereintragDo + Limit(limit int) IKalendereintragDo + Offset(offset int) IKalendereintragDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo + Unscoped() IKalendereintragDo + Create(values ...*model.Kalendereintrag) error + CreateInBatches(values []*model.Kalendereintrag, batchSize int) error + Save(values ...*model.Kalendereintrag) error + First() (*model.Kalendereintrag, error) + Take() (*model.Kalendereintrag, error) + Last() (*model.Kalendereintrag, error) + Find() ([]*model.Kalendereintrag, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) + FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalendereintrag) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalendereintragDo + Assign(attrs ...field.AssignExpr) IKalendereintragDo + Joins(fields ...field.RelationField) IKalendereintragDo + Preload(fields ...field.RelationField) IKalendereintragDo + FirstOrInit() (*model.Kalendereintrag, error) + FirstOrCreate() (*model.Kalendereintrag, error) + FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalendereintragDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalendereintragDo) Debug() IKalendereintragDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalendereintragDo) WithContext(ctx context.Context) IKalendereintragDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalendereintragDo) ReadDB() IKalendereintragDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalendereintragDo) WriteDB() IKalendereintragDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalendereintragDo) Session(config *gorm.Session) IKalendereintragDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalendereintragDo) Clauses(conds ...clause.Expression) IKalendereintragDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalendereintragDo) Returning(value interface{}, columns ...string) IKalendereintragDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalendereintragDo) Not(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalendereintragDo) Or(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalendereintragDo) Select(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalendereintragDo) Where(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalendereintragDo) Order(conds ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalendereintragDo) Distinct(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalendereintragDo) Omit(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalendereintragDo) Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalendereintragDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalendereintragDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalendereintragDo) Group(cols ...field.Expr) IKalendereintragDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalendereintragDo) Having(conds ...gen.Condition) IKalendereintragDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalendereintragDo) Limit(limit int) IKalendereintragDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalendereintragDo) Offset(offset int) IKalendereintragDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalendereintragDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalendereintragDo) Unscoped() IKalendereintragDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalendereintragDo) Create(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalendereintragDo) CreateInBatches(values []*model.Kalendereintrag, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalendereintragDo) Save(values ...*model.Kalendereintrag) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalendereintragDo) First() (*model.Kalendereintrag, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Take() (*model.Kalendereintrag, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Last() (*model.Kalendereintrag, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) Find() ([]*model.Kalendereintrag, error) { + result, err := k.DO.Find() + return result.([]*model.Kalendereintrag), err +} + +func (k kalendereintragDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) { + buf := make([]*model.Kalendereintrag, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalendereintragDo) FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalendereintragDo) Attrs(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalendereintragDo) Assign(attrs ...field.AssignExpr) IKalendereintragDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalendereintragDo) Joins(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalendereintragDo) Preload(fields ...field.RelationField) IKalendereintragDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalendereintragDo) FirstOrInit() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FirstOrCreate() (*model.Kalendereintrag, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalendereintrag), nil + } +} + +func (k kalendereintragDo) FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalendereintragDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalendereintragDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalendereintragDo) Delete(models ...*model.Kalendereintrag) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalendereintragDo) withDO(do gen.Dao) *kalendereintragDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/mailingest/query/kalenders.gen.go b/cmd/mailingest/query/kalenders.gen.go new file mode 100644 index 0000000..2993174 --- /dev/null +++ b/cmd/mailingest/query/kalenders.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKalender(db *gorm.DB, opts ...gen.DOOption) kalender { + _kalender := kalender{} + + _kalender.kalenderDo.UseDB(db, opts...) + _kalender.kalenderDo.UseModel(&model.Kalender{}) + + tableName := _kalender.kalenderDo.TableName() + _kalender.ALL = field.NewAsterisk(tableName) + _kalender.ID = field.NewUint(tableName, "id") + _kalender.CreatedAt = field.NewTime(tableName, "created_at") + _kalender.UpdatedAt = field.NewTime(tableName, "updated_at") + _kalender.DeletedAt = field.NewField(tableName, "deleted_at") + + _kalender.fillFieldMap() + + return _kalender +} + +type kalender struct { + kalenderDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kalender) Table(newTableName string) *kalender { + k.kalenderDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kalender) As(alias string) *kalender { + k.kalenderDo.DO = *(k.kalenderDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kalender) updateTableName(table string) *kalender { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kalender) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kalender) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kalender) clone(db *gorm.DB) kalender { + k.kalenderDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kalender) replaceDB(db *gorm.DB) kalender { + k.kalenderDo.ReplaceDB(db) + return k +} + +type kalenderDo struct{ gen.DO } + +type IKalenderDo interface { + gen.SubQuery + Debug() IKalenderDo + WithContext(ctx context.Context) IKalenderDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKalenderDo + WriteDB() IKalenderDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKalenderDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKalenderDo + Not(conds ...gen.Condition) IKalenderDo + Or(conds ...gen.Condition) IKalenderDo + Select(conds ...field.Expr) IKalenderDo + Where(conds ...gen.Condition) IKalenderDo + Order(conds ...field.Expr) IKalenderDo + Distinct(cols ...field.Expr) IKalenderDo + Omit(cols ...field.Expr) IKalenderDo + Join(table schema.Tabler, on ...field.Expr) IKalenderDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo + Group(cols ...field.Expr) IKalenderDo + Having(conds ...gen.Condition) IKalenderDo + Limit(limit int) IKalenderDo + Offset(offset int) IKalenderDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo + Unscoped() IKalenderDo + Create(values ...*model.Kalender) error + CreateInBatches(values []*model.Kalender, batchSize int) error + Save(values ...*model.Kalender) error + First() (*model.Kalender, error) + Take() (*model.Kalender, error) + Last() (*model.Kalender, error) + Find() ([]*model.Kalender, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) + FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kalender) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKalenderDo + Assign(attrs ...field.AssignExpr) IKalenderDo + Joins(fields ...field.RelationField) IKalenderDo + Preload(fields ...field.RelationField) IKalenderDo + FirstOrInit() (*model.Kalender, error) + FirstOrCreate() (*model.Kalender, error) + FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKalenderDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kalenderDo) Debug() IKalenderDo { + return k.withDO(k.DO.Debug()) +} + +func (k kalenderDo) WithContext(ctx context.Context) IKalenderDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kalenderDo) ReadDB() IKalenderDo { + return k.Clauses(dbresolver.Read) +} + +func (k kalenderDo) WriteDB() IKalenderDo { + return k.Clauses(dbresolver.Write) +} + +func (k kalenderDo) Session(config *gorm.Session) IKalenderDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kalenderDo) Clauses(conds ...clause.Expression) IKalenderDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kalenderDo) Returning(value interface{}, columns ...string) IKalenderDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kalenderDo) Not(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kalenderDo) Or(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kalenderDo) Select(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kalenderDo) Where(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kalenderDo) Order(conds ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kalenderDo) Distinct(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kalenderDo) Omit(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kalenderDo) Join(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kalenderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kalenderDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kalenderDo) Group(cols ...field.Expr) IKalenderDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kalenderDo) Having(conds ...gen.Condition) IKalenderDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kalenderDo) Limit(limit int) IKalenderDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kalenderDo) Offset(offset int) IKalenderDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kalenderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kalenderDo) Unscoped() IKalenderDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kalenderDo) Create(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kalenderDo) CreateInBatches(values []*model.Kalender, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kalenderDo) Save(values ...*model.Kalender) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kalenderDo) First() (*model.Kalender, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Take() (*model.Kalender, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Last() (*model.Kalender, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) Find() ([]*model.Kalender, error) { + result, err := k.DO.Find() + return result.([]*model.Kalender), err +} + +func (k kalenderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) { + buf := make([]*model.Kalender, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kalenderDo) FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kalenderDo) Attrs(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kalenderDo) Assign(attrs ...field.AssignExpr) IKalenderDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kalenderDo) Joins(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kalenderDo) Preload(fields ...field.RelationField) IKalenderDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kalenderDo) FirstOrInit() (*model.Kalender, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FirstOrCreate() (*model.Kalender, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kalender), nil + } +} + +func (k kalenderDo) FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kalenderDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kalenderDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kalenderDo) Delete(models ...*model.Kalender) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kalenderDo) withDO(do gen.Dao) *kalenderDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/mailingest/query/kostenstelles.gen.go b/cmd/mailingest/query/kostenstelles.gen.go new file mode 100644 index 0000000..ffbbbae --- /dev/null +++ b/cmd/mailingest/query/kostenstelles.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newKostenstelle(db *gorm.DB, opts ...gen.DOOption) kostenstelle { + _kostenstelle := kostenstelle{} + + _kostenstelle.kostenstelleDo.UseDB(db, opts...) + _kostenstelle.kostenstelleDo.UseModel(&model.Kostenstelle{}) + + tableName := _kostenstelle.kostenstelleDo.TableName() + _kostenstelle.ALL = field.NewAsterisk(tableName) + _kostenstelle.ID = field.NewUint(tableName, "id") + _kostenstelle.CreatedAt = field.NewTime(tableName, "created_at") + _kostenstelle.UpdatedAt = field.NewTime(tableName, "updated_at") + _kostenstelle.DeletedAt = field.NewField(tableName, "deleted_at") + + _kostenstelle.fillFieldMap() + + return _kostenstelle +} + +type kostenstelle struct { + kostenstelleDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (k kostenstelle) Table(newTableName string) *kostenstelle { + k.kostenstelleDo.UseTable(newTableName) + return k.updateTableName(newTableName) +} + +func (k kostenstelle) As(alias string) *kostenstelle { + k.kostenstelleDo.DO = *(k.kostenstelleDo.As(alias).(*gen.DO)) + return k.updateTableName(alias) +} + +func (k *kostenstelle) updateTableName(table string) *kostenstelle { + k.ALL = field.NewAsterisk(table) + k.ID = field.NewUint(table, "id") + k.CreatedAt = field.NewTime(table, "created_at") + k.UpdatedAt = field.NewTime(table, "updated_at") + k.DeletedAt = field.NewField(table, "deleted_at") + + k.fillFieldMap() + + return k +} + +func (k *kostenstelle) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := k.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (k *kostenstelle) fillFieldMap() { + k.fieldMap = make(map[string]field.Expr, 4) + k.fieldMap["id"] = k.ID + k.fieldMap["created_at"] = k.CreatedAt + k.fieldMap["updated_at"] = k.UpdatedAt + k.fieldMap["deleted_at"] = k.DeletedAt +} + +func (k kostenstelle) clone(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceConnPool(db.Statement.ConnPool) + return k +} + +func (k kostenstelle) replaceDB(db *gorm.DB) kostenstelle { + k.kostenstelleDo.ReplaceDB(db) + return k +} + +type kostenstelleDo struct{ gen.DO } + +type IKostenstelleDo interface { + gen.SubQuery + Debug() IKostenstelleDo + WithContext(ctx context.Context) IKostenstelleDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IKostenstelleDo + WriteDB() IKostenstelleDo + As(alias string) gen.Dao + Session(config *gorm.Session) IKostenstelleDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IKostenstelleDo + Not(conds ...gen.Condition) IKostenstelleDo + Or(conds ...gen.Condition) IKostenstelleDo + Select(conds ...field.Expr) IKostenstelleDo + Where(conds ...gen.Condition) IKostenstelleDo + Order(conds ...field.Expr) IKostenstelleDo + Distinct(cols ...field.Expr) IKostenstelleDo + Omit(cols ...field.Expr) IKostenstelleDo + Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo + LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo + Group(cols ...field.Expr) IKostenstelleDo + Having(conds ...gen.Condition) IKostenstelleDo + Limit(limit int) IKostenstelleDo + Offset(offset int) IKostenstelleDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo + Unscoped() IKostenstelleDo + Create(values ...*model.Kostenstelle) error + CreateInBatches(values []*model.Kostenstelle, batchSize int) error + Save(values ...*model.Kostenstelle) error + First() (*model.Kostenstelle, error) + Take() (*model.Kostenstelle, error) + Last() (*model.Kostenstelle, error) + Find() ([]*model.Kostenstelle, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) + FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Kostenstelle) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IKostenstelleDo + Assign(attrs ...field.AssignExpr) IKostenstelleDo + Joins(fields ...field.RelationField) IKostenstelleDo + Preload(fields ...field.RelationField) IKostenstelleDo + FirstOrInit() (*model.Kostenstelle, error) + FirstOrCreate() (*model.Kostenstelle, error) + FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IKostenstelleDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (k kostenstelleDo) Debug() IKostenstelleDo { + return k.withDO(k.DO.Debug()) +} + +func (k kostenstelleDo) WithContext(ctx context.Context) IKostenstelleDo { + return k.withDO(k.DO.WithContext(ctx)) +} + +func (k kostenstelleDo) ReadDB() IKostenstelleDo { + return k.Clauses(dbresolver.Read) +} + +func (k kostenstelleDo) WriteDB() IKostenstelleDo { + return k.Clauses(dbresolver.Write) +} + +func (k kostenstelleDo) Session(config *gorm.Session) IKostenstelleDo { + return k.withDO(k.DO.Session(config)) +} + +func (k kostenstelleDo) Clauses(conds ...clause.Expression) IKostenstelleDo { + return k.withDO(k.DO.Clauses(conds...)) +} + +func (k kostenstelleDo) Returning(value interface{}, columns ...string) IKostenstelleDo { + return k.withDO(k.DO.Returning(value, columns...)) +} + +func (k kostenstelleDo) Not(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Not(conds...)) +} + +func (k kostenstelleDo) Or(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Or(conds...)) +} + +func (k kostenstelleDo) Select(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Select(conds...)) +} + +func (k kostenstelleDo) Where(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Where(conds...)) +} + +func (k kostenstelleDo) Order(conds ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Order(conds...)) +} + +func (k kostenstelleDo) Distinct(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Distinct(cols...)) +} + +func (k kostenstelleDo) Omit(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Omit(cols...)) +} + +func (k kostenstelleDo) Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Join(table, on...)) +} + +func (k kostenstelleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.LeftJoin(table, on...)) +} + +func (k kostenstelleDo) RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.RightJoin(table, on...)) +} + +func (k kostenstelleDo) Group(cols ...field.Expr) IKostenstelleDo { + return k.withDO(k.DO.Group(cols...)) +} + +func (k kostenstelleDo) Having(conds ...gen.Condition) IKostenstelleDo { + return k.withDO(k.DO.Having(conds...)) +} + +func (k kostenstelleDo) Limit(limit int) IKostenstelleDo { + return k.withDO(k.DO.Limit(limit)) +} + +func (k kostenstelleDo) Offset(offset int) IKostenstelleDo { + return k.withDO(k.DO.Offset(offset)) +} + +func (k kostenstelleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo { + return k.withDO(k.DO.Scopes(funcs...)) +} + +func (k kostenstelleDo) Unscoped() IKostenstelleDo { + return k.withDO(k.DO.Unscoped()) +} + +func (k kostenstelleDo) Create(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Create(values) +} + +func (k kostenstelleDo) CreateInBatches(values []*model.Kostenstelle, batchSize int) error { + return k.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (k kostenstelleDo) Save(values ...*model.Kostenstelle) error { + if len(values) == 0 { + return nil + } + return k.DO.Save(values) +} + +func (k kostenstelleDo) First() (*model.Kostenstelle, error) { + if result, err := k.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Take() (*model.Kostenstelle, error) { + if result, err := k.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Last() (*model.Kostenstelle, error) { + if result, err := k.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) Find() ([]*model.Kostenstelle, error) { + result, err := k.DO.Find() + return result.([]*model.Kostenstelle), err +} + +func (k kostenstelleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) { + buf := make([]*model.Kostenstelle, 0, batchSize) + err = k.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (k kostenstelleDo) FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return k.DO.FindInBatches(result, batchSize, fc) +} + +func (k kostenstelleDo) Attrs(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Attrs(attrs...)) +} + +func (k kostenstelleDo) Assign(attrs ...field.AssignExpr) IKostenstelleDo { + return k.withDO(k.DO.Assign(attrs...)) +} + +func (k kostenstelleDo) Joins(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Joins(_f)) + } + return &k +} + +func (k kostenstelleDo) Preload(fields ...field.RelationField) IKostenstelleDo { + for _, _f := range fields { + k = *k.withDO(k.DO.Preload(_f)) + } + return &k +} + +func (k kostenstelleDo) FirstOrInit() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FirstOrCreate() (*model.Kostenstelle, error) { + if result, err := k.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Kostenstelle), nil + } +} + +func (k kostenstelleDo) FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) { + result, err = k.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = k.Offset(-1).Limit(-1).Count() + return +} + +func (k kostenstelleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = k.Count() + if err != nil { + return + } + + err = k.Offset(offset).Limit(limit).Scan(result) + return +} + +func (k kostenstelleDo) Scan(result interface{}) (err error) { + return k.DO.Scan(result) +} + +func (k kostenstelleDo) Delete(models ...*model.Kostenstelle) (result gen.ResultInfo, err error) { + return k.DO.Delete(models) +} + +func (k *kostenstelleDo) withDO(do gen.Dao) *kostenstelleDo { + k.DO = *do.(*gen.DO) + return k +} diff --git a/cmd/mailingest/query/lagerplatzs.gen.go b/cmd/mailingest/query/lagerplatzs.gen.go new file mode 100644 index 0000000..e83e134 --- /dev/null +++ b/cmd/mailingest/query/lagerplatzs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLagerplatz(db *gorm.DB, opts ...gen.DOOption) lagerplatz { + _lagerplatz := lagerplatz{} + + _lagerplatz.lagerplatzDo.UseDB(db, opts...) + _lagerplatz.lagerplatzDo.UseModel(&model.Lagerplatz{}) + + tableName := _lagerplatz.lagerplatzDo.TableName() + _lagerplatz.ALL = field.NewAsterisk(tableName) + _lagerplatz.ID = field.NewUint(tableName, "id") + _lagerplatz.CreatedAt = field.NewTime(tableName, "created_at") + _lagerplatz.UpdatedAt = field.NewTime(tableName, "updated_at") + _lagerplatz.DeletedAt = field.NewField(tableName, "deleted_at") + + _lagerplatz.fillFieldMap() + + return _lagerplatz +} + +type lagerplatz struct { + lagerplatzDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lagerplatz) Table(newTableName string) *lagerplatz { + l.lagerplatzDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lagerplatz) As(alias string) *lagerplatz { + l.lagerplatzDo.DO = *(l.lagerplatzDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lagerplatz) updateTableName(table string) *lagerplatz { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lagerplatz) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lagerplatz) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lagerplatz) clone(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lagerplatz) replaceDB(db *gorm.DB) lagerplatz { + l.lagerplatzDo.ReplaceDB(db) + return l +} + +type lagerplatzDo struct{ gen.DO } + +type ILagerplatzDo interface { + gen.SubQuery + Debug() ILagerplatzDo + WithContext(ctx context.Context) ILagerplatzDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerplatzDo + WriteDB() ILagerplatzDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerplatzDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerplatzDo + Not(conds ...gen.Condition) ILagerplatzDo + Or(conds ...gen.Condition) ILagerplatzDo + Select(conds ...field.Expr) ILagerplatzDo + Where(conds ...gen.Condition) ILagerplatzDo + Order(conds ...field.Expr) ILagerplatzDo + Distinct(cols ...field.Expr) ILagerplatzDo + Omit(cols ...field.Expr) ILagerplatzDo + Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo + Group(cols ...field.Expr) ILagerplatzDo + Having(conds ...gen.Condition) ILagerplatzDo + Limit(limit int) ILagerplatzDo + Offset(offset int) ILagerplatzDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo + Unscoped() ILagerplatzDo + Create(values ...*model.Lagerplatz) error + CreateInBatches(values []*model.Lagerplatz, batchSize int) error + Save(values ...*model.Lagerplatz) error + First() (*model.Lagerplatz, error) + Take() (*model.Lagerplatz, error) + Last() (*model.Lagerplatz, error) + Find() ([]*model.Lagerplatz, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) + FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lagerplatz) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerplatzDo + Assign(attrs ...field.AssignExpr) ILagerplatzDo + Joins(fields ...field.RelationField) ILagerplatzDo + Preload(fields ...field.RelationField) ILagerplatzDo + FirstOrInit() (*model.Lagerplatz, error) + FirstOrCreate() (*model.Lagerplatz, error) + FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerplatzDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerplatzDo) Debug() ILagerplatzDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerplatzDo) WithContext(ctx context.Context) ILagerplatzDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerplatzDo) ReadDB() ILagerplatzDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerplatzDo) WriteDB() ILagerplatzDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerplatzDo) Session(config *gorm.Session) ILagerplatzDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerplatzDo) Clauses(conds ...clause.Expression) ILagerplatzDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerplatzDo) Returning(value interface{}, columns ...string) ILagerplatzDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerplatzDo) Not(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerplatzDo) Or(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerplatzDo) Select(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerplatzDo) Where(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerplatzDo) Order(conds ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerplatzDo) Distinct(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerplatzDo) Omit(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerplatzDo) Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerplatzDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerplatzDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerplatzDo) Group(cols ...field.Expr) ILagerplatzDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerplatzDo) Having(conds ...gen.Condition) ILagerplatzDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerplatzDo) Limit(limit int) ILagerplatzDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerplatzDo) Offset(offset int) ILagerplatzDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerplatzDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerplatzDo) Unscoped() ILagerplatzDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerplatzDo) Create(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerplatzDo) CreateInBatches(values []*model.Lagerplatz, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerplatzDo) Save(values ...*model.Lagerplatz) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerplatzDo) First() (*model.Lagerplatz, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Take() (*model.Lagerplatz, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Last() (*model.Lagerplatz, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) Find() ([]*model.Lagerplatz, error) { + result, err := l.DO.Find() + return result.([]*model.Lagerplatz), err +} + +func (l lagerplatzDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) { + buf := make([]*model.Lagerplatz, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerplatzDo) FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerplatzDo) Attrs(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerplatzDo) Assign(attrs ...field.AssignExpr) ILagerplatzDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerplatzDo) Joins(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerplatzDo) Preload(fields ...field.RelationField) ILagerplatzDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerplatzDo) FirstOrInit() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FirstOrCreate() (*model.Lagerplatz, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lagerplatz), nil + } +} + +func (l lagerplatzDo) FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerplatzDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerplatzDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerplatzDo) Delete(models ...*model.Lagerplatz) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerplatzDo) withDO(do gen.Dao) *lagerplatzDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/cmd/mailingest/query/lagers.gen.go b/cmd/mailingest/query/lagers.gen.go new file mode 100644 index 0000000..20a3da0 --- /dev/null +++ b/cmd/mailingest/query/lagers.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newLager(db *gorm.DB, opts ...gen.DOOption) lager { + _lager := lager{} + + _lager.lagerDo.UseDB(db, opts...) + _lager.lagerDo.UseModel(&model.Lager{}) + + tableName := _lager.lagerDo.TableName() + _lager.ALL = field.NewAsterisk(tableName) + _lager.ID = field.NewUint(tableName, "id") + _lager.CreatedAt = field.NewTime(tableName, "created_at") + _lager.UpdatedAt = field.NewTime(tableName, "updated_at") + _lager.DeletedAt = field.NewField(tableName, "deleted_at") + + _lager.fillFieldMap() + + return _lager +} + +type lager struct { + lagerDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (l lager) Table(newTableName string) *lager { + l.lagerDo.UseTable(newTableName) + return l.updateTableName(newTableName) +} + +func (l lager) As(alias string) *lager { + l.lagerDo.DO = *(l.lagerDo.As(alias).(*gen.DO)) + return l.updateTableName(alias) +} + +func (l *lager) updateTableName(table string) *lager { + l.ALL = field.NewAsterisk(table) + l.ID = field.NewUint(table, "id") + l.CreatedAt = field.NewTime(table, "created_at") + l.UpdatedAt = field.NewTime(table, "updated_at") + l.DeletedAt = field.NewField(table, "deleted_at") + + l.fillFieldMap() + + return l +} + +func (l *lager) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := l.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (l *lager) fillFieldMap() { + l.fieldMap = make(map[string]field.Expr, 4) + l.fieldMap["id"] = l.ID + l.fieldMap["created_at"] = l.CreatedAt + l.fieldMap["updated_at"] = l.UpdatedAt + l.fieldMap["deleted_at"] = l.DeletedAt +} + +func (l lager) clone(db *gorm.DB) lager { + l.lagerDo.ReplaceConnPool(db.Statement.ConnPool) + return l +} + +func (l lager) replaceDB(db *gorm.DB) lager { + l.lagerDo.ReplaceDB(db) + return l +} + +type lagerDo struct{ gen.DO } + +type ILagerDo interface { + gen.SubQuery + Debug() ILagerDo + WithContext(ctx context.Context) ILagerDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() ILagerDo + WriteDB() ILagerDo + As(alias string) gen.Dao + Session(config *gorm.Session) ILagerDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) ILagerDo + Not(conds ...gen.Condition) ILagerDo + Or(conds ...gen.Condition) ILagerDo + Select(conds ...field.Expr) ILagerDo + Where(conds ...gen.Condition) ILagerDo + Order(conds ...field.Expr) ILagerDo + Distinct(cols ...field.Expr) ILagerDo + Omit(cols ...field.Expr) ILagerDo + Join(table schema.Tabler, on ...field.Expr) ILagerDo + LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo + RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo + Group(cols ...field.Expr) ILagerDo + Having(conds ...gen.Condition) ILagerDo + Limit(limit int) ILagerDo + Offset(offset int) ILagerDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo + Unscoped() ILagerDo + Create(values ...*model.Lager) error + CreateInBatches(values []*model.Lager, batchSize int) error + Save(values ...*model.Lager) error + First() (*model.Lager, error) + Take() (*model.Lager, error) + Last() (*model.Lager, error) + Find() ([]*model.Lager, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) + FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Lager) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) ILagerDo + Assign(attrs ...field.AssignExpr) ILagerDo + Joins(fields ...field.RelationField) ILagerDo + Preload(fields ...field.RelationField) ILagerDo + FirstOrInit() (*model.Lager, error) + FirstOrCreate() (*model.Lager, error) + FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) ILagerDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (l lagerDo) Debug() ILagerDo { + return l.withDO(l.DO.Debug()) +} + +func (l lagerDo) WithContext(ctx context.Context) ILagerDo { + return l.withDO(l.DO.WithContext(ctx)) +} + +func (l lagerDo) ReadDB() ILagerDo { + return l.Clauses(dbresolver.Read) +} + +func (l lagerDo) WriteDB() ILagerDo { + return l.Clauses(dbresolver.Write) +} + +func (l lagerDo) Session(config *gorm.Session) ILagerDo { + return l.withDO(l.DO.Session(config)) +} + +func (l lagerDo) Clauses(conds ...clause.Expression) ILagerDo { + return l.withDO(l.DO.Clauses(conds...)) +} + +func (l lagerDo) Returning(value interface{}, columns ...string) ILagerDo { + return l.withDO(l.DO.Returning(value, columns...)) +} + +func (l lagerDo) Not(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Not(conds...)) +} + +func (l lagerDo) Or(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Or(conds...)) +} + +func (l lagerDo) Select(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Select(conds...)) +} + +func (l lagerDo) Where(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Where(conds...)) +} + +func (l lagerDo) Order(conds ...field.Expr) ILagerDo { + return l.withDO(l.DO.Order(conds...)) +} + +func (l lagerDo) Distinct(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Distinct(cols...)) +} + +func (l lagerDo) Omit(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Omit(cols...)) +} + +func (l lagerDo) Join(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.Join(table, on...)) +} + +func (l lagerDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.LeftJoin(table, on...)) +} + +func (l lagerDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo { + return l.withDO(l.DO.RightJoin(table, on...)) +} + +func (l lagerDo) Group(cols ...field.Expr) ILagerDo { + return l.withDO(l.DO.Group(cols...)) +} + +func (l lagerDo) Having(conds ...gen.Condition) ILagerDo { + return l.withDO(l.DO.Having(conds...)) +} + +func (l lagerDo) Limit(limit int) ILagerDo { + return l.withDO(l.DO.Limit(limit)) +} + +func (l lagerDo) Offset(offset int) ILagerDo { + return l.withDO(l.DO.Offset(offset)) +} + +func (l lagerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo { + return l.withDO(l.DO.Scopes(funcs...)) +} + +func (l lagerDo) Unscoped() ILagerDo { + return l.withDO(l.DO.Unscoped()) +} + +func (l lagerDo) Create(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Create(values) +} + +func (l lagerDo) CreateInBatches(values []*model.Lager, batchSize int) error { + return l.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (l lagerDo) Save(values ...*model.Lager) error { + if len(values) == 0 { + return nil + } + return l.DO.Save(values) +} + +func (l lagerDo) First() (*model.Lager, error) { + if result, err := l.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Take() (*model.Lager, error) { + if result, err := l.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Last() (*model.Lager, error) { + if result, err := l.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) Find() ([]*model.Lager, error) { + result, err := l.DO.Find() + return result.([]*model.Lager), err +} + +func (l lagerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) { + buf := make([]*model.Lager, 0, batchSize) + err = l.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (l lagerDo) FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return l.DO.FindInBatches(result, batchSize, fc) +} + +func (l lagerDo) Attrs(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Attrs(attrs...)) +} + +func (l lagerDo) Assign(attrs ...field.AssignExpr) ILagerDo { + return l.withDO(l.DO.Assign(attrs...)) +} + +func (l lagerDo) Joins(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Joins(_f)) + } + return &l +} + +func (l lagerDo) Preload(fields ...field.RelationField) ILagerDo { + for _, _f := range fields { + l = *l.withDO(l.DO.Preload(_f)) + } + return &l +} + +func (l lagerDo) FirstOrInit() (*model.Lager, error) { + if result, err := l.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FirstOrCreate() (*model.Lager, error) { + if result, err := l.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Lager), nil + } +} + +func (l lagerDo) FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) { + result, err = l.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = l.Offset(-1).Limit(-1).Count() + return +} + +func (l lagerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = l.Count() + if err != nil { + return + } + + err = l.Offset(offset).Limit(limit).Scan(result) + return +} + +func (l lagerDo) Scan(result interface{}) (err error) { + return l.DO.Scan(result) +} + +func (l lagerDo) Delete(models ...*model.Lager) (result gen.ResultInfo, err error) { + return l.DO.Delete(models) +} + +func (l *lagerDo) withDO(do gen.Dao) *lagerDo { + l.DO = *do.(*gen.DO) + return l +} diff --git a/cmd/mailingest/query/mandants.gen.go b/cmd/mailingest/query/mandants.gen.go new file mode 100644 index 0000000..e806c6a --- /dev/null +++ b/cmd/mailingest/query/mandants.gen.go @@ -0,0 +1,411 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newMandant(db *gorm.DB, opts ...gen.DOOption) mandant { + _mandant := mandant{} + + _mandant.mandantDo.UseDB(db, opts...) + _mandant.mandantDo.UseModel(&model.Mandant{}) + + tableName := _mandant.mandantDo.TableName() + _mandant.ALL = field.NewAsterisk(tableName) + _mandant.ID = field.NewUint(tableName, "id") + _mandant.CreatedAt = field.NewTime(tableName, "created_at") + _mandant.UpdatedAt = field.NewTime(tableName, "updated_at") + _mandant.DeletedAt = field.NewField(tableName, "deleted_at") + _mandant.Name = field.NewString(tableName, "name") + _mandant.Logo = field.NewString(tableName, "logo") + _mandant.Plan = field.NewString(tableName, "plan") + _mandant.Color = field.NewString(tableName, "color") + + _mandant.fillFieldMap() + + return _mandant +} + +type mandant struct { + mandantDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Name field.String + Logo field.String + Plan field.String + Color field.String + + fieldMap map[string]field.Expr +} + +func (m mandant) Table(newTableName string) *mandant { + m.mandantDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m mandant) As(alias string) *mandant { + m.mandantDo.DO = *(m.mandantDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *mandant) updateTableName(table string) *mandant { + m.ALL = field.NewAsterisk(table) + m.ID = field.NewUint(table, "id") + m.CreatedAt = field.NewTime(table, "created_at") + m.UpdatedAt = field.NewTime(table, "updated_at") + m.DeletedAt = field.NewField(table, "deleted_at") + m.Name = field.NewString(table, "name") + m.Logo = field.NewString(table, "logo") + m.Plan = field.NewString(table, "plan") + m.Color = field.NewString(table, "color") + + m.fillFieldMap() + + return m +} + +func (m *mandant) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *mandant) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 8) + m.fieldMap["id"] = m.ID + m.fieldMap["created_at"] = m.CreatedAt + m.fieldMap["updated_at"] = m.UpdatedAt + m.fieldMap["deleted_at"] = m.DeletedAt + m.fieldMap["name"] = m.Name + m.fieldMap["logo"] = m.Logo + m.fieldMap["plan"] = m.Plan + m.fieldMap["color"] = m.Color +} + +func (m mandant) clone(db *gorm.DB) mandant { + m.mandantDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m mandant) replaceDB(db *gorm.DB) mandant { + m.mandantDo.ReplaceDB(db) + return m +} + +type mandantDo struct{ gen.DO } + +type IMandantDo interface { + gen.SubQuery + Debug() IMandantDo + WithContext(ctx context.Context) IMandantDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IMandantDo + WriteDB() IMandantDo + As(alias string) gen.Dao + Session(config *gorm.Session) IMandantDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IMandantDo + Not(conds ...gen.Condition) IMandantDo + Or(conds ...gen.Condition) IMandantDo + Select(conds ...field.Expr) IMandantDo + Where(conds ...gen.Condition) IMandantDo + Order(conds ...field.Expr) IMandantDo + Distinct(cols ...field.Expr) IMandantDo + Omit(cols ...field.Expr) IMandantDo + Join(table schema.Tabler, on ...field.Expr) IMandantDo + LeftJoin(table schema.Tabler, on ...field.Expr) IMandantDo + RightJoin(table schema.Tabler, on ...field.Expr) IMandantDo + Group(cols ...field.Expr) IMandantDo + Having(conds ...gen.Condition) IMandantDo + Limit(limit int) IMandantDo + Offset(offset int) IMandantDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IMandantDo + Unscoped() IMandantDo + Create(values ...*model.Mandant) error + CreateInBatches(values []*model.Mandant, batchSize int) error + Save(values ...*model.Mandant) error + First() (*model.Mandant, error) + Take() (*model.Mandant, error) + Last() (*model.Mandant, error) + Find() ([]*model.Mandant, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Mandant, err error) + FindInBatches(result *[]*model.Mandant, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Mandant) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IMandantDo + Assign(attrs ...field.AssignExpr) IMandantDo + Joins(fields ...field.RelationField) IMandantDo + Preload(fields ...field.RelationField) IMandantDo + FirstOrInit() (*model.Mandant, error) + FirstOrCreate() (*model.Mandant, error) + FindByPage(offset int, limit int) (result []*model.Mandant, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IMandantDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (m mandantDo) Debug() IMandantDo { + return m.withDO(m.DO.Debug()) +} + +func (m mandantDo) WithContext(ctx context.Context) IMandantDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m mandantDo) ReadDB() IMandantDo { + return m.Clauses(dbresolver.Read) +} + +func (m mandantDo) WriteDB() IMandantDo { + return m.Clauses(dbresolver.Write) +} + +func (m mandantDo) Session(config *gorm.Session) IMandantDo { + return m.withDO(m.DO.Session(config)) +} + +func (m mandantDo) Clauses(conds ...clause.Expression) IMandantDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m mandantDo) Returning(value interface{}, columns ...string) IMandantDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m mandantDo) Not(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m mandantDo) Or(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m mandantDo) Select(conds ...field.Expr) IMandantDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m mandantDo) Where(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m mandantDo) Order(conds ...field.Expr) IMandantDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m mandantDo) Distinct(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m mandantDo) Omit(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m mandantDo) Join(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m mandantDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m mandantDo) RightJoin(table schema.Tabler, on ...field.Expr) IMandantDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m mandantDo) Group(cols ...field.Expr) IMandantDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m mandantDo) Having(conds ...gen.Condition) IMandantDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m mandantDo) Limit(limit int) IMandantDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m mandantDo) Offset(offset int) IMandantDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m mandantDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMandantDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m mandantDo) Unscoped() IMandantDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m mandantDo) Create(values ...*model.Mandant) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m mandantDo) CreateInBatches(values []*model.Mandant, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m mandantDo) Save(values ...*model.Mandant) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m mandantDo) First() (*model.Mandant, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Take() (*model.Mandant, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Last() (*model.Mandant, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) Find() ([]*model.Mandant, error) { + result, err := m.DO.Find() + return result.([]*model.Mandant), err +} + +func (m mandantDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Mandant, err error) { + buf := make([]*model.Mandant, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m mandantDo) FindInBatches(result *[]*model.Mandant, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m mandantDo) Attrs(attrs ...field.AssignExpr) IMandantDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m mandantDo) Assign(attrs ...field.AssignExpr) IMandantDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m mandantDo) Joins(fields ...field.RelationField) IMandantDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m mandantDo) Preload(fields ...field.RelationField) IMandantDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m mandantDo) FirstOrInit() (*model.Mandant, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) FirstOrCreate() (*model.Mandant, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Mandant), nil + } +} + +func (m mandantDo) FindByPage(offset int, limit int) (result []*model.Mandant, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m mandantDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m mandantDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m mandantDo) Delete(models ...*model.Mandant) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *mandantDo) withDO(do gen.Dao) *mandantDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/cmd/mailingest/query/materials.gen.go b/cmd/mailingest/query/materials.gen.go new file mode 100644 index 0000000..1f6c21e --- /dev/null +++ b/cmd/mailingest/query/materials.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newMaterial(db *gorm.DB, opts ...gen.DOOption) material { + _material := material{} + + _material.materialDo.UseDB(db, opts...) + _material.materialDo.UseModel(&model.Material{}) + + tableName := _material.materialDo.TableName() + _material.ALL = field.NewAsterisk(tableName) + _material.ID = field.NewUint(tableName, "id") + _material.CreatedAt = field.NewTime(tableName, "created_at") + _material.UpdatedAt = field.NewTime(tableName, "updated_at") + _material.DeletedAt = field.NewField(tableName, "deleted_at") + + _material.fillFieldMap() + + return _material +} + +type material struct { + materialDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (m material) Table(newTableName string) *material { + m.materialDo.UseTable(newTableName) + return m.updateTableName(newTableName) +} + +func (m material) As(alias string) *material { + m.materialDo.DO = *(m.materialDo.As(alias).(*gen.DO)) + return m.updateTableName(alias) +} + +func (m *material) updateTableName(table string) *material { + m.ALL = field.NewAsterisk(table) + m.ID = field.NewUint(table, "id") + m.CreatedAt = field.NewTime(table, "created_at") + m.UpdatedAt = field.NewTime(table, "updated_at") + m.DeletedAt = field.NewField(table, "deleted_at") + + m.fillFieldMap() + + return m +} + +func (m *material) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := m.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (m *material) fillFieldMap() { + m.fieldMap = make(map[string]field.Expr, 4) + m.fieldMap["id"] = m.ID + m.fieldMap["created_at"] = m.CreatedAt + m.fieldMap["updated_at"] = m.UpdatedAt + m.fieldMap["deleted_at"] = m.DeletedAt +} + +func (m material) clone(db *gorm.DB) material { + m.materialDo.ReplaceConnPool(db.Statement.ConnPool) + return m +} + +func (m material) replaceDB(db *gorm.DB) material { + m.materialDo.ReplaceDB(db) + return m +} + +type materialDo struct{ gen.DO } + +type IMaterialDo interface { + gen.SubQuery + Debug() IMaterialDo + WithContext(ctx context.Context) IMaterialDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IMaterialDo + WriteDB() IMaterialDo + As(alias string) gen.Dao + Session(config *gorm.Session) IMaterialDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IMaterialDo + Not(conds ...gen.Condition) IMaterialDo + Or(conds ...gen.Condition) IMaterialDo + Select(conds ...field.Expr) IMaterialDo + Where(conds ...gen.Condition) IMaterialDo + Order(conds ...field.Expr) IMaterialDo + Distinct(cols ...field.Expr) IMaterialDo + Omit(cols ...field.Expr) IMaterialDo + Join(table schema.Tabler, on ...field.Expr) IMaterialDo + LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo + Group(cols ...field.Expr) IMaterialDo + Having(conds ...gen.Condition) IMaterialDo + Limit(limit int) IMaterialDo + Offset(offset int) IMaterialDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo + Unscoped() IMaterialDo + Create(values ...*model.Material) error + CreateInBatches(values []*model.Material, batchSize int) error + Save(values ...*model.Material) error + First() (*model.Material, error) + Take() (*model.Material, error) + Last() (*model.Material, error) + Find() ([]*model.Material, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) + FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Material) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IMaterialDo + Assign(attrs ...field.AssignExpr) IMaterialDo + Joins(fields ...field.RelationField) IMaterialDo + Preload(fields ...field.RelationField) IMaterialDo + FirstOrInit() (*model.Material, error) + FirstOrCreate() (*model.Material, error) + FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IMaterialDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (m materialDo) Debug() IMaterialDo { + return m.withDO(m.DO.Debug()) +} + +func (m materialDo) WithContext(ctx context.Context) IMaterialDo { + return m.withDO(m.DO.WithContext(ctx)) +} + +func (m materialDo) ReadDB() IMaterialDo { + return m.Clauses(dbresolver.Read) +} + +func (m materialDo) WriteDB() IMaterialDo { + return m.Clauses(dbresolver.Write) +} + +func (m materialDo) Session(config *gorm.Session) IMaterialDo { + return m.withDO(m.DO.Session(config)) +} + +func (m materialDo) Clauses(conds ...clause.Expression) IMaterialDo { + return m.withDO(m.DO.Clauses(conds...)) +} + +func (m materialDo) Returning(value interface{}, columns ...string) IMaterialDo { + return m.withDO(m.DO.Returning(value, columns...)) +} + +func (m materialDo) Not(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Not(conds...)) +} + +func (m materialDo) Or(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Or(conds...)) +} + +func (m materialDo) Select(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Select(conds...)) +} + +func (m materialDo) Where(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Where(conds...)) +} + +func (m materialDo) Order(conds ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Order(conds...)) +} + +func (m materialDo) Distinct(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Distinct(cols...)) +} + +func (m materialDo) Omit(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Omit(cols...)) +} + +func (m materialDo) Join(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Join(table, on...)) +} + +func (m materialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.LeftJoin(table, on...)) +} + +func (m materialDo) RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo { + return m.withDO(m.DO.RightJoin(table, on...)) +} + +func (m materialDo) Group(cols ...field.Expr) IMaterialDo { + return m.withDO(m.DO.Group(cols...)) +} + +func (m materialDo) Having(conds ...gen.Condition) IMaterialDo { + return m.withDO(m.DO.Having(conds...)) +} + +func (m materialDo) Limit(limit int) IMaterialDo { + return m.withDO(m.DO.Limit(limit)) +} + +func (m materialDo) Offset(offset int) IMaterialDo { + return m.withDO(m.DO.Offset(offset)) +} + +func (m materialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo { + return m.withDO(m.DO.Scopes(funcs...)) +} + +func (m materialDo) Unscoped() IMaterialDo { + return m.withDO(m.DO.Unscoped()) +} + +func (m materialDo) Create(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Create(values) +} + +func (m materialDo) CreateInBatches(values []*model.Material, batchSize int) error { + return m.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (m materialDo) Save(values ...*model.Material) error { + if len(values) == 0 { + return nil + } + return m.DO.Save(values) +} + +func (m materialDo) First() (*model.Material, error) { + if result, err := m.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Take() (*model.Material, error) { + if result, err := m.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Last() (*model.Material, error) { + if result, err := m.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) Find() ([]*model.Material, error) { + result, err := m.DO.Find() + return result.([]*model.Material), err +} + +func (m materialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) { + buf := make([]*model.Material, 0, batchSize) + err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (m materialDo) FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return m.DO.FindInBatches(result, batchSize, fc) +} + +func (m materialDo) Attrs(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Attrs(attrs...)) +} + +func (m materialDo) Assign(attrs ...field.AssignExpr) IMaterialDo { + return m.withDO(m.DO.Assign(attrs...)) +} + +func (m materialDo) Joins(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Joins(_f)) + } + return &m +} + +func (m materialDo) Preload(fields ...field.RelationField) IMaterialDo { + for _, _f := range fields { + m = *m.withDO(m.DO.Preload(_f)) + } + return &m +} + +func (m materialDo) FirstOrInit() (*model.Material, error) { + if result, err := m.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FirstOrCreate() (*model.Material, error) { + if result, err := m.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Material), nil + } +} + +func (m materialDo) FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) { + result, err = m.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = m.Offset(-1).Limit(-1).Count() + return +} + +func (m materialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = m.Count() + if err != nil { + return + } + + err = m.Offset(offset).Limit(limit).Scan(result) + return +} + +func (m materialDo) Scan(result interface{}) (err error) { + return m.DO.Scan(result) +} + +func (m materialDo) Delete(models ...*model.Material) (result gen.ResultInfo, err error) { + return m.DO.Delete(models) +} + +func (m *materialDo) withDO(do gen.Dao) *materialDo { + m.DO = *do.(*gen.DO) + return m +} diff --git a/cmd/mailingest/query/nachrichts.gen.go b/cmd/mailingest/query/nachrichts.gen.go new file mode 100644 index 0000000..19de00c --- /dev/null +++ b/cmd/mailingest/query/nachrichts.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newNachricht(db *gorm.DB, opts ...gen.DOOption) nachricht { + _nachricht := nachricht{} + + _nachricht.nachrichtDo.UseDB(db, opts...) + _nachricht.nachrichtDo.UseModel(&model.Nachricht{}) + + tableName := _nachricht.nachrichtDo.TableName() + _nachricht.ALL = field.NewAsterisk(tableName) + _nachricht.ID = field.NewUint(tableName, "id") + _nachricht.CreatedAt = field.NewTime(tableName, "created_at") + _nachricht.UpdatedAt = field.NewTime(tableName, "updated_at") + _nachricht.DeletedAt = field.NewField(tableName, "deleted_at") + + _nachricht.fillFieldMap() + + return _nachricht +} + +type nachricht struct { + nachrichtDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (n nachricht) Table(newTableName string) *nachricht { + n.nachrichtDo.UseTable(newTableName) + return n.updateTableName(newTableName) +} + +func (n nachricht) As(alias string) *nachricht { + n.nachrichtDo.DO = *(n.nachrichtDo.As(alias).(*gen.DO)) + return n.updateTableName(alias) +} + +func (n *nachricht) updateTableName(table string) *nachricht { + n.ALL = field.NewAsterisk(table) + n.ID = field.NewUint(table, "id") + n.CreatedAt = field.NewTime(table, "created_at") + n.UpdatedAt = field.NewTime(table, "updated_at") + n.DeletedAt = field.NewField(table, "deleted_at") + + n.fillFieldMap() + + return n +} + +func (n *nachricht) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := n.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (n *nachricht) fillFieldMap() { + n.fieldMap = make(map[string]field.Expr, 4) + n.fieldMap["id"] = n.ID + n.fieldMap["created_at"] = n.CreatedAt + n.fieldMap["updated_at"] = n.UpdatedAt + n.fieldMap["deleted_at"] = n.DeletedAt +} + +func (n nachricht) clone(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceConnPool(db.Statement.ConnPool) + return n +} + +func (n nachricht) replaceDB(db *gorm.DB) nachricht { + n.nachrichtDo.ReplaceDB(db) + return n +} + +type nachrichtDo struct{ gen.DO } + +type INachrichtDo interface { + gen.SubQuery + Debug() INachrichtDo + WithContext(ctx context.Context) INachrichtDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() INachrichtDo + WriteDB() INachrichtDo + As(alias string) gen.Dao + Session(config *gorm.Session) INachrichtDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) INachrichtDo + Not(conds ...gen.Condition) INachrichtDo + Or(conds ...gen.Condition) INachrichtDo + Select(conds ...field.Expr) INachrichtDo + Where(conds ...gen.Condition) INachrichtDo + Order(conds ...field.Expr) INachrichtDo + Distinct(cols ...field.Expr) INachrichtDo + Omit(cols ...field.Expr) INachrichtDo + Join(table schema.Tabler, on ...field.Expr) INachrichtDo + LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo + Group(cols ...field.Expr) INachrichtDo + Having(conds ...gen.Condition) INachrichtDo + Limit(limit int) INachrichtDo + Offset(offset int) INachrichtDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo + Unscoped() INachrichtDo + Create(values ...*model.Nachricht) error + CreateInBatches(values []*model.Nachricht, batchSize int) error + Save(values ...*model.Nachricht) error + First() (*model.Nachricht, error) + Take() (*model.Nachricht, error) + Last() (*model.Nachricht, error) + Find() ([]*model.Nachricht, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) + FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Nachricht) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) INachrichtDo + Assign(attrs ...field.AssignExpr) INachrichtDo + Joins(fields ...field.RelationField) INachrichtDo + Preload(fields ...field.RelationField) INachrichtDo + FirstOrInit() (*model.Nachricht, error) + FirstOrCreate() (*model.Nachricht, error) + FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) INachrichtDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (n nachrichtDo) Debug() INachrichtDo { + return n.withDO(n.DO.Debug()) +} + +func (n nachrichtDo) WithContext(ctx context.Context) INachrichtDo { + return n.withDO(n.DO.WithContext(ctx)) +} + +func (n nachrichtDo) ReadDB() INachrichtDo { + return n.Clauses(dbresolver.Read) +} + +func (n nachrichtDo) WriteDB() INachrichtDo { + return n.Clauses(dbresolver.Write) +} + +func (n nachrichtDo) Session(config *gorm.Session) INachrichtDo { + return n.withDO(n.DO.Session(config)) +} + +func (n nachrichtDo) Clauses(conds ...clause.Expression) INachrichtDo { + return n.withDO(n.DO.Clauses(conds...)) +} + +func (n nachrichtDo) Returning(value interface{}, columns ...string) INachrichtDo { + return n.withDO(n.DO.Returning(value, columns...)) +} + +func (n nachrichtDo) Not(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Not(conds...)) +} + +func (n nachrichtDo) Or(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Or(conds...)) +} + +func (n nachrichtDo) Select(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Select(conds...)) +} + +func (n nachrichtDo) Where(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Where(conds...)) +} + +func (n nachrichtDo) Order(conds ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Order(conds...)) +} + +func (n nachrichtDo) Distinct(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Distinct(cols...)) +} + +func (n nachrichtDo) Omit(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Omit(cols...)) +} + +func (n nachrichtDo) Join(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Join(table, on...)) +} + +func (n nachrichtDo) LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.LeftJoin(table, on...)) +} + +func (n nachrichtDo) RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo { + return n.withDO(n.DO.RightJoin(table, on...)) +} + +func (n nachrichtDo) Group(cols ...field.Expr) INachrichtDo { + return n.withDO(n.DO.Group(cols...)) +} + +func (n nachrichtDo) Having(conds ...gen.Condition) INachrichtDo { + return n.withDO(n.DO.Having(conds...)) +} + +func (n nachrichtDo) Limit(limit int) INachrichtDo { + return n.withDO(n.DO.Limit(limit)) +} + +func (n nachrichtDo) Offset(offset int) INachrichtDo { + return n.withDO(n.DO.Offset(offset)) +} + +func (n nachrichtDo) Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo { + return n.withDO(n.DO.Scopes(funcs...)) +} + +func (n nachrichtDo) Unscoped() INachrichtDo { + return n.withDO(n.DO.Unscoped()) +} + +func (n nachrichtDo) Create(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Create(values) +} + +func (n nachrichtDo) CreateInBatches(values []*model.Nachricht, batchSize int) error { + return n.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (n nachrichtDo) Save(values ...*model.Nachricht) error { + if len(values) == 0 { + return nil + } + return n.DO.Save(values) +} + +func (n nachrichtDo) First() (*model.Nachricht, error) { + if result, err := n.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Take() (*model.Nachricht, error) { + if result, err := n.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Last() (*model.Nachricht, error) { + if result, err := n.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) Find() ([]*model.Nachricht, error) { + result, err := n.DO.Find() + return result.([]*model.Nachricht), err +} + +func (n nachrichtDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) { + buf := make([]*model.Nachricht, 0, batchSize) + err = n.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (n nachrichtDo) FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return n.DO.FindInBatches(result, batchSize, fc) +} + +func (n nachrichtDo) Attrs(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Attrs(attrs...)) +} + +func (n nachrichtDo) Assign(attrs ...field.AssignExpr) INachrichtDo { + return n.withDO(n.DO.Assign(attrs...)) +} + +func (n nachrichtDo) Joins(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Joins(_f)) + } + return &n +} + +func (n nachrichtDo) Preload(fields ...field.RelationField) INachrichtDo { + for _, _f := range fields { + n = *n.withDO(n.DO.Preload(_f)) + } + return &n +} + +func (n nachrichtDo) FirstOrInit() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FirstOrCreate() (*model.Nachricht, error) { + if result, err := n.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Nachricht), nil + } +} + +func (n nachrichtDo) FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) { + result, err = n.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = n.Offset(-1).Limit(-1).Count() + return +} + +func (n nachrichtDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = n.Count() + if err != nil { + return + } + + err = n.Offset(offset).Limit(limit).Scan(result) + return +} + +func (n nachrichtDo) Scan(result interface{}) (err error) { + return n.DO.Scan(result) +} + +func (n nachrichtDo) Delete(models ...*model.Nachricht) (result gen.ResultInfo, err error) { + return n.DO.Delete(models) +} + +func (n *nachrichtDo) withDO(do gen.Dao) *nachrichtDo { + n.DO = *do.(*gen.DO) + return n +} diff --git a/cmd/mailingest/query/projekts.gen.go b/cmd/mailingest/query/projekts.gen.go new file mode 100644 index 0000000..5dfbd2b --- /dev/null +++ b/cmd/mailingest/query/projekts.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt { + _projekt := projekt{} + + _projekt.projektDo.UseDB(db, opts...) + _projekt.projektDo.UseModel(&model.Projekt{}) + + tableName := _projekt.projektDo.TableName() + _projekt.ALL = field.NewAsterisk(tableName) + _projekt.ID = field.NewUint(tableName, "id") + _projekt.CreatedAt = field.NewTime(tableName, "created_at") + _projekt.UpdatedAt = field.NewTime(tableName, "updated_at") + _projekt.DeletedAt = field.NewField(tableName, "deleted_at") + + _projekt.fillFieldMap() + + return _projekt +} + +type projekt struct { + projektDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (p projekt) Table(newTableName string) *projekt { + p.projektDo.UseTable(newTableName) + return p.updateTableName(newTableName) +} + +func (p projekt) As(alias string) *projekt { + p.projektDo.DO = *(p.projektDo.As(alias).(*gen.DO)) + return p.updateTableName(alias) +} + +func (p *projekt) updateTableName(table string) *projekt { + p.ALL = field.NewAsterisk(table) + p.ID = field.NewUint(table, "id") + p.CreatedAt = field.NewTime(table, "created_at") + p.UpdatedAt = field.NewTime(table, "updated_at") + p.DeletedAt = field.NewField(table, "deleted_at") + + p.fillFieldMap() + + return p +} + +func (p *projekt) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := p.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (p *projekt) fillFieldMap() { + p.fieldMap = make(map[string]field.Expr, 4) + p.fieldMap["id"] = p.ID + p.fieldMap["created_at"] = p.CreatedAt + p.fieldMap["updated_at"] = p.UpdatedAt + p.fieldMap["deleted_at"] = p.DeletedAt +} + +func (p projekt) clone(db *gorm.DB) projekt { + p.projektDo.ReplaceConnPool(db.Statement.ConnPool) + return p +} + +func (p projekt) replaceDB(db *gorm.DB) projekt { + p.projektDo.ReplaceDB(db) + return p +} + +type projektDo struct{ gen.DO } + +type IProjektDo interface { + gen.SubQuery + Debug() IProjektDo + WithContext(ctx context.Context) IProjektDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IProjektDo + WriteDB() IProjektDo + As(alias string) gen.Dao + Session(config *gorm.Session) IProjektDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IProjektDo + Not(conds ...gen.Condition) IProjektDo + Or(conds ...gen.Condition) IProjektDo + Select(conds ...field.Expr) IProjektDo + Where(conds ...gen.Condition) IProjektDo + Order(conds ...field.Expr) IProjektDo + Distinct(cols ...field.Expr) IProjektDo + Omit(cols ...field.Expr) IProjektDo + Join(table schema.Tabler, on ...field.Expr) IProjektDo + LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo + RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo + Group(cols ...field.Expr) IProjektDo + Having(conds ...gen.Condition) IProjektDo + Limit(limit int) IProjektDo + Offset(offset int) IProjektDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo + Unscoped() IProjektDo + Create(values ...*model.Projekt) error + CreateInBatches(values []*model.Projekt, batchSize int) error + Save(values ...*model.Projekt) error + First() (*model.Projekt, error) + Take() (*model.Projekt, error) + Last() (*model.Projekt, error) + Find() ([]*model.Projekt, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) + FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Projekt) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IProjektDo + Assign(attrs ...field.AssignExpr) IProjektDo + Joins(fields ...field.RelationField) IProjektDo + Preload(fields ...field.RelationField) IProjektDo + FirstOrInit() (*model.Projekt, error) + FirstOrCreate() (*model.Projekt, error) + FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IProjektDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (p projektDo) Debug() IProjektDo { + return p.withDO(p.DO.Debug()) +} + +func (p projektDo) WithContext(ctx context.Context) IProjektDo { + return p.withDO(p.DO.WithContext(ctx)) +} + +func (p projektDo) ReadDB() IProjektDo { + return p.Clauses(dbresolver.Read) +} + +func (p projektDo) WriteDB() IProjektDo { + return p.Clauses(dbresolver.Write) +} + +func (p projektDo) Session(config *gorm.Session) IProjektDo { + return p.withDO(p.DO.Session(config)) +} + +func (p projektDo) Clauses(conds ...clause.Expression) IProjektDo { + return p.withDO(p.DO.Clauses(conds...)) +} + +func (p projektDo) Returning(value interface{}, columns ...string) IProjektDo { + return p.withDO(p.DO.Returning(value, columns...)) +} + +func (p projektDo) Not(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Not(conds...)) +} + +func (p projektDo) Or(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Or(conds...)) +} + +func (p projektDo) Select(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Select(conds...)) +} + +func (p projektDo) Where(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Where(conds...)) +} + +func (p projektDo) Order(conds ...field.Expr) IProjektDo { + return p.withDO(p.DO.Order(conds...)) +} + +func (p projektDo) Distinct(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Distinct(cols...)) +} + +func (p projektDo) Omit(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Omit(cols...)) +} + +func (p projektDo) Join(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.Join(table, on...)) +} + +func (p projektDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.LeftJoin(table, on...)) +} + +func (p projektDo) RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo { + return p.withDO(p.DO.RightJoin(table, on...)) +} + +func (p projektDo) Group(cols ...field.Expr) IProjektDo { + return p.withDO(p.DO.Group(cols...)) +} + +func (p projektDo) Having(conds ...gen.Condition) IProjektDo { + return p.withDO(p.DO.Having(conds...)) +} + +func (p projektDo) Limit(limit int) IProjektDo { + return p.withDO(p.DO.Limit(limit)) +} + +func (p projektDo) Offset(offset int) IProjektDo { + return p.withDO(p.DO.Offset(offset)) +} + +func (p projektDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo { + return p.withDO(p.DO.Scopes(funcs...)) +} + +func (p projektDo) Unscoped() IProjektDo { + return p.withDO(p.DO.Unscoped()) +} + +func (p projektDo) Create(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Create(values) +} + +func (p projektDo) CreateInBatches(values []*model.Projekt, batchSize int) error { + return p.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (p projektDo) Save(values ...*model.Projekt) error { + if len(values) == 0 { + return nil + } + return p.DO.Save(values) +} + +func (p projektDo) First() (*model.Projekt, error) { + if result, err := p.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Take() (*model.Projekt, error) { + if result, err := p.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Last() (*model.Projekt, error) { + if result, err := p.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) Find() ([]*model.Projekt, error) { + result, err := p.DO.Find() + return result.([]*model.Projekt), err +} + +func (p projektDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) { + buf := make([]*model.Projekt, 0, batchSize) + err = p.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (p projektDo) FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return p.DO.FindInBatches(result, batchSize, fc) +} + +func (p projektDo) Attrs(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Attrs(attrs...)) +} + +func (p projektDo) Assign(attrs ...field.AssignExpr) IProjektDo { + return p.withDO(p.DO.Assign(attrs...)) +} + +func (p projektDo) Joins(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Joins(_f)) + } + return &p +} + +func (p projektDo) Preload(fields ...field.RelationField) IProjektDo { + for _, _f := range fields { + p = *p.withDO(p.DO.Preload(_f)) + } + return &p +} + +func (p projektDo) FirstOrInit() (*model.Projekt, error) { + if result, err := p.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FirstOrCreate() (*model.Projekt, error) { + if result, err := p.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Projekt), nil + } +} + +func (p projektDo) FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) { + result, err = p.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = p.Offset(-1).Limit(-1).Count() + return +} + +func (p projektDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = p.Count() + if err != nil { + return + } + + err = p.Offset(offset).Limit(limit).Scan(result) + return +} + +func (p projektDo) Scan(result interface{}) (err error) { + return p.DO.Scan(result) +} + +func (p projektDo) Delete(models ...*model.Projekt) (result gen.ResultInfo, err error) { + return p.DO.Delete(models) +} + +func (p *projektDo) withDO(do gen.Dao) *projektDo { + p.DO = *do.(*gen.DO) + return p +} diff --git a/cmd/mailingest/query/rechnungs.gen.go b/cmd/mailingest/query/rechnungs.gen.go new file mode 100644 index 0000000..c3e25ed --- /dev/null +++ b/cmd/mailingest/query/rechnungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnung(db *gorm.DB, opts ...gen.DOOption) rechnung { + _rechnung := rechnung{} + + _rechnung.rechnungDo.UseDB(db, opts...) + _rechnung.rechnungDo.UseModel(&model.Rechnung{}) + + tableName := _rechnung.rechnungDo.TableName() + _rechnung.ALL = field.NewAsterisk(tableName) + _rechnung.ID = field.NewUint(tableName, "id") + _rechnung.CreatedAt = field.NewTime(tableName, "created_at") + _rechnung.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnung.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnung.fillFieldMap() + + return _rechnung +} + +type rechnung struct { + rechnungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnung) Table(newTableName string) *rechnung { + r.rechnungDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnung) As(alias string) *rechnung { + r.rechnungDo.DO = *(r.rechnungDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnung) updateTableName(table string) *rechnung { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnung) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnung) clone(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnung) replaceDB(db *gorm.DB) rechnung { + r.rechnungDo.ReplaceDB(db) + return r +} + +type rechnungDo struct{ gen.DO } + +type IRechnungDo interface { + gen.SubQuery + Debug() IRechnungDo + WithContext(ctx context.Context) IRechnungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungDo + WriteDB() IRechnungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungDo + Not(conds ...gen.Condition) IRechnungDo + Or(conds ...gen.Condition) IRechnungDo + Select(conds ...field.Expr) IRechnungDo + Where(conds ...gen.Condition) IRechnungDo + Order(conds ...field.Expr) IRechnungDo + Distinct(cols ...field.Expr) IRechnungDo + Omit(cols ...field.Expr) IRechnungDo + Join(table schema.Tabler, on ...field.Expr) IRechnungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo + Group(cols ...field.Expr) IRechnungDo + Having(conds ...gen.Condition) IRechnungDo + Limit(limit int) IRechnungDo + Offset(offset int) IRechnungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo + Unscoped() IRechnungDo + Create(values ...*model.Rechnung) error + CreateInBatches(values []*model.Rechnung, batchSize int) error + Save(values ...*model.Rechnung) error + First() (*model.Rechnung, error) + Take() (*model.Rechnung, error) + Last() (*model.Rechnung, error) + Find() ([]*model.Rechnung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) + FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungDo + Assign(attrs ...field.AssignExpr) IRechnungDo + Joins(fields ...field.RelationField) IRechnungDo + Preload(fields ...field.RelationField) IRechnungDo + FirstOrInit() (*model.Rechnung, error) + FirstOrCreate() (*model.Rechnung, error) + FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungDo) Debug() IRechnungDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungDo) WithContext(ctx context.Context) IRechnungDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungDo) ReadDB() IRechnungDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungDo) WriteDB() IRechnungDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungDo) Session(config *gorm.Session) IRechnungDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungDo) Clauses(conds ...clause.Expression) IRechnungDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungDo) Returning(value interface{}, columns ...string) IRechnungDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungDo) Not(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungDo) Or(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungDo) Select(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungDo) Where(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungDo) Order(conds ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungDo) Distinct(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungDo) Omit(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungDo) Join(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungDo) Group(cols ...field.Expr) IRechnungDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungDo) Having(conds ...gen.Condition) IRechnungDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungDo) Limit(limit int) IRechnungDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungDo) Offset(offset int) IRechnungDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungDo) Unscoped() IRechnungDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungDo) Create(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungDo) CreateInBatches(values []*model.Rechnung, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungDo) Save(values ...*model.Rechnung) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungDo) First() (*model.Rechnung, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Take() (*model.Rechnung, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Last() (*model.Rechnung, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) Find() ([]*model.Rechnung, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnung), err +} + +func (r rechnungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) { + buf := make([]*model.Rechnung, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungDo) FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungDo) Attrs(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungDo) Assign(attrs ...field.AssignExpr) IRechnungDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungDo) Joins(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungDo) Preload(fields ...field.RelationField) IRechnungDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungDo) FirstOrInit() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FirstOrCreate() (*model.Rechnung, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnung), nil + } +} + +func (r rechnungDo) FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungDo) Delete(models ...*model.Rechnung) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungDo) withDO(do gen.Dao) *rechnungDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/cmd/mailingest/query/rechnungspositions.gen.go b/cmd/mailingest/query/rechnungspositions.gen.go new file mode 100644 index 0000000..de07dec --- /dev/null +++ b/cmd/mailingest/query/rechnungspositions.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newRechnungsposition(db *gorm.DB, opts ...gen.DOOption) rechnungsposition { + _rechnungsposition := rechnungsposition{} + + _rechnungsposition.rechnungspositionDo.UseDB(db, opts...) + _rechnungsposition.rechnungspositionDo.UseModel(&model.Rechnungsposition{}) + + tableName := _rechnungsposition.rechnungspositionDo.TableName() + _rechnungsposition.ALL = field.NewAsterisk(tableName) + _rechnungsposition.ID = field.NewUint(tableName, "id") + _rechnungsposition.CreatedAt = field.NewTime(tableName, "created_at") + _rechnungsposition.UpdatedAt = field.NewTime(tableName, "updated_at") + _rechnungsposition.DeletedAt = field.NewField(tableName, "deleted_at") + + _rechnungsposition.fillFieldMap() + + return _rechnungsposition +} + +type rechnungsposition struct { + rechnungspositionDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (r rechnungsposition) Table(newTableName string) *rechnungsposition { + r.rechnungspositionDo.UseTable(newTableName) + return r.updateTableName(newTableName) +} + +func (r rechnungsposition) As(alias string) *rechnungsposition { + r.rechnungspositionDo.DO = *(r.rechnungspositionDo.As(alias).(*gen.DO)) + return r.updateTableName(alias) +} + +func (r *rechnungsposition) updateTableName(table string) *rechnungsposition { + r.ALL = field.NewAsterisk(table) + r.ID = field.NewUint(table, "id") + r.CreatedAt = field.NewTime(table, "created_at") + r.UpdatedAt = field.NewTime(table, "updated_at") + r.DeletedAt = field.NewField(table, "deleted_at") + + r.fillFieldMap() + + return r +} + +func (r *rechnungsposition) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := r.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (r *rechnungsposition) fillFieldMap() { + r.fieldMap = make(map[string]field.Expr, 4) + r.fieldMap["id"] = r.ID + r.fieldMap["created_at"] = r.CreatedAt + r.fieldMap["updated_at"] = r.UpdatedAt + r.fieldMap["deleted_at"] = r.DeletedAt +} + +func (r rechnungsposition) clone(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceConnPool(db.Statement.ConnPool) + return r +} + +func (r rechnungsposition) replaceDB(db *gorm.DB) rechnungsposition { + r.rechnungspositionDo.ReplaceDB(db) + return r +} + +type rechnungspositionDo struct{ gen.DO } + +type IRechnungspositionDo interface { + gen.SubQuery + Debug() IRechnungspositionDo + WithContext(ctx context.Context) IRechnungspositionDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IRechnungspositionDo + WriteDB() IRechnungspositionDo + As(alias string) gen.Dao + Session(config *gorm.Session) IRechnungspositionDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IRechnungspositionDo + Not(conds ...gen.Condition) IRechnungspositionDo + Or(conds ...gen.Condition) IRechnungspositionDo + Select(conds ...field.Expr) IRechnungspositionDo + Where(conds ...gen.Condition) IRechnungspositionDo + Order(conds ...field.Expr) IRechnungspositionDo + Distinct(cols ...field.Expr) IRechnungspositionDo + Omit(cols ...field.Expr) IRechnungspositionDo + Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo + Group(cols ...field.Expr) IRechnungspositionDo + Having(conds ...gen.Condition) IRechnungspositionDo + Limit(limit int) IRechnungspositionDo + Offset(offset int) IRechnungspositionDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo + Unscoped() IRechnungspositionDo + Create(values ...*model.Rechnungsposition) error + CreateInBatches(values []*model.Rechnungsposition, batchSize int) error + Save(values ...*model.Rechnungsposition) error + First() (*model.Rechnungsposition, error) + Take() (*model.Rechnungsposition, error) + Last() (*model.Rechnungsposition, error) + Find() ([]*model.Rechnungsposition, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) + FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Rechnungsposition) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IRechnungspositionDo + Assign(attrs ...field.AssignExpr) IRechnungspositionDo + Joins(fields ...field.RelationField) IRechnungspositionDo + Preload(fields ...field.RelationField) IRechnungspositionDo + FirstOrInit() (*model.Rechnungsposition, error) + FirstOrCreate() (*model.Rechnungsposition, error) + FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IRechnungspositionDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (r rechnungspositionDo) Debug() IRechnungspositionDo { + return r.withDO(r.DO.Debug()) +} + +func (r rechnungspositionDo) WithContext(ctx context.Context) IRechnungspositionDo { + return r.withDO(r.DO.WithContext(ctx)) +} + +func (r rechnungspositionDo) ReadDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Read) +} + +func (r rechnungspositionDo) WriteDB() IRechnungspositionDo { + return r.Clauses(dbresolver.Write) +} + +func (r rechnungspositionDo) Session(config *gorm.Session) IRechnungspositionDo { + return r.withDO(r.DO.Session(config)) +} + +func (r rechnungspositionDo) Clauses(conds ...clause.Expression) IRechnungspositionDo { + return r.withDO(r.DO.Clauses(conds...)) +} + +func (r rechnungspositionDo) Returning(value interface{}, columns ...string) IRechnungspositionDo { + return r.withDO(r.DO.Returning(value, columns...)) +} + +func (r rechnungspositionDo) Not(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Not(conds...)) +} + +func (r rechnungspositionDo) Or(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Or(conds...)) +} + +func (r rechnungspositionDo) Select(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Select(conds...)) +} + +func (r rechnungspositionDo) Where(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Where(conds...)) +} + +func (r rechnungspositionDo) Order(conds ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Order(conds...)) +} + +func (r rechnungspositionDo) Distinct(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Distinct(cols...)) +} + +func (r rechnungspositionDo) Omit(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Omit(cols...)) +} + +func (r rechnungspositionDo) Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Join(table, on...)) +} + +func (r rechnungspositionDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.LeftJoin(table, on...)) +} + +func (r rechnungspositionDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.RightJoin(table, on...)) +} + +func (r rechnungspositionDo) Group(cols ...field.Expr) IRechnungspositionDo { + return r.withDO(r.DO.Group(cols...)) +} + +func (r rechnungspositionDo) Having(conds ...gen.Condition) IRechnungspositionDo { + return r.withDO(r.DO.Having(conds...)) +} + +func (r rechnungspositionDo) Limit(limit int) IRechnungspositionDo { + return r.withDO(r.DO.Limit(limit)) +} + +func (r rechnungspositionDo) Offset(offset int) IRechnungspositionDo { + return r.withDO(r.DO.Offset(offset)) +} + +func (r rechnungspositionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo { + return r.withDO(r.DO.Scopes(funcs...)) +} + +func (r rechnungspositionDo) Unscoped() IRechnungspositionDo { + return r.withDO(r.DO.Unscoped()) +} + +func (r rechnungspositionDo) Create(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Create(values) +} + +func (r rechnungspositionDo) CreateInBatches(values []*model.Rechnungsposition, batchSize int) error { + return r.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (r rechnungspositionDo) Save(values ...*model.Rechnungsposition) error { + if len(values) == 0 { + return nil + } + return r.DO.Save(values) +} + +func (r rechnungspositionDo) First() (*model.Rechnungsposition, error) { + if result, err := r.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Take() (*model.Rechnungsposition, error) { + if result, err := r.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Last() (*model.Rechnungsposition, error) { + if result, err := r.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) Find() ([]*model.Rechnungsposition, error) { + result, err := r.DO.Find() + return result.([]*model.Rechnungsposition), err +} + +func (r rechnungspositionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) { + buf := make([]*model.Rechnungsposition, 0, batchSize) + err = r.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (r rechnungspositionDo) FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return r.DO.FindInBatches(result, batchSize, fc) +} + +func (r rechnungspositionDo) Attrs(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Attrs(attrs...)) +} + +func (r rechnungspositionDo) Assign(attrs ...field.AssignExpr) IRechnungspositionDo { + return r.withDO(r.DO.Assign(attrs...)) +} + +func (r rechnungspositionDo) Joins(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Joins(_f)) + } + return &r +} + +func (r rechnungspositionDo) Preload(fields ...field.RelationField) IRechnungspositionDo { + for _, _f := range fields { + r = *r.withDO(r.DO.Preload(_f)) + } + return &r +} + +func (r rechnungspositionDo) FirstOrInit() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FirstOrCreate() (*model.Rechnungsposition, error) { + if result, err := r.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Rechnungsposition), nil + } +} + +func (r rechnungspositionDo) FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error) { + result, err = r.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = r.Offset(-1).Limit(-1).Count() + return +} + +func (r rechnungspositionDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = r.Count() + if err != nil { + return + } + + err = r.Offset(offset).Limit(limit).Scan(result) + return +} + +func (r rechnungspositionDo) Scan(result interface{}) (err error) { + return r.DO.Scan(result) +} + +func (r rechnungspositionDo) Delete(models ...*model.Rechnungsposition) (result gen.ResultInfo, err error) { + return r.DO.Delete(models) +} + +func (r *rechnungspositionDo) withDO(do gen.Dao) *rechnungspositionDo { + r.DO = *do.(*gen.DO) + return r +} diff --git a/cmd/mailingest/query/scanobjects.gen.go b/cmd/mailingest/query/scanobjects.gen.go new file mode 100644 index 0000000..661b4e9 --- /dev/null +++ b/cmd/mailingest/query/scanobjects.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newScanobject(db *gorm.DB, opts ...gen.DOOption) scanobject { + _scanobject := scanobject{} + + _scanobject.scanobjectDo.UseDB(db, opts...) + _scanobject.scanobjectDo.UseModel(&model.Scanobject{}) + + tableName := _scanobject.scanobjectDo.TableName() + _scanobject.ALL = field.NewAsterisk(tableName) + _scanobject.ID = field.NewUint(tableName, "id") + _scanobject.CreatedAt = field.NewTime(tableName, "created_at") + _scanobject.UpdatedAt = field.NewTime(tableName, "updated_at") + _scanobject.DeletedAt = field.NewField(tableName, "deleted_at") + + _scanobject.fillFieldMap() + + return _scanobject +} + +type scanobject struct { + scanobjectDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (s scanobject) Table(newTableName string) *scanobject { + s.scanobjectDo.UseTable(newTableName) + return s.updateTableName(newTableName) +} + +func (s scanobject) As(alias string) *scanobject { + s.scanobjectDo.DO = *(s.scanobjectDo.As(alias).(*gen.DO)) + return s.updateTableName(alias) +} + +func (s *scanobject) updateTableName(table string) *scanobject { + s.ALL = field.NewAsterisk(table) + s.ID = field.NewUint(table, "id") + s.CreatedAt = field.NewTime(table, "created_at") + s.UpdatedAt = field.NewTime(table, "updated_at") + s.DeletedAt = field.NewField(table, "deleted_at") + + s.fillFieldMap() + + return s +} + +func (s *scanobject) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := s.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (s *scanobject) fillFieldMap() { + s.fieldMap = make(map[string]field.Expr, 4) + s.fieldMap["id"] = s.ID + s.fieldMap["created_at"] = s.CreatedAt + s.fieldMap["updated_at"] = s.UpdatedAt + s.fieldMap["deleted_at"] = s.DeletedAt +} + +func (s scanobject) clone(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceConnPool(db.Statement.ConnPool) + return s +} + +func (s scanobject) replaceDB(db *gorm.DB) scanobject { + s.scanobjectDo.ReplaceDB(db) + return s +} + +type scanobjectDo struct{ gen.DO } + +type IScanobjectDo interface { + gen.SubQuery + Debug() IScanobjectDo + WithContext(ctx context.Context) IScanobjectDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IScanobjectDo + WriteDB() IScanobjectDo + As(alias string) gen.Dao + Session(config *gorm.Session) IScanobjectDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IScanobjectDo + Not(conds ...gen.Condition) IScanobjectDo + Or(conds ...gen.Condition) IScanobjectDo + Select(conds ...field.Expr) IScanobjectDo + Where(conds ...gen.Condition) IScanobjectDo + Order(conds ...field.Expr) IScanobjectDo + Distinct(cols ...field.Expr) IScanobjectDo + Omit(cols ...field.Expr) IScanobjectDo + Join(table schema.Tabler, on ...field.Expr) IScanobjectDo + LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo + Group(cols ...field.Expr) IScanobjectDo + Having(conds ...gen.Condition) IScanobjectDo + Limit(limit int) IScanobjectDo + Offset(offset int) IScanobjectDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo + Unscoped() IScanobjectDo + Create(values ...*model.Scanobject) error + CreateInBatches(values []*model.Scanobject, batchSize int) error + Save(values ...*model.Scanobject) error + First() (*model.Scanobject, error) + Take() (*model.Scanobject, error) + Last() (*model.Scanobject, error) + Find() ([]*model.Scanobject, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) + FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Scanobject) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IScanobjectDo + Assign(attrs ...field.AssignExpr) IScanobjectDo + Joins(fields ...field.RelationField) IScanobjectDo + Preload(fields ...field.RelationField) IScanobjectDo + FirstOrInit() (*model.Scanobject, error) + FirstOrCreate() (*model.Scanobject, error) + FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IScanobjectDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (s scanobjectDo) Debug() IScanobjectDo { + return s.withDO(s.DO.Debug()) +} + +func (s scanobjectDo) WithContext(ctx context.Context) IScanobjectDo { + return s.withDO(s.DO.WithContext(ctx)) +} + +func (s scanobjectDo) ReadDB() IScanobjectDo { + return s.Clauses(dbresolver.Read) +} + +func (s scanobjectDo) WriteDB() IScanobjectDo { + return s.Clauses(dbresolver.Write) +} + +func (s scanobjectDo) Session(config *gorm.Session) IScanobjectDo { + return s.withDO(s.DO.Session(config)) +} + +func (s scanobjectDo) Clauses(conds ...clause.Expression) IScanobjectDo { + return s.withDO(s.DO.Clauses(conds...)) +} + +func (s scanobjectDo) Returning(value interface{}, columns ...string) IScanobjectDo { + return s.withDO(s.DO.Returning(value, columns...)) +} + +func (s scanobjectDo) Not(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Not(conds...)) +} + +func (s scanobjectDo) Or(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Or(conds...)) +} + +func (s scanobjectDo) Select(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Select(conds...)) +} + +func (s scanobjectDo) Where(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Where(conds...)) +} + +func (s scanobjectDo) Order(conds ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Order(conds...)) +} + +func (s scanobjectDo) Distinct(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Distinct(cols...)) +} + +func (s scanobjectDo) Omit(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Omit(cols...)) +} + +func (s scanobjectDo) Join(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Join(table, on...)) +} + +func (s scanobjectDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.LeftJoin(table, on...)) +} + +func (s scanobjectDo) RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.RightJoin(table, on...)) +} + +func (s scanobjectDo) Group(cols ...field.Expr) IScanobjectDo { + return s.withDO(s.DO.Group(cols...)) +} + +func (s scanobjectDo) Having(conds ...gen.Condition) IScanobjectDo { + return s.withDO(s.DO.Having(conds...)) +} + +func (s scanobjectDo) Limit(limit int) IScanobjectDo { + return s.withDO(s.DO.Limit(limit)) +} + +func (s scanobjectDo) Offset(offset int) IScanobjectDo { + return s.withDO(s.DO.Offset(offset)) +} + +func (s scanobjectDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo { + return s.withDO(s.DO.Scopes(funcs...)) +} + +func (s scanobjectDo) Unscoped() IScanobjectDo { + return s.withDO(s.DO.Unscoped()) +} + +func (s scanobjectDo) Create(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Create(values) +} + +func (s scanobjectDo) CreateInBatches(values []*model.Scanobject, batchSize int) error { + return s.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (s scanobjectDo) Save(values ...*model.Scanobject) error { + if len(values) == 0 { + return nil + } + return s.DO.Save(values) +} + +func (s scanobjectDo) First() (*model.Scanobject, error) { + if result, err := s.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Take() (*model.Scanobject, error) { + if result, err := s.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Last() (*model.Scanobject, error) { + if result, err := s.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) Find() ([]*model.Scanobject, error) { + result, err := s.DO.Find() + return result.([]*model.Scanobject), err +} + +func (s scanobjectDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) { + buf := make([]*model.Scanobject, 0, batchSize) + err = s.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (s scanobjectDo) FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return s.DO.FindInBatches(result, batchSize, fc) +} + +func (s scanobjectDo) Attrs(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Attrs(attrs...)) +} + +func (s scanobjectDo) Assign(attrs ...field.AssignExpr) IScanobjectDo { + return s.withDO(s.DO.Assign(attrs...)) +} + +func (s scanobjectDo) Joins(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Joins(_f)) + } + return &s +} + +func (s scanobjectDo) Preload(fields ...field.RelationField) IScanobjectDo { + for _, _f := range fields { + s = *s.withDO(s.DO.Preload(_f)) + } + return &s +} + +func (s scanobjectDo) FirstOrInit() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FirstOrCreate() (*model.Scanobject, error) { + if result, err := s.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Scanobject), nil + } +} + +func (s scanobjectDo) FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) { + result, err = s.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = s.Offset(-1).Limit(-1).Count() + return +} + +func (s scanobjectDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = s.Count() + if err != nil { + return + } + + err = s.Offset(offset).Limit(limit).Scan(result) + return +} + +func (s scanobjectDo) Scan(result interface{}) (err error) { + return s.DO.Scan(result) +} + +func (s scanobjectDo) Delete(models ...*model.Scanobject) (result gen.ResultInfo, err error) { + return s.DO.Delete(models) +} + +func (s *scanobjectDo) withDO(do gen.Dao) *scanobjectDo { + s.DO = *do.(*gen.DO) + return s +} diff --git a/cmd/mailingest/query/users.gen.go b/cmd/mailingest/query/users.gen.go new file mode 100644 index 0000000..c0b3e51 --- /dev/null +++ b/cmd/mailingest/query/users.gen.go @@ -0,0 +1,403 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newUser(db *gorm.DB, opts ...gen.DOOption) user { + _user := user{} + + _user.userDo.UseDB(db, opts...) + _user.userDo.UseModel(&model.User{}) + + tableName := _user.userDo.TableName() + _user.ALL = field.NewAsterisk(tableName) + _user.ID = field.NewUint(tableName, "id") + _user.CreatedAt = field.NewTime(tableName, "created_at") + _user.UpdatedAt = field.NewTime(tableName, "updated_at") + _user.DeletedAt = field.NewField(tableName, "deleted_at") + _user.Sub = field.NewString(tableName, "sub") + _user.Email = field.NewString(tableName, "email") + + _user.fillFieldMap() + + return _user +} + +type user struct { + userDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Sub field.String + Email field.String + + fieldMap map[string]field.Expr +} + +func (u user) Table(newTableName string) *user { + u.userDo.UseTable(newTableName) + return u.updateTableName(newTableName) +} + +func (u user) As(alias string) *user { + u.userDo.DO = *(u.userDo.As(alias).(*gen.DO)) + return u.updateTableName(alias) +} + +func (u *user) updateTableName(table string) *user { + u.ALL = field.NewAsterisk(table) + u.ID = field.NewUint(table, "id") + u.CreatedAt = field.NewTime(table, "created_at") + u.UpdatedAt = field.NewTime(table, "updated_at") + u.DeletedAt = field.NewField(table, "deleted_at") + u.Sub = field.NewString(table, "sub") + u.Email = field.NewString(table, "email") + + u.fillFieldMap() + + return u +} + +func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := u.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (u *user) fillFieldMap() { + u.fieldMap = make(map[string]field.Expr, 6) + u.fieldMap["id"] = u.ID + u.fieldMap["created_at"] = u.CreatedAt + u.fieldMap["updated_at"] = u.UpdatedAt + u.fieldMap["deleted_at"] = u.DeletedAt + u.fieldMap["sub"] = u.Sub + u.fieldMap["email"] = u.Email +} + +func (u user) clone(db *gorm.DB) user { + u.userDo.ReplaceConnPool(db.Statement.ConnPool) + return u +} + +func (u user) replaceDB(db *gorm.DB) user { + u.userDo.ReplaceDB(db) + return u +} + +type userDo struct{ gen.DO } + +type IUserDo interface { + gen.SubQuery + Debug() IUserDo + WithContext(ctx context.Context) IUserDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IUserDo + WriteDB() IUserDo + As(alias string) gen.Dao + Session(config *gorm.Session) IUserDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IUserDo + Not(conds ...gen.Condition) IUserDo + Or(conds ...gen.Condition) IUserDo + Select(conds ...field.Expr) IUserDo + Where(conds ...gen.Condition) IUserDo + Order(conds ...field.Expr) IUserDo + Distinct(cols ...field.Expr) IUserDo + Omit(cols ...field.Expr) IUserDo + Join(table schema.Tabler, on ...field.Expr) IUserDo + LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo + RightJoin(table schema.Tabler, on ...field.Expr) IUserDo + Group(cols ...field.Expr) IUserDo + Having(conds ...gen.Condition) IUserDo + Limit(limit int) IUserDo + Offset(offset int) IUserDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo + Unscoped() IUserDo + Create(values ...*model.User) error + CreateInBatches(values []*model.User, batchSize int) error + Save(values ...*model.User) error + First() (*model.User, error) + Take() (*model.User, error) + Last() (*model.User, error) + Find() ([]*model.User, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) + FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.User) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IUserDo + Assign(attrs ...field.AssignExpr) IUserDo + Joins(fields ...field.RelationField) IUserDo + Preload(fields ...field.RelationField) IUserDo + FirstOrInit() (*model.User, error) + FirstOrCreate() (*model.User, error) + FindByPage(offset int, limit int) (result []*model.User, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IUserDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (u userDo) Debug() IUserDo { + return u.withDO(u.DO.Debug()) +} + +func (u userDo) WithContext(ctx context.Context) IUserDo { + return u.withDO(u.DO.WithContext(ctx)) +} + +func (u userDo) ReadDB() IUserDo { + return u.Clauses(dbresolver.Read) +} + +func (u userDo) WriteDB() IUserDo { + return u.Clauses(dbresolver.Write) +} + +func (u userDo) Session(config *gorm.Session) IUserDo { + return u.withDO(u.DO.Session(config)) +} + +func (u userDo) Clauses(conds ...clause.Expression) IUserDo { + return u.withDO(u.DO.Clauses(conds...)) +} + +func (u userDo) Returning(value interface{}, columns ...string) IUserDo { + return u.withDO(u.DO.Returning(value, columns...)) +} + +func (u userDo) Not(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Not(conds...)) +} + +func (u userDo) Or(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Or(conds...)) +} + +func (u userDo) Select(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Select(conds...)) +} + +func (u userDo) Where(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Where(conds...)) +} + +func (u userDo) Order(conds ...field.Expr) IUserDo { + return u.withDO(u.DO.Order(conds...)) +} + +func (u userDo) Distinct(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Distinct(cols...)) +} + +func (u userDo) Omit(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Omit(cols...)) +} + +func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.Join(table, on...)) +} + +func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.LeftJoin(table, on...)) +} + +func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo { + return u.withDO(u.DO.RightJoin(table, on...)) +} + +func (u userDo) Group(cols ...field.Expr) IUserDo { + return u.withDO(u.DO.Group(cols...)) +} + +func (u userDo) Having(conds ...gen.Condition) IUserDo { + return u.withDO(u.DO.Having(conds...)) +} + +func (u userDo) Limit(limit int) IUserDo { + return u.withDO(u.DO.Limit(limit)) +} + +func (u userDo) Offset(offset int) IUserDo { + return u.withDO(u.DO.Offset(offset)) +} + +func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo { + return u.withDO(u.DO.Scopes(funcs...)) +} + +func (u userDo) Unscoped() IUserDo { + return u.withDO(u.DO.Unscoped()) +} + +func (u userDo) Create(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Create(values) +} + +func (u userDo) CreateInBatches(values []*model.User, batchSize int) error { + return u.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (u userDo) Save(values ...*model.User) error { + if len(values) == 0 { + return nil + } + return u.DO.Save(values) +} + +func (u userDo) First() (*model.User, error) { + if result, err := u.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Take() (*model.User, error) { + if result, err := u.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Last() (*model.User, error) { + if result, err := u.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) Find() ([]*model.User, error) { + result, err := u.DO.Find() + return result.([]*model.User), err +} + +func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) { + buf := make([]*model.User, 0, batchSize) + err = u.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return u.DO.FindInBatches(result, batchSize, fc) +} + +func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Attrs(attrs...)) +} + +func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo { + return u.withDO(u.DO.Assign(attrs...)) +} + +func (u userDo) Joins(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Joins(_f)) + } + return &u +} + +func (u userDo) Preload(fields ...field.RelationField) IUserDo { + for _, _f := range fields { + u = *u.withDO(u.DO.Preload(_f)) + } + return &u +} + +func (u userDo) FirstOrInit() (*model.User, error) { + if result, err := u.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FirstOrCreate() (*model.User, error) { + if result, err := u.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.User), nil + } +} + +func (u userDo) FindByPage(offset int, limit int) (result []*model.User, count int64, err error) { + result, err = u.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = u.Offset(-1).Limit(-1).Count() + return +} + +func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = u.Count() + if err != nil { + return + } + + err = u.Offset(offset).Limit(limit).Scan(result) + return +} + +func (u userDo) Scan(result interface{}) (err error) { + return u.DO.Scan(result) +} + +func (u userDo) Delete(models ...*model.User) (result gen.ResultInfo, err error) { + return u.DO.Delete(models) +} + +func (u *userDo) withDO(do gen.Dao) *userDo { + u.DO = *do.(*gen.DO) + return u +} diff --git a/cmd/mailingest/query/zahlungs.gen.go b/cmd/mailingest/query/zahlungs.gen.go new file mode 100644 index 0000000..9526702 --- /dev/null +++ b/cmd/mailingest/query/zahlungs.gen.go @@ -0,0 +1,395 @@ +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. +// Code generated by gorm.io/gen. DO NOT EDIT. + +package query + +import ( + "context" + "database/sql" + + "gorm.io/gorm" + "gorm.io/gorm/clause" + "gorm.io/gorm/schema" + + "gorm.io/gen" + "gorm.io/gen/field" + + "gorm.io/plugin/dbresolver" + + "git.kocoder.xyz/kocoded/vt/model" +) + +func newZahlung(db *gorm.DB, opts ...gen.DOOption) zahlung { + _zahlung := zahlung{} + + _zahlung.zahlungDo.UseDB(db, opts...) + _zahlung.zahlungDo.UseModel(&model.Zahlung{}) + + tableName := _zahlung.zahlungDo.TableName() + _zahlung.ALL = field.NewAsterisk(tableName) + _zahlung.ID = field.NewUint(tableName, "id") + _zahlung.CreatedAt = field.NewTime(tableName, "created_at") + _zahlung.UpdatedAt = field.NewTime(tableName, "updated_at") + _zahlung.DeletedAt = field.NewField(tableName, "deleted_at") + + _zahlung.fillFieldMap() + + return _zahlung +} + +type zahlung struct { + zahlungDo + + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + + fieldMap map[string]field.Expr +} + +func (z zahlung) Table(newTableName string) *zahlung { + z.zahlungDo.UseTable(newTableName) + return z.updateTableName(newTableName) +} + +func (z zahlung) As(alias string) *zahlung { + z.zahlungDo.DO = *(z.zahlungDo.As(alias).(*gen.DO)) + return z.updateTableName(alias) +} + +func (z *zahlung) updateTableName(table string) *zahlung { + z.ALL = field.NewAsterisk(table) + z.ID = field.NewUint(table, "id") + z.CreatedAt = field.NewTime(table, "created_at") + z.UpdatedAt = field.NewTime(table, "updated_at") + z.DeletedAt = field.NewField(table, "deleted_at") + + z.fillFieldMap() + + return z +} + +func (z *zahlung) GetFieldByName(fieldName string) (field.OrderExpr, bool) { + _f, ok := z.fieldMap[fieldName] + if !ok || _f == nil { + return nil, false + } + _oe, ok := _f.(field.OrderExpr) + return _oe, ok +} + +func (z *zahlung) fillFieldMap() { + z.fieldMap = make(map[string]field.Expr, 4) + z.fieldMap["id"] = z.ID + z.fieldMap["created_at"] = z.CreatedAt + z.fieldMap["updated_at"] = z.UpdatedAt + z.fieldMap["deleted_at"] = z.DeletedAt +} + +func (z zahlung) clone(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceConnPool(db.Statement.ConnPool) + return z +} + +func (z zahlung) replaceDB(db *gorm.DB) zahlung { + z.zahlungDo.ReplaceDB(db) + return z +} + +type zahlungDo struct{ gen.DO } + +type IZahlungDo interface { + gen.SubQuery + Debug() IZahlungDo + WithContext(ctx context.Context) IZahlungDo + WithResult(fc func(tx gen.Dao)) gen.ResultInfo + ReplaceDB(db *gorm.DB) + ReadDB() IZahlungDo + WriteDB() IZahlungDo + As(alias string) gen.Dao + Session(config *gorm.Session) IZahlungDo + Columns(cols ...field.Expr) gen.Columns + Clauses(conds ...clause.Expression) IZahlungDo + Not(conds ...gen.Condition) IZahlungDo + Or(conds ...gen.Condition) IZahlungDo + Select(conds ...field.Expr) IZahlungDo + Where(conds ...gen.Condition) IZahlungDo + Order(conds ...field.Expr) IZahlungDo + Distinct(cols ...field.Expr) IZahlungDo + Omit(cols ...field.Expr) IZahlungDo + Join(table schema.Tabler, on ...field.Expr) IZahlungDo + LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo + Group(cols ...field.Expr) IZahlungDo + Having(conds ...gen.Condition) IZahlungDo + Limit(limit int) IZahlungDo + Offset(offset int) IZahlungDo + Count() (count int64, err error) + Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo + Unscoped() IZahlungDo + Create(values ...*model.Zahlung) error + CreateInBatches(values []*model.Zahlung, batchSize int) error + Save(values ...*model.Zahlung) error + First() (*model.Zahlung, error) + Take() (*model.Zahlung, error) + Last() (*model.Zahlung, error) + Find() ([]*model.Zahlung, error) + FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) + FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error + Pluck(column field.Expr, dest interface{}) error + Delete(...*model.Zahlung) (info gen.ResultInfo, err error) + Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + Updates(value interface{}) (info gen.ResultInfo, err error) + UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error) + UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error) + UpdateColumns(value interface{}) (info gen.ResultInfo, err error) + UpdateFrom(q gen.SubQuery) gen.Dao + Attrs(attrs ...field.AssignExpr) IZahlungDo + Assign(attrs ...field.AssignExpr) IZahlungDo + Joins(fields ...field.RelationField) IZahlungDo + Preload(fields ...field.RelationField) IZahlungDo + FirstOrInit() (*model.Zahlung, error) + FirstOrCreate() (*model.Zahlung, error) + FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) + ScanByPage(result interface{}, offset int, limit int) (count int64, err error) + Rows() (*sql.Rows, error) + Row() *sql.Row + Scan(result interface{}) (err error) + Returning(value interface{}, columns ...string) IZahlungDo + UnderlyingDB() *gorm.DB + schema.Tabler +} + +func (z zahlungDo) Debug() IZahlungDo { + return z.withDO(z.DO.Debug()) +} + +func (z zahlungDo) WithContext(ctx context.Context) IZahlungDo { + return z.withDO(z.DO.WithContext(ctx)) +} + +func (z zahlungDo) ReadDB() IZahlungDo { + return z.Clauses(dbresolver.Read) +} + +func (z zahlungDo) WriteDB() IZahlungDo { + return z.Clauses(dbresolver.Write) +} + +func (z zahlungDo) Session(config *gorm.Session) IZahlungDo { + return z.withDO(z.DO.Session(config)) +} + +func (z zahlungDo) Clauses(conds ...clause.Expression) IZahlungDo { + return z.withDO(z.DO.Clauses(conds...)) +} + +func (z zahlungDo) Returning(value interface{}, columns ...string) IZahlungDo { + return z.withDO(z.DO.Returning(value, columns...)) +} + +func (z zahlungDo) Not(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Not(conds...)) +} + +func (z zahlungDo) Or(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Or(conds...)) +} + +func (z zahlungDo) Select(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Select(conds...)) +} + +func (z zahlungDo) Where(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Where(conds...)) +} + +func (z zahlungDo) Order(conds ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Order(conds...)) +} + +func (z zahlungDo) Distinct(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Distinct(cols...)) +} + +func (z zahlungDo) Omit(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Omit(cols...)) +} + +func (z zahlungDo) Join(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Join(table, on...)) +} + +func (z zahlungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.LeftJoin(table, on...)) +} + +func (z zahlungDo) RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo { + return z.withDO(z.DO.RightJoin(table, on...)) +} + +func (z zahlungDo) Group(cols ...field.Expr) IZahlungDo { + return z.withDO(z.DO.Group(cols...)) +} + +func (z zahlungDo) Having(conds ...gen.Condition) IZahlungDo { + return z.withDO(z.DO.Having(conds...)) +} + +func (z zahlungDo) Limit(limit int) IZahlungDo { + return z.withDO(z.DO.Limit(limit)) +} + +func (z zahlungDo) Offset(offset int) IZahlungDo { + return z.withDO(z.DO.Offset(offset)) +} + +func (z zahlungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo { + return z.withDO(z.DO.Scopes(funcs...)) +} + +func (z zahlungDo) Unscoped() IZahlungDo { + return z.withDO(z.DO.Unscoped()) +} + +func (z zahlungDo) Create(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Create(values) +} + +func (z zahlungDo) CreateInBatches(values []*model.Zahlung, batchSize int) error { + return z.DO.CreateInBatches(values, batchSize) +} + +// Save : !!! underlying implementation is different with GORM +// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values) +func (z zahlungDo) Save(values ...*model.Zahlung) error { + if len(values) == 0 { + return nil + } + return z.DO.Save(values) +} + +func (z zahlungDo) First() (*model.Zahlung, error) { + if result, err := z.DO.First(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Take() (*model.Zahlung, error) { + if result, err := z.DO.Take(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Last() (*model.Zahlung, error) { + if result, err := z.DO.Last(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) Find() ([]*model.Zahlung, error) { + result, err := z.DO.Find() + return result.([]*model.Zahlung), err +} + +func (z zahlungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) { + buf := make([]*model.Zahlung, 0, batchSize) + err = z.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error { + defer func() { results = append(results, buf...) }() + return fc(tx, batch) + }) + return results, err +} + +func (z zahlungDo) FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error { + return z.DO.FindInBatches(result, batchSize, fc) +} + +func (z zahlungDo) Attrs(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Attrs(attrs...)) +} + +func (z zahlungDo) Assign(attrs ...field.AssignExpr) IZahlungDo { + return z.withDO(z.DO.Assign(attrs...)) +} + +func (z zahlungDo) Joins(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Joins(_f)) + } + return &z +} + +func (z zahlungDo) Preload(fields ...field.RelationField) IZahlungDo { + for _, _f := range fields { + z = *z.withDO(z.DO.Preload(_f)) + } + return &z +} + +func (z zahlungDo) FirstOrInit() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrInit(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FirstOrCreate() (*model.Zahlung, error) { + if result, err := z.DO.FirstOrCreate(); err != nil { + return nil, err + } else { + return result.(*model.Zahlung), nil + } +} + +func (z zahlungDo) FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) { + result, err = z.Offset(offset).Limit(limit).Find() + if err != nil { + return + } + + if size := len(result); 0 < limit && 0 < size && size < limit { + count = int64(size + offset) + return + } + + count, err = z.Offset(-1).Limit(-1).Count() + return +} + +func (z zahlungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) { + count, err = z.Count() + if err != nil { + return + } + + err = z.Offset(offset).Limit(limit).Scan(result) + return +} + +func (z zahlungDo) Scan(result interface{}) (err error) { + return z.DO.Scan(result) +} + +func (z zahlungDo) Delete(models ...*model.Zahlung) (result gen.ResultInfo, err error) { + return z.DO.Delete(models) +} + +func (z *zahlungDo) withDO(do gen.Dao) *zahlungDo { + z.DO = *do.(*gen.DO) + return z +} diff --git a/go.mod b/go.mod index 79fe1ef..7eaa09d 100644 --- a/go.mod +++ b/go.mod @@ -3,7 +3,10 @@ module git.kocoder.xyz/kocoded/vt go 1.24.4 require ( + github.com/emersion/go-imap/v2 v2.0.0-beta.6 + github.com/emersion/go-message v0.18.1 github.com/gofiber/fiber/v2 v2.52.9 + golang.org/x/oauth2 v0.28.0 gorm.io/driver/postgres v1.6.0 gorm.io/gen v0.3.27 gorm.io/gorm v1.30.1 @@ -11,17 +14,20 @@ require ( ) require ( + github.com/emersion/go-sasl v0.0.0-20231106173351-e73c9f7bad43 // indirect github.com/fasthttp/websocket v1.5.8 // indirect github.com/go-jose/go-jose/v4 v4.0.5 // indirect github.com/savsgio/gotils v0.0.0-20240303185622-093b76447511 // indirect + github.com/valkey-io/valkey-glide/go/v2 v2.1.1 // indirect golang.org/x/net v0.43.0 // indirect - golang.org/x/oauth2 v0.28.0 // indirect + google.golang.org/protobuf v1.33.0 // indirect ) require ( filippo.io/edwards25519 v1.1.0 // indirect github.com/andybalholm/brotli v1.2.0 // indirect github.com/coreos/go-oidc/v3 v3.15.0 + github.com/fatih/structs v1.1.0 github.com/go-sql-driver/mysql v1.9.3 // indirect github.com/gofiber/contrib/websocket v1.3.4 github.com/google/uuid v1.6.0 // indirect @@ -41,7 +47,6 @@ require ( github.com/tinylib/msgp v1.3.0 // indirect github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasthttp v1.64.0 // indirect - github.com/valyala/tcplisten v1.0.0 // indirect golang.org/x/crypto v0.41.0 // indirect golang.org/x/mod v0.27.0 // indirect golang.org/x/sync v0.16.0 // indirect diff --git a/go.sum b/go.sum index 3877d85..3046425 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,5 @@ filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA= filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4= -github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M= -github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY= github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ= github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY= github.com/coreos/go-oidc/v3 v3.15.0 h1:R6Oz8Z4bqWR7VFQ+sPSvZPQv4x8M+sJkDO5ojgwlyAg= @@ -9,8 +7,16 @@ github.com/coreos/go-oidc/v3 v3.15.0/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmr github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/emersion/go-imap/v2 v2.0.0-beta.6 h1:3w7QGUcDEoZXr+okRZR75VBjX0yvvJqkfy3gibbH2yY= +github.com/emersion/go-imap/v2 v2.0.0-beta.6/go.mod h1:BZTFHsS1hmgBkFlHqbxGLXk2hnRqTItUgwjSSCsYNAk= +github.com/emersion/go-message v0.18.1 h1:tfTxIoXFSFRwWaZsgnqS1DSZuGpYGzSmCZD8SK3QA2E= +github.com/emersion/go-message v0.18.1/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA= +github.com/emersion/go-sasl v0.0.0-20231106173351-e73c9f7bad43 h1:hH4PQfOndHDlpzYfLAAfl63E8Le6F2+EL/cdhlkyRJY= +github.com/emersion/go-sasl v0.0.0-20231106173351-e73c9f7bad43/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ= github.com/fasthttp/websocket v1.5.8 h1:k5DpirKkftIF/w1R8ZzjSgARJrs54Je9YJK37DL/Ah8= github.com/fasthttp/websocket v1.5.8/go.mod h1:d08g8WaT6nnyvg9uMm8K9zMYyDjfKyj3170AtPRuVU0= +github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo= +github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= github.com/go-jose/go-jose/v4 v4.0.5 h1:M6T8+mKZl/+fNNuFHvGIzDz7BTLQPIounk/b9dw3AaE= github.com/go-jose/go-jose/v4 v4.0.5/go.mod h1:s3P1lRrkT8igV8D9OjyL4WRyHvjB6a4JSllnOrmmBOA= github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo= @@ -41,15 +47,10 @@ github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= -github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= @@ -59,13 +60,10 @@ github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwp github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= github.com/microsoft/go-mssqldb v1.7.2 h1:CHkFJiObW7ItKTJfHo1QX7QBBD1iV+mn1eOyRP3b/PA= github.com/microsoft/go-mssqldb v1.7.2/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpthMITIb2Ko1IoA= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c h1:dAMKvw0MlJT1GshSTtih8C2gDs04w8dReiOGXrGLNoY= -github.com/philhofer/fwd v1.1.3-0.20240916144458-20a13a1f6b7c/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= @@ -74,38 +72,68 @@ github.com/savsgio/gotils v0.0.0-20240303185622-093b76447511/go.mod h1:sM7Mt7uEo github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/tinylib/msgp v1.2.5 h1:WeQg1whrXRFiZusidTQqzETkRpGjFjcIhW6uqWH09po= -github.com/tinylib/msgp v1.2.5/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww= github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= +github.com/valkey-io/valkey-glide/go/v2 v2.1.1 h1:78eoWXIYLbse0ZpspKRMwbREj0+Tkoc/qkSR8H9iRsc= +github.com/valkey-io/valkey-glide/go/v2 v2.1.1/go.mod h1:LK5zmODJa5xnxZndarh1trntExb3GVGJXz4GwDCagho= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.51.0 h1:8b30A5JlZ6C7AS81RsWjYMQmrZG6feChmgAolCl1SqA= -github.com/valyala/fasthttp v1.51.0/go.mod h1:oI2XroL+lI7vdXyYoQk03bXBThfFl2cVdIA3Xl7cH8g= github.com/valyala/fasthttp v1.64.0 h1:QBygLLQmiAyiXuRhthf0tuRkqAFcrC42dckN2S+N3og= github.com/valyala/fasthttp v1.64.0/go.mod h1:dGmFxwkWXSK0NbOSJuF7AMVzU+lkHz0wQVvVITv2UQA= -github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8= -github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc= +github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU= +github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.28.0 h1:CrgCKl8PPAVtLnU3c+EDw6x11699EWlsDeWNWKdIOkc= golang.org/x/oauth2 v0.28.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= diff --git a/model/projekt.go b/model/projekt.go index 4400f23..314883b 100644 --- a/model/projekt.go +++ b/model/projekt.go @@ -4,4 +4,9 @@ import "gorm.io/gorm" type Projekt struct { gorm.Model + Name string `json:"name"` + Description string `json:"description"` + Icon string `json:"icon"` + Mandant Mandant + MandantID uint } diff --git a/model/user.go b/model/user.go index e058490..8360c1b 100644 --- a/model/user.go +++ b/model/user.go @@ -4,6 +4,11 @@ import "gorm.io/gorm" type User struct { gorm.Model - Sub string `json:"sub" gorm:"unique"` - Email string + Sub string `json:"sub" gorm:"unique"` + Email string + Name string `json:"name"` + PreferedUsername string `json:"prefered_username"` + GivenName string `json:"given_name"` + FamilyName string `json:"family_name"` + AvatarURL string `json:"picture"` } diff --git a/query.code-workspace b/query.code-workspace new file mode 100644 index 0000000..bbf37c1 --- /dev/null +++ b/query.code-workspace @@ -0,0 +1,11 @@ +{ + "folders": [ + { + "path": "../query" + }, + { + "path": "." + } + ], + "settings": {} +} \ No newline at end of file diff --git a/query/projekts.gen.go b/query/projekts.gen.go index 5dfbd2b..bd4e4a1 100644 --- a/query/projekts.gen.go +++ b/query/projekts.gen.go @@ -32,6 +32,15 @@ func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt { _projekt.CreatedAt = field.NewTime(tableName, "created_at") _projekt.UpdatedAt = field.NewTime(tableName, "updated_at") _projekt.DeletedAt = field.NewField(tableName, "deleted_at") + _projekt.Name = field.NewString(tableName, "name") + _projekt.Description = field.NewString(tableName, "description") + _projekt.Icon = field.NewString(tableName, "icon") + _projekt.MandantID = field.NewUint(tableName, "mandant_id") + _projekt.Mandant = projektBelongsToMandant{ + db: db.Session(&gorm.Session{}), + + RelationField: field.NewRelation("Mandant", "model.Mandant"), + } _projekt.fillFieldMap() @@ -41,11 +50,16 @@ func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt { type projekt struct { projektDo - ALL field.Asterisk - ID field.Uint - CreatedAt field.Time - UpdatedAt field.Time - DeletedAt field.Field + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Name field.String + Description field.String + Icon field.String + MandantID field.Uint + Mandant projektBelongsToMandant fieldMap map[string]field.Expr } @@ -66,6 +80,10 @@ func (p *projekt) updateTableName(table string) *projekt { p.CreatedAt = field.NewTime(table, "created_at") p.UpdatedAt = field.NewTime(table, "updated_at") p.DeletedAt = field.NewField(table, "deleted_at") + p.Name = field.NewString(table, "name") + p.Description = field.NewString(table, "description") + p.Icon = field.NewString(table, "icon") + p.MandantID = field.NewUint(table, "mandant_id") p.fillFieldMap() @@ -82,23 +100,112 @@ func (p *projekt) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (p *projekt) fillFieldMap() { - p.fieldMap = make(map[string]field.Expr, 4) + p.fieldMap = make(map[string]field.Expr, 9) p.fieldMap["id"] = p.ID p.fieldMap["created_at"] = p.CreatedAt p.fieldMap["updated_at"] = p.UpdatedAt p.fieldMap["deleted_at"] = p.DeletedAt + p.fieldMap["name"] = p.Name + p.fieldMap["description"] = p.Description + p.fieldMap["icon"] = p.Icon + p.fieldMap["mandant_id"] = p.MandantID + } func (p projekt) clone(db *gorm.DB) projekt { p.projektDo.ReplaceConnPool(db.Statement.ConnPool) + p.Mandant.db = db.Session(&gorm.Session{Initialized: true}) + p.Mandant.db.Statement.ConnPool = db.Statement.ConnPool return p } func (p projekt) replaceDB(db *gorm.DB) projekt { p.projektDo.ReplaceDB(db) + p.Mandant.db = db.Session(&gorm.Session{}) return p } +type projektBelongsToMandant struct { + db *gorm.DB + + field.RelationField +} + +func (a projektBelongsToMandant) Where(conds ...field.Expr) *projektBelongsToMandant { + if len(conds) == 0 { + return &a + } + + exprs := make([]clause.Expression, 0, len(conds)) + for _, cond := range conds { + exprs = append(exprs, cond.BeCond().(clause.Expression)) + } + a.db = a.db.Clauses(clause.Where{Exprs: exprs}) + return &a +} + +func (a projektBelongsToMandant) WithContext(ctx context.Context) *projektBelongsToMandant { + a.db = a.db.WithContext(ctx) + return &a +} + +func (a projektBelongsToMandant) Session(session *gorm.Session) *projektBelongsToMandant { + a.db = a.db.Session(session) + return &a +} + +func (a projektBelongsToMandant) Model(m *model.Projekt) *projektBelongsToMandantTx { + return &projektBelongsToMandantTx{a.db.Model(m).Association(a.Name())} +} + +func (a projektBelongsToMandant) Unscoped() *projektBelongsToMandant { + a.db = a.db.Unscoped() + return &a +} + +type projektBelongsToMandantTx struct{ tx *gorm.Association } + +func (a projektBelongsToMandantTx) Find() (result *model.Mandant, err error) { + return result, a.tx.Find(&result) +} + +func (a projektBelongsToMandantTx) Append(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Append(targetValues...) +} + +func (a projektBelongsToMandantTx) Replace(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Replace(targetValues...) +} + +func (a projektBelongsToMandantTx) Delete(values ...*model.Mandant) (err error) { + targetValues := make([]interface{}, len(values)) + for i, v := range values { + targetValues[i] = v + } + return a.tx.Delete(targetValues...) +} + +func (a projektBelongsToMandantTx) Clear() error { + return a.tx.Clear() +} + +func (a projektBelongsToMandantTx) Count() int64 { + return a.tx.Count() +} + +func (a projektBelongsToMandantTx) Unscoped() *projektBelongsToMandantTx { + a.tx = a.tx.Unscoped() + return &a +} + type projektDo struct{ gen.DO } type IProjektDo interface { diff --git a/query/users.gen.go b/query/users.gen.go index c0b3e51..bfc210b 100644 --- a/query/users.gen.go +++ b/query/users.gen.go @@ -34,6 +34,11 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user { _user.DeletedAt = field.NewField(tableName, "deleted_at") _user.Sub = field.NewString(tableName, "sub") _user.Email = field.NewString(tableName, "email") + _user.Name = field.NewString(tableName, "name") + _user.PreferedUsername = field.NewString(tableName, "prefered_username") + _user.GivenName = field.NewString(tableName, "given_name") + _user.FamilyName = field.NewString(tableName, "family_name") + _user.AvatarURL = field.NewString(tableName, "avatar_url") _user.fillFieldMap() @@ -43,13 +48,18 @@ func newUser(db *gorm.DB, opts ...gen.DOOption) user { type user struct { userDo - ALL field.Asterisk - ID field.Uint - CreatedAt field.Time - UpdatedAt field.Time - DeletedAt field.Field - Sub field.String - Email field.String + ALL field.Asterisk + ID field.Uint + CreatedAt field.Time + UpdatedAt field.Time + DeletedAt field.Field + Sub field.String + Email field.String + Name field.String + PreferedUsername field.String + GivenName field.String + FamilyName field.String + AvatarURL field.String fieldMap map[string]field.Expr } @@ -72,6 +82,11 @@ func (u *user) updateTableName(table string) *user { u.DeletedAt = field.NewField(table, "deleted_at") u.Sub = field.NewString(table, "sub") u.Email = field.NewString(table, "email") + u.Name = field.NewString(table, "name") + u.PreferedUsername = field.NewString(table, "prefered_username") + u.GivenName = field.NewString(table, "given_name") + u.FamilyName = field.NewString(table, "family_name") + u.AvatarURL = field.NewString(table, "avatar_url") u.fillFieldMap() @@ -88,13 +103,18 @@ func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) { } func (u *user) fillFieldMap() { - u.fieldMap = make(map[string]field.Expr, 6) + u.fieldMap = make(map[string]field.Expr, 11) u.fieldMap["id"] = u.ID u.fieldMap["created_at"] = u.CreatedAt u.fieldMap["updated_at"] = u.UpdatedAt u.fieldMap["deleted_at"] = u.DeletedAt u.fieldMap["sub"] = u.Sub u.fieldMap["email"] = u.Email + u.fieldMap["name"] = u.Name + u.fieldMap["prefered_username"] = u.PreferedUsername + u.fieldMap["given_name"] = u.GivenName + u.fieldMap["family_name"] = u.FamilyName + u.fieldMap["avatar_url"] = u.AvatarURL } func (u user) clone(db *gorm.DB) user { diff --git a/routers/ansprechpartner.go b/routers/ansprechpartner.go index 0564f2a..96baa78 100644 --- a/routers/ansprechpartner.go +++ b/routers/ansprechpartner.go @@ -14,12 +14,13 @@ type ansprechpartnerRouter struct { func RegisterAnsprechpartnerRouter(group fiber.Router, appCtx utils.Application) { router := &ansprechpartnerRouter{Application: appCtx} - group.Post("/new", router.createAnsprechpartner) - group.Get("/all", router.getAllAnsprechpartners) - group.Get("/:id", router.getAnsprechpartner) - group.Get("/:id/firmen", router.getAnsprechpartnerFirmen) - group.Put("/:id", router.updateAnsprechpartner) - group.Delete("/:id", router.deleteAnsprechpartner) + r := group.Use(utils.IsAuthenticated(appCtx)) + r.Post("/new", router.createAnsprechpartner) + r.Get("/all", router.getAllAnsprechpartners) + r.Get("/:id", router.getAnsprechpartner) + r.Get("/:id/firmen", router.getAnsprechpartnerFirmen) + r.Put("/:id", router.updateAnsprechpartner) + r.Delete("/:id", router.deleteAnsprechpartner) } func (r *ansprechpartnerRouter) createAnsprechpartner(c *fiber.Ctx) error { diff --git a/routers/firma.go b/routers/firma.go index 2ff0356..11b85c6 100644 --- a/routers/firma.go +++ b/routers/firma.go @@ -14,11 +14,12 @@ type firmaRouter struct { func RegisterFirmaRouter(group fiber.Router, appCtx utils.Application) { router := &firmaRouter{Application: appCtx} - group.Post("/new", router.createFirma) - group.Get("/all", router.getAllFirmen) - group.Get("/:id", router.getFirma) - group.Put("/:id", router.updateFirma) - group.Delete("/:id", router.deleteFirma) + r := group.Use(utils.IsAuthenticated(appCtx)) + r.Post("/new", router.createFirma) + r.Get("/all", router.getAllFirmen) + r.Get("/:id", router.getFirma) + r.Put("/:id", router.updateFirma) + r.Delete("/:id", router.deleteFirma) } func (r *firmaRouter) createFirma(c *fiber.Ctx) error { diff --git a/routers/mandant.go b/routers/mandant.go index a399e83..8f1b100 100644 --- a/routers/mandant.go +++ b/routers/mandant.go @@ -15,9 +15,10 @@ type mandantRouter struct { func RegisterMandantRouter(group fiber.Router, appCtx utils.Application) { router := &mandantRouter{currentMandant: 1, Application: appCtx} - group.Get("/current", router.getCurrentMandant) - group.Put("/current", router.setCurrentMandant) - group.Get("/all", router.getAllMandant) + r := group.Use(utils.IsAuthenticated(appCtx)) + r.Get("/current", router.getCurrentMandant) + r.Put("/current", router.setCurrentMandant) + r.Get("/all", router.getAllMandant) } func (r *mandantRouter) getCurrentMandant(c *fiber.Ctx) error { diff --git a/routers/project.go b/routers/project.go new file mode 100644 index 0000000..9a58fd2 --- /dev/null +++ b/routers/project.go @@ -0,0 +1,171 @@ +package routers + +import ( + "strconv" + + "git.kocoder.xyz/kocoded/vt/model" + "git.kocoder.xyz/kocoded/vt/query" + "git.kocoder.xyz/kocoded/vt/utils" + "github.com/gofiber/fiber/v2" +) + +type projectRouter struct { + utils.Application + currentMandant uint +} + +func RegisterProjectRouter(group fiber.Router, appCtx utils.Application) { + router := &projectRouter{currentMandant: 1, Application: appCtx} + + r := group.Use(utils.IsAuthenticated(appCtx)) + r.Get("/all", router.getAllProjects) + r.Post("/new", router.createNewProject) + r.Get("/:id", router.getProject) + r.Post("/:id/edit", router.editProject) + r.Delete("/:id/delete", router.deleteProject) +} + +func (r *projectRouter) getAllProjects(c *fiber.Ctx) error { + p := query.Projekt + pph := c.Get("X-PER-PAGE") + ofh := c.Get("X-OFFSET") + + params := struct { + Id string `params:"id"` + Desc bool `params:"desc"` + }{} + + if err := c.QueryParser(¶ms); err != nil { + r.Logger.Warn("Param Parser Error: ", "err", err) + } + + var pp, of int + pp, err := strconv.Atoi(pph) + if err != nil { + r.Logger.Warn("Per Page header not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + of, err = strconv.Atoi(ofh) + if err != nil { + r.Logger.Warn("Offset header not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + query := p.Where().Limit(pp).Offset(of) + + if params.Id != "" { + f, ok := p.GetFieldByName(params.Id) + if ok { + if params.Desc { + query = query.Order(f.Desc()) + } else { + query = query.Order(f.Asc()) + } + } + } else { + query = query.Order(p.ID.Asc()) + } + + projects, err := query.Order(p.Name.Asc()).Find() + if err != nil { + r.Logger.Warn("Current mandant not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + cnt, err := p.Count() + if err != nil { + r.Logger.Warn("Current mandant not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + res := &PaginatedProjects{Data: projects, Meta: struct { + TotalProjectsCount int64 `json:"totalProjectsCount"` + }{TotalProjectsCount: cnt}} + + return c.JSON(res) +} + +type PaginatedProjects struct { + Data []*model.Projekt `json:"data"` + Meta struct { + TotalProjectsCount int64 `json:"totalProjectsCount"` + } `json:"meta"` +} + +func (r *projectRouter) getProject(c *fiber.Ctx) error { + ids := c.Params("id") + id, err := strconv.ParseUint(ids, 10, 32) + if err != nil { + r.Logger.Warn("Id is not an int.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + p := query.Projekt + + currentProject, err := p.Where(p.ID.Eq(uint(id))).First() + if err != nil { + r.Logger.Warn("Current mandant not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + return c.JSON(currentProject) +} + +func (r *projectRouter) createNewProject(c *fiber.Ctx) error { + p := query.Projekt + project := &model.Projekt{} + + if err := c.BodyParser(project); err != nil { + return err + } + + err := p.Create(project) + if err != nil { + r.Logger.Warn("Couldn't create Projejct.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "list"}}) + utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "get"}, Id: int(project.ID)}) + + return c.JSON(project) +} + +func (r *projectRouter) editProject(c *fiber.Ctx) error { + p := query.Projekt + project := &model.Projekt{} + + if err := c.BodyParser(project); err != nil { + return err + } + + res, err := p.Where(p.ID.Eq(project.ID)).Updates(project) + if err != nil { + r.Logger.Warn("Couldn't create Projejct.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "list"}}) + utils.MessageBus.SendMBObject(int(project.MandantID), utils.MessageBusObject{Entity: []string{"projects", "get"}, Id: int(project.ID)}) + + return c.JSON(res) +} + +func (r *projectRouter) deleteProject(c *fiber.Ctx) error { + ids := c.Params("id") + id, err := strconv.ParseUint(ids, 10, 32) + if err != nil { + r.Logger.Warn("Id is not an int.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + p := query.Projekt + + res, err := p.Where(p.ID.Eq(uint(id))).Delete() + if err != nil { + r.Logger.Warn("Couldn't create Projejct.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + return c.JSON(res) +} diff --git a/routers/user.go b/routers/user.go new file mode 100644 index 0000000..3b47310 --- /dev/null +++ b/routers/user.go @@ -0,0 +1,32 @@ +package routers + +import ( + "git.kocoder.xyz/kocoded/vt/query" + "git.kocoder.xyz/kocoded/vt/utils" + "github.com/gofiber/fiber/v2" +) + +type userRouter struct { + utils.Application +} + +func RegisterUserRouter(group fiber.Router, appCtx utils.Application) { + router := &userRouter{Application: appCtx} + + r := group.Use(utils.IsAuthenticated(appCtx)) + r.Get("/current", router.getCurrentUserInfo) +} + +func (r *userRouter) getCurrentUserInfo(c *fiber.Ctx) error { + u := query.User + + session := c.Locals("USER_KEY").(*utils.Session) + + currentUser, err := u.Where(u.ID.Eq(session.UserID)).First() + if err != nil { + r.Logger.Warn("Current mandant not found.", "error", err) + return c.SendStatus(fiber.StatusInternalServerError) + } + + return c.JSON(currentUser) +} diff --git a/utils/applicationCtx.go b/utils/applicationCtx.go index ad39487..3a2e4dc 100644 --- a/utils/applicationCtx.go +++ b/utils/applicationCtx.go @@ -1,20 +1,84 @@ package utils import ( + "context" + "errors" "log/slog" + "strconv" "time" + glide "github.com/valkey-io/valkey-glide/go/v2" "gorm.io/gorm" ) type Application struct { - Logger *slog.Logger - DB *gorm.DB - ActiveSessions []Session + Logger *slog.Logger + DB *gorm.DB + Client *glide.Client } type Session struct { Token string UserID uint - CreatedAt time.Time + MandantId uint +} + +func (s *Session) Deserialize(t string, m map[string]string) (*Session, error) { + userid, err := strconv.Atoi(m["userid"]) + if err != nil { + return nil, errors.New("Userid from cache not an int") + } + + mandantid, err := strconv.Atoi(m["mandantid"]) + if err != nil { + return nil, errors.New("Mandantid from cache not an int") + } + + s.Token = t + s.UserID = uint(userid) + s.MandantId = uint(mandantid) + + return s, nil +} + +func (s *Session) Serialize() map[string]string { + m := make(map[string]string) + m["userid"] = strconv.Itoa(int(s.UserID)) + m["mandantid"] = strconv.Itoa(int(s.MandantId)) + return m +} + +func (a *Application) AddSession(s *Session) { + // options.HSetExOptions{Expiry: options.NewExpiryIn(time.Hour * 2)} + _, err := a.Client.HSet(context.Background(), s.Token, s.Serialize()) + if err != nil { + panic(err) + } + + _, err = a.Client.Expire(context.Background(), s.Token, time.Hour*2) + if err != nil { + panic(err) + } +} + +func (a *Application) GetSessionFromToken(token string) (*Session, error) { + s, err := a.Client.HGetAll(context.Background(), token) + if err != nil { + panic(err) + } + + _, err = a.Client.Expire(context.Background(), token, time.Hour*2) + if err != nil { + panic(err) + } + + return (&Session{}).Deserialize(token, s) +} + +func (a *Application) RemoveSession(token string) { + _, err := a.Client.HDel(context.Background(), token, []string{"userid", "mandantid"}) + + if err != nil { + panic(err) + } } diff --git a/utils/authentication.go b/utils/authentication.go index a297302..2ed7e28 100644 --- a/utils/authentication.go +++ b/utils/authentication.go @@ -2,10 +2,9 @@ package utils import ( "context" - "encoding/json" + "fmt" "net/http" "os" - "slices" "time" "git.kocoder.xyz/kocoded/vt/model" @@ -31,6 +30,9 @@ func setCallbackCookieExp(w http.ResponseWriter, r *http.Request, name, value st http.SetCookie(w, c) } +type Info struct { +} + func CreateOIDCClient(ctx context.Context, app *fiber.App, appCtx Application) { provider, err := oidc.NewProvider(ctx, "https://keycloak.kocoder.xyz/realms/che") if err != nil { @@ -40,7 +42,7 @@ func CreateOIDCClient(ctx context.Context, app *fiber.App, appCtx Application) { oauthConfig := oauth2.Config{ ClientID: os.Getenv("CLIENT_ID"), ClientSecret: os.Getenv("CLIENT_SECRET"), - RedirectURL: "http://localhost:3000/api/auth/callback", + RedirectURL: os.Getenv("BACKEND_URI") + "/api/auth/callback", Endpoint: provider.Endpoint(), @@ -92,15 +94,15 @@ func CreateOIDCClient(ctx context.Context, app *fiber.App, appCtx Application) { UserInfo *oidc.UserInfo }{oauth2Token, userInfo} - data, err := json.MarshalIndent(resp, "", " ") + claims := &model.User{} + err = resp.UserInfo.Claims(claims) if err != nil { - appCtx.Logger.Warn("Failed to parse JSON", "error", err) - http.Error(w, err.Error(), http.StatusInternalServerError) - return + panic(err) } + fmt.Println(claims) user := &model.User{} - if appCtx.DB.Where(model.User{Email: resp.UserInfo.Email}).Assign(model.User{Sub: resp.UserInfo.Subject}).FirstOrCreate(user).Error != nil { + if appCtx.DB.Where(model.User{Email: resp.UserInfo.Email}).Assign(claims).FirstOrCreate(user).Error != nil { appCtx.Logger.Warn("Failed to create user in DB") http.Error(w, "failed to create user", http.StatusInternalServerError) return @@ -116,25 +118,56 @@ func CreateOIDCClient(ctx context.Context, app *fiber.App, appCtx Application) { } setCallbackCookieExp(w, r, "auth-cookie", cookie, int(time.Hour.Seconds())) - appCtx.ActiveSessions = append(appCtx.ActiveSessions, Session{Token: cookie, UserID: user.ID, CreatedAt: time.Now()}) + appCtx.AddSession(&Session{Token: cookie, UserID: user.ID, MandantId: 1}) - http.Redirect(w, r, "http://localhost:3001", http.StatusFound) - - _, err = w.Write(data) - if err != nil { - appCtx.Logger.Error("Unable to send response", "error", err) - } + http.Redirect(w, r, os.Getenv("FRONTEND_URI")+"/dashboard", http.StatusFound) })) app.Get("/api/auth/currentSession", func(c *fiber.Ctx) error { authToken := c.Cookies("auth-cookie") - sessionId := slices.IndexFunc(appCtx.ActiveSessions, func(s Session) bool { - return s.Token == authToken - }) - - session := appCtx.ActiveSessions[sessionId] + session, err := appCtx.GetSessionFromToken(authToken) + if err != nil { + return err + } return c.JSON(session) }) + + app.Get("/api/auth/logout", func(c *fiber.Ctx) error { + authToken := c.Cookies("auth-cookie") + + appCtx.RemoveSession(authToken) + + cookie := new(fiber.Cookie) + cookie.Name = "auth-cookie" + cookie.Expires = time.Now().Add(-1 * time.Minute) + + c.Cookie(cookie) + + return c.Redirect(os.Getenv("FRONTEND_URI")) + }) +} + +type keyType struct{} + +var UserKey keyType + +func IsAuthenticated(appCtx Application) fiber.Handler { + fmt.Println("Gettings Session") + + return func(c *fiber.Ctx) error { + authToken := c.Cookies("auth-cookie") + fmt.Println("Gettings Session", "sessiontoken", authToken) + session, err := appCtx.GetSessionFromToken(authToken) + if err != nil { + appCtx.Logger.Warn("Unauthorized GET Attempt", "reason", err) + return c.SendStatus(fiber.StatusUnauthorized) + } + + fmt.Println("Saving Session", "session", session) + c.Locals("USER_KEY", session) + + return c.Next() + } } diff --git a/utils/cache.go b/utils/cache.go new file mode 100644 index 0000000..c170db8 --- /dev/null +++ b/utils/cache.go @@ -0,0 +1,35 @@ +package utils + +import ( + "context" + "fmt" + "strconv" + + glide "github.com/valkey-io/valkey-glide/go/v2" + "github.com/valkey-io/valkey-glide/go/v2/config" +) + +func SetupCache(host, port, user, pass string) (*glide.Client, bool) { + p, err := strconv.Atoi(port) + if err != nil { + fmt.Println("VALKEY_PORT is not a number") + return nil, false + } + + config := config.NewClientConfiguration().WithAddress(&config.NodeAddress{Host: host, Port: p}).WithCredentials(config.NewServerCredentials(user, pass)) + + client, err := glide.NewClient(config) + if err != nil { + fmt.Println("There was an error: ", err) + return nil, false + } + + res, err := client.Ping(context.Background()) + if err != nil { + fmt.Println("There was an error: ", err) + return nil, false + } + fmt.Println(res) // PONG + + return client, true +} diff --git a/utils/db.go b/utils/db.go index 39c0520..5e9846f 100644 --- a/utils/db.go +++ b/utils/db.go @@ -24,13 +24,13 @@ func SetupDatabase(dsn string, logger *slog.Logger) *gorm.DB { if err != nil { logger.Error("Error setting up Join Tables", "error", err) } - err = db.AutoMigrate(&model.Mandant{}, &model.User{}, &model.Ansprechpartner{}, &model.FirmaAnsprechpartner{}, &model.Firma{}) + err = db.AutoMigrate(&model.Mandant{}, &model.User{}, &model.Ansprechpartner{}, &model.FirmaAnsprechpartner{}, &model.Firma{}, &model.Projekt{}) if err != nil { logger.Error("Error setting up Join Tables", "error", err) } g := gen.NewGenerator(gen.Config{ - OutPath: "./query", + OutPath: "query", Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode }) diff --git a/utils/messagebus.go b/utils/messagebus.go new file mode 100644 index 0000000..91b4ca4 --- /dev/null +++ b/utils/messagebus.go @@ -0,0 +1,68 @@ +package utils + +import ( + "encoding/json" + "io" + "log/slog" + + "github.com/gofiber/contrib/websocket" +) + +var MessageBus = &messagebus{mandanten: make(map[int][]*websocket.Conn)} + +type messagebus struct { + mandanten map[int][]*websocket.Conn +} + +func (mb *messagebus) AddConn(mid int, c *websocket.Conn) { + mb.mandanten[mid] = append(mb.mandanten[mid], c) + + ReadLoop(c) +} + +func ReadLoop(c *websocket.Conn) { + for { + var t int + var r io.Reader + var err error + + if t, r, err = c.NextReader(); err != nil { + c.Close() + break + } + + bytes, err := io.ReadAll(r) + + slog.Info("READLOOP: ", "Type", t, "value", bytes) + } +} + +func (mb *messagebus) SendMBObject(mid int, mbo MessageBusObject) { + bytes, err := json.Marshal(mbo) + if err != nil { + slog.Info("marshal", "error", err) + } + + i := 0 + for _, c := range mb.mandanten[mid] { + if err := c.WriteMessage(websocket.TextMessage, bytes); err != nil { + slog.Info("conn to remove", "conns", mb.mandanten) + mb.RemoveConn(mid, i) + slog.Info("write", "error", err, "index", i) + } else { + i++ + } + } +} + +func (mb *messagebus) RemoveConn(mid int, i int) { + s := mb.mandanten[mid] + s[i] = s[len(s)-1] + mb.mandanten[mid] = s[:len(s)-1] + slog.Info("conn removed", "conns", mb.mandanten) +} + +type MessageBusObject struct { + Entity []string `json:"entity"` + Id any `json:"id"` +} diff --git a/utils/middleware.go b/utils/middleware.go index 35e1042..1eb2910 100644 --- a/utils/middleware.go +++ b/utils/middleware.go @@ -1,6 +1,8 @@ package utils import ( + "os" + "github.com/gofiber/fiber/v2" "github.com/gofiber/fiber/v2/middleware/compress" "github.com/gofiber/fiber/v2/middleware/cors" @@ -19,7 +21,7 @@ func RegisterMiddlewares(app *fiber.App) { app.Use(compress.New()) app.Use(helmet.New()) app.Use(cors.New(cors.Config{ - AllowOrigins: "http://localhost:3000, http://localhost:3001", + AllowOrigins: os.Getenv("FRONTEND_URI"), AllowCredentials: true, })) // app.Use(csrf.New())