Bulk commit: November work

.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"
+    }
+  ]
+}

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<int>", 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"))

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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

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 <me@kocoder.xyz>\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
+		}
+	}
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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
+}

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

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=

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
 }

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"`
 }

query.code-workspace

@@ -0,0 +1,11 @@
+{
+	"folders": [
+		{
+			"path": "../query"
+		},
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

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 {

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 {

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<int>", router.getAnsprechpartner)
-	group.Get("/:id<int>/firmen", router.getAnsprechpartnerFirmen)
-	group.Put("/:id<int>", router.updateAnsprechpartner)
-	group.Delete("/:id<int>", router.deleteAnsprechpartner)
+	r := group.Use(utils.IsAuthenticated(appCtx))
+	r.Post("/new", router.createAnsprechpartner)
+	r.Get("/all", router.getAllAnsprechpartners)
+	r.Get("/:id<int>", router.getAnsprechpartner)
+	r.Get("/:id<int>/firmen", router.getAnsprechpartnerFirmen)
+	r.Put("/:id<int>", router.updateAnsprechpartner)
+	r.Delete("/:id<int>", router.deleteAnsprechpartner)
 }
 
 func (r *ansprechpartnerRouter) createAnsprechpartner(c *fiber.Ctx) error {

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<int>", router.getFirma)
-	group.Put("/:id<int>", router.updateFirma)
-	group.Delete("/:id<int>", router.deleteFirma)
+	r := group.Use(utils.IsAuthenticated(appCtx))
+	r.Post("/new", router.createFirma)
+	r.Get("/all", router.getAllFirmen)
+	r.Get("/:id<int>", router.getFirma)
+	r.Put("/:id<int>", router.updateFirma)
+	r.Delete("/:id<int>", router.deleteFirma)
 }
 
 func (r *firmaRouter) createFirma(c *fiber.Ctx) error {

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 {

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<int>", router.getProject)
+	r.Post("/:id<int>/edit", router.editProject)
+	r.Delete("/:id<int>/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(&params); 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)
+}

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)
+}

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)
+	}
 }

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()
+	}
 }

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
+}

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
 	})
 

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"`
+}

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())