## Credits
- Logo by [@lakotelman](https://github.com/lakotelman)
diff --git a/Taskfile.yml b/Taskfile.yml
index 816077a..4d9c1aa 100644
--- a/Taskfile.yml
+++ b/Taskfile.yml
@@ -1,7 +1,9 @@
version: "3"
env:
- HBOX_STORAGE_SQLITE_URL: .data/homebox.db?_fk=1
+ HBOX_LOG_LEVEL: debug
+ HBOX_STORAGE_SQLITE_URL: .data/homebox.db?_pragma=busy_timeout=1000&_pragma=journal_mode=WAL&_fk=1
+ HBOX_OPTIONS_ALLOW_REGISTRATION: true
UNSAFE_DISABLE_PASSWORD_PROJECTION: "yes_i_am_sure"
tasks:
setup:
@@ -11,61 +13,77 @@ tasks:
- cd backend && go mod tidy
- cd frontend && pnpm install --shamefully-hoist
- generate:
- desc: |
- Generates collateral files from the backend project
- including swagger docs and typescripts type for the frontend
- deps:
- - db:generate
+ swag:
+ desc: Generate swagger docs
+ dir: backend/app/api/static/
+ vars:
+ API: "../"
+ INTERNAL: "../../../internal"
+ PKGS: "../../../pkgs"
+ cmds:
+ - swag fmt --dir={{ .API }}
+ - swag init --dir={{ .API }},{{ .INTERNAL }}/core/services,{{ .INTERNAL }}/data/repo --parseDependency
+ sources:
+ - "./backend/app/api/**/*"
+ - "./backend/internal/data/**"
+ - "./backend/internal/core/services/**/*"
+ - "./backend/app/tools/typegen/main.go"
+
+ typescript-types:
+ desc: Generates typescript types from swagger definition
cmds:
- - cd backend/app/api/static && swag fmt --dir=../
- - cd backend/app/api/static && swag init --dir=../,../../../internal,../../../pkgs
- |
npx swagger-typescript-api \
--no-client \
--modular \
--path ./backend/app/api/static/docs/swagger.json \
--output ./frontend/lib/api/types
- - go run ./scripts/process-types/*.go ./frontend/lib/api/types/data-contracts.ts
+ - go run ./backend/app/tools/typegen/main.go ./frontend/lib/api/types/data-contracts.ts
sources:
- - "./backend/app/api/**/*"
- - "./backend/internal/data/**"
- - "./backend/internal/services/**/*"
- - "./scripts/process-types.py"
- generates:
- - "./frontend/lib/api/types/data-contracts.ts"
- - "./backend/internal/data/ent/schema"
- - "./backend/app/api/static/docs/swagger.json"
- - "./backend/app/api/static/docs/swagger.yaml"
+ - ./backend/app/tools/typegen/main.go
+ - ./backend/app/api/static/docs/swagger.json
+
+ generate:
+ deps:
+ - db:generate
+ cmds:
+ - task: swag
+ - task: typescript-types
+ - cp ./backend/app/api/static/docs/swagger.json docs/docs/api/openapi-2.0.json
go:run:
desc: Starts the backend api server (depends on generate task)
+ dir: backend
deps:
- generate
cmds:
- - cd backend && go run ./app/api/ {{ .CLI_ARGS }}
+ - go run ./app/api/ {{ .CLI_ARGS }}
silent: false
go:test:
desc: Runs all go tests using gotestsum - supports passing gotestsum args
+ dir: backend
cmds:
- - cd backend && gotestsum {{ .CLI_ARGS }} ./...
+ - gotestsum {{ .CLI_ARGS }} ./...
go:coverage:
desc: Runs all go tests with -race flag and generates a coverage report
+ dir: backend
cmds:
- - cd backend && go test -race -coverprofile=coverage.out -covermode=atomic ./app/... ./internal/... ./pkgs/... -v -cover
+ - go test -race -coverprofile=coverage.out -covermode=atomic ./app/... ./internal/... ./pkgs/... -v -cover
silent: true
go:tidy:
desc: Runs go mod tidy on the backend
+ dir: backend
cmds:
- - cd backend && go mod tidy
+ - go mod tidy
go:lint:
desc: Runs golangci-lint
+ dir: backend
cmds:
- - cd backend && golangci-lint run ./...
+ - golangci-lint run ./...
go:all:
desc: Runs all go test and lint related tasks
@@ -76,19 +94,18 @@ tasks:
go:build:
desc: Builds the backend binary
+ dir: backend
cmds:
- - cd backend && go build -o ../build/backend ./app/api
+ - go build -o ../build/backend ./app/api
db:generate:
desc: Run Entgo.io Code Generation
+ dir: backend/internal/
cmds:
- |
- cd backend/internal/ && go generate ./... \
- --template=./data/ent/schema/templates/has_id.tmpl
+ go generate ./...
sources:
- "./backend/internal/data/ent/schema/**/*"
- generates:
- - "./backend/internal/ent/"
db:migration:
desc: Runs the database diff engine to generate a SQL migration files
@@ -99,13 +116,27 @@ tasks:
ui:watch:
desc: Starts the vitest test runner in watch mode
+ dir: frontend
cmds:
- - cd frontend && pnpm run test:watch
+ - pnpm run test:watch
ui:dev:
desc: Run frontend development server
+ dir: frontend
cmds:
- - cd frontend && pnpm dev
+ - pnpm dev
+
+ ui:fix:
+ desc: Runs prettier and eslint on the frontend
+ dir: frontend
+ cmds:
+ - pnpm run lint:fix
+
+ ui:check:
+ desc: Runs type checking
+ dir: frontend
+ cmds:
+ - pnpm run typecheck
test:ci:
desc: Runs end-to-end test on a live server (only for use in CI)
@@ -115,3 +146,12 @@ tasks:
- sleep 5
- cd frontend && pnpm run test:ci
silent: true
+
+ pr:
+ desc: Runs all tasks required for a PR
+ cmds:
+ - task: generate
+ - task: go:all
+ - task: ui:check
+ - task: ui:fix
+ - task: test:ci
diff --git a/backend/.gitignore b/backend/.gitignore
new file mode 100644
index 0000000..cde0123
--- /dev/null
+++ b/backend/.gitignore
@@ -0,0 +1,2 @@
+
+dist/
diff --git a/backend/.golangci.yml b/backend/.golangci.yml
new file mode 100644
index 0000000..8f63110
--- /dev/null
+++ b/backend/.golangci.yml
@@ -0,0 +1,74 @@
+run:
+ timeout: 10m
+ skip-dirs:
+ - internal/data/ent.*
+linters-settings:
+ goconst:
+ min-len: 5
+ min-occurrences: 5
+ exhaustive:
+ default-signifies-exhaustive: true
+ revive:
+ ignore-generated-header: false
+ severity: warning
+ confidence: 3
+ depguard:
+ rules:
+ main:
+ deny:
+ - pkg: io/util
+ desc: |
+ Deprecated: As of Go 1.16, the same functionality is now provided by
+ package io or package os, and those implementations should be
+ preferred in new code. See the specific function documentation for
+ details.
+ gocritic:
+ enabled-checks:
+ - ruleguard
+ testifylint:
+ enable-all: true
+ tagalign:
+ order:
+ - json
+ - schema
+ - yaml
+ - yml
+ - toml
+ - validate
+linters:
+ disable-all: true
+ enable:
+ - asciicheck
+ - bodyclose
+ - depguard
+ - dogsled
+ - errcheck
+ - errorlint
+ - exhaustive
+ - exportloopref
+ - gochecknoinits
+ - goconst
+ - gocritic
+ - gocyclo
+ - gofmt
+ - goprintffuncname
+ - gosimple
+ - govet
+ - ineffassign
+ - misspell
+ - nakedret
+ - revive
+ - staticcheck
+ - stylecheck
+ - tagalign
+ - testifylint
+ - typecheck
+ - typecheck
+ - unconvert
+ - unused
+ - whitespace
+ - zerologlint
+ - sqlclosecheck
+issues:
+ exclude-use-default: false
+ fix: true
diff --git a/backend/.goreleaser.yaml b/backend/.goreleaser.yaml
new file mode 100644
index 0000000..37752ec
--- /dev/null
+++ b/backend/.goreleaser.yaml
@@ -0,0 +1,54 @@
+# This is an example .goreleaser.yml file with some sensible defaults.
+# Make sure to check the documentation at https://goreleaser.com
+before:
+ hooks:
+ # you may remove this if you don't need go generate
+ - go generate ./...
+builds:
+ - main: ./app/api
+ env:
+ - CGO_ENABLED=0
+ goos:
+ - linux
+ - windows
+ - darwin
+ goarch:
+ - amd64
+ - "386"
+ - arm
+ - arm64
+ ignore:
+ - goos: windows
+ goarch: arm
+ - goos: windows
+ goarch: "386"
+
+archives:
+ - format: tar.gz
+ # this name template makes the OS and Arch compatible with the results of uname.
+ name_template: >-
+ {{ .ProjectName }}_
+ {{- title .Os }}_
+ {{- if eq .Arch "amd64" }}x86_64
+ {{- else if eq .Arch "386" }}i386
+ {{- else }}{{ .Arch }}{{ end }}
+ {{- if .Arm }}v{{ .Arm }}{{ end }}
+ # use zip for windows archives
+ format_overrides:
+ - goos: windows
+ format: zip
+checksum:
+ name_template: 'checksums.txt'
+snapshot:
+ name_template: "{{ incpatch .Version }}-next"
+changelog:
+ sort: asc
+ filters:
+ exclude:
+ - '^docs:'
+ - '^test:'
+
+# The lines beneath this are called `modelines`. See `:help modeline`
+# Feel free to remove those if you don't want/use them.
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
diff --git a/backend/app/api/app.go b/backend/app/api/app.go
index 854c4e5..5d285d3 100644
--- a/backend/app/api/app.go
+++ b/backend/app/api/app.go
@@ -1,23 +1,21 @@
package main
import (
- "time"
-
"github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/core/services/reporting/eventbus"
"github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/config"
"github.com/hay-kot/homebox/backend/pkgs/mailer"
- "github.com/hay-kot/homebox/backend/pkgs/server"
)
type app struct {
conf *config.Config
mailer mailer.Mailer
db *ent.Client
- server *server.Server
repos *repo.AllRepos
services *services.AllServices
+ bus *eventbus.EventBus
}
func new(conf *config.Config) *app {
@@ -35,10 +33,3 @@ func new(conf *config.Config) *app {
return s
}
-
-func (a *app) startBgTask(t time.Duration, fn func()) {
- for {
- a.server.Background(fn)
- time.Sleep(t)
- }
-}
diff --git a/backend/app/api/bgrunner.go b/backend/app/api/bgrunner.go
new file mode 100644
index 0000000..ce4b7cc
--- /dev/null
+++ b/backend/app/api/bgrunner.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+ "context"
+ "time"
+)
+
+type BackgroundTask struct {
+ name string
+ Interval time.Duration
+ Fn func(context.Context)
+}
+
+func (tsk *BackgroundTask) Name() string {
+ return tsk.name
+}
+
+func NewTask(name string, interval time.Duration, fn func(context.Context)) *BackgroundTask {
+ return &BackgroundTask{
+ Interval: interval,
+ Fn: fn,
+ }
+}
+
+func (tsk *BackgroundTask) Start(ctx context.Context) error {
+ timer := time.NewTimer(tsk.Interval)
+
+ for {
+ select {
+ case <-ctx.Done():
+ return nil
+ case <-timer.C:
+ timer.Reset(tsk.Interval)
+ tsk.Fn(ctx)
+ }
+ }
+}
diff --git a/backend/app/api/demo.go b/backend/app/api/demo.go
index 538655d..183e0e0 100644
--- a/backend/app/api/demo.go
+++ b/backend/app/api/demo.go
@@ -2,57 +2,61 @@ package main
import (
"context"
- "encoding/csv"
"strings"
+ "time"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/rs/zerolog/log"
)
func (a *app) SetupDemo() {
- csvText := `Import Ref,Location,Labels,Quantity,Name,Description,Insured,Serial Number,Model Number,Manufacturer,Notes,Purchase From,Purchased Price,Purchased Time,Lifetime Warranty,Warranty Expires,Warranty Details,Sold To,Sold Price,Sold Time,Sold Notes
+ csvText := `HB.import_ref,HB.location,HB.labels,HB.quantity,HB.name,HB.description,HB.insured,HB.serial_number,HB.model_number,HB.manufacturer,HB.notes,HB.purchase_from,HB.purchase_price,HB.purchase_time,HB.lifetime_warranty,HB.warranty_expires,HB.warranty_details,HB.sold_to,HB.sold_price,HB.sold_time,HB.sold_notes
,Garage,IOT;Home Assistant; Z-Wave,1,Zooz Universal Relay ZEN17,"Zooz 700 Series Z-Wave Universal Relay ZEN17 for Awnings, Garage Doors, Sprinklers, and More | 2 NO-C-NC Relays (20A, 10A) | Signal Repeater | Hub Required (Compatible with SmartThings and Hubitat)",,,ZEN17,Zooz,,Amazon,39.95,10/13/2021,,,,,,,
,Living Room,IOT;Home Assistant; Z-Wave,1,Zooz Motion Sensor,"Zooz Z-Wave Plus S2 Motion Sensor ZSE18 with Magnetic Mount, Works with Vera and SmartThings",,,ZSE18,Zooz,,Amazon,29.95,10/15/2021,,,,,,,
,Office,IOT;Home Assistant; Z-Wave,1,Zooz 110v Power Switch,"Zooz Z-Wave Plus Power Switch ZEN15 for 110V AC Units, Sump Pumps, Humidifiers, and More",,,ZEN15,Zooz,,Amazon,39.95,10/13/2021,,,,,,,
,Downstairs,IOT;Home Assistant; Z-Wave,1,Ecolink Z-Wave PIR Motion Sensor,"Ecolink Z-Wave PIR Motion Detector Pet Immune, White (PIRZWAVE2.5-ECO)",,,PIRZWAVE2.5-ECO,Ecolink,,Amazon,35.58,10/21/2020,,,,,,,
,Entry,IOT;Home Assistant; Z-Wave,1,Yale Security Touchscreen Deadbolt,"Yale Security YRD226-ZW2-619 YRD226ZW2619 Touchscreen Deadbolt, Satin Nickel",,,YRD226ZW2619,Yale,,Amazon,120.39,10/14/2020,,,,,,,
-,Kitchen,IOT;Home Assistant; Z-Wave,1,Smart Rocker Light Dimmer,"UltraPro Z-Wave Smart Rocker Light Dimmer with QuickFit and SimpleWire, 3-Way Ready, Compatible with Alexa, Google Assistant, ZWave Hub Required, Repeater/Range Extender, White Paddle Only, 39351",,,39351,Honeywell,,Amazon,65.98,09/30/0202,,,,,,,
+,Kitchen,IOT;Home Assistant; Z-Wave,1,Smart Rocker Light Dimmer,"UltraPro Z-Wave Smart Rocker Light Dimmer with QuickFit and SimpleWire, 3-Way Ready, Compatible with Alexa, Google Assistant, ZWave Hub Required, Repeater/Range Extender, White Paddle Only, 39351",,,39351,Honeywell,,Amazon,65.98,09/30/0202,,,,,,,
`
- var (
- registration = services.UserRegistration{
- Email: "demo@example.com",
- Name: "Demo",
- Password: "demo",
- }
- )
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+
+ registration := services.UserRegistration{
+ Email: "demo@example.com",
+ Name: "Demo",
+ Password: "demo",
+ }
// First check if we've already setup a demo user and skip if so
- _, err := a.services.User.Login(context.Background(), registration.Email, registration.Password)
+ log.Debug().Msg("Checking if demo user already exists")
+ _, err := a.services.User.Login(ctx, registration.Email, registration.Password, false)
if err == nil {
+ log.Info().Msg("Demo user already exists, skipping setup")
return
}
- _, err = a.services.User.RegisterUser(context.Background(), registration)
+ log.Debug().Msg("Demo user does not exist, setting up demo")
+ _, err = a.services.User.RegisterUser(ctx, registration)
if err != nil {
log.Err(err).Msg("Failed to register demo user")
log.Fatal().Msg("Failed to setup demo")
}
- token, _ := a.services.User.Login(context.Background(), registration.Email, registration.Password)
- self, _ := a.services.User.GetSelf(context.Background(), token.Raw)
-
- // Read CSV Text
- reader := csv.NewReader(strings.NewReader(csvText))
- reader.Comma = ','
-
- records, err := reader.ReadAll()
+ token, err := a.services.User.Login(ctx, registration.Email, registration.Password, false)
if err != nil {
- log.Err(err).Msg("Failed to read CSV")
+ log.Err(err).Msg("Failed to login demo user")
log.Fatal().Msg("Failed to setup demo")
+ return
+ }
+ self, err := a.services.User.GetSelf(ctx, token.Raw)
+ if err != nil {
+ log.Err(err).Msg("Failed to get self")
+ log.Fatal().Msg("Failed to setup demo")
+ return
}
- _, err = a.services.Items.CsvImport(context.Background(), self.GroupID, records)
+ _, err = a.services.Items.CsvImport(ctx, self.GroupID, strings.NewReader(csvText))
if err != nil {
log.Err(err).Msg("Failed to import CSV")
log.Fatal().Msg("Failed to setup demo")
diff --git a/backend/app/api/handlers/debughandlers/debug.go b/backend/app/api/handlers/debughandlers/debug.go
index ffba624..5f66fed 100644
--- a/backend/app/api/handlers/debughandlers/debug.go
+++ b/backend/app/api/handlers/debughandlers/debug.go
@@ -1,3 +1,4 @@
+// Package debughandlers provides handlers for debugging.
package debughandlers
import (
diff --git a/backend/app/api/handlers/v1/controller.go b/backend/app/api/handlers/v1/controller.go
index 4f7a73e..eb60212 100644
--- a/backend/app/api/handlers/v1/controller.go
+++ b/backend/app/api/handlers/v1/controller.go
@@ -1,13 +1,38 @@
+// Package v1 provides the API handlers for version 1 of the API.
package v1
import (
+ "encoding/json"
"net/http"
+ "time"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/core/services/reporting/eventbus"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
+ "github.com/rs/zerolog/log"
+
+ "github.com/olahol/melody"
)
+type Results[T any] struct {
+ Items []T `json:"items"`
+}
+
+func WrapResults[T any](items []T) Results[T] {
+ return Results[T]{Items: items}
+}
+
+type Wrapped struct {
+ Item interface{} `json:"item"`
+}
+
+func Wrap(v any) Wrapped {
+ return Wrapped{Item: v}
+}
+
func WithMaxUploadSize(maxUploadSize int64) func(*V1Controller) {
return func(ctrl *V1Controller) {
ctrl.maxUploadSize = maxUploadSize
@@ -26,12 +51,20 @@ func WithRegistration(allowRegistration bool) func(*V1Controller) {
}
}
+func WithSecureCookies(secure bool) func(*V1Controller) {
+ return func(ctrl *V1Controller) {
+ ctrl.cookieSecure = secure
+ }
+}
+
type V1Controller struct {
+ cookieSecure bool
repo *repo.AllRepos
svc *services.AllServices
maxUploadSize int64
isDemo bool
allowRegistration bool
+ bus *eventbus.EventBus
}
type (
@@ -43,27 +76,29 @@ type (
BuildTime string `json:"buildTime"`
}
- ApiSummary struct {
- Healthy bool `json:"health"`
- Versions []string `json:"versions"`
- Title string `json:"title"`
- Message string `json:"message"`
- Build Build `json:"build"`
- Demo bool `json:"demo"`
+ APISummary struct {
+ Healthy bool `json:"health"`
+ Versions []string `json:"versions"`
+ Title string `json:"title"`
+ Message string `json:"message"`
+ Build Build `json:"build"`
+ Demo bool `json:"demo"`
+ AllowRegistration bool `json:"allowRegistration"`
}
)
-func BaseUrlFunc(prefix string) func(s string) string {
+func BaseURLFunc(prefix string) func(s string) string {
return func(s string) string {
return prefix + "/v1" + s
}
}
-func NewControllerV1(svc *services.AllServices, repos *repo.AllRepos, options ...func(*V1Controller)) *V1Controller {
+func NewControllerV1(svc *services.AllServices, repos *repo.AllRepos, bus *eventbus.EventBus, options ...func(*V1Controller)) *V1Controller {
ctrl := &V1Controller{
repo: repos,
svc: svc,
allowRegistration: true,
+ bus: bus,
}
for _, opt := range options {
@@ -74,19 +109,105 @@ func NewControllerV1(svc *services.AllServices, repos *repo.AllRepos, options ..
}
// HandleBase godoc
-// @Summary Retrieves the basic information about the API
-// @Tags Base
-// @Produce json
-// @Success 200 {object} ApiSummary
-// @Router /v1/status [GET]
-func (ctrl *V1Controller) HandleBase(ready ReadyFunc, build Build) server.HandlerFunc {
+//
+// @Summary Application Info
+// @Tags Base
+// @Produce json
+// @Success 200 {object} APISummary
+// @Router /v1/status [GET]
+func (ctrl *V1Controller) HandleBase(ready ReadyFunc, build Build) errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
- return server.Respond(w, http.StatusOK, ApiSummary{
- Healthy: ready(),
- Title: "Go API Template",
- Message: "Welcome to the Go API Template Application!",
- Build: build,
- Demo: ctrl.isDemo,
+ return server.JSON(w, http.StatusOK, APISummary{
+ Healthy: ready(),
+ Title: "Homebox",
+ Message: "Track, Manage, and Organize your Things",
+ Build: build,
+ Demo: ctrl.isDemo,
+ AllowRegistration: ctrl.allowRegistration,
})
}
}
+
+// HandleCurrency godoc
+//
+// @Summary Currency
+// @Tags Base
+// @Produce json
+// @Success 200 {object} currencies.Currency
+// @Router /v1/currency [GET]
+func (ctrl *V1Controller) HandleCurrency() errchain.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) error {
+ // Set Cache for 10 Minutes
+ w.Header().Set("Cache-Control", "max-age=600")
+
+ return server.JSON(w, http.StatusOK, ctrl.svc.Currencies.Slice())
+ }
+}
+
+func (ctrl *V1Controller) HandleCacheWS() errchain.HandlerFunc {
+ type eventMsg struct {
+ Event string `json:"event"`
+ }
+
+ m := melody.New()
+
+ m.HandleConnect(func(s *melody.Session) {
+ auth := services.NewContext(s.Request.Context())
+ s.Set("gid", auth.GID)
+ })
+
+ factory := func(e string) func(data any) {
+ return func(data any) {
+ eventData, ok := data.(eventbus.GroupMutationEvent)
+ if !ok {
+ log.Log().Msgf("invalid event data: %v", data)
+ return
+ }
+
+ msg := &eventMsg{Event: e}
+
+ jsonBytes, err := json.Marshal(msg)
+ if err != nil {
+ log.Log().Msgf("error marshling event data %v: %v", data, err)
+ return
+ }
+
+ _ = m.BroadcastFilter(jsonBytes, func(s *melody.Session) bool {
+ groupIDStr, ok := s.Get("gid")
+ if !ok {
+ return false
+ }
+
+ GID := groupIDStr.(uuid.UUID)
+ return GID == eventData.GID
+ })
+ }
+ }
+
+ ctrl.bus.Subscribe(eventbus.EventLabelMutation, factory("label.mutation"))
+ ctrl.bus.Subscribe(eventbus.EventLocationMutation, factory("location.mutation"))
+ ctrl.bus.Subscribe(eventbus.EventItemMutation, factory("item.mutation"))
+
+ // Persistent asynchronous ticker that keeps all websocket connections alive with periodic pings.
+ go func() {
+ const interval = 10 * time.Second
+
+ ping := time.NewTicker(interval)
+ defer ping.Stop()
+
+ for range ping.C {
+ msg := &eventMsg{Event: "ping"}
+
+ pingBytes, err := json.Marshal(msg)
+ if err != nil {
+ log.Log().Msgf("error marshaling ping: %v", err)
+ } else {
+ _ = m.Broadcast(pingBytes)
+ }
+ }
+ }()
+
+ return func(w http.ResponseWriter, r *http.Request) error {
+ return m.HandleRequest(w, r)
+ }
+}
diff --git a/backend/app/api/handlers/v1/partials.go b/backend/app/api/handlers/v1/partials.go
index 763805f..5c81ad5 100644
--- a/backend/app/api/handlers/v1/partials.go
+++ b/backend/app/api/handlers/v1/partials.go
@@ -21,7 +21,7 @@ func (ctrl *V1Controller) routeID(r *http.Request) (uuid.UUID, error) {
func (ctrl *V1Controller) routeUUID(r *http.Request, key string) (uuid.UUID, error) {
ID, err := uuid.Parse(chi.URLParam(r, key))
if err != nil {
- return uuid.Nil, validate.NewInvalidRouteKeyError(key)
+ return uuid.Nil, validate.NewRouteKeyError(key)
}
return ID, nil
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_actions.go b/backend/app/api/handlers/v1/v1_ctrl_actions.go
index 37e2b72..75f39a5 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_actions.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_actions.go
@@ -1,35 +1,83 @@
package v1
import (
+ "context"
"net/http"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
-type EnsureAssetIDResult struct {
+type ActionAmountResult struct {
Completed int `json:"completed"`
}
-// HandleGroupInvitationsCreate godoc
-// @Summary Get the current user
-// @Tags Group
-// @Produce json
-// @Success 200 {object} EnsureAssetIDResult
-// @Router /v1/actions/ensure-asset-ids [Post]
-// @Security Bearer
-func (ctrl *V1Controller) HandleEnsureAssetID() server.HandlerFunc {
+func actionHandlerFactory(ref string, fn func(context.Context, uuid.UUID) (int, error)) errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
ctx := services.NewContext(r.Context())
- totalCompleted, err := ctrl.svc.Items.EnsureAssetID(ctx, ctx.GID)
+ totalCompleted, err := fn(ctx, ctx.GID)
if err != nil {
- log.Err(err).Msg("failed to ensure asset id")
+ log.Err(err).Str("action_ref", ref).Msg("failed to run action")
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, EnsureAssetIDResult{Completed: totalCompleted})
+ return server.JSON(w, http.StatusOK, ActionAmountResult{Completed: totalCompleted})
}
}
+
+// HandleEnsureAssetID godoc
+//
+// @Summary Ensure Asset IDs
+// @Description Ensures all items in the database have an asset ID
+// @Tags Actions
+// @Produce json
+// @Success 200 {object} ActionAmountResult
+// @Router /v1/actions/ensure-asset-ids [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleEnsureAssetID() errchain.HandlerFunc {
+ return actionHandlerFactory("ensure asset IDs", ctrl.svc.Items.EnsureAssetID)
+}
+
+// HandleEnsureImportRefs godoc
+//
+// @Summary Ensures Import Refs
+// @Description Ensures all items in the database have an import ref
+// @Tags Actions
+// @Produce json
+// @Success 200 {object} ActionAmountResult
+// @Router /v1/actions/ensure-import-refs [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleEnsureImportRefs() errchain.HandlerFunc {
+ return actionHandlerFactory("ensure import refs", ctrl.svc.Items.EnsureImportRef)
+}
+
+// HandleItemDateZeroOut godoc
+//
+// @Summary Zero Out Time Fields
+// @Description Resets all item date fields to the beginning of the day
+// @Tags Actions
+// @Produce json
+// @Success 200 {object} ActionAmountResult
+// @Router /v1/actions/zero-item-time-fields [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemDateZeroOut() errchain.HandlerFunc {
+ return actionHandlerFactory("zero out date time", ctrl.repo.Items.ZeroOutTimeFields)
+}
+
+// HandleSetPrimaryPhotos godoc
+//
+// @Summary Set Primary Photos
+// @Description Sets the first photo of each item as the primary photo
+// @Tags Actions
+// @Produce json
+// @Success 200 {object} ActionAmountResult
+// @Router /v1/actions/set-primary-photos [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleSetPrimaryPhotos() errchain.HandlerFunc {
+ return actionHandlerFactory("ensure asset IDs", ctrl.repo.Items.SetPrimaryPhotos)
+}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_assets.go b/backend/app/api/handlers/v1/v1_ctrl_assets.go
index 82653fe..91e9a3c 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_assets.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_assets.go
@@ -9,26 +9,28 @@ import (
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
-// HandleItemGet godocs
-// @Summary Gets an item by Asset ID
-// @Tags Assets
-// @Produce json
-// @Param id path string true "Asset ID"
-// @Success 200 {object} repo.PaginationResult[repo.ItemSummary]{}
-// @Router /v1/assets/{id} [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleAssetGet() server.HandlerFunc {
+// HandleAssetGet godocs
+//
+// @Summary Get Item by Asset ID
+// @Tags Items
+// @Produce json
+// @Param id path string true "Asset ID"
+// @Success 200 {object} repo.PaginationResult[repo.ItemSummary]{}
+// @Router /v1/assets/{id} [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleAssetGet() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
ctx := services.NewContext(r.Context())
- assetIdParam := chi.URLParam(r, "id")
- assetIdParam = strings.ReplaceAll(assetIdParam, "-", "") // Remove dashes
+ assetIDParam := chi.URLParam(r, "id")
+ assetIDParam = strings.ReplaceAll(assetIDParam, "-", "") // Remove dashes
// Convert the asset ID to an int64
- assetId, err := strconv.ParseInt(assetIdParam, 10, 64)
+ assetID, err := strconv.ParseInt(assetIDParam, 10, 64)
if err != nil {
return err
}
@@ -37,7 +39,7 @@ func (ctrl *V1Controller) HandleAssetGet() server.HandlerFunc {
if pageParam != "" {
page, err = strconv.ParseInt(pageParam, 10, 64)
if err != nil {
- return server.Respond(w, http.StatusBadRequest, "Invalid page number")
+ return server.JSON(w, http.StatusBadRequest, "Invalid page number")
}
}
@@ -46,16 +48,15 @@ func (ctrl *V1Controller) HandleAssetGet() server.HandlerFunc {
if pageSizeParam != "" {
pageSize, err = strconv.ParseInt(pageSizeParam, 10, 64)
if err != nil {
- return server.Respond(w, http.StatusBadRequest, "Invalid page size")
+ return server.JSON(w, http.StatusBadRequest, "Invalid page size")
}
}
-
- items, err := ctrl.repo.Items.QueryByAssetID(r.Context(), ctx.GID, repo.AssetID(assetId), int(page), int(pageSize))
+ items, err := ctrl.repo.Items.QueryByAssetID(r.Context(), ctx.GID, repo.AssetID(assetID), int(page), int(pageSize))
if err != nil {
log.Err(err).Msg("failed to get item")
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, items)
+ return server.JSON(w, http.StatusOK, items)
}
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_auth.go b/backend/app/api/handlers/v1/v1_ctrl_auth.go
index 24b1654..47b69fd 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_auth.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_auth.go
@@ -3,14 +3,23 @@ package v1
import (
"errors"
"net/http"
+ "strconv"
+ "strings"
"time"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
+const (
+ cookieNameToken = "hb.auth.token"
+ cookieNameRemember = "hb.auth.remember"
+ cookieNameSession = "hb.auth.session"
+)
+
type (
TokenResponse struct {
Token string `json:"token"`
@@ -19,64 +28,100 @@ type (
}
LoginForm struct {
- Username string `json:"username"`
- Password string `json:"password"`
+ Username string `json:"username"`
+ Password string `json:"password"`
+ StayLoggedIn bool `json:"stayLoggedIn"`
}
)
+type CookieContents struct {
+ Token string
+ ExpiresAt time.Time
+ Remember bool
+}
+
+func GetCookies(r *http.Request) (*CookieContents, error) {
+ cookie, err := r.Cookie(cookieNameToken)
+ if err != nil {
+ return nil, errors.New("authorization cookie is required")
+ }
+
+ rememberCookie, err := r.Cookie(cookieNameRemember)
+ if err != nil {
+ return nil, errors.New("remember cookie is required")
+ }
+
+ return &CookieContents{
+ Token: cookie.Value,
+ ExpiresAt: cookie.Expires,
+ Remember: rememberCookie.Value == "true",
+ }, nil
+}
+
+// AuthProvider is an interface that can be implemented by any authentication provider.
+// to extend authentication methods for the API.
+type AuthProvider interface {
+ // Name returns the name of the authentication provider. This should be a unique name.
+ // that is URL friendly.
+ //
+ // Example: "local", "ldap"
+ Name() string
+ // Authenticate is called when a user attempts to login to the API. The implementation
+ // should return an error if the user cannot be authenticated. If an error is returned
+ // the API controller will return a vague error message to the user.
+ //
+ // Authenticate should do the following:
+ //
+ // 1. Ensure that the user exists within the database (either create, or get)
+ // 2. On successful authentication, they must set the user cookies.
+ Authenticate(w http.ResponseWriter, r *http.Request) (services.UserAuthTokenDetail, error)
+}
+
// HandleAuthLogin godoc
-// @Summary User Login
-// @Tags Authentication
-// @Accept x-www-form-urlencoded
-// @Accept application/json
-// @Param username formData string false "string" example(admin@admin.com)
-// @Param password formData string false "string" example(admin)
-// @Produce json
-// @Success 200 {object} TokenResponse
-// @Router /v1/users/login [POST]
-func (ctrl *V1Controller) HandleAuthLogin() server.HandlerFunc {
+//
+// @Summary User Login
+// @Tags Authentication
+// @Accept x-www-form-urlencoded
+// @Accept application/json
+// @Param username formData string false "string" example(admin@admin.com)
+// @Param password formData string false "string" example(admin)
+// @Param payload body LoginForm true "Login Data"
+// @Param provider query string false "auth provider"
+// @Produce json
+// @Success 200 {object} TokenResponse
+// @Router /v1/users/login [POST]
+func (ctrl *V1Controller) HandleAuthLogin(ps ...AuthProvider) errchain.HandlerFunc {
+ if len(ps) == 0 {
+ panic("no auth providers provided")
+ }
+
+ providers := make(map[string]AuthProvider)
+ for _, p := range ps {
+ log.Info().Str("name", p.Name()).Msg("registering auth provider")
+ providers[p.Name()] = p
+ }
+
return func(w http.ResponseWriter, r *http.Request) error {
- loginForm := &LoginForm{}
-
- switch r.Header.Get("Content-Type") {
- case server.ContentFormUrlEncoded:
- err := r.ParseForm()
- if err != nil {
- return server.Respond(w, http.StatusBadRequest, server.Wrap(err))
- }
-
- loginForm.Username = r.PostFormValue("username")
- loginForm.Password = r.PostFormValue("password")
- case server.ContentJSON:
- err := server.Decode(r, loginForm)
-
- if err != nil {
- log.Err(err).Msg("failed to decode login form")
- }
- default:
- return server.Respond(w, http.StatusBadRequest, errors.New("invalid content type"))
+ // Extract provider query
+ provider := r.URL.Query().Get("provider")
+ if provider == "" {
+ provider = "local"
}
- if loginForm.Username == "" || loginForm.Password == "" {
- return validate.NewFieldErrors(
- validate.FieldError{
- Field: "username",
- Error: "username or password is empty",
- },
- validate.FieldError{
- Field: "password",
- Error: "username or password is empty",
- },
- )
+ // Get the provider
+ p, ok := providers[provider]
+ if !ok {
+ return validate.NewRequestError(errors.New("invalid auth provider"), http.StatusBadRequest)
}
- newToken, err := ctrl.svc.User.Login(r.Context(), loginForm.Username, loginForm.Password)
-
+ newToken, err := p.Authenticate(w, r)
if err != nil {
- return validate.NewRequestError(errors.New("authentication failed"), http.StatusInternalServerError)
+ log.Err(err).Msg("failed to authenticate")
+ return server.JSON(w, http.StatusInternalServerError, err.Error())
}
- return server.Respond(w, http.StatusOK, TokenResponse{
+ ctrl.setCookies(w, noPort(r.Host), newToken.Raw, newToken.ExpiresAt, true)
+ return server.JSON(w, http.StatusOK, TokenResponse{
Token: "Bearer " + newToken.Raw,
ExpiresAt: newToken.ExpiresAt,
AttachmentToken: newToken.AttachmentToken,
@@ -85,12 +130,13 @@ func (ctrl *V1Controller) HandleAuthLogin() server.HandlerFunc {
}
// HandleAuthLogout godoc
-// @Summary User Logout
-// @Tags Authentication
-// @Success 204
-// @Router /v1/users/logout [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleAuthLogout() server.HandlerFunc {
+//
+// @Summary User Logout
+// @Tags Authentication
+// @Success 204
+// @Router /v1/users/logout [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleAuthLogout() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
token := services.UseTokenCtx(r.Context())
if token == "" {
@@ -102,19 +148,21 @@ func (ctrl *V1Controller) HandleAuthLogout() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ ctrl.unsetCookies(w, noPort(r.Host))
+ return server.JSON(w, http.StatusNoContent, nil)
}
}
-// HandleAuthLogout godoc
-// @Summary User Token Refresh
-// @Description handleAuthRefresh returns a handler that will issue a new token from an existing token.
-// @Description This does not validate that the user still exists within the database.
-// @Tags Authentication
-// @Success 200
-// @Router /v1/users/refresh [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleAuthRefresh() server.HandlerFunc {
+// HandleAuthRefresh godoc
+//
+// @Summary User Token Refresh
+// @Description handleAuthRefresh returns a handler that will issue a new token from an existing token.
+// @Description This does not validate that the user still exists within the database.
+// @Tags Authentication
+// @Success 200
+// @Router /v1/users/refresh [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleAuthRefresh() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
requestToken := services.UseTokenCtx(r.Context())
if requestToken == "" {
@@ -126,6 +174,78 @@ func (ctrl *V1Controller) HandleAuthRefresh() server.HandlerFunc {
return validate.NewUnauthorizedError()
}
- return server.Respond(w, http.StatusOK, newToken)
+ ctrl.setCookies(w, noPort(r.Host), newToken.Raw, newToken.ExpiresAt, false)
+ return server.JSON(w, http.StatusOK, newToken)
}
}
+
+func noPort(host string) string {
+ return strings.Split(host, ":")[0]
+}
+
+func (ctrl *V1Controller) setCookies(w http.ResponseWriter, domain, token string, expires time.Time, remember bool) {
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameRemember,
+ Value: strconv.FormatBool(remember),
+ Expires: expires,
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: true,
+ Path: "/",
+ })
+
+ // Set HTTP only cookie
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameToken,
+ Value: token,
+ Expires: expires,
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: true,
+ Path: "/",
+ })
+
+ // Set Fake Session cookie
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameSession,
+ Value: "true",
+ Expires: expires,
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: false,
+ Path: "/",
+ })
+}
+
+func (ctrl *V1Controller) unsetCookies(w http.ResponseWriter, domain string) {
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameToken,
+ Value: "",
+ Expires: time.Unix(0, 0),
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: true,
+ Path: "/",
+ })
+
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameRemember,
+ Value: "false",
+ Expires: time.Unix(0, 0),
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: true,
+ Path: "/",
+ })
+
+ // Set Fake Session cookie
+ http.SetCookie(w, &http.Cookie{
+ Name: cookieNameSession,
+ Value: "false",
+ Expires: time.Unix(0, 0),
+ Domain: domain,
+ Secure: ctrl.cookieSecure,
+ HttpOnly: false,
+ Path: "/",
+ })
+}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_group.go b/backend/app/api/handlers/v1/v1_ctrl_group.go
index a3e8992..69bc024 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_group.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_group.go
@@ -7,13 +7,13 @@ import (
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- "github.com/rs/zerolog/log"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
)
type (
GroupInvitationCreate struct {
- Uses int `json:"uses"`
+ Uses int `json:"uses" validate:"required,min=1,max=100"`
ExpiresAt time.Time `json:"expiresAt"`
}
@@ -25,93 +25,73 @@ type (
)
// HandleGroupGet godoc
-// @Summary Get the current user's group
-// @Tags Group
-// @Produce json
-// @Success 200 {object} repo.Group
-// @Router /v1/groups [Get]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupGet() server.HandlerFunc {
- return ctrl.handleGroupGeneral()
+//
+// @Summary Get Group
+// @Tags Group
+// @Produce json
+// @Success 200 {object} repo.Group
+// @Router /v1/groups [Get]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupGet() errchain.HandlerFunc {
+ fn := func(r *http.Request) (repo.Group, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Groups.GroupByID(auth, auth.GID)
+ }
+
+ return adapters.Command(fn, http.StatusOK)
}
// HandleGroupUpdate godoc
-// @Summary Updates some fields of the current users group
-// @Tags Group
-// @Produce json
-// @Param payload body repo.GroupUpdate true "User Data"
-// @Success 200 {object} repo.Group
-// @Router /v1/groups [Put]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupUpdate() server.HandlerFunc {
- return ctrl.handleGroupGeneral()
-}
+//
+// @Summary Update Group
+// @Tags Group
+// @Produce json
+// @Param payload body repo.GroupUpdate true "User Data"
+// @Success 200 {object} repo.Group
+// @Router /v1/groups [Put]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupUpdate() errchain.HandlerFunc {
+ fn := func(r *http.Request, body repo.GroupUpdate) (repo.Group, error) {
+ auth := services.NewContext(r.Context())
-func (ctrl *V1Controller) handleGroupGeneral() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
-
- switch r.Method {
- case http.MethodGet:
- group, err := ctrl.repo.Groups.GroupByID(ctx, ctx.GID)
- if err != nil {
- log.Err(err).Msg("failed to get group")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, group)
-
- case http.MethodPut:
- data := repo.GroupUpdate{}
- if err := server.Decode(r, &data); err != nil {
- return validate.NewRequestError(err, http.StatusBadRequest)
- }
-
- group, err := ctrl.svc.Group.UpdateGroup(ctx, data)
- if err != nil {
- log.Err(err).Msg("failed to update group")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, group)
+ ok := ctrl.svc.Currencies.IsSupported(body.Currency)
+ if !ok {
+ return repo.Group{}, validate.NewFieldErrors(
+ validate.NewFieldError("currency", "currency '"+body.Currency+"' is not supported"),
+ )
}
- return nil
+ return ctrl.svc.Group.UpdateGroup(auth, body)
}
+
+ return adapters.Action(fn, http.StatusOK)
}
// HandleGroupInvitationsCreate godoc
-// @Summary Get the current user
-// @Tags Group
-// @Produce json
-// @Param payload body GroupInvitationCreate true "User Data"
-// @Success 200 {object} GroupInvitation
-// @Router /v1/groups/invitations [Post]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupInvitationsCreate() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- data := GroupInvitationCreate{}
- if err := server.Decode(r, &data); err != nil {
- log.Err(err).Msg("failed to decode user registration data")
- return validate.NewRequestError(err, http.StatusBadRequest)
+//
+// @Summary Create Group Invitation
+// @Tags Group
+// @Produce json
+// @Param payload body GroupInvitationCreate true "User Data"
+// @Success 200 {object} GroupInvitation
+// @Router /v1/groups/invitations [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupInvitationsCreate() errchain.HandlerFunc {
+ fn := func(r *http.Request, body GroupInvitationCreate) (GroupInvitation, error) {
+ if body.ExpiresAt.IsZero() {
+ body.ExpiresAt = time.Now().Add(time.Hour * 24)
}
- if data.ExpiresAt.IsZero() {
- data.ExpiresAt = time.Now().Add(time.Hour * 24)
- }
+ auth := services.NewContext(r.Context())
- ctx := services.NewContext(r.Context())
+ token, err := ctrl.svc.Group.NewInvitation(auth, body.Uses, body.ExpiresAt)
- token, err := ctrl.svc.Group.NewInvitation(ctx, data.Uses, data.ExpiresAt)
- if err != nil {
- log.Err(err).Msg("failed to create new token")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusCreated, GroupInvitation{
+ return GroupInvitation{
Token: token,
- ExpiresAt: data.ExpiresAt,
- Uses: data.Uses,
- })
+ ExpiresAt: body.ExpiresAt,
+ Uses: body.Uses,
+ }, err
}
+
+ return adapters.Action(fn, http.StatusCreated)
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_items.go b/backend/app/api/handlers/v1/v1_ctrl_items.go
index d7be19d..6a25663 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_items.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_items.go
@@ -2,176 +2,292 @@ package v1
import (
"database/sql"
+ "encoding/csv"
"errors"
"net/http"
+ "strings"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
// HandleItemsGetAll godoc
-// @Summary Get All Items
-// @Tags Items
-// @Produce json
-// @Param q query string false "search string"
-// @Param page query int false "page number"
-// @Param pageSize query int false "items per page"
-// @Param labels query []string false "label Ids" collectionFormat(multi)
-// @Param locations query []string false "location Ids" collectionFormat(multi)
-// @Success 200 {object} repo.PaginationResult[repo.ItemSummary]{}
-// @Router /v1/items [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemsGetAll() server.HandlerFunc {
-
+//
+// @Summary Query All Items
+// @Tags Items
+// @Produce json
+// @Param q query string false "search string"
+// @Param page query int false "page number"
+// @Param pageSize query int false "items per page"
+// @Param labels query []string false "label Ids" collectionFormat(multi)
+// @Param locations query []string false "location Ids" collectionFormat(multi)
+// @Param parentIds query []string false "parent Ids" collectionFormat(multi)
+// @Success 200 {object} repo.PaginationResult[repo.ItemSummary]{}
+// @Router /v1/items [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemsGetAll() errchain.HandlerFunc {
extractQuery := func(r *http.Request) repo.ItemQuery {
params := r.URL.Query()
- return repo.ItemQuery{
+ filterFieldItems := func(raw []string) []repo.FieldQuery {
+ var items []repo.FieldQuery
+
+ for _, v := range raw {
+ parts := strings.SplitN(v, "=", 2)
+ if len(parts) == 2 {
+ items = append(items, repo.FieldQuery{
+ Name: parts[0],
+ Value: parts[1],
+ })
+ }
+ }
+
+ return items
+ }
+
+ v := repo.ItemQuery{
Page: queryIntOrNegativeOne(params.Get("page")),
PageSize: queryIntOrNegativeOne(params.Get("pageSize")),
Search: params.Get("q"),
LocationIDs: queryUUIDList(params, "locations"),
LabelIDs: queryUUIDList(params, "labels"),
+ ParentItemIDs: queryUUIDList(params, "parentIds"),
IncludeArchived: queryBool(params.Get("includeArchived")),
+ Fields: filterFieldItems(params["fields"]),
+ OrderBy: params.Get("orderBy"),
}
+
+ if strings.HasPrefix(v.Search, "#") {
+ aidStr := strings.TrimPrefix(v.Search, "#")
+
+ aid, ok := repo.ParseAssetID(aidStr)
+ if ok {
+ v.Search = ""
+ v.AssetID = aid
+ }
+ }
+
+ return v
}
return func(w http.ResponseWriter, r *http.Request) error {
ctx := services.NewContext(r.Context())
+
items, err := ctrl.repo.Items.QueryByGroup(ctx, ctx.GID, extractQuery(r))
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
- return server.Respond(w, http.StatusOK, repo.PaginationResult[repo.ItemSummary]{
+ return server.JSON(w, http.StatusOK, repo.PaginationResult[repo.ItemSummary]{
Items: []repo.ItemSummary{},
})
}
log.Err(err).Msg("failed to get items")
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, items)
+ return server.JSON(w, http.StatusOK, items)
}
}
+// HandleItemFullPath godoc
+//
+// @Summary Get the full path of an item
+// @Tags Items
+// @Produce json
+// @Param id path string true "Item ID"
+// @Success 200 {object} []repo.ItemPath
+// @Router /v1/items/{id}/path [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemFullPath() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) ([]repo.ItemPath, error) {
+ auth := services.NewContext(r.Context())
+ item, err := ctrl.repo.Items.GetOneByGroup(auth, auth.GID, ID)
+ if err != nil {
+ return nil, err
+ }
+
+ paths, err := ctrl.repo.Locations.PathForLoc(auth, auth.GID, item.Location.ID)
+ if err != nil {
+ return nil, err
+ }
+
+ if item.Parent != nil {
+ paths = append(paths, repo.ItemPath{
+ Type: repo.ItemTypeItem,
+ ID: item.Parent.ID,
+ Name: item.Parent.Name,
+ })
+ }
+
+ paths = append(paths, repo.ItemPath{
+ Type: repo.ItemTypeItem,
+ ID: item.ID,
+ Name: item.Name,
+ })
+
+ return paths, nil
+ }
+
+ return adapters.CommandID("id", fn, http.StatusOK)
+}
+
// HandleItemsCreate godoc
-// @Summary Create a new item
-// @Tags Items
-// @Produce json
-// @Param payload body repo.ItemCreate true "Item Data"
-// @Success 200 {object} repo.ItemSummary
-// @Router /v1/items [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemsCreate() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- createData := repo.ItemCreate{}
- if err := server.Decode(r, &createData); err != nil {
- log.Err(err).Msg("failed to decode request body")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- ctx := services.NewContext(r.Context())
- item, err := ctrl.svc.Items.Create(ctx, createData)
- if err != nil {
- log.Err(err).Msg("failed to create item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusCreated, item)
+//
+// @Summary Create Item
+// @Tags Items
+// @Produce json
+// @Param payload body repo.ItemCreate true "Item Data"
+// @Success 201 {object} repo.ItemSummary
+// @Router /v1/items [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemsCreate() errchain.HandlerFunc {
+ fn := func(r *http.Request, body repo.ItemCreate) (repo.ItemOut, error) {
+ return ctrl.svc.Items.Create(services.NewContext(r.Context()), body)
}
+
+ return adapters.Action(fn, http.StatusCreated)
}
// HandleItemGet godocs
-// @Summary Gets a item and fields
-// @Tags Items
-// @Produce json
-// @Param id path string true "Item ID"
-// @Success 200 {object} repo.ItemOut
-// @Router /v1/items/{id} [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemGet() server.HandlerFunc {
- return ctrl.handleItemsGeneral()
+//
+// @Summary Get Item
+// @Tags Items
+// @Produce json
+// @Param id path string true "Item ID"
+// @Success 200 {object} repo.ItemOut
+// @Router /v1/items/{id} [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemGet() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (repo.ItemOut, error) {
+ auth := services.NewContext(r.Context())
+
+ return ctrl.repo.Items.GetOneByGroup(auth, auth.GID, ID)
+ }
+
+ return adapters.CommandID("id", fn, http.StatusOK)
}
// HandleItemDelete godocs
-// @Summary deletes a item
-// @Tags Items
-// @Produce json
-// @Param id path string true "Item ID"
-// @Success 204
-// @Router /v1/items/{id} [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemDelete() server.HandlerFunc {
- return ctrl.handleItemsGeneral()
+//
+// @Summary Delete Item
+// @Tags Items
+// @Produce json
+// @Param id path string true "Item ID"
+// @Success 204
+// @Router /v1/items/{id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemDelete() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (any, error) {
+ auth := services.NewContext(r.Context())
+ err := ctrl.repo.Items.DeleteByGroup(auth, auth.GID, ID)
+ return nil, err
+ }
+
+ return adapters.CommandID("id", fn, http.StatusNoContent)
}
// HandleItemUpdate godocs
-// @Summary updates a item
-// @Tags Items
-// @Produce json
-// @Param id path string true "Item ID"
-// @Param payload body repo.ItemUpdate true "Item Data"
-// @Success 200 {object} repo.ItemOut
-// @Router /v1/items/{id} [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemUpdate() server.HandlerFunc {
- return ctrl.handleItemsGeneral()
+//
+// @Summary Update Item
+// @Tags Items
+// @Produce json
+// @Param id path string true "Item ID"
+// @Param payload body repo.ItemUpdate true "Item Data"
+// @Success 200 {object} repo.ItemOut
+// @Router /v1/items/{id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemUpdate() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, body repo.ItemUpdate) (repo.ItemOut, error) {
+ auth := services.NewContext(r.Context())
+
+ body.ID = ID
+ return ctrl.repo.Items.UpdateByGroup(auth, auth.GID, body)
+ }
+
+ return adapters.ActionID("id", fn, http.StatusOK)
}
-func (ctrl *V1Controller) handleItemsGeneral() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
- ID, err := ctrl.routeID(r)
+// HandleItemPatch godocs
+//
+// @Summary Update Item
+// @Tags Items
+// @Produce json
+// @Param id path string true "Item ID"
+// @Param payload body repo.ItemPatch true "Item Data"
+// @Success 200 {object} repo.ItemOut
+// @Router /v1/items/{id} [Patch]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemPatch() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, body repo.ItemPatch) (repo.ItemOut, error) {
+ auth := services.NewContext(r.Context())
+
+ body.ID = ID
+ err := ctrl.repo.Items.Patch(auth, auth.GID, ID, body)
if err != nil {
- return err
+ return repo.ItemOut{}, err
}
- switch r.Method {
- case http.MethodGet:
- items, err := ctrl.repo.Items.GetOneByGroup(r.Context(), ctx.GID, ID)
- if err != nil {
- log.Err(err).Msg("failed to get item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, items)
- case http.MethodDelete:
- err = ctrl.repo.Items.DeleteByGroup(r.Context(), ctx.GID, ID)
- if err != nil {
- log.Err(err).Msg("failed to delete item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusNoContent, nil)
- case http.MethodPut:
- body := repo.ItemUpdate{}
- if err := server.Decode(r, &body); err != nil {
- log.Err(err).Msg("failed to decode request body")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- body.ID = ID
- result, err := ctrl.repo.Items.UpdateByGroup(r.Context(), ctx.GID, body)
- if err != nil {
- log.Err(err).Msg("failed to update item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, result)
- }
-
- return nil
+ return ctrl.repo.Items.GetOneByGroup(auth, auth.GID, ID)
}
+
+ return adapters.ActionID("id", fn, http.StatusOK)
+}
+
+// HandleGetAllCustomFieldNames godocs
+//
+// @Summary Get All Custom Field Names
+// @Tags Items
+// @Produce json
+// @Success 200
+// @Router /v1/items/fields [GET]
+// @Success 200 {object} []string
+// @Security Bearer
+func (ctrl *V1Controller) HandleGetAllCustomFieldNames() errchain.HandlerFunc {
+ fn := func(r *http.Request) ([]string, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Items.GetAllCustomFieldNames(auth, auth.GID)
+ }
+
+ return adapters.Command(fn, http.StatusOK)
+}
+
+// HandleGetAllCustomFieldValues godocs
+//
+// @Summary Get All Custom Field Values
+// @Tags Items
+// @Produce json
+// @Success 200
+// @Router /v1/items/fields/values [GET]
+// @Success 200 {object} []string
+// @Security Bearer
+func (ctrl *V1Controller) HandleGetAllCustomFieldValues() errchain.HandlerFunc {
+ type query struct {
+ Field string `schema:"field" validate:"required"`
+ }
+
+ fn := func(r *http.Request, q query) ([]string, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Items.GetAllCustomFieldValues(auth, auth.GID, q.Field)
+ }
+
+ return adapters.Query(fn, http.StatusOK)
}
// HandleItemsImport godocs
-// @Summary imports items into the database
-// @Tags Items
-// @Produce json
-// @Success 204
-// @Param csv formData file true "Image to upload"
-// @Router /v1/items/import [Post]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemsImport() server.HandlerFunc {
+//
+// @Summary Import Items
+// @Tags Items
+// @Produce json
+// @Success 204
+// @Param csv formData file true "Image to upload"
+// @Router /v1/items/import [Post]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemsImport() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
-
err := r.ParseMultipartForm(ctrl.maxUploadSize << 20)
if err != nil {
log.Err(err).Msg("failed to parse multipart form")
@@ -184,20 +300,40 @@ func (ctrl *V1Controller) HandleItemsImport() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- data, err := services.ReadCsv(file)
- if err != nil {
- log.Err(err).Msg("failed to read csv")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
user := services.UseUserCtx(r.Context())
- _, err = ctrl.svc.Items.CsvImport(r.Context(), user.GroupID, data)
+ _, err = ctrl.svc.Items.CsvImport(r.Context(), user.GroupID, file)
if err != nil {
log.Err(err).Msg("failed to import items")
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ return server.JSON(w, http.StatusNoContent, nil)
+ }
+}
+
+// HandleItemsExport godocs
+//
+// @Summary Export Items
+// @Tags Items
+// @Success 200 {string} string "text/csv"
+// @Router /v1/items/export [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemsExport() errchain.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) error {
+ ctx := services.NewContext(r.Context())
+
+ csvData, err := ctrl.svc.Items.ExportTSV(r.Context(), ctx.GID)
+ if err != nil {
+ log.Err(err).Msg("failed to export items")
+ return validate.NewRequestError(err, http.StatusInternalServerError)
+ }
+
+ w.Header().Set("Content-Type", "text/tsv")
+ w.Header().Set("Content-Disposition", "attachment;filename=homebox-items.tsv")
+
+ writer := csv.NewWriter(w)
+ writer.Comma = '\t'
+ return writer.WriteAll(csvData)
}
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_items_attachments.go b/backend/app/api/handlers/v1/v1_ctrl_items_attachments.go
index 033f683..ae2782a 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_items_attachments.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_items_attachments.go
@@ -3,12 +3,15 @@ package v1
import (
"errors"
"net/http"
+ "path/filepath"
+ "strings"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/ent/attachment"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
@@ -18,25 +21,25 @@ type (
}
)
-// HandleItemsImport godocs
-// @Summary imports items into the database
-// @Tags Items Attachments
-// @Produce json
-// @Param id path string true "Item ID"
-// @Param file formData file true "File attachment"
-// @Param type formData string true "Type of file"
-// @Param name formData string true "name of the file including extension"
-// @Success 200 {object} repo.ItemOut
-// @Failure 422 {object} server.ErrorResponse
-// @Router /v1/items/{id}/attachments [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemAttachmentCreate() server.HandlerFunc {
+// HandleItemAttachmentCreate godocs
+//
+// @Summary Create Item Attachment
+// @Tags Items Attachments
+// @Produce json
+// @Param id path string true "Item ID"
+// @Param file formData file true "File attachment"
+// @Param type formData string true "Type of file"
+// @Param name formData string true "name of the file including extension"
+// @Success 200 {object} repo.ItemOut
+// @Failure 422 {object} validate.ErrorResponse
+// @Router /v1/items/{id}/attachments [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemAttachmentCreate() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
err := r.ParseMultipartForm(ctrl.maxUploadSize << 20)
if err != nil {
log.Err(err).Msg("failed to parse multipart form")
return validate.NewRequestError(errors.New("failed to parse multipart form"), http.StatusBadRequest)
-
}
errs := validate.NewFieldErrors()
@@ -60,12 +63,20 @@ func (ctrl *V1Controller) HandleItemAttachmentCreate() server.HandlerFunc {
}
if !errs.Nil() {
- return server.Respond(w, http.StatusUnprocessableEntity, errs)
+ return server.JSON(w, http.StatusUnprocessableEntity, errs)
}
attachmentType := r.FormValue("type")
if attachmentType == "" {
- attachmentType = attachment.TypeAttachment.String()
+ // Attempt to auto-detect the type of the file
+ ext := filepath.Ext(attachmentName)
+
+ switch strings.ToLower(ext) {
+ case ".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff":
+ attachmentType = attachment.TypePhoto.String()
+ default:
+ attachmentType = attachment.TypeAttachment.String()
+ }
}
id, err := ctrl.routeID(r)
@@ -82,51 +93,53 @@ func (ctrl *V1Controller) HandleItemAttachmentCreate() server.HandlerFunc {
attachment.Type(attachmentType),
file,
)
-
if err != nil {
log.Err(err).Msg("failed to add attachment")
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusCreated, item)
+ return server.JSON(w, http.StatusCreated, item)
}
}
// HandleItemAttachmentGet godocs
-// @Summary retrieves an attachment for an item
-// @Tags Items Attachments
-// @Produce application/octet-stream
-// @Param id path string true "Item ID"
-// @Param attachment_id path string true "Attachment ID"
-// @Success 200 {object} ItemAttachmentToken
-// @Router /v1/items/{id}/attachments/{attachment_id} [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemAttachmentGet() server.HandlerFunc {
+//
+// @Summary Get Item Attachment
+// @Tags Items Attachments
+// @Produce application/octet-stream
+// @Param id path string true "Item ID"
+// @Param attachment_id path string true "Attachment ID"
+// @Success 200 {object} ItemAttachmentToken
+// @Router /v1/items/{id}/attachments/{attachment_id} [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemAttachmentGet() errchain.HandlerFunc {
return ctrl.handleItemAttachmentsHandler
}
// HandleItemAttachmentDelete godocs
-// @Summary retrieves an attachment for an item
-// @Tags Items Attachments
-// @Param id path string true "Item ID"
-// @Param attachment_id path string true "Attachment ID"
-// @Success 204
-// @Router /v1/items/{id}/attachments/{attachment_id} [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemAttachmentDelete() server.HandlerFunc {
+//
+// @Summary Delete Item Attachment
+// @Tags Items Attachments
+// @Param id path string true "Item ID"
+// @Param attachment_id path string true "Attachment ID"
+// @Success 204
+// @Router /v1/items/{id}/attachments/{attachment_id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemAttachmentDelete() errchain.HandlerFunc {
return ctrl.handleItemAttachmentsHandler
}
// HandleItemAttachmentUpdate godocs
-// @Summary retrieves an attachment for an item
-// @Tags Items Attachments
-// @Param id path string true "Item ID"
-// @Param attachment_id path string true "Attachment ID"
-// @Param payload body repo.ItemAttachmentUpdate true "Attachment Update"
-// @Success 200 {object} repo.ItemOut
-// @Router /v1/items/{id}/attachments/{attachment_id} [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleItemAttachmentUpdate() server.HandlerFunc {
+//
+// @Summary Update Item Attachment
+// @Tags Items Attachments
+// @Param id path string true "Item ID"
+// @Param attachment_id path string true "Attachment ID"
+// @Param payload body repo.ItemAttachmentUpdate true "Attachment Update"
+// @Success 200 {object} repo.ItemOut
+// @Router /v1/items/{id}/attachments/{attachment_id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleItemAttachmentUpdate() errchain.HandlerFunc {
return ctrl.handleItemAttachmentsHandler
}
@@ -161,7 +174,7 @@ func (ctrl *V1Controller) handleItemAttachmentsHandler(w http.ResponseWriter, r
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ return server.JSON(w, http.StatusNoContent, nil)
// Update Attachment Handler
case http.MethodPut:
@@ -179,7 +192,7 @@ func (ctrl *V1Controller) handleItemAttachmentsHandler(w http.ResponseWriter, r
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, val)
+ return server.JSON(w, http.StatusOK, val)
}
return nil
diff --git a/backend/app/api/handlers/v1/v1_ctrl_labels.go b/backend/app/api/handlers/v1/v1_ctrl_labels.go
index 2551b46..dae23db 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_labels.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_labels.go
@@ -3,141 +3,100 @@ package v1
import (
"net/http"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
- "github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- "github.com/rs/zerolog/log"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
)
// HandleLabelsGetAll godoc
-// @Summary Get All Labels
-// @Tags Labels
-// @Produce json
-// @Success 200 {object} server.Results{items=[]repo.LabelOut}
-// @Router /v1/labels [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLabelsGetAll() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- user := services.UseUserCtx(r.Context())
- labels, err := ctrl.repo.Labels.GetAll(r.Context(), user.GroupID)
- if err != nil {
- log.Err(err).Msg("error getting labels")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, server.Results{Items: labels})
+//
+// @Summary Get All Labels
+// @Tags Labels
+// @Produce json
+// @Success 200 {object} []repo.LabelOut
+// @Router /v1/labels [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLabelsGetAll() errchain.HandlerFunc {
+ fn := func(r *http.Request) ([]repo.LabelSummary, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Labels.GetAll(auth, auth.GID)
}
+
+ return adapters.Command(fn, http.StatusOK)
}
// HandleLabelsCreate godoc
-// @Summary Create a new label
-// @Tags Labels
-// @Produce json
-// @Param payload body repo.LabelCreate true "Label Data"
-// @Success 200 {object} repo.LabelSummary
-// @Router /v1/labels [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLabelsCreate() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- createData := repo.LabelCreate{}
- if err := server.Decode(r, &createData); err != nil {
- log.Err(err).Msg("error decoding label create data")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- user := services.UseUserCtx(r.Context())
- label, err := ctrl.repo.Labels.Create(r.Context(), user.GroupID, createData)
- if err != nil {
- log.Err(err).Msg("error creating label")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusCreated, label)
+//
+// @Summary Create Label
+// @Tags Labels
+// @Produce json
+// @Param payload body repo.LabelCreate true "Label Data"
+// @Success 200 {object} repo.LabelSummary
+// @Router /v1/labels [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLabelsCreate() errchain.HandlerFunc {
+ fn := func(r *http.Request, data repo.LabelCreate) (repo.LabelOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Labels.Create(auth, auth.GID, data)
}
+
+ return adapters.Action(fn, http.StatusCreated)
}
// HandleLabelDelete godocs
-// @Summary deletes a label
-// @Tags Labels
-// @Produce json
-// @Param id path string true "Label ID"
-// @Success 204
-// @Router /v1/labels/{id} [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLabelDelete() server.HandlerFunc {
- return ctrl.handleLabelsGeneral()
+//
+// @Summary Delete Label
+// @Tags Labels
+// @Produce json
+// @Param id path string true "Label ID"
+// @Success 204
+// @Router /v1/labels/{id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLabelDelete() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (any, error) {
+ auth := services.NewContext(r.Context())
+ err := ctrl.repo.Labels.DeleteByGroup(auth, auth.GID, ID)
+ return nil, err
+ }
+
+ return adapters.CommandID("id", fn, http.StatusNoContent)
}
// HandleLabelGet godocs
-// @Summary Gets a label and fields
-// @Tags Labels
-// @Produce json
-// @Param id path string true "Label ID"
-// @Success 200 {object} repo.LabelOut
-// @Router /v1/labels/{id} [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLabelGet() server.HandlerFunc {
- return ctrl.handleLabelsGeneral()
+//
+// @Summary Get Label
+// @Tags Labels
+// @Produce json
+// @Param id path string true "Label ID"
+// @Success 200 {object} repo.LabelOut
+// @Router /v1/labels/{id} [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLabelGet() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (repo.LabelOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Labels.GetOneByGroup(auth, auth.GID, ID)
+ }
+
+ return adapters.CommandID("id", fn, http.StatusOK)
}
// HandleLabelUpdate godocs
-// @Summary updates a label
-// @Tags Labels
-// @Produce json
-// @Param id path string true "Label ID"
-// @Success 200 {object} repo.LabelOut
-// @Router /v1/labels/{id} [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLabelUpdate() server.HandlerFunc {
- return ctrl.handleLabelsGeneral()
-}
-
-func (ctrl *V1Controller) handleLabelsGeneral() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
- ID, err := ctrl.routeID(r)
- if err != nil {
- return err
- }
-
- switch r.Method {
- case http.MethodGet:
- labels, err := ctrl.repo.Labels.GetOneByGroup(r.Context(), ctx.GID, ID)
- if err != nil {
- if ent.IsNotFound(err) {
- log.Err(err).
- Str("id", ID.String()).
- Msg("label not found")
- return validate.NewRequestError(err, http.StatusNotFound)
- }
- log.Err(err).Msg("error getting label")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, labels)
-
- case http.MethodDelete:
- err = ctrl.repo.Labels.DeleteByGroup(ctx, ctx.GID, ID)
- if err != nil {
- log.Err(err).Msg("error deleting label")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusNoContent, nil)
-
- case http.MethodPut:
- body := repo.LabelUpdate{}
- if err := server.Decode(r, &body); err != nil {
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- body.ID = ID
- result, err := ctrl.repo.Labels.UpdateByGroup(ctx, ctx.GID, body)
- if err != nil {
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, result)
- }
-
- return nil
+//
+// @Summary Update Label
+// @Tags Labels
+// @Produce json
+// @Param id path string true "Label ID"
+// @Success 200 {object} repo.LabelOut
+// @Router /v1/labels/{id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLabelUpdate() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, data repo.LabelUpdate) (repo.LabelOut, error) {
+ auth := services.NewContext(r.Context())
+ data.ID = ID
+ return ctrl.repo.Labels.UpdateByGroup(auth, auth.GID, data)
}
+
+ return adapters.ActionID("id", fn, http.StatusOK)
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_locations.go b/backend/app/api/handlers/v1/v1_ctrl_locations.go
index 12e3c29..d84ce31 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_locations.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_locations.go
@@ -3,154 +3,120 @@ package v1
import (
"net/http"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
- "github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- "github.com/rs/zerolog/log"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
)
-// HandleLocationGetAll godoc
-// @Summary Get All Locations
-// @Tags Locations
-// @Produce json
-// @Param filterChildren query bool false "Filter locations with parents"
-// @Success 200 {object} server.Results{items=[]repo.LocationOutCount}
-// @Router /v1/locations [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLocationGetAll() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- user := services.UseUserCtx(r.Context())
-
- q := r.URL.Query()
-
- filter := repo.LocationQuery{
- FilterChildren: queryBool(q.Get("filterChildren")),
- }
-
- locations, err := ctrl.repo.Locations.GetAll(r.Context(), user.GroupID, filter)
- if err != nil {
- log.Err(err).Msg("failed to get locations")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, server.Results{Items: locations})
+// HandleLocationTreeQuery godoc
+//
+// @Summary Get Locations Tree
+// @Tags Locations
+// @Produce json
+// @Param withItems query bool false "include items in response tree"
+// @Success 200 {object} []repo.TreeItem
+// @Router /v1/locations/tree [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationTreeQuery() errchain.HandlerFunc {
+ fn := func(r *http.Request, query repo.TreeQuery) ([]repo.TreeItem, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Locations.Tree(auth, auth.GID, query)
}
+
+ return adapters.Query(fn, http.StatusOK)
+}
+
+// HandleLocationGetAll godoc
+//
+// @Summary Get All Locations
+// @Tags Locations
+// @Produce json
+// @Param filterChildren query bool false "Filter locations with parents"
+// @Success 200 {object} []repo.LocationOutCount
+// @Router /v1/locations [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationGetAll() errchain.HandlerFunc {
+ fn := func(r *http.Request, q repo.LocationQuery) ([]repo.LocationOutCount, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Locations.GetAll(auth, auth.GID, q)
+ }
+
+ return adapters.Query(fn, http.StatusOK)
}
// HandleLocationCreate godoc
-// @Summary Create a new location
-// @Tags Locations
-// @Produce json
-// @Param payload body repo.LocationCreate true "Location Data"
-// @Success 200 {object} repo.LocationSummary
-// @Router /v1/locations [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLocationCreate() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- createData := repo.LocationCreate{}
- if err := server.Decode(r, &createData); err != nil {
- log.Err(err).Msg("failed to decode location create data")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- user := services.UseUserCtx(r.Context())
- location, err := ctrl.repo.Locations.Create(r.Context(), user.GroupID, createData)
- if err != nil {
- log.Err(err).Msg("failed to create location")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusCreated, location)
+//
+// @Summary Create Location
+// @Tags Locations
+// @Produce json
+// @Param payload body repo.LocationCreate true "Location Data"
+// @Success 200 {object} repo.LocationSummary
+// @Router /v1/locations [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationCreate() errchain.HandlerFunc {
+ fn := func(r *http.Request, createData repo.LocationCreate) (repo.LocationOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Locations.Create(auth, auth.GID, createData)
}
+
+ return adapters.Action(fn, http.StatusCreated)
}
-// HandleLocationDelete godocs
-// @Summary deletes a location
-// @Tags Locations
-// @Produce json
-// @Param id path string true "Location ID"
-// @Success 204
-// @Router /v1/locations/{id} [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLocationDelete() server.HandlerFunc {
- return ctrl.handleLocationGeneral()
-}
-
-// HandleLocationGet godocs
-// @Summary Gets a location and fields
-// @Tags Locations
-// @Produce json
-// @Param id path string true "Location ID"
-// @Success 200 {object} repo.LocationOut
-// @Router /v1/locations/{id} [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLocationGet() server.HandlerFunc {
- return ctrl.handleLocationGeneral()
-}
-
-// HandleLocationUpdate godocs
-// @Summary updates a location
-// @Tags Locations
-// @Produce json
-// @Param id path string true "Location ID"
-// @Param payload body repo.LocationUpdate true "Location Data"
-// @Success 200 {object} repo.LocationOut
-// @Router /v1/locations/{id} [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleLocationUpdate() server.HandlerFunc {
- return ctrl.handleLocationGeneral()
-}
-
-func (ctrl *V1Controller) handleLocationGeneral() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
- ID, err := ctrl.routeID(r)
- if err != nil {
- return err
- }
-
- switch r.Method {
- case http.MethodGet:
- location, err := ctrl.repo.Locations.GetOneByGroup(r.Context(), ctx.GID, ID)
- if err != nil {
- l := log.Err(err).
- Str("ID", ID.String()).
- Str("GID", ctx.GID.String())
-
- if ent.IsNotFound(err) {
- l.Msg("location not found")
- return validate.NewRequestError(err, http.StatusNotFound)
- }
-
- l.Msg("failed to get location")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, location)
- case http.MethodPut:
- body := repo.LocationUpdate{}
- if err := server.Decode(r, &body); err != nil {
- log.Err(err).Msg("failed to decode location update data")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- body.ID = ID
-
- result, err := ctrl.repo.Locations.UpdateOneByGroup(r.Context(), ctx.GID, ID, body)
- if err != nil {
- log.Err(err).Msg("failed to update location")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, result)
- case http.MethodDelete:
- err = ctrl.repo.Locations.DeleteByGroup(r.Context(), ctx.GID, ID)
- if err != nil {
- log.Err(err).Msg("failed to delete location")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusNoContent, nil)
- }
- return nil
+// HandleLocationDelete godoc
+//
+// @Summary Delete Location
+// @Tags Locations
+// @Produce json
+// @Param id path string true "Location ID"
+// @Success 204
+// @Router /v1/locations/{id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationDelete() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (any, error) {
+ auth := services.NewContext(r.Context())
+ err := ctrl.repo.Locations.DeleteByGroup(auth, auth.GID, ID)
+ return nil, err
}
+
+ return adapters.CommandID("id", fn, http.StatusNoContent)
+}
+
+// HandleLocationGet godoc
+//
+// @Summary Get Location
+// @Tags Locations
+// @Produce json
+// @Param id path string true "Location ID"
+// @Success 200 {object} repo.LocationOut
+// @Router /v1/locations/{id} [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationGet() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (repo.LocationOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Locations.GetOneByGroup(auth, auth.GID, ID)
+ }
+
+ return adapters.CommandID("id", fn, http.StatusOK)
+}
+
+// HandleLocationUpdate godoc
+//
+// @Summary Update Location
+// @Tags Locations
+// @Produce json
+// @Param id path string true "Location ID"
+// @Param payload body repo.LocationUpdate true "Location Data"
+// @Success 200 {object} repo.LocationOut
+// @Router /v1/locations/{id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleLocationUpdate() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, body repo.LocationUpdate) (repo.LocationOut, error) {
+ auth := services.NewContext(r.Context())
+ body.ID = ID
+ return ctrl.repo.Locations.UpdateByGroup(auth, auth.GID, ID, body)
+ }
+
+ return adapters.ActionID("id", fn, http.StatusOK)
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_maint_entry.go b/backend/app/api/handlers/v1/v1_ctrl_maint_entry.go
index 3f3f1a1..e94c12a 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_maint_entry.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_maint_entry.go
@@ -3,123 +3,80 @@ package v1
import (
"net/http"
+ "github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- "github.com/rs/zerolog/log"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
)
-// HandleMaintenanceGetLog godoc
-// @Summary Get Maintenance Log
-// @Tags Maintenance
-// @Produce json
-// @Success 200 {object} repo.MaintenanceLog
-// @Router /v1/items/{id}/maintenance [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleMaintenanceLogGet() server.HandlerFunc {
- return ctrl.handleMaintenanceLog()
+// HandleMaintenanceLogGet godoc
+//
+// @Summary Get Maintenance Log
+// @Tags Maintenance
+// @Produce json
+// @Success 200 {object} repo.MaintenanceLog
+// @Router /v1/items/{id}/maintenance [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleMaintenanceLogGet() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, q repo.MaintenanceLogQuery) (repo.MaintenanceLog, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.MaintEntry.GetLog(auth, auth.GID, ID, q)
+ }
+
+ return adapters.QueryID("id", fn, http.StatusOK)
}
// HandleMaintenanceEntryCreate godoc
-// @Summary Create Maintenance Entry
-// @Tags Maintenance
-// @Produce json
-// @Param payload body repo.MaintenanceEntryCreate true "Entry Data"
-// @Success 200 {object} repo.MaintenanceEntry
-// @Router /v1/items/{id}/maintenance [POST]
-// @Security Bearer
-func (ctrl *V1Controller) HandleMaintenanceEntryCreate() server.HandlerFunc {
- return ctrl.handleMaintenanceLog()
+//
+// @Summary Create Maintenance Entry
+// @Tags Maintenance
+// @Produce json
+// @Param payload body repo.MaintenanceEntryCreate true "Entry Data"
+// @Success 201 {object} repo.MaintenanceEntry
+// @Router /v1/items/{id}/maintenance [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleMaintenanceEntryCreate() errchain.HandlerFunc {
+ fn := func(r *http.Request, itemID uuid.UUID, body repo.MaintenanceEntryCreate) (repo.MaintenanceEntry, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.MaintEntry.Create(auth, itemID, body)
+ }
+
+ return adapters.ActionID("id", fn, http.StatusCreated)
}
// HandleMaintenanceEntryDelete godoc
-// @Summary Delete Maintenance Entry
-// @Tags Maintenance
-// @Produce json
-// @Success 204
-// @Router /v1/items/{id}/maintenance/{entry_id} [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleMaintenanceEntryDelete() server.HandlerFunc {
- return ctrl.handleMaintenanceLog()
+//
+// @Summary Delete Maintenance Entry
+// @Tags Maintenance
+// @Produce json
+// @Success 204
+// @Router /v1/items/{id}/maintenance/{entry_id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleMaintenanceEntryDelete() errchain.HandlerFunc {
+ fn := func(r *http.Request, entryID uuid.UUID) (any, error) {
+ auth := services.NewContext(r.Context())
+ err := ctrl.repo.MaintEntry.Delete(auth, entryID)
+ return nil, err
+ }
+
+ return adapters.CommandID("entry_id", fn, http.StatusNoContent)
}
// HandleMaintenanceEntryUpdate godoc
-// @Summary Update Maintenance Entry
-// @Tags Maintenance
-// @Produce json
-// @Param payload body repo.MaintenanceEntryUpdate true "Entry Data"
-// @Success 200 {object} repo.MaintenanceEntry
-// @Router /v1/items/{id}/maintenance/{entry_id} [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleMaintenanceEntryUpdate() server.HandlerFunc {
- return ctrl.handleMaintenanceLog()
-}
-
-func (ctrl *V1Controller) handleMaintenanceLog() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
- itemID, err := ctrl.routeID(r)
- if err != nil {
- return err
- }
-
- switch r.Method {
- case http.MethodGet:
- mlog, err := ctrl.repo.MaintEntry.GetLog(ctx, itemID)
- if err != nil {
- log.Err(err).Msg("failed to get items")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
- return server.Respond(w, http.StatusOK, mlog)
- case http.MethodPost:
- var create repo.MaintenanceEntryCreate
- err := server.Decode(r, &create)
- if err != nil {
- return validate.NewRequestError(err, http.StatusBadRequest)
- }
-
- entry, err := ctrl.repo.MaintEntry.Create(ctx, itemID, create)
- if err != nil {
- log.Err(err).Msg("failed to create item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusCreated, entry)
- case http.MethodPut:
- entryID, err := ctrl.routeUUID(r, "entry_id")
- if err != nil {
- return err
- }
-
- var update repo.MaintenanceEntryUpdate
- err = server.Decode(r, &update)
- if err != nil {
- return validate.NewRequestError(err, http.StatusBadRequest)
- }
-
- entry, err := ctrl.repo.MaintEntry.Update(ctx, entryID, update)
- if err != nil {
- log.Err(err).Msg("failed to update item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, entry)
- case http.MethodDelete:
- entryID, err := ctrl.routeUUID(r, "entry_id")
- if err != nil {
- return err
- }
-
- err = ctrl.repo.MaintEntry.Delete(ctx, entryID)
- if err != nil {
- log.Err(err).Msg("failed to delete item")
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusNoContent, nil)
- }
-
- return nil
+//
+// @Summary Update Maintenance Entry
+// @Tags Maintenance
+// @Produce json
+// @Param payload body repo.MaintenanceEntryUpdate true "Entry Data"
+// @Success 200 {object} repo.MaintenanceEntry
+// @Router /v1/items/{id}/maintenance/{entry_id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleMaintenanceEntryUpdate() errchain.HandlerFunc {
+ fn := func(r *http.Request, entryID uuid.UUID, body repo.MaintenanceEntryUpdate) (repo.MaintenanceEntry, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.MaintEntry.Update(auth, entryID, body)
}
+
+ return adapters.ActionID("entry_id", fn, http.StatusOK)
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_notifiers.go b/backend/app/api/handlers/v1/v1_ctrl_notifiers.go
new file mode 100644
index 0000000..3c64dc7
--- /dev/null
+++ b/backend/app/api/handlers/v1/v1_ctrl_notifiers.go
@@ -0,0 +1,105 @@
+package v1
+
+import (
+ "net/http"
+
+ "github.com/containrrr/shoutrrr"
+ "github.com/google/uuid"
+ "github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
+)
+
+// HandleGetUserNotifiers godoc
+//
+// @Summary Get Notifiers
+// @Tags Notifiers
+// @Produce json
+// @Success 200 {object} []repo.NotifierOut
+// @Router /v1/notifiers [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGetUserNotifiers() errchain.HandlerFunc {
+ fn := func(r *http.Request, _ struct{}) ([]repo.NotifierOut, error) {
+ user := services.UseUserCtx(r.Context())
+ return ctrl.repo.Notifiers.GetByUser(r.Context(), user.ID)
+ }
+
+ return adapters.Query(fn, http.StatusOK)
+}
+
+// HandleCreateNotifier godoc
+//
+// @Summary Create Notifier
+// @Tags Notifiers
+// @Produce json
+// @Param payload body repo.NotifierCreate true "Notifier Data"
+// @Success 200 {object} repo.NotifierOut
+// @Router /v1/notifiers [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandleCreateNotifier() errchain.HandlerFunc {
+ fn := func(r *http.Request, in repo.NotifierCreate) (repo.NotifierOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Notifiers.Create(auth, auth.GID, auth.UID, in)
+ }
+
+ return adapters.Action(fn, http.StatusCreated)
+}
+
+// HandleDeleteNotifier godocs
+//
+// @Summary Delete a Notifier
+// @Tags Notifiers
+// @Param id path string true "Notifier ID"
+// @Success 204
+// @Router /v1/notifiers/{id} [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleDeleteNotifier() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID) (any, error) {
+ auth := services.NewContext(r.Context())
+ return nil, ctrl.repo.Notifiers.Delete(auth, auth.UID, ID)
+ }
+
+ return adapters.CommandID("id", fn, http.StatusNoContent)
+}
+
+// HandleUpdateNotifier godocs
+//
+// @Summary Update Notifier
+// @Tags Notifiers
+// @Param id path string true "Notifier ID"
+// @Param payload body repo.NotifierUpdate true "Notifier Data"
+// @Success 200 {object} repo.NotifierOut
+// @Router /v1/notifiers/{id} [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleUpdateNotifier() errchain.HandlerFunc {
+ fn := func(r *http.Request, ID uuid.UUID, in repo.NotifierUpdate) (repo.NotifierOut, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Notifiers.Update(auth, auth.UID, ID, in)
+ }
+
+ return adapters.ActionID("id", fn, http.StatusOK)
+}
+
+// HandlerNotifierTest godoc
+//
+// @Summary Test Notifier
+// @Tags Notifiers
+// @Produce json
+// @Param id path string true "Notifier ID"
+// @Param url query string true "URL"
+// @Success 204
+// @Router /v1/notifiers/test [POST]
+// @Security Bearer
+func (ctrl *V1Controller) HandlerNotifierTest() errchain.HandlerFunc {
+ type body struct {
+ URL string `json:"url" validate:"required"`
+ }
+
+ fn := func(r *http.Request, q body) (any, error) {
+ err := shoutrrr.Send(q.URL, "Test message from Homebox")
+ return nil, err
+ }
+
+ return adapters.Action(fn, http.StatusOK)
+}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_qrcode.go b/backend/app/api/handlers/v1/v1_ctrl_qrcode.go
index 5055274..25f7c75 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_qrcode.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_qrcode.go
@@ -5,9 +5,10 @@ import (
"image/png"
"io"
"net/http"
+ "net/url"
- "github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
"github.com/yeqown/go-qrcode/v2"
"github.com/yeqown/go-qrcode/writer/standard"
@@ -19,32 +20,36 @@ var qrcodeLogo []byte
// HandleGenerateQRCode godoc
//
-// @Summary Encode data into QRCode
+// @Summary Create QR Code
// @Tags Items
// @Produce json
// @Param data query string false "data to be encoded into qrcode"
// @Success 200 {string} string "image/jpeg"
// @Router /v1/qrcode [GET]
// @Security Bearer
-func (ctrl *V1Controller) HandleGenerateQRCode() server.HandlerFunc {
- const MaxLength = 4_296 // assume alphanumeric characters only
+func (ctrl *V1Controller) HandleGenerateQRCode() errchain.HandlerFunc {
+ type query struct {
+ // 4,296 characters is the maximum length of a QR code
+ Data string `schema:"data" validate:"required,max=4296"`
+ }
return func(w http.ResponseWriter, r *http.Request) error {
- data := r.URL.Query().Get("data")
+ q, err := adapters.DecodeQuery[query](r)
+ if err != nil {
+ return err
+ }
image, err := png.Decode(bytes.NewReader(qrcodeLogo))
if err != nil {
panic(err)
}
- if len(data) > MaxLength {
- return validate.NewFieldErrors(validate.FieldError{
- Field: "data",
- Error: "max length is 4,296 characters exceeded",
- })
+ decodedStr, err := url.QueryUnescape(q.Data)
+ if err != nil {
+ return err
}
- qrc, err := qrcode.New(data)
+ qrc, err := qrcode.New(decodedStr)
if err != nil {
return err
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_reporting.go b/backend/app/api/handlers/v1/v1_ctrl_reporting.go
new file mode 100644
index 0000000..40f0d22
--- /dev/null
+++ b/backend/app/api/handlers/v1/v1_ctrl_reporting.go
@@ -0,0 +1,32 @@
+package v1
+
+import (
+ "net/http"
+
+ "github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/httpkit/errchain"
+)
+
+// HandleBillOfMaterialsExport godoc
+//
+// @Summary Export Bill of Materials
+// @Tags Reporting
+// @Produce json
+// @Success 200 {string} string "text/csv"
+// @Router /v1/reporting/bill-of-materials [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleBillOfMaterialsExport() errchain.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) error {
+ actor := services.UseUserCtx(r.Context())
+
+ csv, err := ctrl.svc.Items.ExportBillOfMaterialsTSV(r.Context(), actor.GroupID)
+ if err != nil {
+ return err
+ }
+
+ w.Header().Set("Content-Type", "text/tsv")
+ w.Header().Set("Content-Disposition", "attachment; filename=bill-of-materials.tsv")
+ _, err = w.Write(csv)
+ return err
+ }
+}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_statistics.go b/backend/app/api/handlers/v1/v1_ctrl_statistics.go
index 6c09bc6..0a5a319 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_statistics.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_statistics.go
@@ -5,80 +5,75 @@ import (
"time"
"github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/homebox/backend/internal/web/adapters"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
)
-// HandleGroupGet godoc
-// @Summary Get the current user's group statistics
-// @Tags Statistics
-// @Produce json
-// @Success 200 {object} []repo.TotalsByOrganizer
-// @Router /v1/groups/statistics/locations [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupStatisticsLocations() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
-
- stats, err := ctrl.repo.Groups.StatsLocationsByPurchasePrice(ctx, ctx.GID)
- if err != nil {
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, stats)
+// HandleGroupStatisticsLocations godoc
+//
+// @Summary Get Location Statistics
+// @Tags Statistics
+// @Produce json
+// @Success 200 {object} []repo.TotalsByOrganizer
+// @Router /v1/groups/statistics/locations [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupStatisticsLocations() errchain.HandlerFunc {
+ fn := func(r *http.Request) ([]repo.TotalsByOrganizer, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Groups.StatsLocationsByPurchasePrice(auth, auth.GID)
}
+
+ return adapters.Command(fn, http.StatusOK)
}
-// HandleGroupGet godoc
-// @Summary Get the current user's group statistics
-// @Tags Statistics
-// @Produce json
-// @Success 200 {object} []repo.TotalsByOrganizer
-// @Router /v1/groups/statistics/labels [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupStatisticsLabels() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
-
- stats, err := ctrl.repo.Groups.StatsLabelsByPurchasePrice(ctx, ctx.GID)
- if err != nil {
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, stats)
+// HandleGroupStatisticsLabels godoc
+//
+// @Summary Get Label Statistics
+// @Tags Statistics
+// @Produce json
+// @Success 200 {object} []repo.TotalsByOrganizer
+// @Router /v1/groups/statistics/labels [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupStatisticsLabels() errchain.HandlerFunc {
+ fn := func(r *http.Request) ([]repo.TotalsByOrganizer, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Groups.StatsLabelsByPurchasePrice(auth, auth.GID)
}
+
+ return adapters.Command(fn, http.StatusOK)
}
-// HandleGroupGet godoc
-// @Summary Get the current user's group statistics
-// @Tags Statistics
-// @Produce json
-// @Success 200 {object} repo.GroupStatistics
-// @Router /v1/groups/statistics [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupStatistics() server.HandlerFunc {
- return func(w http.ResponseWriter, r *http.Request) error {
- ctx := services.NewContext(r.Context())
-
- stats, err := ctrl.repo.Groups.StatsGroup(ctx, ctx.GID)
- if err != nil {
- return validate.NewRequestError(err, http.StatusInternalServerError)
- }
-
- return server.Respond(w, http.StatusOK, stats)
+// HandleGroupStatistics godoc
+//
+// @Summary Get Group Statistics
+// @Tags Statistics
+// @Produce json
+// @Success 200 {object} repo.GroupStatistics
+// @Router /v1/groups/statistics [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupStatistics() errchain.HandlerFunc {
+ fn := func(r *http.Request) (repo.GroupStatistics, error) {
+ auth := services.NewContext(r.Context())
+ return ctrl.repo.Groups.StatsGroup(auth, auth.GID)
}
+
+ return adapters.Command(fn, http.StatusOK)
}
-// HandleGroupGet godoc
-// @Summary Queries the changes overtime of the purchase price over time
-// @Tags Statistics
-// @Produce json
-// @Success 200 {object} repo.ValueOverTime
-// @Param start query string false "start date"
-// @Param end query string false "end date"
-// @Router /v1/groups/statistics/purchase-price [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleGroupStatisticsPriceOverTime() server.HandlerFunc {
+// HandleGroupStatisticsPriceOverTime godoc
+//
+// @Summary Get Purchase Price Statistics
+// @Tags Statistics
+// @Produce json
+// @Success 200 {object} repo.ValueOverTime
+// @Param start query string false "start date"
+// @Param end query string false "end date"
+// @Router /v1/groups/statistics/purchase-price [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleGroupStatisticsPriceOverTime() errchain.HandlerFunc {
parseDate := func(datestr string, defaultDate time.Time) (time.Time, error) {
if datestr == "" {
return defaultDate, nil
@@ -104,6 +99,6 @@ func (ctrl *V1Controller) HandleGroupStatisticsPriceOverTime() server.HandlerFun
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, stats)
+ return server.JSON(w, http.StatusOK, stats)
}
}
diff --git a/backend/app/api/handlers/v1/v1_ctrl_user.go b/backend/app/api/handlers/v1/v1_ctrl_user.go
index 565a723..8708d24 100644
--- a/backend/app/api/handlers/v1/v1_ctrl_user.go
+++ b/backend/app/api/handlers/v1/v1_ctrl_user.go
@@ -1,24 +1,27 @@
package v1
import (
+ "fmt"
"net/http"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/core/services"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/server"
"github.com/rs/zerolog/log"
)
-// HandleUserSelf godoc
-// @Summary Get the current user
-// @Tags User
-// @Produce json
-// @Param payload body services.UserRegistration true "User Data"
-// @Success 204
-// @Router /v1/users/register [Post]
-func (ctrl *V1Controller) HandleUserRegistration() server.HandlerFunc {
+// HandleUserRegistration godoc
+//
+// @Summary Register New User
+// @Tags User
+// @Produce json
+// @Param payload body services.UserRegistration true "User Data"
+// @Success 204
+// @Router /v1/users/register [Post]
+func (ctrl *V1Controller) HandleUserRegistration() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
regData := services.UserRegistration{}
@@ -28,7 +31,7 @@ func (ctrl *V1Controller) HandleUserRegistration() server.HandlerFunc {
}
if !ctrl.allowRegistration && regData.GroupToken == "" {
- return validate.NewRequestError(nil, http.StatusForbidden)
+ return validate.NewRequestError(fmt.Errorf("user registration disabled"), http.StatusForbidden)
}
_, err := ctrl.svc.User.RegisterUser(r.Context(), regData)
@@ -37,18 +40,19 @@ func (ctrl *V1Controller) HandleUserRegistration() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ return server.JSON(w, http.StatusNoContent, nil)
}
}
// HandleUserSelf godoc
-// @Summary Get the current user
-// @Tags User
-// @Produce json
-// @Success 200 {object} server.Result{item=repo.UserOut}
-// @Router /v1/users/self [GET]
-// @Security Bearer
-func (ctrl *V1Controller) HandleUserSelf() server.HandlerFunc {
+//
+// @Summary Get User Self
+// @Tags User
+// @Produce json
+// @Success 200 {object} Wrapped{item=repo.UserOut}
+// @Router /v1/users/self [GET]
+// @Security Bearer
+func (ctrl *V1Controller) HandleUserSelf() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
token := services.UseTokenCtx(r.Context())
usr, err := ctrl.svc.User.GetSelf(r.Context(), token)
@@ -57,19 +61,20 @@ func (ctrl *V1Controller) HandleUserSelf() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, server.Wrap(usr))
+ return server.JSON(w, http.StatusOK, Wrap(usr))
}
}
// HandleUserSelfUpdate godoc
-// @Summary Update the current user
-// @Tags User
-// @Produce json
-// @Param payload body repo.UserUpdate true "User Data"
-// @Success 200 {object} server.Result{item=repo.UserUpdate}
-// @Router /v1/users/self [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleUserSelfUpdate() server.HandlerFunc {
+//
+// @Summary Update Account
+// @Tags User
+// @Produce json
+// @Param payload body repo.UserUpdate true "User Data"
+// @Success 200 {object} Wrapped{item=repo.UserUpdate}
+// @Router /v1/users/self [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleUserSelfUpdate() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
updateData := repo.UserUpdate{}
if err := server.Decode(r, &updateData); err != nil {
@@ -79,23 +84,23 @@ func (ctrl *V1Controller) HandleUserSelfUpdate() server.HandlerFunc {
actor := services.UseUserCtx(r.Context())
newData, err := ctrl.svc.User.UpdateSelf(r.Context(), actor.ID, updateData)
-
if err != nil {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusOK, server.Wrap(newData))
+ return server.JSON(w, http.StatusOK, Wrap(newData))
}
}
// HandleUserSelfDelete godoc
-// @Summary Deletes the user account
-// @Tags User
-// @Produce json
-// @Success 204
-// @Router /v1/users/self [DELETE]
-// @Security Bearer
-func (ctrl *V1Controller) HandleUserSelfDelete() server.HandlerFunc {
+//
+// @Summary Delete Account
+// @Tags User
+// @Produce json
+// @Success 204
+// @Router /v1/users/self [DELETE]
+// @Security Bearer
+func (ctrl *V1Controller) HandleUserSelfDelete() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
if ctrl.isDemo {
return validate.NewRequestError(nil, http.StatusForbidden)
@@ -106,7 +111,7 @@ func (ctrl *V1Controller) HandleUserSelfDelete() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ return server.JSON(w, http.StatusNoContent, nil)
}
}
@@ -118,13 +123,14 @@ type (
)
// HandleUserSelfChangePassword godoc
-// @Summary Updates the users password
-// @Tags User
-// @Success 204
-// @Param payload body ChangePassword true "Password Payload"
-// @Router /v1/users/change-password [PUT]
-// @Security Bearer
-func (ctrl *V1Controller) HandleUserSelfChangePassword() server.HandlerFunc {
+//
+// @Summary Change Password
+// @Tags User
+// @Success 204
+// @Param payload body ChangePassword true "Password Payload"
+// @Router /v1/users/change-password [PUT]
+// @Security Bearer
+func (ctrl *V1Controller) HandleUserSelfChangePassword() errchain.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) error {
if ctrl.isDemo {
return validate.NewRequestError(nil, http.StatusForbidden)
@@ -143,6 +149,6 @@ func (ctrl *V1Controller) HandleUserSelfChangePassword() server.HandlerFunc {
return validate.NewRequestError(err, http.StatusInternalServerError)
}
- return server.Respond(w, http.StatusNoContent, nil)
+ return server.JSON(w, http.StatusNoContent, nil)
}
}
diff --git a/backend/app/api/logger.go b/backend/app/api/logger.go
index ddc574f..34659c6 100644
--- a/backend/app/api/logger.go
+++ b/backend/app/api/logger.go
@@ -2,7 +2,6 @@ package main
import (
"os"
- "strings"
"github.com/hay-kot/homebox/backend/internal/sys/config"
"github.com/rs/zerolog"
@@ -18,24 +17,8 @@ func (a *app) setupLogger() {
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).With().Caller().Logger()
}
- log.Level(getLevel(a.conf.Log.Level))
-}
-
-func getLevel(l string) zerolog.Level {
- switch strings.ToLower(l) {
- case "debug":
- return zerolog.DebugLevel
- case "info":
- return zerolog.InfoLevel
- case "warn":
- return zerolog.WarnLevel
- case "error":
- return zerolog.ErrorLevel
- case "fatal":
- return zerolog.FatalLevel
- case "panic":
- return zerolog.PanicLevel
- default:
- return zerolog.InfoLevel
+ level, err := zerolog.ParseLevel(a.conf.Log.Level)
+ if err == nil {
+ zerolog.SetGlobalLevel(level)
}
}
diff --git a/backend/app/api/main.go b/backend/app/api/main.go
index c505eea..4811bfa 100644
--- a/backend/app/api/main.go
+++ b/backend/app/api/main.go
@@ -1,7 +1,9 @@
package main
import (
+ "bytes"
"context"
+ "fmt"
"net/http"
"os"
"path/filepath"
@@ -9,16 +11,24 @@ import (
atlas "ariga.io/atlas/sql/migrate"
"entgo.io/ent/dialect/sql/schema"
- "github.com/hay-kot/homebox/backend/app/api/static/docs"
+ "github.com/go-chi/chi/v5"
+ "github.com/go-chi/chi/v5/middleware"
+
+ "github.com/hay-kot/homebox/backend/internal/core/currencies"
"github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/core/services/reporting/eventbus"
"github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/data/migrations"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/internal/sys/config"
"github.com/hay-kot/homebox/backend/internal/web/mid"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- _ "github.com/mattn/go-sqlite3"
+ "github.com/hay-kot/httpkit/errchain"
+ "github.com/hay-kot/httpkit/graceful"
+ "github.com/rs/zerolog"
"github.com/rs/zerolog/log"
+ "github.com/rs/zerolog/pkgerrors"
+
+ _ "github.com/hay-kot/homebox/backend/pkgs/cgofreesqlite"
)
var (
@@ -27,24 +37,32 @@ var (
buildTime = "now"
)
-// @title Go API Templates
+func build() string {
+ short := commit
+ if len(short) > 7 {
+ short = short[:7]
+ }
+
+ return fmt.Sprintf("%s, commit %s, built at %s", version, short, buildTime)
+}
+
+// @title Homebox API
// @version 1.0
-// @description This is a simple Rest API Server Template that implements some basic User and Authentication patterns to help you get started and bootstrap your next project!.
+// @description Track, Manage, and Organize your Things.
// @contact.name Don't
-// @license.name MIT
// @BasePath /api
// @securityDefinitions.apikey Bearer
// @in header
// @name Authorization
// @description "Type 'Bearer TOKEN' to correctly set the API Key"
func main() {
- cfg, err := config.New()
+ zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
+
+ cfg, err := config.New(build(), "Homebox inventory management system")
if err != nil {
panic(err)
}
- docs.SwaggerInfo.Host = cfg.Swagger.Host
-
if err := run(cfg); err != nil {
panic(err)
}
@@ -57,17 +75,17 @@ func run(cfg *config.Config) error {
// =========================================================================
// Initialize Database & Repos
- err := os.MkdirAll(cfg.Storage.Data, 0755)
+ err := os.MkdirAll(cfg.Storage.Data, 0o755)
if err != nil {
log.Fatal().Err(err).Msg("failed to create data directory")
}
- c, err := ent.Open("sqlite3", cfg.Storage.SqliteUrl)
+ c, err := ent.Open("sqlite3", cfg.Storage.SqliteURL)
if err != nil {
log.Fatal().
Err(err).
Str("driver", "sqlite").
- Str("url", cfg.Storage.SqliteUrl).
+ Str("url", cfg.Storage.SqliteURL).
Msg("failed opening connection to sqlite")
}
defer func(c *ent.Client) {
@@ -100,7 +118,7 @@ func run(cfg *config.Config) error {
log.Fatal().
Err(err).
Str("driver", "sqlite").
- Str("url", cfg.Storage.SqliteUrl).
+ Str("url", cfg.Storage.SqliteURL).
Msg("failed creating schema resources")
}
@@ -110,70 +128,145 @@ func run(cfg *config.Config) error {
return err
}
+ collectFuncs := []currencies.CollectorFunc{
+ currencies.CollectDefaults(),
+ }
+
+ if cfg.Options.CurrencyConfig != "" {
+ log.Info().
+ Str("path", cfg.Options.CurrencyConfig).
+ Msg("loading currency config file")
+
+ content, err := os.ReadFile(cfg.Options.CurrencyConfig)
+ if err != nil {
+ log.Fatal().
+ Err(err).
+ Str("path", cfg.Options.CurrencyConfig).
+ Msg("failed to read currency config file")
+ }
+
+ collectFuncs = append(collectFuncs, currencies.CollectJSON(bytes.NewReader(content)))
+ }
+
+ currencies, err := currencies.CollectionCurrencies(collectFuncs...)
+ if err != nil {
+ log.Fatal().
+ Err(err).
+ Msg("failed to collect currencies")
+ }
+
+ app.bus = eventbus.New()
app.db = c
- app.repos = repo.New(c, cfg.Storage.Data)
+ app.repos = repo.New(c, app.bus, cfg.Storage.Data)
app.services = services.New(
app.repos,
services.WithAutoIncrementAssetID(cfg.Options.AutoIncrementAssetID),
+ services.WithCurrencies(currencies),
)
// =========================================================================
- // Start Server\
+ // Start Server
+
logger := log.With().Caller().Logger()
- mwLogger := mid.Logger(logger)
- if app.conf.Mode == config.ModeDevelopment {
- mwLogger = mid.SugarLogger(logger)
- }
-
- app.server = server.NewServer(
- server.WithHost(app.conf.Web.Host),
- server.WithPort(app.conf.Web.Port),
- server.WithMiddleware(
- mwLogger,
- mid.Errors(logger),
- mid.Panic(app.conf.Mode == config.ModeDevelopment),
- ),
+ router := chi.NewMux()
+ router.Use(
+ middleware.RequestID,
+ middleware.RealIP,
+ mid.Logger(logger),
+ middleware.Recoverer,
+ middleware.StripSlashes,
)
- app.mountRoutes(app.repos)
+ chain := errchain.New(mid.Errors(logger))
- log.Info().Msgf("Starting HTTP Server on %s:%s", app.server.Host, app.server.Port)
+ app.mountRoutes(router, chain, app.repos)
+
+ runner := graceful.NewRunner()
+
+ runner.AddFunc("server", func(ctx context.Context) error {
+ httpserver := http.Server{
+ Addr: fmt.Sprintf("%s:%s", cfg.Web.Host, cfg.Web.Port),
+ Handler: router,
+ ReadTimeout: cfg.Web.ReadTimeout,
+ WriteTimeout: cfg.Web.WriteTimeout,
+ IdleTimeout: cfg.Web.IdleTimeout,
+ }
+
+ go func() {
+ <-ctx.Done()
+ _ = httpserver.Shutdown(context.Background())
+ }()
+
+ log.Info().Msgf("Server is running on %s:%s", cfg.Web.Host, cfg.Web.Port)
+ return httpserver.ListenAndServe()
+ })
// =========================================================================
// Start Reoccurring Tasks
- go app.startBgTask(time.Duration(24)*time.Hour, func() {
- _, err := app.repos.AuthTokens.PurgeExpiredTokens(context.Background())
+ runner.AddFunc("eventbus", app.bus.Run)
+
+ runner.AddFunc("seed_database", func(ctx context.Context) error {
+ // TODO: Remove through external API that does setup
+ if cfg.Demo {
+ log.Info().Msg("Running in demo mode, creating demo data")
+ app.SetupDemo()
+ }
+ return nil
+ })
+
+ runner.AddPlugin(NewTask("purge-tokens", time.Duration(24)*time.Hour, func(ctx context.Context) {
+ _, err := app.repos.AuthTokens.PurgeExpiredTokens(ctx)
if err != nil {
log.Error().
Err(err).
Msg("failed to purge expired tokens")
}
- })
- go app.startBgTask(time.Duration(24)*time.Hour, func() {
- _, err := app.repos.Groups.InvitationPurge(context.Background())
+ }))
+
+ runner.AddPlugin(NewTask("purge-invitations", time.Duration(24)*time.Hour, func(ctx context.Context) {
+ _, err := app.repos.Groups.InvitationPurge(ctx)
if err != nil {
log.Error().
Err(err).
Msg("failed to purge expired invitations")
}
- })
+ }))
- // TODO: Remove through external API that does setup
- if cfg.Demo {
- log.Info().Msg("Running in demo mode, creating demo data")
- app.SetupDemo()
- }
+ runner.AddPlugin(NewTask("send-notifications", time.Duration(1)*time.Hour, func(ctx context.Context) {
+ now := time.Now()
+
+ if now.Hour() == 8 {
+ fmt.Println("run notifiers")
+ err := app.services.BackgroundService.SendNotifiersToday(context.Background())
+ if err != nil {
+ log.Error().
+ Err(err).
+ Msg("failed to send notifiers")
+ }
+ }
+ }))
if cfg.Debug.Enabled {
- debugrouter := app.debugRouter()
- go func() {
- if err := http.ListenAndServe(":"+cfg.Debug.Port, debugrouter); err != nil {
- log.Fatal().Err(err).Msg("failed to start debug server")
+ runner.AddFunc("debug", func(ctx context.Context) error {
+ debugserver := http.Server{
+ Addr: fmt.Sprintf("%s:%s", cfg.Web.Host, cfg.Debug.Port),
+ Handler: app.debugRouter(),
+ ReadTimeout: cfg.Web.ReadTimeout,
+ WriteTimeout: cfg.Web.WriteTimeout,
+ IdleTimeout: cfg.Web.IdleTimeout,
}
- }()
+
+ go func() {
+ <-ctx.Done()
+ _ = debugserver.Shutdown(context.Background())
+ }()
+
+ log.Info().Msgf("Debug server is running on %s:%s", cfg.Web.Host, cfg.Debug.Port)
+ return debugserver.ListenAndServe()
+ })
}
- return app.server.Start()
+ return runner.Start(context.Background())
}
diff --git a/backend/app/api/middleware.go b/backend/app/api/middleware.go
index 8baddfb..02b3a6c 100644
--- a/backend/app/api/middleware.go
+++ b/backend/app/api/middleware.go
@@ -4,20 +4,21 @@ import (
"context"
"errors"
"net/http"
+ "net/url"
"strings"
+ v1 "github.com/hay-kot/homebox/backend/app/api/handlers/v1"
"github.com/hay-kot/homebox/backend/internal/core/services"
+ "github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/sys/validate"
- "github.com/hay-kot/homebox/backend/pkgs/server"
+ "github.com/hay-kot/httpkit/errchain"
)
type tokenHasKey struct {
key string
}
-var (
- hashedToken = tokenHasKey{key: "hashedToken"}
-)
+var hashedToken = tokenHasKey{key: "hashedToken"}
type RoleMode int
@@ -31,9 +32,9 @@ const (
// the required roles, a 403 Forbidden will be returned.
//
// WARNING: This middleware _MUST_ be called after mwAuthToken or else it will panic
-func (a *app) mwRoles(rm RoleMode, required ...string) server.Middleware {
- return func(next server.Handler) server.Handler {
- return server.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
+func (a *app) mwRoles(rm RoleMode, required ...string) errchain.Middleware {
+ return func(next errchain.Handler) errchain.Handler {
+ return errchain.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
ctx := r.Context()
maybeToken := ctx.Value(hashedToken)
@@ -70,6 +71,31 @@ func (a *app) mwRoles(rm RoleMode, required ...string) server.Middleware {
}
}
+type KeyFunc func(r *http.Request) (string, error)
+
+func getBearer(r *http.Request) (string, error) {
+ auth := r.Header.Get("Authorization")
+ if auth == "" {
+ return "", errors.New("authorization header is required")
+ }
+
+ return auth, nil
+}
+
+func getQuery(r *http.Request) (string, error) {
+ token := r.URL.Query().Get("access_token")
+ if token == "" {
+ return "", errors.New("access_token query is required")
+ }
+
+ token, err := url.QueryUnescape(token)
+ if err != nil {
+ return "", errors.New("access_token query is required")
+ }
+
+ return token, nil
+}
+
// mwAuthToken is a middleware that will check the database for a stateful token
// and attach it's user to the request context, or return an appropriate error.
// Authorization support is by token via Headers or Query Parameter
@@ -77,26 +103,49 @@ func (a *app) mwRoles(rm RoleMode, required ...string) server.Middleware {
// Example:
// - header = "Bearer 1234567890"
// - query = "?access_token=1234567890"
-func (a *app) mwAuthToken(next server.Handler) server.Handler {
- return server.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
- requestToken := r.Header.Get("Authorization")
- if requestToken == "" {
- // check for query param
- requestToken = r.URL.Query().Get("access_token")
- if requestToken == "" {
- return validate.NewRequestError(errors.New("Authorization header or query is required"), http.StatusUnauthorized)
+func (a *app) mwAuthToken(next errchain.Handler) errchain.Handler {
+ return errchain.HandlerFunc(func(w http.ResponseWriter, r *http.Request) error {
+ var requestToken string
+
+ // We ignore the error to allow the next strategy to be attempted
+ {
+ cookies, _ := v1.GetCookies(r)
+ if cookies != nil {
+ requestToken = cookies.Token
}
}
+ if requestToken == "" {
+ keyFuncs := [...]KeyFunc{
+ getBearer,
+ getQuery,
+ }
+
+ for _, keyFunc := range keyFuncs {
+ token, err := keyFunc(r)
+ if err == nil {
+ requestToken = token
+ break
+ }
+ }
+ }
+
+ if requestToken == "" {
+ return validate.NewRequestError(errors.New("authorization header or query is required"), http.StatusUnauthorized)
+ }
+
requestToken = strings.TrimPrefix(requestToken, "Bearer ")
r = r.WithContext(context.WithValue(r.Context(), hashedToken, requestToken))
usr, err := a.services.User.GetSelf(r.Context(), requestToken)
-
// Check the database for the token
if err != nil {
- return validate.NewRequestError(errors.New("Authorization header is required"), http.StatusUnauthorized)
+ if ent.IsNotFound(err) {
+ return validate.NewRequestError(errors.New("valid authorization token is required"), http.StatusUnauthorized)
+ }
+
+ return err
}
r = r.WithContext(services.SetUserCtx(r.Context(), &usr, requestToken))
diff --git a/backend/app/api/providers/doc.go b/backend/app/api/providers/doc.go
new file mode 100644
index 0000000..f58615d
--- /dev/null
+++ b/backend/app/api/providers/doc.go
@@ -0,0 +1,2 @@
+// Package providers provides a authentication abstraction for the backend.
+package providers
diff --git a/backend/app/api/providers/extractors.go b/backend/app/api/providers/extractors.go
new file mode 100644
index 0000000..bc042a4
--- /dev/null
+++ b/backend/app/api/providers/extractors.go
@@ -0,0 +1,55 @@
+package providers
+
+import (
+ "errors"
+ "net/http"
+
+ "github.com/hay-kot/homebox/backend/internal/sys/validate"
+ "github.com/hay-kot/httpkit/server"
+ "github.com/rs/zerolog/log"
+)
+
+type LoginForm struct {
+ Username string `json:"username"`
+ Password string `json:"password"`
+ StayLoggedIn bool `json:"stayLoggedIn"`
+}
+
+func getLoginForm(r *http.Request) (LoginForm, error) {
+ loginForm := LoginForm{}
+
+ switch r.Header.Get("Content-Type") {
+ case "application/x-www-form-urlencoded":
+ err := r.ParseForm()
+ if err != nil {
+ return loginForm, errors.New("failed to parse form")
+ }
+
+ loginForm.Username = r.PostFormValue("username")
+ loginForm.Password = r.PostFormValue("password")
+ loginForm.StayLoggedIn = r.PostFormValue("stayLoggedIn") == "true"
+ case "application/json":
+ err := server.Decode(r, &loginForm)
+ if err != nil {
+ log.Err(err).Msg("failed to decode login form")
+ return loginForm, errors.New("failed to decode login form")
+ }
+ default:
+ return loginForm, errors.New("invalid content type")
+ }
+
+ if loginForm.Username == "" || loginForm.Password == "" {
+ return loginForm, validate.NewFieldErrors(
+ validate.FieldError{
+ Field: "username",
+ Error: "username or password is empty",
+ },
+ validate.FieldError{
+ Field: "password",
+ Error: "username or password is empty",
+ },
+ )
+ }
+
+ return loginForm, nil
+}
diff --git a/backend/app/api/providers/local.go b/backend/app/api/providers/local.go
new file mode 100644
index 0000000..991f51a
--- /dev/null
+++ b/backend/app/api/providers/local.go
@@ -0,0 +1,30 @@
+package providers
+
+import (
+ "net/http"
+
+ "github.com/hay-kot/homebox/backend/internal/core/services"
+)
+
+type LocalProvider struct {
+ service *services.UserService
+}
+
+func NewLocalProvider(service *services.UserService) *LocalProvider {
+ return &LocalProvider{
+ service: service,
+ }
+}
+
+func (p *LocalProvider) Name() string {
+ return "local"
+}
+
+func (p *LocalProvider) Authenticate(w http.ResponseWriter, r *http.Request) (services.UserAuthTokenDetail, error) {
+ loginForm, err := getLoginForm(r)
+ if err != nil {
+ return services.UserAuthTokenDetail{}, err
+ }
+
+ return p.service.Login(r.Context(), loginForm.Username, loginForm.Password, loginForm.StayLoggedIn)
+}
diff --git a/backend/app/api/routes.go b/backend/app/api/routes.go
index b5ae495..de10942 100644
--- a/backend/app/api/routes.go
+++ b/backend/app/api/routes.go
@@ -3,20 +3,21 @@ package main
import (
"embed"
"errors"
- "fmt"
"io"
"mime"
"net/http"
"path"
"path/filepath"
+ "github.com/go-chi/chi/v5"
"github.com/hay-kot/homebox/backend/app/api/handlers/debughandlers"
v1 "github.com/hay-kot/homebox/backend/app/api/handlers/v1"
+ "github.com/hay-kot/homebox/backend/app/api/providers"
_ "github.com/hay-kot/homebox/backend/app/api/static/docs"
"github.com/hay-kot/homebox/backend/internal/data/ent/authroles"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/hay-kot/homebox/backend/pkgs/server"
- httpSwagger "github.com/swaggo/http-swagger" // http-swagger middleware
+ "github.com/hay-kot/httpkit/errchain"
+ httpSwagger "github.com/swaggo/http-swagger/v2" // http-swagger middleware
)
const prefix = "/api"
@@ -36,102 +37,133 @@ func (a *app) debugRouter() *http.ServeMux {
}
// registerRoutes registers all the routes for the API
-func (a *app) mountRoutes(repos *repo.AllRepos) {
+func (a *app) mountRoutes(r *chi.Mux, chain *errchain.ErrChain, repos *repo.AllRepos) {
registerMimes()
- a.server.Get("/swagger/*", server.ToHandler(httpSwagger.Handler(
- httpSwagger.URL(fmt.Sprintf("%s://%s/swagger/doc.json", a.conf.Swagger.Scheme, a.conf.Swagger.Host)),
- )))
+ r.Get("/swagger/*", httpSwagger.Handler(
+ httpSwagger.URL("/swagger/doc.json"),
+ ))
// =========================================================================
// API Version 1
- v1Base := v1.BaseUrlFunc(prefix)
+ v1Base := v1.BaseURLFunc(prefix)
v1Ctrl := v1.NewControllerV1(
a.services,
a.repos,
+ a.bus,
v1.WithMaxUploadSize(a.conf.Web.MaxUploadSize),
v1.WithRegistration(a.conf.Options.AllowRegistration),
v1.WithDemoStatus(a.conf.Demo), // Disable Password Change in Demo Mode
)
- a.server.Get(v1Base("/status"), v1Ctrl.HandleBase(func() bool { return true }, v1.Build{
+ r.Get(v1Base("/status"), chain.ToHandlerFunc(v1Ctrl.HandleBase(func() bool { return true }, v1.Build{
Version: version,
Commit: commit,
BuildTime: buildTime,
- }))
+ })))
- a.server.Post(v1Base("/users/register"), v1Ctrl.HandleUserRegistration())
- a.server.Post(v1Base("/users/login"), v1Ctrl.HandleAuthLogin())
+ r.Get(v1Base("/currencies"), chain.ToHandlerFunc(v1Ctrl.HandleCurrency()))
- userMW := []server.Middleware{
+ providers := []v1.AuthProvider{
+ providers.NewLocalProvider(a.services.User),
+ }
+
+ r.Post(v1Base("/users/register"), chain.ToHandlerFunc(v1Ctrl.HandleUserRegistration()))
+ r.Post(v1Base("/users/login"), chain.ToHandlerFunc(v1Ctrl.HandleAuthLogin(providers...)))
+
+ userMW := []errchain.Middleware{
a.mwAuthToken,
a.mwRoles(RoleModeOr, authroles.RoleUser.String()),
}
- a.server.Get(v1Base("/users/self"), v1Ctrl.HandleUserSelf(), userMW...)
- a.server.Put(v1Base("/users/self"), v1Ctrl.HandleUserSelfUpdate(), userMW...)
- a.server.Delete(v1Base("/users/self"), v1Ctrl.HandleUserSelfDelete(), userMW...)
- a.server.Post(v1Base("/users/logout"), v1Ctrl.HandleAuthLogout(), userMW...)
- a.server.Get(v1Base("/users/refresh"), v1Ctrl.HandleAuthRefresh(), userMW...)
- a.server.Put(v1Base("/users/self/change-password"), v1Ctrl.HandleUserSelfChangePassword(), userMW...)
+ r.Get(v1Base("/ws/events"), chain.ToHandlerFunc(v1Ctrl.HandleCacheWS(), userMW...))
+ r.Get(v1Base("/users/self"), chain.ToHandlerFunc(v1Ctrl.HandleUserSelf(), userMW...))
+ r.Put(v1Base("/users/self"), chain.ToHandlerFunc(v1Ctrl.HandleUserSelfUpdate(), userMW...))
+ r.Delete(v1Base("/users/self"), chain.ToHandlerFunc(v1Ctrl.HandleUserSelfDelete(), userMW...))
+ r.Post(v1Base("/users/logout"), chain.ToHandlerFunc(v1Ctrl.HandleAuthLogout(), userMW...))
+ r.Get(v1Base("/users/refresh"), chain.ToHandlerFunc(v1Ctrl.HandleAuthRefresh(), userMW...))
+ r.Put(v1Base("/users/self/change-password"), chain.ToHandlerFunc(v1Ctrl.HandleUserSelfChangePassword(), userMW...))
- a.server.Post(v1Base("/groups/invitations"), v1Ctrl.HandleGroupInvitationsCreate(), userMW...)
- a.server.Get(v1Base("/groups/statistics"), v1Ctrl.HandleGroupStatistics(), userMW...)
- a.server.Get(v1Base("/groups/statistics/purchase-price"), v1Ctrl.HandleGroupStatisticsPriceOverTime(), userMW...)
- a.server.Get(v1Base("/groups/statistics/locations"), v1Ctrl.HandleGroupStatisticsLocations(), userMW...)
- a.server.Get(v1Base("/groups/statistics/labels"), v1Ctrl.HandleGroupStatisticsLabels(), userMW...)
+ r.Post(v1Base("/groups/invitations"), chain.ToHandlerFunc(v1Ctrl.HandleGroupInvitationsCreate(), userMW...))
+ r.Get(v1Base("/groups/statistics"), chain.ToHandlerFunc(v1Ctrl.HandleGroupStatistics(), userMW...))
+ r.Get(v1Base("/groups/statistics/purchase-price"), chain.ToHandlerFunc(v1Ctrl.HandleGroupStatisticsPriceOverTime(), userMW...))
+ r.Get(v1Base("/groups/statistics/locations"), chain.ToHandlerFunc(v1Ctrl.HandleGroupStatisticsLocations(), userMW...))
+ r.Get(v1Base("/groups/statistics/labels"), chain.ToHandlerFunc(v1Ctrl.HandleGroupStatisticsLabels(), userMW...))
// TODO: I don't like /groups being the URL for users
- a.server.Get(v1Base("/groups"), v1Ctrl.HandleGroupGet(), userMW...)
- a.server.Put(v1Base("/groups"), v1Ctrl.HandleGroupUpdate(), userMW...)
+ r.Get(v1Base("/groups"), chain.ToHandlerFunc(v1Ctrl.HandleGroupGet(), userMW...))
+ r.Put(v1Base("/groups"), chain.ToHandlerFunc(v1Ctrl.HandleGroupUpdate(), userMW...))
- a.server.Post(v1Base("/actions/ensure-asset-ids"), v1Ctrl.HandleEnsureAssetID(), userMW...)
+ r.Post(v1Base("/actions/ensure-asset-ids"), chain.ToHandlerFunc(v1Ctrl.HandleEnsureAssetID(), userMW...))
+ r.Post(v1Base("/actions/zero-item-time-fields"), chain.ToHandlerFunc(v1Ctrl.HandleItemDateZeroOut(), userMW...))
+ r.Post(v1Base("/actions/ensure-import-refs"), chain.ToHandlerFunc(v1Ctrl.HandleEnsureImportRefs(), userMW...))
+ r.Post(v1Base("/actions/set-primary-photos"), chain.ToHandlerFunc(v1Ctrl.HandleSetPrimaryPhotos(), userMW...))
- a.server.Get(v1Base("/locations"), v1Ctrl.HandleLocationGetAll(), userMW...)
- a.server.Post(v1Base("/locations"), v1Ctrl.HandleLocationCreate(), userMW...)
- a.server.Get(v1Base("/locations/{id}"), v1Ctrl.HandleLocationGet(), userMW...)
- a.server.Put(v1Base("/locations/{id}"), v1Ctrl.HandleLocationUpdate(), userMW...)
- a.server.Delete(v1Base("/locations/{id}"), v1Ctrl.HandleLocationDelete(), userMW...)
+ r.Get(v1Base("/locations"), chain.ToHandlerFunc(v1Ctrl.HandleLocationGetAll(), userMW...))
+ r.Post(v1Base("/locations"), chain.ToHandlerFunc(v1Ctrl.HandleLocationCreate(), userMW...))
+ r.Get(v1Base("/locations/tree"), chain.ToHandlerFunc(v1Ctrl.HandleLocationTreeQuery(), userMW...))
+ r.Get(v1Base("/locations/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLocationGet(), userMW...))
+ r.Put(v1Base("/locations/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLocationUpdate(), userMW...))
+ r.Delete(v1Base("/locations/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLocationDelete(), userMW...))
- a.server.Get(v1Base("/labels"), v1Ctrl.HandleLabelsGetAll(), userMW...)
- a.server.Post(v1Base("/labels"), v1Ctrl.HandleLabelsCreate(), userMW...)
- a.server.Get(v1Base("/labels/{id}"), v1Ctrl.HandleLabelGet(), userMW...)
- a.server.Put(v1Base("/labels/{id}"), v1Ctrl.HandleLabelUpdate(), userMW...)
- a.server.Delete(v1Base("/labels/{id}"), v1Ctrl.HandleLabelDelete(), userMW...)
+ r.Get(v1Base("/labels"), chain.ToHandlerFunc(v1Ctrl.HandleLabelsGetAll(), userMW...))
+ r.Post(v1Base("/labels"), chain.ToHandlerFunc(v1Ctrl.HandleLabelsCreate(), userMW...))
+ r.Get(v1Base("/labels/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLabelGet(), userMW...))
+ r.Put(v1Base("/labels/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLabelUpdate(), userMW...))
+ r.Delete(v1Base("/labels/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleLabelDelete(), userMW...))
- a.server.Get(v1Base("/items"), v1Ctrl.HandleItemsGetAll(), userMW...)
- a.server.Post(v1Base("/items/import"), v1Ctrl.HandleItemsImport(), userMW...)
- a.server.Post(v1Base("/items"), v1Ctrl.HandleItemsCreate(), userMW...)
- a.server.Get(v1Base("/items/{id}"), v1Ctrl.HandleItemGet(), userMW...)
- a.server.Put(v1Base("/items/{id}"), v1Ctrl.HandleItemUpdate(), userMW...)
- a.server.Delete(v1Base("/items/{id}"), v1Ctrl.HandleItemDelete(), userMW...)
+ r.Get(v1Base("/items"), chain.ToHandlerFunc(v1Ctrl.HandleItemsGetAll(), userMW...))
+ r.Post(v1Base("/items"), chain.ToHandlerFunc(v1Ctrl.HandleItemsCreate(), userMW...))
+ r.Post(v1Base("/items/import"), chain.ToHandlerFunc(v1Ctrl.HandleItemsImport(), userMW...))
+ r.Get(v1Base("/items/export"), chain.ToHandlerFunc(v1Ctrl.HandleItemsExport(), userMW...))
+ r.Get(v1Base("/items/fields"), chain.ToHandlerFunc(v1Ctrl.HandleGetAllCustomFieldNames(), userMW...))
+ r.Get(v1Base("/items/fields/values"), chain.ToHandlerFunc(v1Ctrl.HandleGetAllCustomFieldValues(), userMW...))
- a.server.Post(v1Base("/items/{id}/attachments"), v1Ctrl.HandleItemAttachmentCreate(), userMW...)
- a.server.Put(v1Base("/items/{id}/attachments/{attachment_id}"), v1Ctrl.HandleItemAttachmentUpdate(), userMW...)
- a.server.Delete(v1Base("/items/{id}/attachments/{attachment_id}"), v1Ctrl.HandleItemAttachmentDelete(), userMW...)
+ r.Get(v1Base("/items/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemGet(), userMW...))
+ r.Get(v1Base("/items/{id}/path"), chain.ToHandlerFunc(v1Ctrl.HandleItemFullPath(), userMW...))
+ r.Put(v1Base("/items/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemUpdate(), userMW...))
+ r.Patch(v1Base("/items/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemPatch(), userMW...))
+ r.Delete(v1Base("/items/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemDelete(), userMW...))
- a.server.Get(v1Base("/items/{id}/maintenance"), v1Ctrl.HandleMaintenanceEntryCreate(), userMW...)
- a.server.Post(v1Base("/items/{id}/maintenance"), v1Ctrl.HandleMaintenanceEntryCreate(), userMW...)
- a.server.Put(v1Base("/items/{id}/maintenance/{entry_id}"), v1Ctrl.HandleMaintenanceEntryUpdate(), userMW...)
- a.server.Delete(v1Base("/items/{id}/maintenance/{entry_id}"), v1Ctrl.HandleMaintenanceEntryDelete(), userMW...)
+ r.Post(v1Base("/items/{id}/attachments"), chain.ToHandlerFunc(v1Ctrl.HandleItemAttachmentCreate(), userMW...))
+ r.Put(v1Base("/items/{id}/attachments/{attachment_id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemAttachmentUpdate(), userMW...))
+ r.Delete(v1Base("/items/{id}/attachments/{attachment_id}"), chain.ToHandlerFunc(v1Ctrl.HandleItemAttachmentDelete(), userMW...))
- a.server.Get(v1Base("/asset/{id}"), v1Ctrl.HandleAssetGet(), userMW...)
+ r.Get(v1Base("/items/{id}/maintenance"), chain.ToHandlerFunc(v1Ctrl.HandleMaintenanceLogGet(), userMW...))
+ r.Post(v1Base("/items/{id}/maintenance"), chain.ToHandlerFunc(v1Ctrl.HandleMaintenanceEntryCreate(), userMW...))
+ r.Put(v1Base("/items/{id}/maintenance/{entry_id}"), chain.ToHandlerFunc(v1Ctrl.HandleMaintenanceEntryUpdate(), userMW...))
+ r.Delete(v1Base("/items/{id}/maintenance/{entry_id}"), chain.ToHandlerFunc(v1Ctrl.HandleMaintenanceEntryDelete(), userMW...))
+
+ r.Get(v1Base("/assets/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleAssetGet(), userMW...))
+
+ // Notifiers
+ r.Get(v1Base("/notifiers"), chain.ToHandlerFunc(v1Ctrl.HandleGetUserNotifiers(), userMW...))
+ r.Post(v1Base("/notifiers"), chain.ToHandlerFunc(v1Ctrl.HandleCreateNotifier(), userMW...))
+ r.Put(v1Base("/notifiers/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleUpdateNotifier(), userMW...))
+ r.Delete(v1Base("/notifiers/{id}"), chain.ToHandlerFunc(v1Ctrl.HandleDeleteNotifier(), userMW...))
+ r.Post(v1Base("/notifiers/test"), chain.ToHandlerFunc(v1Ctrl.HandlerNotifierTest(), userMW...))
// Asset-Like endpoints
- a.server.Get(
+ assetMW := []errchain.Middleware{
+ a.mwAuthToken,
+ a.mwRoles(RoleModeOr, authroles.RoleUser.String(), authroles.RoleAttachments.String()),
+ }
+
+ r.Get(
v1Base("/qrcode"),
- v1Ctrl.HandleGenerateQRCode(),
- a.mwAuthToken, a.mwRoles(RoleModeOr, authroles.RoleUser.String(), authroles.RoleAttachments.String()),
+ chain.ToHandlerFunc(v1Ctrl.HandleGenerateQRCode(), assetMW...),
)
- a.server.Get(
+ r.Get(
v1Base("/items/{id}/attachments/{attachment_id}"),
- v1Ctrl.HandleItemAttachmentGet(),
- a.mwAuthToken, a.mwRoles(RoleModeOr, authroles.RoleUser.String(), authroles.RoleAttachments.String()),
+ chain.ToHandlerFunc(v1Ctrl.HandleItemAttachmentGet(), assetMW...),
)
- a.server.NotFound(notFoundHandler())
+ // Reporting Services
+ r.Get(v1Base("/reporting/bill-of-materials"), chain.ToHandlerFunc(v1Ctrl.HandleBillOfMaterialsExport(), userMW...))
+
+ r.NotFound(chain.ToHandlerFunc(notFoundHandler()))
}
func registerMimes() {
@@ -148,13 +180,13 @@ func registerMimes() {
// notFoundHandler perform the main logic around handling the internal SPA embed and ensuring that
// the client side routing is handled correctly.
-func notFoundHandler() server.HandlerFunc {
+func notFoundHandler() errchain.HandlerFunc {
tryRead := func(fs embed.FS, prefix, requestedPath string, w http.ResponseWriter) error {
f, err := fs.Open(path.Join(prefix, requestedPath))
if err != nil {
return err
}
- defer f.Close()
+ defer func() { _ = f.Close() }()
stat, _ := f.Stat()
if stat.IsDir() {
diff --git a/backend/app/api/static/docs/docs.go b/backend/app/api/static/docs/docs.go
index 4aa7410..7c9a748 100644
--- a/backend/app/api/static/docs/docs.go
+++ b/backend/app/api/static/docs/docs.go
@@ -1,5 +1,4 @@
-// Package docs GENERATED BY SWAG; DO NOT EDIT
-// This file was generated by swaggo/swag
+// Package docs Code generated by swaggo/swag. DO NOT EDIT
package docs
import "github.com/swaggo/swag"
@@ -13,9 +12,6 @@ const docTemplate = `{
"contact": {
"name": "Don't"
},
- "license": {
- "name": "MIT"
- },
"version": "{{.Version}}"
},
"host": "{{.Host}}",
@@ -28,18 +24,94 @@ const docTemplate = `{
"Bearer": []
}
],
+ "description": "Ensures all items in the database have an asset ID",
"produces": [
"application/json"
],
"tags": [
- "Group"
+ "Actions"
],
- "summary": "Get the current user",
+ "summary": "Ensure Asset IDs",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/v1.EnsureAssetIDResult"
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/ensure-import-refs": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Ensures all items in the database have an import ref",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Ensures Import Refs",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/set-primary-photos": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Sets the first photo of each item as the primary photo",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Set Primary Photos",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/zero-item-time-fields": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Resets all item date fields to the beginning of the day",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Zero Out Time Fields",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
}
}
}
@@ -56,9 +128,9 @@ const docTemplate = `{
"application/json"
],
"tags": [
- "Assets"
+ "Items"
],
- "summary": "Gets an item by Asset ID",
+ "summary": "Get Item by Asset ID",
"parameters": [
{
"type": "string",
@@ -78,6 +150,25 @@ const docTemplate = `{
}
}
},
+ "/v1/currency": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Base"
+ ],
+ "summary": "Currency",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/currencies.Currency"
+ }
+ }
+ }
+ }
+ },
"/v1/groups": {
"get": {
"security": [
@@ -91,7 +182,7 @@ const docTemplate = `{
"tags": [
"Group"
],
- "summary": "Get the current user's group",
+ "summary": "Get Group",
"responses": {
"200": {
"description": "OK",
@@ -113,7 +204,7 @@ const docTemplate = `{
"tags": [
"Group"
],
- "summary": "Updates some fields of the current users group",
+ "summary": "Update Group",
"parameters": [
{
"description": "User Data",
@@ -148,7 +239,7 @@ const docTemplate = `{
"tags": [
"Group"
],
- "summary": "Get the current user",
+ "summary": "Create Group Invitation",
"parameters": [
{
"description": "User Data",
@@ -183,7 +274,7 @@ const docTemplate = `{
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Group Statistics",
"responses": {
"200": {
"description": "OK",
@@ -207,7 +298,7 @@ const docTemplate = `{
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Label Statistics",
"responses": {
"200": {
"description": "OK",
@@ -234,7 +325,7 @@ const docTemplate = `{
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Location Statistics",
"responses": {
"200": {
"description": "OK",
@@ -261,7 +352,7 @@ const docTemplate = `{
"tags": [
"Statistics"
],
- "summary": "Queries the changes overtime of the purchase price over time",
+ "summary": "Get Purchase Price Statistics",
"parameters": [
{
"type": "string",
@@ -299,7 +390,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "Get All Items",
+ "summary": "Query All Items",
"parameters": [
{
"type": "string",
@@ -338,6 +429,16 @@ const docTemplate = `{
"description": "location Ids",
"name": "locations",
"in": "query"
+ },
+ {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "collectionFormat": "multi",
+ "description": "parent Ids",
+ "name": "parentIds",
+ "in": "query"
}
],
"responses": {
@@ -361,7 +462,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "Create a new item",
+ "summary": "Create Item",
"parameters": [
{
"description": "Item Data",
@@ -373,11 +474,86 @@ const docTemplate = `{
}
}
],
+ "responses": {
+ "201": {
+ "description": "Created",
+ "schema": {
+ "$ref": "#/definitions/repo.ItemSummary"
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/export": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Export Items",
+ "responses": {
+ "200": {
+ "description": "text/csv",
+ "schema": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/fields": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get All Custom Field Names",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/repo.ItemSummary"
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/fields/values": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get All Custom Field Values",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
}
}
}
@@ -396,7 +572,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "imports items into the database",
+ "summary": "Import Items",
"parameters": [
{
"type": "file",
@@ -426,7 +602,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "Gets a item and fields",
+ "summary": "Get Item",
"parameters": [
{
"type": "string",
@@ -457,7 +633,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "updates a item",
+ "summary": "Update Item",
"parameters": [
{
"type": "string",
@@ -497,7 +673,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "deletes a item",
+ "summary": "Delete Item",
"parameters": [
{
"type": "string",
@@ -512,6 +688,46 @@ const docTemplate = `{
"description": "No Content"
}
}
+ },
+ "patch": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Update Item",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Item ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "description": "Item Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.ItemPatch"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.ItemOut"
+ }
+ }
+ }
}
},
"/v1/items/{id}/attachments": {
@@ -527,7 +743,7 @@ const docTemplate = `{
"tags": [
"Items Attachments"
],
- "summary": "imports items into the database",
+ "summary": "Create Item Attachment",
"parameters": [
{
"type": "string",
@@ -568,7 +784,7 @@ const docTemplate = `{
"422": {
"description": "Unprocessable Entity",
"schema": {
- "$ref": "#/definitions/server.ErrorResponse"
+ "$ref": "#/definitions/validate.ErrorResponse"
}
}
}
@@ -587,7 +803,7 @@ const docTemplate = `{
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Get Item Attachment",
"parameters": [
{
"type": "string",
@@ -622,7 +838,7 @@ const docTemplate = `{
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Update Item Attachment",
"parameters": [
{
"type": "string",
@@ -666,7 +882,7 @@ const docTemplate = `{
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Delete Item Attachment",
"parameters": [
{
"type": "string",
@@ -738,8 +954,8 @@ const docTemplate = `{
}
],
"responses": {
- "200": {
- "description": "OK",
+ "201": {
+ "description": "Created",
"schema": {
"$ref": "#/definitions/repo.MaintenanceEntry"
}
@@ -801,6 +1017,42 @@ const docTemplate = `{
}
}
},
+ "/v1/items/{id}/path": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get the full path of an item",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Item ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.ItemPath"
+ }
+ }
+ }
+ }
+ }
+ },
"/v1/labels": {
"get": {
"security": [
@@ -819,22 +1071,10 @@ const docTemplate = `{
"200": {
"description": "OK",
"schema": {
- "allOf": [
- {
- "$ref": "#/definitions/server.Results"
- },
- {
- "type": "object",
- "properties": {
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.LabelOut"
- }
- }
- }
- }
- ]
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.LabelOut"
+ }
}
}
}
@@ -851,7 +1091,7 @@ const docTemplate = `{
"tags": [
"Labels"
],
- "summary": "Create a new label",
+ "summary": "Create Label",
"parameters": [
{
"description": "Label Data",
@@ -886,7 +1126,7 @@ const docTemplate = `{
"tags": [
"Labels"
],
- "summary": "Gets a label and fields",
+ "summary": "Get Label",
"parameters": [
{
"type": "string",
@@ -917,7 +1157,7 @@ const docTemplate = `{
"tags": [
"Labels"
],
- "summary": "updates a label",
+ "summary": "Update Label",
"parameters": [
{
"type": "string",
@@ -948,7 +1188,7 @@ const docTemplate = `{
"tags": [
"Labels"
],
- "summary": "deletes a label",
+ "summary": "Delete Label",
"parameters": [
{
"type": "string",
@@ -991,22 +1231,10 @@ const docTemplate = `{
"200": {
"description": "OK",
"schema": {
- "allOf": [
- {
- "$ref": "#/definitions/server.Results"
- },
- {
- "type": "object",
- "properties": {
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.LocationOutCount"
- }
- }
- }
- }
- ]
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.LocationOutCount"
+ }
}
}
}
@@ -1023,7 +1251,7 @@ const docTemplate = `{
"tags": [
"Locations"
],
- "summary": "Create a new location",
+ "summary": "Create Location",
"parameters": [
{
"description": "Location Data",
@@ -1045,6 +1273,41 @@ const docTemplate = `{
}
}
},
+ "/v1/locations/tree": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Locations"
+ ],
+ "summary": "Get Locations Tree",
+ "parameters": [
+ {
+ "type": "boolean",
+ "description": "include items in response tree",
+ "name": "withItems",
+ "in": "query"
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.TreeItem"
+ }
+ }
+ }
+ }
+ }
+ },
"/v1/locations/{id}": {
"get": {
"security": [
@@ -1058,7 +1321,7 @@ const docTemplate = `{
"tags": [
"Locations"
],
- "summary": "Gets a location and fields",
+ "summary": "Get Location",
"parameters": [
{
"type": "string",
@@ -1089,7 +1352,7 @@ const docTemplate = `{
"tags": [
"Locations"
],
- "summary": "updates a location",
+ "summary": "Update Location",
"parameters": [
{
"type": "string",
@@ -1129,7 +1392,7 @@ const docTemplate = `{
"tags": [
"Locations"
],
- "summary": "deletes a location",
+ "summary": "Delete Location",
"parameters": [
{
"type": "string",
@@ -1146,6 +1409,167 @@ const docTemplate = `{
}
}
},
+ "/v1/notifiers": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Get Notifiers",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ }
+ },
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Create Notifier",
+ "parameters": [
+ {
+ "description": "Notifier Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierCreate"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ }
+ },
+ "/v1/notifiers/test": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Test Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "type": "string",
+ "description": "URL",
+ "name": "url",
+ "in": "query",
+ "required": true
+ }
+ ],
+ "responses": {
+ "204": {
+ "description": "No Content"
+ }
+ }
+ }
+ },
+ "/v1/notifiers/{id}": {
+ "put": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Update Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "description": "Notifier Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierUpdate"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ },
+ "delete": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Delete a Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "204": {
+ "description": "No Content"
+ }
+ }
+ }
+ },
"/v1/qrcode": {
"get": {
"security": [
@@ -1159,7 +1583,7 @@ const docTemplate = `{
"tags": [
"Items"
],
- "summary": "Encode data into QRCode",
+ "summary": "Create QR Code",
"parameters": [
{
"type": "string",
@@ -1178,6 +1602,30 @@ const docTemplate = `{
}
}
},
+ "/v1/reporting/bill-of-materials": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Reporting"
+ ],
+ "summary": "Export Bill of Materials",
+ "responses": {
+ "200": {
+ "description": "text/csv",
+ "schema": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ },
"/v1/status": {
"get": {
"produces": [
@@ -1186,12 +1634,12 @@ const docTemplate = `{
"tags": [
"Base"
],
- "summary": "Retrieves the basic information about the API",
+ "summary": "Application Info",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/v1.ApiSummary"
+ "$ref": "#/definitions/v1.APISummary"
}
}
}
@@ -1207,7 +1655,7 @@ const docTemplate = `{
"tags": [
"User"
],
- "summary": "Updates the users password",
+ "summary": "Change Password",
"parameters": [
{
"description": "Password Payload",
@@ -1253,6 +1701,21 @@ const docTemplate = `{
"description": "string",
"name": "password",
"in": "formData"
+ },
+ {
+ "description": "Login Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/v1.LoginForm"
+ }
+ },
+ {
+ "type": "string",
+ "description": "auth provider",
+ "name": "provider",
+ "in": "query"
}
],
"responses": {
@@ -1310,7 +1773,7 @@ const docTemplate = `{
"tags": [
"User"
],
- "summary": "Get the current user",
+ "summary": "Register New User",
"parameters": [
{
"description": "User Data",
@@ -1342,14 +1805,14 @@ const docTemplate = `{
"tags": [
"User"
],
- "summary": "Get the current user",
+ "summary": "Get User Self",
"responses": {
"200": {
"description": "OK",
"schema": {
"allOf": [
{
- "$ref": "#/definitions/server.Result"
+ "$ref": "#/definitions/v1.Wrapped"
},
{
"type": "object",
@@ -1376,7 +1839,7 @@ const docTemplate = `{
"tags": [
"User"
],
- "summary": "Update the current user",
+ "summary": "Update Account",
"parameters": [
{
"description": "User Data",
@@ -1394,7 +1857,7 @@ const docTemplate = `{
"schema": {
"allOf": [
{
- "$ref": "#/definitions/server.Result"
+ "$ref": "#/definitions/v1.Wrapped"
},
{
"type": "object",
@@ -1421,7 +1884,7 @@ const docTemplate = `{
"tags": [
"User"
],
- "summary": "Deletes the user account",
+ "summary": "Delete Account",
"responses": {
"204": {
"description": "No Content"
@@ -1431,6 +1894,23 @@ const docTemplate = `{
}
},
"definitions": {
+ "currencies.Currency": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "local": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "symbol": {
+ "type": "string"
+ }
+ }
+ },
"repo.DocumentOut": {
"type": "object",
"properties": {
@@ -1511,6 +1991,9 @@ const docTemplate = `{
"id": {
"type": "string"
},
+ "primary": {
+ "type": "boolean"
+ },
"type": {
"type": "string"
},
@@ -1522,6 +2005,9 @@ const docTemplate = `{
"repo.ItemAttachmentUpdate": {
"type": "object",
"properties": {
+ "primary": {
+ "type": "boolean"
+ },
"title": {
"type": "string"
},
@@ -1532,9 +2018,13 @@ const docTemplate = `{
},
"repo.ItemCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
"description": {
- "type": "string"
+ "type": "string",
+ "maxLength": 1000
},
"labelIds": {
"type": "array",
@@ -1547,7 +2037,9 @@ const docTemplate = `{
"type": "string"
},
"name": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
},
"parentId": {
"type": "string",
@@ -1573,9 +2065,6 @@ const docTemplate = `{
"textValue": {
"type": "string"
},
- "timeValue": {
- "type": "string"
- },
"type": {
"type": "string"
}
@@ -1597,12 +2086,6 @@ const docTemplate = `{
"$ref": "#/definitions/repo.ItemAttachment"
}
},
- "children": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"createdAt": {
"type": "string"
},
@@ -1618,6 +2101,9 @@ const docTemplate = `{
"id": {
"type": "string"
},
+ "imageId": {
+ "type": "string"
+ },
"insured": {
"type": "boolean"
},
@@ -1633,9 +2119,13 @@ const docTemplate = `{
},
"location": {
"description": "Edges",
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.LocationSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.LocationSummary"
+ "x-omitempty": true
},
"manufacturer": {
"type": "string"
@@ -1651,9 +2141,13 @@ const docTemplate = `{
"type": "string"
},
"parent": {
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.ItemSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.ItemSummary"
+ "x-omitempty": true
},
"purchaseFrom": {
"type": "string"
@@ -1697,6 +2191,33 @@ const docTemplate = `{
}
}
},
+ "repo.ItemPatch": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "integer",
+ "x-nullable": true,
+ "x-omitempty": true
+ }
+ }
+ },
+ "repo.ItemPath": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "type": {
+ "$ref": "#/definitions/repo.ItemType"
+ }
+ }
+ },
"repo.ItemSummary": {
"type": "object",
"properties": {
@@ -1712,6 +2233,9 @@ const docTemplate = `{
"id": {
"type": "string"
},
+ "imageId": {
+ "type": "string"
+ },
"insured": {
"type": "boolean"
},
@@ -1723,9 +2247,13 @@ const docTemplate = `{
},
"location": {
"description": "Edges",
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.LocationSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.LocationSummary"
+ "x-omitempty": true
},
"name": {
"type": "string"
@@ -1742,6 +2270,17 @@ const docTemplate = `{
}
}
},
+ "repo.ItemType": {
+ "type": "string",
+ "enum": [
+ "location",
+ "item"
+ ],
+ "x-enum-varnames": [
+ "ItemTypeLocation",
+ "ItemTypeItem"
+ ]
+ },
"repo.ItemUpdate": {
"type": "object",
"properties": {
@@ -1840,15 +2379,21 @@ const docTemplate = `{
},
"repo.LabelCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
"color": {
"type": "string"
},
"description": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255
},
"name": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
}
}
},
@@ -1864,12 +2409,6 @@ const docTemplate = `{
"id": {
"type": "string"
},
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"name": {
"type": "string"
},
@@ -1906,6 +2445,10 @@ const docTemplate = `{
},
"name": {
"type": "string"
+ },
+ "parentId": {
+ "type": "string",
+ "x-nullable": true
}
}
},
@@ -1927,12 +2470,6 @@ const docTemplate = `{
"id": {
"type": "string"
},
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"name": {
"type": "string"
},
@@ -2008,13 +2545,13 @@ const docTemplate = `{
"repo.MaintenanceEntry": {
"type": "object",
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
@@ -2023,42 +2560,54 @@ const docTemplate = `{
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
"repo.MaintenanceEntryCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
"repo.MaintenanceEntryUpdate": {
"type": "object",
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
@@ -2082,6 +2631,72 @@ const docTemplate = `{
}
}
},
+ "repo.NotifierCreate": {
+ "type": "object",
+ "required": [
+ "name",
+ "url"
+ ],
+ "properties": {
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
+ },
+ "url": {
+ "type": "string"
+ }
+ }
+ },
+ "repo.NotifierOut": {
+ "type": "object",
+ "properties": {
+ "createdAt": {
+ "type": "string"
+ },
+ "groupId": {
+ "type": "string"
+ },
+ "id": {
+ "type": "string"
+ },
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "updatedAt": {
+ "type": "string"
+ },
+ "userId": {
+ "type": "string"
+ }
+ }
+ },
+ "repo.NotifierUpdate": {
+ "type": "object",
+ "required": [
+ "name"
+ ],
+ "properties": {
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
+ },
+ "url": {
+ "type": "string",
+ "x-nullable": true
+ }
+ }
+ },
"repo.PaginationResult-repo_ItemSummary": {
"type": "object",
"properties": {
@@ -2116,6 +2731,26 @@ const docTemplate = `{
}
}
},
+ "repo.TreeItem": {
+ "type": "object",
+ "properties": {
+ "children": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.TreeItem"
+ }
+ },
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ }
+ }
+ },
"repo.UserOut": {
"type": "object",
"properties": {
@@ -2190,39 +2825,6 @@ const docTemplate = `{
}
}
},
- "server.ErrorResponse": {
- "type": "object",
- "properties": {
- "error": {
- "type": "string"
- },
- "fields": {
- "type": "object",
- "additionalProperties": {
- "type": "string"
- }
- }
- }
- },
- "server.Result": {
- "type": "object",
- "properties": {
- "details": {},
- "error": {
- "type": "boolean"
- },
- "item": {},
- "message": {
- "type": "string"
- }
- }
- },
- "server.Results": {
- "type": "object",
- "properties": {
- "items": {}
- }
- },
"services.UserRegistration": {
"type": "object",
"properties": {
@@ -2240,9 +2842,12 @@ const docTemplate = `{
}
}
},
- "v1.ApiSummary": {
+ "v1.APISummary": {
"type": "object",
"properties": {
+ "allowRegistration": {
+ "type": "boolean"
+ },
"build": {
"$ref": "#/definitions/v1.Build"
},
@@ -2266,6 +2871,14 @@ const docTemplate = `{
}
}
},
+ "v1.ActionAmountResult": {
+ "type": "object",
+ "properties": {
+ "completed": {
+ "type": "integer"
+ }
+ }
+ },
"v1.Build": {
"type": "object",
"properties": {
@@ -2291,14 +2904,6 @@ const docTemplate = `{
}
}
},
- "v1.EnsureAssetIDResult": {
- "type": "object",
- "properties": {
- "completed": {
- "type": "integer"
- }
- }
- },
"v1.GroupInvitation": {
"type": "object",
"properties": {
@@ -2315,12 +2920,17 @@ const docTemplate = `{
},
"v1.GroupInvitationCreate": {
"type": "object",
+ "required": [
+ "uses"
+ ],
"properties": {
"expiresAt": {
"type": "string"
},
"uses": {
- "type": "integer"
+ "type": "integer",
+ "maximum": 100,
+ "minimum": 1
}
}
},
@@ -2332,6 +2942,20 @@ const docTemplate = `{
}
}
},
+ "v1.LoginForm": {
+ "type": "object",
+ "properties": {
+ "password": {
+ "type": "string"
+ },
+ "stayLoggedIn": {
+ "type": "boolean"
+ },
+ "username": {
+ "type": "string"
+ }
+ }
+ },
"v1.TokenResponse": {
"type": "object",
"properties": {
@@ -2345,6 +2969,23 @@ const docTemplate = `{
"type": "string"
}
}
+ },
+ "v1.Wrapped": {
+ "type": "object",
+ "properties": {
+ "item": {}
+ }
+ },
+ "validate.ErrorResponse": {
+ "type": "object",
+ "properties": {
+ "error": {
+ "type": "string"
+ },
+ "fields": {
+ "type": "string"
+ }
+ }
}
},
"securityDefinitions": {
@@ -2363,10 +3004,12 @@ var SwaggerInfo = &swag.Spec{
Host: "",
BasePath: "/api",
Schemes: []string{},
- Title: "Go API Templates",
- Description: "This is a simple Rest API Server Template that implements some basic User and Authentication patterns to help you get started and bootstrap your next project!.",
+ Title: "Homebox API",
+ Description: "Track, Manage, and Organize your Things.",
InfoInstanceName: "swagger",
SwaggerTemplate: docTemplate,
+ LeftDelim: "{{",
+ RightDelim: "}}",
}
func init() {
diff --git a/backend/app/api/static/docs/swagger.json b/backend/app/api/static/docs/swagger.json
index 6e2c0cf..b10c93a 100644
--- a/backend/app/api/static/docs/swagger.json
+++ b/backend/app/api/static/docs/swagger.json
@@ -1,14 +1,11 @@
{
"swagger": "2.0",
"info": {
- "description": "This is a simple Rest API Server Template that implements some basic User and Authentication patterns to help you get started and bootstrap your next project!.",
- "title": "Go API Templates",
+ "description": "Track, Manage, and Organize your Things.",
+ "title": "Homebox API",
"contact": {
"name": "Don't"
},
- "license": {
- "name": "MIT"
- },
"version": "1.0"
},
"basePath": "/api",
@@ -20,18 +17,94 @@
"Bearer": []
}
],
+ "description": "Ensures all items in the database have an asset ID",
"produces": [
"application/json"
],
"tags": [
- "Group"
+ "Actions"
],
- "summary": "Get the current user",
+ "summary": "Ensure Asset IDs",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/v1.EnsureAssetIDResult"
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/ensure-import-refs": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Ensures all items in the database have an import ref",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Ensures Import Refs",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/set-primary-photos": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Sets the first photo of each item as the primary photo",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Set Primary Photos",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
+ }
+ }
+ }
+ }
+ },
+ "/v1/actions/zero-item-time-fields": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "description": "Resets all item date fields to the beginning of the day",
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Actions"
+ ],
+ "summary": "Zero Out Time Fields",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/v1.ActionAmountResult"
}
}
}
@@ -48,9 +121,9 @@
"application/json"
],
"tags": [
- "Assets"
+ "Items"
],
- "summary": "Gets an item by Asset ID",
+ "summary": "Get Item by Asset ID",
"parameters": [
{
"type": "string",
@@ -70,6 +143,25 @@
}
}
},
+ "/v1/currency": {
+ "get": {
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Base"
+ ],
+ "summary": "Currency",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/currencies.Currency"
+ }
+ }
+ }
+ }
+ },
"/v1/groups": {
"get": {
"security": [
@@ -83,7 +175,7 @@
"tags": [
"Group"
],
- "summary": "Get the current user's group",
+ "summary": "Get Group",
"responses": {
"200": {
"description": "OK",
@@ -105,7 +197,7 @@
"tags": [
"Group"
],
- "summary": "Updates some fields of the current users group",
+ "summary": "Update Group",
"parameters": [
{
"description": "User Data",
@@ -140,7 +232,7 @@
"tags": [
"Group"
],
- "summary": "Get the current user",
+ "summary": "Create Group Invitation",
"parameters": [
{
"description": "User Data",
@@ -175,7 +267,7 @@
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Group Statistics",
"responses": {
"200": {
"description": "OK",
@@ -199,7 +291,7 @@
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Label Statistics",
"responses": {
"200": {
"description": "OK",
@@ -226,7 +318,7 @@
"tags": [
"Statistics"
],
- "summary": "Get the current user's group statistics",
+ "summary": "Get Location Statistics",
"responses": {
"200": {
"description": "OK",
@@ -253,7 +345,7 @@
"tags": [
"Statistics"
],
- "summary": "Queries the changes overtime of the purchase price over time",
+ "summary": "Get Purchase Price Statistics",
"parameters": [
{
"type": "string",
@@ -291,7 +383,7 @@
"tags": [
"Items"
],
- "summary": "Get All Items",
+ "summary": "Query All Items",
"parameters": [
{
"type": "string",
@@ -330,6 +422,16 @@
"description": "location Ids",
"name": "locations",
"in": "query"
+ },
+ {
+ "type": "array",
+ "items": {
+ "type": "string"
+ },
+ "collectionFormat": "multi",
+ "description": "parent Ids",
+ "name": "parentIds",
+ "in": "query"
}
],
"responses": {
@@ -353,7 +455,7 @@
"tags": [
"Items"
],
- "summary": "Create a new item",
+ "summary": "Create Item",
"parameters": [
{
"description": "Item Data",
@@ -365,11 +467,86 @@
}
}
],
+ "responses": {
+ "201": {
+ "description": "Created",
+ "schema": {
+ "$ref": "#/definitions/repo.ItemSummary"
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/export": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Export Items",
+ "responses": {
+ "200": {
+ "description": "text/csv",
+ "schema": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/fields": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get All Custom Field Names",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/repo.ItemSummary"
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ }
+ },
+ "/v1/items/fields/values": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get All Custom Field Values",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
}
}
}
@@ -388,7 +565,7 @@
"tags": [
"Items"
],
- "summary": "imports items into the database",
+ "summary": "Import Items",
"parameters": [
{
"type": "file",
@@ -418,7 +595,7 @@
"tags": [
"Items"
],
- "summary": "Gets a item and fields",
+ "summary": "Get Item",
"parameters": [
{
"type": "string",
@@ -449,7 +626,7 @@
"tags": [
"Items"
],
- "summary": "updates a item",
+ "summary": "Update Item",
"parameters": [
{
"type": "string",
@@ -489,7 +666,7 @@
"tags": [
"Items"
],
- "summary": "deletes a item",
+ "summary": "Delete Item",
"parameters": [
{
"type": "string",
@@ -504,6 +681,46 @@
"description": "No Content"
}
}
+ },
+ "patch": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Update Item",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Item ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "description": "Item Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.ItemPatch"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.ItemOut"
+ }
+ }
+ }
}
},
"/v1/items/{id}/attachments": {
@@ -519,7 +736,7 @@
"tags": [
"Items Attachments"
],
- "summary": "imports items into the database",
+ "summary": "Create Item Attachment",
"parameters": [
{
"type": "string",
@@ -560,7 +777,7 @@
"422": {
"description": "Unprocessable Entity",
"schema": {
- "$ref": "#/definitions/server.ErrorResponse"
+ "$ref": "#/definitions/validate.ErrorResponse"
}
}
}
@@ -579,7 +796,7 @@
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Get Item Attachment",
"parameters": [
{
"type": "string",
@@ -614,7 +831,7 @@
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Update Item Attachment",
"parameters": [
{
"type": "string",
@@ -658,7 +875,7 @@
"tags": [
"Items Attachments"
],
- "summary": "retrieves an attachment for an item",
+ "summary": "Delete Item Attachment",
"parameters": [
{
"type": "string",
@@ -730,8 +947,8 @@
}
],
"responses": {
- "200": {
- "description": "OK",
+ "201": {
+ "description": "Created",
"schema": {
"$ref": "#/definitions/repo.MaintenanceEntry"
}
@@ -793,6 +1010,42 @@
}
}
},
+ "/v1/items/{id}/path": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Items"
+ ],
+ "summary": "Get the full path of an item",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Item ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.ItemPath"
+ }
+ }
+ }
+ }
+ }
+ },
"/v1/labels": {
"get": {
"security": [
@@ -811,22 +1064,10 @@
"200": {
"description": "OK",
"schema": {
- "allOf": [
- {
- "$ref": "#/definitions/server.Results"
- },
- {
- "type": "object",
- "properties": {
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.LabelOut"
- }
- }
- }
- }
- ]
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.LabelOut"
+ }
}
}
}
@@ -843,7 +1084,7 @@
"tags": [
"Labels"
],
- "summary": "Create a new label",
+ "summary": "Create Label",
"parameters": [
{
"description": "Label Data",
@@ -878,7 +1119,7 @@
"tags": [
"Labels"
],
- "summary": "Gets a label and fields",
+ "summary": "Get Label",
"parameters": [
{
"type": "string",
@@ -909,7 +1150,7 @@
"tags": [
"Labels"
],
- "summary": "updates a label",
+ "summary": "Update Label",
"parameters": [
{
"type": "string",
@@ -940,7 +1181,7 @@
"tags": [
"Labels"
],
- "summary": "deletes a label",
+ "summary": "Delete Label",
"parameters": [
{
"type": "string",
@@ -983,22 +1224,10 @@
"200": {
"description": "OK",
"schema": {
- "allOf": [
- {
- "$ref": "#/definitions/server.Results"
- },
- {
- "type": "object",
- "properties": {
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.LocationOutCount"
- }
- }
- }
- }
- ]
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.LocationOutCount"
+ }
}
}
}
@@ -1015,7 +1244,7 @@
"tags": [
"Locations"
],
- "summary": "Create a new location",
+ "summary": "Create Location",
"parameters": [
{
"description": "Location Data",
@@ -1037,6 +1266,41 @@
}
}
},
+ "/v1/locations/tree": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Locations"
+ ],
+ "summary": "Get Locations Tree",
+ "parameters": [
+ {
+ "type": "boolean",
+ "description": "include items in response tree",
+ "name": "withItems",
+ "in": "query"
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.TreeItem"
+ }
+ }
+ }
+ }
+ }
+ },
"/v1/locations/{id}": {
"get": {
"security": [
@@ -1050,7 +1314,7 @@
"tags": [
"Locations"
],
- "summary": "Gets a location and fields",
+ "summary": "Get Location",
"parameters": [
{
"type": "string",
@@ -1081,7 +1345,7 @@
"tags": [
"Locations"
],
- "summary": "updates a location",
+ "summary": "Update Location",
"parameters": [
{
"type": "string",
@@ -1121,7 +1385,7 @@
"tags": [
"Locations"
],
- "summary": "deletes a location",
+ "summary": "Delete Location",
"parameters": [
{
"type": "string",
@@ -1138,6 +1402,167 @@
}
}
},
+ "/v1/notifiers": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Get Notifiers",
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ }
+ },
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Create Notifier",
+ "parameters": [
+ {
+ "description": "Notifier Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierCreate"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ }
+ },
+ "/v1/notifiers/test": {
+ "post": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Test Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "type": "string",
+ "description": "URL",
+ "name": "url",
+ "in": "query",
+ "required": true
+ }
+ ],
+ "responses": {
+ "204": {
+ "description": "No Content"
+ }
+ }
+ }
+ },
+ "/v1/notifiers/{id}": {
+ "put": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Update Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ },
+ {
+ "description": "Notifier Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierUpdate"
+ }
+ }
+ ],
+ "responses": {
+ "200": {
+ "description": "OK",
+ "schema": {
+ "$ref": "#/definitions/repo.NotifierOut"
+ }
+ }
+ }
+ },
+ "delete": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "tags": [
+ "Notifiers"
+ ],
+ "summary": "Delete a Notifier",
+ "parameters": [
+ {
+ "type": "string",
+ "description": "Notifier ID",
+ "name": "id",
+ "in": "path",
+ "required": true
+ }
+ ],
+ "responses": {
+ "204": {
+ "description": "No Content"
+ }
+ }
+ }
+ },
"/v1/qrcode": {
"get": {
"security": [
@@ -1151,7 +1576,7 @@
"tags": [
"Items"
],
- "summary": "Encode data into QRCode",
+ "summary": "Create QR Code",
"parameters": [
{
"type": "string",
@@ -1170,6 +1595,30 @@
}
}
},
+ "/v1/reporting/bill-of-materials": {
+ "get": {
+ "security": [
+ {
+ "Bearer": []
+ }
+ ],
+ "produces": [
+ "application/json"
+ ],
+ "tags": [
+ "Reporting"
+ ],
+ "summary": "Export Bill of Materials",
+ "responses": {
+ "200": {
+ "description": "text/csv",
+ "schema": {
+ "type": "string"
+ }
+ }
+ }
+ }
+ },
"/v1/status": {
"get": {
"produces": [
@@ -1178,12 +1627,12 @@
"tags": [
"Base"
],
- "summary": "Retrieves the basic information about the API",
+ "summary": "Application Info",
"responses": {
"200": {
"description": "OK",
"schema": {
- "$ref": "#/definitions/v1.ApiSummary"
+ "$ref": "#/definitions/v1.APISummary"
}
}
}
@@ -1199,7 +1648,7 @@
"tags": [
"User"
],
- "summary": "Updates the users password",
+ "summary": "Change Password",
"parameters": [
{
"description": "Password Payload",
@@ -1245,6 +1694,21 @@
"description": "string",
"name": "password",
"in": "formData"
+ },
+ {
+ "description": "Login Data",
+ "name": "payload",
+ "in": "body",
+ "required": true,
+ "schema": {
+ "$ref": "#/definitions/v1.LoginForm"
+ }
+ },
+ {
+ "type": "string",
+ "description": "auth provider",
+ "name": "provider",
+ "in": "query"
}
],
"responses": {
@@ -1302,7 +1766,7 @@
"tags": [
"User"
],
- "summary": "Get the current user",
+ "summary": "Register New User",
"parameters": [
{
"description": "User Data",
@@ -1334,14 +1798,14 @@
"tags": [
"User"
],
- "summary": "Get the current user",
+ "summary": "Get User Self",
"responses": {
"200": {
"description": "OK",
"schema": {
"allOf": [
{
- "$ref": "#/definitions/server.Result"
+ "$ref": "#/definitions/v1.Wrapped"
},
{
"type": "object",
@@ -1368,7 +1832,7 @@
"tags": [
"User"
],
- "summary": "Update the current user",
+ "summary": "Update Account",
"parameters": [
{
"description": "User Data",
@@ -1386,7 +1850,7 @@
"schema": {
"allOf": [
{
- "$ref": "#/definitions/server.Result"
+ "$ref": "#/definitions/v1.Wrapped"
},
{
"type": "object",
@@ -1413,7 +1877,7 @@
"tags": [
"User"
],
- "summary": "Deletes the user account",
+ "summary": "Delete Account",
"responses": {
"204": {
"description": "No Content"
@@ -1423,6 +1887,23 @@
}
},
"definitions": {
+ "currencies.Currency": {
+ "type": "object",
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "local": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "symbol": {
+ "type": "string"
+ }
+ }
+ },
"repo.DocumentOut": {
"type": "object",
"properties": {
@@ -1503,6 +1984,9 @@
"id": {
"type": "string"
},
+ "primary": {
+ "type": "boolean"
+ },
"type": {
"type": "string"
},
@@ -1514,6 +1998,9 @@
"repo.ItemAttachmentUpdate": {
"type": "object",
"properties": {
+ "primary": {
+ "type": "boolean"
+ },
"title": {
"type": "string"
},
@@ -1524,9 +2011,13 @@
},
"repo.ItemCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
"description": {
- "type": "string"
+ "type": "string",
+ "maxLength": 1000
},
"labelIds": {
"type": "array",
@@ -1539,7 +2030,9 @@
"type": "string"
},
"name": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
},
"parentId": {
"type": "string",
@@ -1565,9 +2058,6 @@
"textValue": {
"type": "string"
},
- "timeValue": {
- "type": "string"
- },
"type": {
"type": "string"
}
@@ -1589,12 +2079,6 @@
"$ref": "#/definitions/repo.ItemAttachment"
}
},
- "children": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"createdAt": {
"type": "string"
},
@@ -1610,6 +2094,9 @@
"id": {
"type": "string"
},
+ "imageId": {
+ "type": "string"
+ },
"insured": {
"type": "boolean"
},
@@ -1625,9 +2112,13 @@
},
"location": {
"description": "Edges",
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.LocationSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.LocationSummary"
+ "x-omitempty": true
},
"manufacturer": {
"type": "string"
@@ -1643,9 +2134,13 @@
"type": "string"
},
"parent": {
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.ItemSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.ItemSummary"
+ "x-omitempty": true
},
"purchaseFrom": {
"type": "string"
@@ -1689,6 +2184,33 @@
}
}
},
+ "repo.ItemPatch": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "quantity": {
+ "type": "integer",
+ "x-nullable": true,
+ "x-omitempty": true
+ }
+ }
+ },
+ "repo.ItemPath": {
+ "type": "object",
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "type": {
+ "$ref": "#/definitions/repo.ItemType"
+ }
+ }
+ },
"repo.ItemSummary": {
"type": "object",
"properties": {
@@ -1704,6 +2226,9 @@
"id": {
"type": "string"
},
+ "imageId": {
+ "type": "string"
+ },
"insured": {
"type": "boolean"
},
@@ -1715,9 +2240,13 @@
},
"location": {
"description": "Edges",
+ "allOf": [
+ {
+ "$ref": "#/definitions/repo.LocationSummary"
+ }
+ ],
"x-nullable": true,
- "x-omitempty": true,
- "$ref": "#/definitions/repo.LocationSummary"
+ "x-omitempty": true
},
"name": {
"type": "string"
@@ -1734,6 +2263,17 @@
}
}
},
+ "repo.ItemType": {
+ "type": "string",
+ "enum": [
+ "location",
+ "item"
+ ],
+ "x-enum-varnames": [
+ "ItemTypeLocation",
+ "ItemTypeItem"
+ ]
+ },
"repo.ItemUpdate": {
"type": "object",
"properties": {
@@ -1832,15 +2372,21 @@
},
"repo.LabelCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
"color": {
"type": "string"
},
"description": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255
},
"name": {
- "type": "string"
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
}
}
},
@@ -1856,12 +2402,6 @@
"id": {
"type": "string"
},
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"name": {
"type": "string"
},
@@ -1898,6 +2438,10 @@
},
"name": {
"type": "string"
+ },
+ "parentId": {
+ "type": "string",
+ "x-nullable": true
}
}
},
@@ -1919,12 +2463,6 @@
"id": {
"type": "string"
},
- "items": {
- "type": "array",
- "items": {
- "$ref": "#/definitions/repo.ItemSummary"
- }
- },
"name": {
"type": "string"
},
@@ -2000,13 +2538,13 @@
"repo.MaintenanceEntry": {
"type": "object",
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
@@ -2015,42 +2553,54 @@
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
"repo.MaintenanceEntryCreate": {
"type": "object",
+ "required": [
+ "name"
+ ],
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
"repo.MaintenanceEntryUpdate": {
"type": "object",
"properties": {
+ "completedDate": {
+ "type": "string"
+ },
"cost": {
"type": "string",
"example": "0"
},
- "date": {
- "type": "string"
- },
"description": {
"type": "string"
},
"name": {
"type": "string"
+ },
+ "scheduledDate": {
+ "type": "string"
}
}
},
@@ -2074,6 +2624,72 @@
}
}
},
+ "repo.NotifierCreate": {
+ "type": "object",
+ "required": [
+ "name",
+ "url"
+ ],
+ "properties": {
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
+ },
+ "url": {
+ "type": "string"
+ }
+ }
+ },
+ "repo.NotifierOut": {
+ "type": "object",
+ "properties": {
+ "createdAt": {
+ "type": "string"
+ },
+ "groupId": {
+ "type": "string"
+ },
+ "id": {
+ "type": "string"
+ },
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "updatedAt": {
+ "type": "string"
+ },
+ "userId": {
+ "type": "string"
+ }
+ }
+ },
+ "repo.NotifierUpdate": {
+ "type": "object",
+ "required": [
+ "name"
+ ],
+ "properties": {
+ "isActive": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string",
+ "maxLength": 255,
+ "minLength": 1
+ },
+ "url": {
+ "type": "string",
+ "x-nullable": true
+ }
+ }
+ },
"repo.PaginationResult-repo_ItemSummary": {
"type": "object",
"properties": {
@@ -2108,6 +2724,26 @@
}
}
},
+ "repo.TreeItem": {
+ "type": "object",
+ "properties": {
+ "children": {
+ "type": "array",
+ "items": {
+ "$ref": "#/definitions/repo.TreeItem"
+ }
+ },
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ }
+ }
+ },
"repo.UserOut": {
"type": "object",
"properties": {
@@ -2182,39 +2818,6 @@
}
}
},
- "server.ErrorResponse": {
- "type": "object",
- "properties": {
- "error": {
- "type": "string"
- },
- "fields": {
- "type": "object",
- "additionalProperties": {
- "type": "string"
- }
- }
- }
- },
- "server.Result": {
- "type": "object",
- "properties": {
- "details": {},
- "error": {
- "type": "boolean"
- },
- "item": {},
- "message": {
- "type": "string"
- }
- }
- },
- "server.Results": {
- "type": "object",
- "properties": {
- "items": {}
- }
- },
"services.UserRegistration": {
"type": "object",
"properties": {
@@ -2232,9 +2835,12 @@
}
}
},
- "v1.ApiSummary": {
+ "v1.APISummary": {
"type": "object",
"properties": {
+ "allowRegistration": {
+ "type": "boolean"
+ },
"build": {
"$ref": "#/definitions/v1.Build"
},
@@ -2258,6 +2864,14 @@
}
}
},
+ "v1.ActionAmountResult": {
+ "type": "object",
+ "properties": {
+ "completed": {
+ "type": "integer"
+ }
+ }
+ },
"v1.Build": {
"type": "object",
"properties": {
@@ -2283,14 +2897,6 @@
}
}
},
- "v1.EnsureAssetIDResult": {
- "type": "object",
- "properties": {
- "completed": {
- "type": "integer"
- }
- }
- },
"v1.GroupInvitation": {
"type": "object",
"properties": {
@@ -2307,12 +2913,17 @@
},
"v1.GroupInvitationCreate": {
"type": "object",
+ "required": [
+ "uses"
+ ],
"properties": {
"expiresAt": {
"type": "string"
},
"uses": {
- "type": "integer"
+ "type": "integer",
+ "maximum": 100,
+ "minimum": 1
}
}
},
@@ -2324,6 +2935,20 @@
}
}
},
+ "v1.LoginForm": {
+ "type": "object",
+ "properties": {
+ "password": {
+ "type": "string"
+ },
+ "stayLoggedIn": {
+ "type": "boolean"
+ },
+ "username": {
+ "type": "string"
+ }
+ }
+ },
"v1.TokenResponse": {
"type": "object",
"properties": {
@@ -2337,6 +2962,23 @@
"type": "string"
}
}
+ },
+ "v1.Wrapped": {
+ "type": "object",
+ "properties": {
+ "item": {}
+ }
+ },
+ "validate.ErrorResponse": {
+ "type": "object",
+ "properties": {
+ "error": {
+ "type": "string"
+ },
+ "fields": {
+ "type": "string"
+ }
+ }
}
},
"securityDefinitions": {
diff --git a/backend/app/api/static/docs/swagger.yaml b/backend/app/api/static/docs/swagger.yaml
index a6ef340..dbb31e6 100644
--- a/backend/app/api/static/docs/swagger.yaml
+++ b/backend/app/api/static/docs/swagger.yaml
@@ -1,5 +1,16 @@
basePath: /api
definitions:
+ currencies.Currency:
+ properties:
+ code:
+ type: string
+ local:
+ type: string
+ name:
+ type: string
+ symbol:
+ type: string
+ type: object
repo.DocumentOut:
properties:
id:
@@ -52,6 +63,8 @@ definitions:
$ref: '#/definitions/repo.DocumentOut'
id:
type: string
+ primary:
+ type: boolean
type:
type: string
updatedAt:
@@ -59,6 +72,8 @@ definitions:
type: object
repo.ItemAttachmentUpdate:
properties:
+ primary:
+ type: boolean
title:
type: string
type:
@@ -67,6 +82,7 @@ definitions:
repo.ItemCreate:
properties:
description:
+ maxLength: 1000
type: string
labelIds:
items:
@@ -76,10 +92,14 @@ definitions:
description: Edges
type: string
name:
+ maxLength: 255
+ minLength: 1
type: string
parentId:
type: string
x-nullable: true
+ required:
+ - name
type: object
repo.ItemField:
properties:
@@ -93,8 +113,6 @@ definitions:
type: integer
textValue:
type: string
- timeValue:
- type: string
type:
type: string
type: object
@@ -109,10 +127,6 @@ definitions:
items:
$ref: '#/definitions/repo.ItemAttachment'
type: array
- children:
- items:
- $ref: '#/definitions/repo.ItemSummary'
- type: array
createdAt:
type: string
description:
@@ -123,6 +137,8 @@ definitions:
type: array
id:
type: string
+ imageId:
+ type: string
insured:
type: boolean
labels:
@@ -133,7 +149,8 @@ definitions:
description: Warranty
type: boolean
location:
- $ref: '#/definitions/repo.LocationSummary'
+ allOf:
+ - $ref: '#/definitions/repo.LocationSummary'
description: Edges
x-nullable: true
x-omitempty: true
@@ -147,7 +164,8 @@ definitions:
description: Extras
type: string
parent:
- $ref: '#/definitions/repo.ItemSummary'
+ allOf:
+ - $ref: '#/definitions/repo.ItemSummary'
x-nullable: true
x-omitempty: true
purchaseFrom:
@@ -179,6 +197,24 @@ definitions:
warrantyExpires:
type: string
type: object
+ repo.ItemPatch:
+ properties:
+ id:
+ type: string
+ quantity:
+ type: integer
+ x-nullable: true
+ x-omitempty: true
+ type: object
+ repo.ItemPath:
+ properties:
+ id:
+ type: string
+ name:
+ type: string
+ type:
+ $ref: '#/definitions/repo.ItemType'
+ type: object
repo.ItemSummary:
properties:
archived:
@@ -189,6 +225,8 @@ definitions:
type: string
id:
type: string
+ imageId:
+ type: string
insured:
type: boolean
labels:
@@ -196,7 +234,8 @@ definitions:
$ref: '#/definitions/repo.LabelSummary'
type: array
location:
- $ref: '#/definitions/repo.LocationSummary'
+ allOf:
+ - $ref: '#/definitions/repo.LocationSummary'
description: Edges
x-nullable: true
x-omitempty: true
@@ -210,6 +249,14 @@ definitions:
updatedAt:
type: string
type: object
+ repo.ItemType:
+ enum:
+ - location
+ - item
+ type: string
+ x-enum-varnames:
+ - ItemTypeLocation
+ - ItemTypeItem
repo.ItemUpdate:
properties:
archived:
@@ -282,9 +329,14 @@ definitions:
color:
type: string
description:
+ maxLength: 255
type: string
name:
+ maxLength: 255
+ minLength: 1
type: string
+ required:
+ - name
type: object
repo.LabelOut:
properties:
@@ -294,10 +346,6 @@ definitions:
type: string
id:
type: string
- items:
- items:
- $ref: '#/definitions/repo.ItemSummary'
- type: array
name:
type: string
updatedAt:
@@ -322,6 +370,9 @@ definitions:
type: string
name:
type: string
+ parentId:
+ type: string
+ x-nullable: true
type: object
repo.LocationOut:
properties:
@@ -335,10 +386,6 @@ definitions:
type: string
id:
type: string
- items:
- items:
- $ref: '#/definitions/repo.ItemSummary'
- type: array
name:
type: string
parent:
@@ -388,41 +435,49 @@ definitions:
type: object
repo.MaintenanceEntry:
properties:
+ completedDate:
+ type: string
cost:
example: "0"
type: string
- date:
- type: string
description:
type: string
id:
type: string
name:
type: string
+ scheduledDate:
+ type: string
type: object
repo.MaintenanceEntryCreate:
properties:
+ completedDate:
+ type: string
cost:
example: "0"
type: string
- date:
- type: string
description:
type: string
name:
type: string
+ scheduledDate:
+ type: string
+ required:
+ - name
type: object
repo.MaintenanceEntryUpdate:
properties:
+ completedDate:
+ type: string
cost:
example: "0"
type: string
- date:
- type: string
description:
type: string
name:
type: string
+ scheduledDate:
+ type: string
type: object
repo.MaintenanceLog:
properties:
@@ -437,6 +492,51 @@ definitions:
itemId:
type: string
type: object
+ repo.NotifierCreate:
+ properties:
+ isActive:
+ type: boolean
+ name:
+ maxLength: 255
+ minLength: 1
+ type: string
+ url:
+ type: string
+ required:
+ - name
+ - url
+ type: object
+ repo.NotifierOut:
+ properties:
+ createdAt:
+ type: string
+ groupId:
+ type: string
+ id:
+ type: string
+ isActive:
+ type: boolean
+ name:
+ type: string
+ updatedAt:
+ type: string
+ userId:
+ type: string
+ type: object
+ repo.NotifierUpdate:
+ properties:
+ isActive:
+ type: boolean
+ name:
+ maxLength: 255
+ minLength: 1
+ type: string
+ url:
+ type: string
+ x-nullable: true
+ required:
+ - name
+ type: object
repo.PaginationResult-repo_ItemSummary:
properties:
items:
@@ -459,6 +559,19 @@ definitions:
total:
type: number
type: object
+ repo.TreeItem:
+ properties:
+ children:
+ items:
+ $ref: '#/definitions/repo.TreeItem'
+ type: array
+ id:
+ type: string
+ name:
+ type: string
+ type:
+ type: string
+ type: object
repo.UserOut:
properties:
email:
@@ -507,28 +620,6 @@ definitions:
value:
type: number
type: object
- server.ErrorResponse:
- properties:
- error:
- type: string
- fields:
- additionalProperties:
- type: string
- type: object
- type: object
- server.Result:
- properties:
- details: {}
- error:
- type: boolean
- item: {}
- message:
- type: string
- type: object
- server.Results:
- properties:
- items: {}
- type: object
services.UserRegistration:
properties:
email:
@@ -540,8 +631,10 @@ definitions:
token:
type: string
type: object
- v1.ApiSummary:
+ v1.APISummary:
properties:
+ allowRegistration:
+ type: boolean
build:
$ref: '#/definitions/v1.Build'
demo:
@@ -557,6 +650,11 @@ definitions:
type: string
type: array
type: object
+ v1.ActionAmountResult:
+ properties:
+ completed:
+ type: integer
+ type: object
v1.Build:
properties:
buildTime:
@@ -573,11 +671,6 @@ definitions:
new:
type: string
type: object
- v1.EnsureAssetIDResult:
- properties:
- completed:
- type: integer
- type: object
v1.GroupInvitation:
properties:
expiresAt:
@@ -592,13 +685,26 @@ definitions:
expiresAt:
type: string
uses:
+ maximum: 100
+ minimum: 1
type: integer
+ required:
+ - uses
type: object
v1.ItemAttachmentToken:
properties:
token:
type: string
type: object
+ v1.LoginForm:
+ properties:
+ password:
+ type: string
+ stayLoggedIn:
+ type: boolean
+ username:
+ type: string
+ type: object
v1.TokenResponse:
properties:
attachmentToken:
@@ -608,31 +714,84 @@ definitions:
token:
type: string
type: object
+ v1.Wrapped:
+ properties:
+ item: {}
+ type: object
+ validate.ErrorResponse:
+ properties:
+ error:
+ type: string
+ fields:
+ type: string
+ type: object
info:
contact:
name: Don't
- description: This is a simple Rest API Server Template that implements some basic
- User and Authentication patterns to help you get started and bootstrap your next
- project!.
- license:
- name: MIT
- title: Go API Templates
+ description: Track, Manage, and Organize your Things.
+ title: Homebox API
version: "1.0"
paths:
/v1/actions/ensure-asset-ids:
post:
+ description: Ensures all items in the database have an asset ID
produces:
- application/json
responses:
"200":
description: OK
schema:
- $ref: '#/definitions/v1.EnsureAssetIDResult'
+ $ref: '#/definitions/v1.ActionAmountResult'
security:
- Bearer: []
- summary: Get the current user
+ summary: Ensure Asset IDs
tags:
- - Group
+ - Actions
+ /v1/actions/ensure-import-refs:
+ post:
+ description: Ensures all items in the database have an import ref
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/v1.ActionAmountResult'
+ security:
+ - Bearer: []
+ summary: Ensures Import Refs
+ tags:
+ - Actions
+ /v1/actions/set-primary-photos:
+ post:
+ description: Sets the first photo of each item as the primary photo
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/v1.ActionAmountResult'
+ security:
+ - Bearer: []
+ summary: Set Primary Photos
+ tags:
+ - Actions
+ /v1/actions/zero-item-time-fields:
+ post:
+ description: Resets all item date fields to the beginning of the day
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/v1.ActionAmountResult'
+ security:
+ - Bearer: []
+ summary: Zero Out Time Fields
+ tags:
+ - Actions
/v1/assets/{id}:
get:
parameters:
@@ -650,9 +809,21 @@ paths:
$ref: '#/definitions/repo.PaginationResult-repo_ItemSummary'
security:
- Bearer: []
- summary: Gets an item by Asset ID
+ summary: Get Item by Asset ID
tags:
- - Assets
+ - Items
+ /v1/currency:
+ get:
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/currencies.Currency'
+ summary: Currency
+ tags:
+ - Base
/v1/groups:
get:
produces:
@@ -664,7 +835,7 @@ paths:
$ref: '#/definitions/repo.Group'
security:
- Bearer: []
- summary: Get the current user's group
+ summary: Get Group
tags:
- Group
put:
@@ -684,7 +855,7 @@ paths:
$ref: '#/definitions/repo.Group'
security:
- Bearer: []
- summary: Updates some fields of the current users group
+ summary: Update Group
tags:
- Group
/v1/groups/invitations:
@@ -705,7 +876,7 @@ paths:
$ref: '#/definitions/v1.GroupInvitation'
security:
- Bearer: []
- summary: Get the current user
+ summary: Create Group Invitation
tags:
- Group
/v1/groups/statistics:
@@ -719,7 +890,7 @@ paths:
$ref: '#/definitions/repo.GroupStatistics'
security:
- Bearer: []
- summary: Get the current user's group statistics
+ summary: Get Group Statistics
tags:
- Statistics
/v1/groups/statistics/labels:
@@ -735,7 +906,7 @@ paths:
type: array
security:
- Bearer: []
- summary: Get the current user's group statistics
+ summary: Get Label Statistics
tags:
- Statistics
/v1/groups/statistics/locations:
@@ -751,7 +922,7 @@ paths:
type: array
security:
- Bearer: []
- summary: Get the current user's group statistics
+ summary: Get Location Statistics
tags:
- Statistics
/v1/groups/statistics/purchase-price:
@@ -774,7 +945,7 @@ paths:
$ref: '#/definitions/repo.ValueOverTime'
security:
- Bearer: []
- summary: Queries the changes overtime of the purchase price over time
+ summary: Get Purchase Price Statistics
tags:
- Statistics
/v1/items:
@@ -806,6 +977,13 @@ paths:
type: string
name: locations
type: array
+ - collectionFormat: multi
+ description: parent Ids
+ in: query
+ items:
+ type: string
+ name: parentIds
+ type: array
produces:
- application/json
responses:
@@ -815,7 +993,7 @@ paths:
$ref: '#/definitions/repo.PaginationResult-repo_ItemSummary'
security:
- Bearer: []
- summary: Get All Items
+ summary: Query All Items
tags:
- Items
post:
@@ -829,13 +1007,13 @@ paths:
produces:
- application/json
responses:
- "200":
- description: OK
+ "201":
+ description: Created
schema:
$ref: '#/definitions/repo.ItemSummary'
security:
- Bearer: []
- summary: Create a new item
+ summary: Create Item
tags:
- Items
/v1/items/{id}:
@@ -853,7 +1031,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: deletes a item
+ summary: Delete Item
tags:
- Items
get:
@@ -872,7 +1050,32 @@ paths:
$ref: '#/definitions/repo.ItemOut'
security:
- Bearer: []
- summary: Gets a item and fields
+ summary: Get Item
+ tags:
+ - Items
+ patch:
+ parameters:
+ - description: Item ID
+ in: path
+ name: id
+ required: true
+ type: string
+ - description: Item Data
+ in: body
+ name: payload
+ required: true
+ schema:
+ $ref: '#/definitions/repo.ItemPatch'
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/repo.ItemOut'
+ security:
+ - Bearer: []
+ summary: Update Item
tags:
- Items
put:
@@ -897,7 +1100,7 @@ paths:
$ref: '#/definitions/repo.ItemOut'
security:
- Bearer: []
- summary: updates a item
+ summary: Update Item
tags:
- Items
/v1/items/{id}/attachments:
@@ -933,10 +1136,10 @@ paths:
"422":
description: Unprocessable Entity
schema:
- $ref: '#/definitions/server.ErrorResponse'
+ $ref: '#/definitions/validate.ErrorResponse'
security:
- Bearer: []
- summary: imports items into the database
+ summary: Create Item Attachment
tags:
- Items Attachments
/v1/items/{id}/attachments/{attachment_id}:
@@ -957,7 +1160,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: retrieves an attachment for an item
+ summary: Delete Item Attachment
tags:
- Items Attachments
get:
@@ -981,7 +1184,7 @@ paths:
$ref: '#/definitions/v1.ItemAttachmentToken'
security:
- Bearer: []
- summary: retrieves an attachment for an item
+ summary: Get Item Attachment
tags:
- Items Attachments
put:
@@ -1009,7 +1212,7 @@ paths:
$ref: '#/definitions/repo.ItemOut'
security:
- Bearer: []
- summary: retrieves an attachment for an item
+ summary: Update Item Attachment
tags:
- Items Attachments
/v1/items/{id}/maintenance:
@@ -1037,8 +1240,8 @@ paths:
produces:
- application/json
responses:
- "200":
- description: OK
+ "201":
+ description: Created
schema:
$ref: '#/definitions/repo.MaintenanceEntry'
security:
@@ -1078,6 +1281,72 @@ paths:
summary: Update Maintenance Entry
tags:
- Maintenance
+ /v1/items/{id}/path:
+ get:
+ parameters:
+ - description: Item ID
+ in: path
+ name: id
+ required: true
+ type: string
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ items:
+ $ref: '#/definitions/repo.ItemPath'
+ type: array
+ security:
+ - Bearer: []
+ summary: Get the full path of an item
+ tags:
+ - Items
+ /v1/items/export:
+ get:
+ responses:
+ "200":
+ description: text/csv
+ schema:
+ type: string
+ security:
+ - Bearer: []
+ summary: Export Items
+ tags:
+ - Items
+ /v1/items/fields:
+ get:
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ items:
+ type: string
+ type: array
+ security:
+ - Bearer: []
+ summary: Get All Custom Field Names
+ tags:
+ - Items
+ /v1/items/fields/values:
+ get:
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ items:
+ type: string
+ type: array
+ security:
+ - Bearer: []
+ summary: Get All Custom Field Values
+ tags:
+ - Items
/v1/items/import:
post:
parameters:
@@ -1093,7 +1362,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: imports items into the database
+ summary: Import Items
tags:
- Items
/v1/labels:
@@ -1104,14 +1373,9 @@ paths:
"200":
description: OK
schema:
- allOf:
- - $ref: '#/definitions/server.Results'
- - properties:
- items:
- items:
- $ref: '#/definitions/repo.LabelOut'
- type: array
- type: object
+ items:
+ $ref: '#/definitions/repo.LabelOut'
+ type: array
security:
- Bearer: []
summary: Get All Labels
@@ -1134,7 +1398,7 @@ paths:
$ref: '#/definitions/repo.LabelSummary'
security:
- Bearer: []
- summary: Create a new label
+ summary: Create Label
tags:
- Labels
/v1/labels/{id}:
@@ -1152,7 +1416,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: deletes a label
+ summary: Delete Label
tags:
- Labels
get:
@@ -1171,7 +1435,7 @@ paths:
$ref: '#/definitions/repo.LabelOut'
security:
- Bearer: []
- summary: Gets a label and fields
+ summary: Get Label
tags:
- Labels
put:
@@ -1190,7 +1454,7 @@ paths:
$ref: '#/definitions/repo.LabelOut'
security:
- Bearer: []
- summary: updates a label
+ summary: Update Label
tags:
- Labels
/v1/locations:
@@ -1206,14 +1470,9 @@ paths:
"200":
description: OK
schema:
- allOf:
- - $ref: '#/definitions/server.Results'
- - properties:
- items:
- items:
- $ref: '#/definitions/repo.LocationOutCount'
- type: array
- type: object
+ items:
+ $ref: '#/definitions/repo.LocationOutCount'
+ type: array
security:
- Bearer: []
summary: Get All Locations
@@ -1236,7 +1495,7 @@ paths:
$ref: '#/definitions/repo.LocationSummary'
security:
- Bearer: []
- summary: Create a new location
+ summary: Create Location
tags:
- Locations
/v1/locations/{id}:
@@ -1254,7 +1513,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: deletes a location
+ summary: Delete Location
tags:
- Locations
get:
@@ -1273,7 +1532,7 @@ paths:
$ref: '#/definitions/repo.LocationOut'
security:
- Bearer: []
- summary: Gets a location and fields
+ summary: Get Location
tags:
- Locations
put:
@@ -1298,9 +1557,128 @@ paths:
$ref: '#/definitions/repo.LocationOut'
security:
- Bearer: []
- summary: updates a location
+ summary: Update Location
tags:
- Locations
+ /v1/locations/tree:
+ get:
+ parameters:
+ - description: include items in response tree
+ in: query
+ name: withItems
+ type: boolean
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ items:
+ $ref: '#/definitions/repo.TreeItem'
+ type: array
+ security:
+ - Bearer: []
+ summary: Get Locations Tree
+ tags:
+ - Locations
+ /v1/notifiers:
+ get:
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ items:
+ $ref: '#/definitions/repo.NotifierOut'
+ type: array
+ security:
+ - Bearer: []
+ summary: Get Notifiers
+ tags:
+ - Notifiers
+ post:
+ parameters:
+ - description: Notifier Data
+ in: body
+ name: payload
+ required: true
+ schema:
+ $ref: '#/definitions/repo.NotifierCreate'
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/repo.NotifierOut'
+ security:
+ - Bearer: []
+ summary: Create Notifier
+ tags:
+ - Notifiers
+ /v1/notifiers/{id}:
+ delete:
+ parameters:
+ - description: Notifier ID
+ in: path
+ name: id
+ required: true
+ type: string
+ responses:
+ "204":
+ description: No Content
+ security:
+ - Bearer: []
+ summary: Delete a Notifier
+ tags:
+ - Notifiers
+ put:
+ parameters:
+ - description: Notifier ID
+ in: path
+ name: id
+ required: true
+ type: string
+ - description: Notifier Data
+ in: body
+ name: payload
+ required: true
+ schema:
+ $ref: '#/definitions/repo.NotifierUpdate'
+ responses:
+ "200":
+ description: OK
+ schema:
+ $ref: '#/definitions/repo.NotifierOut'
+ security:
+ - Bearer: []
+ summary: Update Notifier
+ tags:
+ - Notifiers
+ /v1/notifiers/test:
+ post:
+ parameters:
+ - description: Notifier ID
+ in: path
+ name: id
+ required: true
+ type: string
+ - description: URL
+ in: query
+ name: url
+ required: true
+ type: string
+ produces:
+ - application/json
+ responses:
+ "204":
+ description: No Content
+ security:
+ - Bearer: []
+ summary: Test Notifier
+ tags:
+ - Notifiers
/v1/qrcode:
get:
parameters:
@@ -1317,9 +1695,23 @@ paths:
type: string
security:
- Bearer: []
- summary: Encode data into QRCode
+ summary: Create QR Code
tags:
- Items
+ /v1/reporting/bill-of-materials:
+ get:
+ produces:
+ - application/json
+ responses:
+ "200":
+ description: text/csv
+ schema:
+ type: string
+ security:
+ - Bearer: []
+ summary: Export Bill of Materials
+ tags:
+ - Reporting
/v1/status:
get:
produces:
@@ -1328,8 +1720,8 @@ paths:
"200":
description: OK
schema:
- $ref: '#/definitions/v1.ApiSummary'
- summary: Retrieves the basic information about the API
+ $ref: '#/definitions/v1.APISummary'
+ summary: Application Info
tags:
- Base
/v1/users/change-password:
@@ -1346,7 +1738,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: Updates the users password
+ summary: Change Password
tags:
- User
/v1/users/login:
@@ -1365,6 +1757,16 @@ paths:
in: formData
name: password
type: string
+ - description: Login Data
+ in: body
+ name: payload
+ required: true
+ schema:
+ $ref: '#/definitions/v1.LoginForm'
+ - description: auth provider
+ in: query
+ name: provider
+ type: string
produces:
- application/json
responses:
@@ -1412,7 +1814,7 @@ paths:
responses:
"204":
description: No Content
- summary: Get the current user
+ summary: Register New User
tags:
- User
/v1/users/self:
@@ -1424,7 +1826,7 @@ paths:
description: No Content
security:
- Bearer: []
- summary: Deletes the user account
+ summary: Delete Account
tags:
- User
get:
@@ -1435,14 +1837,14 @@ paths:
description: OK
schema:
allOf:
- - $ref: '#/definitions/server.Result'
+ - $ref: '#/definitions/v1.Wrapped'
- properties:
item:
$ref: '#/definitions/repo.UserOut'
type: object
security:
- Bearer: []
- summary: Get the current user
+ summary: Get User Self
tags:
- User
put:
@@ -1460,14 +1862,14 @@ paths:
description: OK
schema:
allOf:
- - $ref: '#/definitions/server.Result'
+ - $ref: '#/definitions/v1.Wrapped'
- properties:
item:
$ref: '#/definitions/repo.UserUpdate'
type: object
security:
- Bearer: []
- summary: Update the current user
+ summary: Update Account
tags:
- User
securityDefinitions:
diff --git a/backend/app/tools/typegen/main.go b/backend/app/tools/typegen/main.go
new file mode 100644
index 0000000..5f4d8da
--- /dev/null
+++ b/backend/app/tools/typegen/main.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+ "fmt"
+ "os"
+ "regexp"
+)
+
+type ReReplace struct {
+ Regex *regexp.Regexp
+ Text string
+}
+
+func NewReReplace(regex string, replace string) ReReplace {
+ return ReReplace{
+ Regex: regexp.MustCompile(regex),
+ Text: replace,
+ }
+}
+
+func NewReDate(dateStr string) ReReplace {
+ return ReReplace{
+ Regex: regexp.MustCompile(fmt.Sprintf(`%s: string`, dateStr)),
+ Text: fmt.Sprintf(`%s: Date | string`, dateStr),
+ }
+}
+
+func main() {
+ if len(os.Args) != 2 {
+ fmt.Println("Please provide a file path as an argument")
+ os.Exit(1)
+ }
+
+ path := os.Args[1]
+
+ fmt.Printf("Processing %s\n", path)
+
+ if _, err := os.Stat(path); os.IsNotExist(err) {
+ fmt.Printf("File %s does not exist\n", path)
+ os.Exit(1)
+ }
+
+ text := "/* post-processed by ./scripts/process-types.go */\n"
+ data, err := os.ReadFile(path)
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+ text += string(data)
+
+ replaces := [...]ReReplace{
+ NewReReplace(` Repo`, " "),
+ NewReReplace(` PaginationResultRepo`, " PaginationResult"),
+ NewReReplace(` Services`, " "),
+ NewReReplace(` V1`, " "),
+ NewReReplace(`\?:`, ":"),
+ NewReReplace(`(\w+):\s(.*null.*)`, "$1?: $2"), // make null union types optional
+ NewReDate("createdAt"),
+ NewReDate("updatedAt"),
+ NewReDate("soldTime"),
+ NewReDate("purchaseTime"),
+ NewReDate("warrantyExpires"),
+ NewReDate("expiresAt"),
+ NewReDate("date"),
+ NewReDate("completedDate"),
+ NewReDate("scheduledDate"),
+ }
+
+ for _, replace := range replaces {
+ fmt.Printf("Replacing '%v' -> '%s'\n", replace.Regex, replace.Text)
+ text = replace.Regex.ReplaceAllString(text, replace.Text)
+ }
+
+ err = os.WriteFile(path, []byte(text), 0644)
+ if err != nil {
+ fmt.Println(err)
+ os.Exit(1)
+ }
+
+ os.Exit(0)
+}
diff --git a/backend/go.mod b/backend/go.mod
index 4030e48..8a0f9d9 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -1,56 +1,78 @@
module github.com/hay-kot/homebox/backend
-go 1.19
+go 1.22
+
+toolchain go1.22.0
require (
- ariga.io/atlas v0.9.0
- entgo.io/ent v0.11.5
- github.com/ardanlabs/conf/v2 v2.2.0
- github.com/go-chi/chi/v5 v5.0.8
- github.com/go-playground/validator/v10 v10.11.1
- github.com/google/uuid v1.3.0
- github.com/mattn/go-sqlite3 v1.14.16
- github.com/rs/zerolog v1.28.0
- github.com/stretchr/testify v1.8.1
- github.com/swaggo/http-swagger v1.3.3
- github.com/swaggo/swag v1.8.9
- github.com/yeqown/go-qrcode/v2 v2.2.1
- github.com/yeqown/go-qrcode/writer/standard v1.2.1
- golang.org/x/crypto v0.5.0
+ ariga.io/atlas v0.19.1
+ entgo.io/ent v0.12.5
+ github.com/ardanlabs/conf/v3 v3.1.7
+ github.com/containrrr/shoutrrr v0.8.0
+ github.com/go-chi/chi/v5 v5.0.12
+ github.com/go-playground/validator/v10 v10.18.0
+ github.com/gocarina/gocsv v0.0.0-20231116093920-b87c2d0e983a
+ github.com/google/uuid v1.6.0
+ github.com/gorilla/schema v1.2.1
+ github.com/hay-kot/httpkit v0.0.9
+ github.com/mattn/go-sqlite3 v1.14.22
+ github.com/olahol/melody v1.1.4
+ github.com/pkg/errors v0.9.1
+ github.com/rs/zerolog v1.32.0
+ github.com/stretchr/testify v1.8.4
+ github.com/swaggo/http-swagger/v2 v2.0.2
+ github.com/swaggo/swag v1.16.3
+ github.com/yeqown/go-qrcode/v2 v2.2.2
+ github.com/yeqown/go-qrcode/writer/standard v1.2.2
+ golang.org/x/crypto v0.19.0
+ modernc.org/sqlite v1.29.2
)
require (
github.com/KyleBanks/depth v1.2.1 // indirect
github.com/agext/levenshtein v1.2.3 // indirect
- github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
+ github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
+ github.com/dustin/go-humanize v1.0.1 // indirect
+ github.com/fatih/color v1.16.0 // indirect
github.com/fogleman/gg v1.3.0 // indirect
+ github.com/gabriel-vasile/mimetype v1.4.3 // indirect
github.com/go-openapi/inflect v0.19.0 // indirect
- github.com/go-openapi/jsonpointer v0.19.5 // indirect
- github.com/go-openapi/jsonreference v0.20.0 // indirect
- github.com/go-openapi/spec v0.20.7 // indirect
- github.com/go-openapi/swag v0.22.3 // indirect
- github.com/go-playground/locales v0.14.0 // indirect
- github.com/go-playground/universal-translator v0.18.0 // indirect
+ github.com/go-openapi/jsonpointer v0.20.0 // indirect
+ github.com/go-openapi/jsonreference v0.20.2 // indirect
+ github.com/go-openapi/spec v0.20.9 // indirect
+ github.com/go-openapi/swag v0.22.4 // indirect
+ github.com/go-playground/locales v0.14.1 // indirect
+ github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
- github.com/google/go-cmp v0.5.9 // indirect
- github.com/hashicorp/hcl/v2 v2.15.0 // indirect
+ github.com/google/go-cmp v0.6.0 // indirect
+ github.com/gorilla/websocket v1.5.1 // indirect
+ github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+ github.com/hashicorp/hcl/v2 v2.19.1 // indirect
github.com/josharian/intern v1.0.0 // indirect
- github.com/leodido/go-urn v1.2.1 // indirect
+ github.com/leodido/go-urn v1.4.0 // indirect
github.com/mailru/easyjson v0.7.7 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect
- github.com/mattn/go-isatty v0.0.17 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
github.com/mitchellh/go-wordwrap v1.0.1 // indirect
- github.com/pkg/errors v0.9.1 // indirect
+ github.com/ncruces/go-strftime v0.1.9 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
- github.com/swaggo/files v1.0.0 // indirect
+ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+ github.com/rogpeppe/go-internal v1.11.0 // indirect
+ github.com/swaggo/files/v2 v2.0.0 // indirect
github.com/yeqown/reedsolomon v1.0.0 // indirect
- github.com/zclconf/go-cty v1.12.1 // indirect
- golang.org/x/image v0.0.0-20200927104501-e162460cd6b5 // indirect
- golang.org/x/mod v0.7.0 // indirect
- golang.org/x/net v0.5.0 // indirect
- golang.org/x/sys v0.4.0 // indirect
- golang.org/x/text v0.6.0 // indirect
- golang.org/x/tools v0.4.0 // indirect
+ github.com/zclconf/go-cty v1.14.1 // indirect
+ golang.org/x/image v0.14.0 // indirect
+ golang.org/x/mod v0.15.0 // indirect
+ golang.org/x/net v0.21.0 // indirect
+ golang.org/x/sys v0.17.0 // indirect
+ golang.org/x/text v0.14.0 // indirect
+ golang.org/x/tools v0.17.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
+ modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 // indirect
+ modernc.org/libc v1.41.0 // indirect
+ modernc.org/mathutil v1.6.0 // indirect
+ modernc.org/memory v1.7.2 // indirect
+ modernc.org/strutil v1.2.0 // indirect
+ modernc.org/token v1.1.0 // indirect
)
diff --git a/backend/go.sum b/backend/go.sum
index c3313f6..fec9706 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -1,187 +1,218 @@
-ariga.io/atlas v0.9.0 h1:q0JMtqyA3X1YWtPcn+E/kVPwLDslb+jAC8Ejl/vW6d0=
-ariga.io/atlas v0.9.0/go.mod h1:T230JFcENj4ZZzMkZrXFDSkv+2kXkUgpJ5FQQ5hMcKU=
-entgo.io/ent v0.11.5 h1:V2qhG91C4PMQTa82Q4StoESMQ4dzkMNeStCzszxi0jQ=
-entgo.io/ent v0.11.5/go.mod h1:u7eKwNWAo/VlHIKxgwbmsFy3J7cKDxwi3jyF5TW/okY=
+ariga.io/atlas v0.19.0 h1:gilVpXabeiGhGI9lj/rQURkXBemnloc41RGOtwVLNc4=
+ariga.io/atlas v0.19.0/go.mod h1:uj3pm+hUTVN/X5yfdBexHlZv+1Xu5u5ZbZx7+CDavNU=
+ariga.io/atlas v0.19.1 h1:QzBHkakwzEhmPWOzNhw8Yr/Bbicj6Iq5hwEoNI/Jr9A=
+ariga.io/atlas v0.19.1/go.mod h1:VPlcXdd4w2KqKnH54yEZcry79UAhpaWaxEsmn5JRNoE=
+entgo.io/ent v0.12.5 h1:KREM5E4CSoej4zeGa88Ou/gfturAnpUv0mzAjch1sj4=
+entgo.io/ent v0.12.5/go.mod h1:Y3JVAjtlIk8xVZYSn3t3mf8xlZIn5SAOXZQxD6kKI+Q=
github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
-github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
-github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
-github.com/ardanlabs/conf/v2 v2.2.0 h1:ar1+TYIYAh2Tdeg2DQroh7ruR56/vJR8BDfzDIrXgtk=
-github.com/ardanlabs/conf/v2 v2.2.0/go.mod h1:m37ZKdW9jwMUEhGX36jRNt8VzSQ/HVmSziLZH2p33nY=
-github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
+github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
+github.com/ardanlabs/conf/v3 v3.1.7 h1:p232cF68TafoA5U9ZlbxUIhGJtGNdKHBXF80Fdqb5t0=
+github.com/ardanlabs/conf/v3 v3.1.7/go.mod h1:zclexWKe0NVj6LHQ8NgDDZ7bQ1spE0KeKPFficdtAjU=
+github.com/containrrr/shoutrrr v0.8.0 h1:mfG2ATzIS7NR2Ec6XL+xyoHzN97H8WPjir8aYzJUSec=
+github.com/containrrr/shoutrrr v0.8.0/go.mod h1:ioyQAyu1LJY6sILuNyKaQaw+9Ttik5QePU8atnAdO2o=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
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/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/fogleman/gg v1.3.0 h1:/7zJX8F6AaYQc57WQCyN9cAIz+4bCJGO9B+dyW29am8=
github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k=
-github.com/go-chi/chi/v5 v5.0.8 h1:lD+NLqFcAi1ovnVZpsnObHGW4xb4J8lNmoYVfECH1Y0=
-github.com/go-chi/chi/v5 v5.0.8/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/go-chi/chi/v5 v5.0.12 h1:9euLV5sTrTNTRUU9POmDUvfxyj6LAABLUcEWO+JJb4s=
+github.com/go-chi/chi/v5 v5.0.12/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
+github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
-github.com/go-openapi/jsonpointer v0.19.5 h1:gZr+CIYByUqjcgeLXnQu2gHYQC9o73G2XUeOFYEICuY=
github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
-github.com/go-openapi/jsonreference v0.20.0 h1:MYlu0sBgChmCfJxxUKZ8g1cPWFOB37YSZqewK7OKeyA=
+github.com/go-openapi/jsonpointer v0.19.6/go.mod h1:osyAmYz/mB/C3I+WsTTSgw1ONzaLJoLCyoi6/zppojs=
+github.com/go-openapi/jsonpointer v0.20.0 h1:ESKJdU9ASRfaPNOPRx12IUyA1vn3R9GiE3KYD14BXdQ=
+github.com/go-openapi/jsonpointer v0.20.0/go.mod h1:6PGzBjjIIumbLYysB73Klnms1mwnU4G3YHOECG3CedA=
github.com/go-openapi/jsonreference v0.20.0/go.mod h1:Ag74Ico3lPc+zR+qjn4XBUmXymS4zJbYVCZmcgkasdo=
-github.com/go-openapi/spec v0.20.7 h1:1Rlu/ZrOCCob0n+JKKJAWhNWMPW8bOZRg8FJaY+0SKI=
-github.com/go-openapi/spec v0.20.7/go.mod h1:2OpW+JddWPrpXSCIX8eOx7lZ5iyuWj3RYR6VaaBKcWA=
+github.com/go-openapi/jsonreference v0.20.2 h1:3sVjiK66+uXK/6oQ8xgcRKcFgQ5KXa2KvnJRumpMGbE=
+github.com/go-openapi/jsonreference v0.20.2/go.mod h1:Bl1zwGIM8/wsvqjsOQLJ/SH+En5Ap4rVB5KVcIDZG2k=
+github.com/go-openapi/spec v0.20.9 h1:xnlYNQAwKd2VQRRfwTEI0DcK+2cbuvI/0c7jx3gA8/8=
+github.com/go-openapi/spec v0.20.9/go.mod h1:2OpW+JddWPrpXSCIX8eOx7lZ5iyuWj3RYR6VaaBKcWA=
github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
github.com/go-openapi/swag v0.19.15/go.mod h1:QYRuS/SOXUCsnplDa677K7+DxSOj6IPNl/eQntq43wQ=
-github.com/go-openapi/swag v0.22.3 h1:yMBqmnQ0gyZvEb/+KzuWZOXgllrXT4SADYbvDaXHv/g=
github.com/go-openapi/swag v0.22.3/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
-github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
-github.com/go-playground/locales v0.14.0 h1:u50s323jtVGugKlcYeyzC0etD1HifMjqmJqb8WugfUU=
-github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
-github.com/go-playground/universal-translator v0.18.0 h1:82dyy6p4OuJq4/CByFNOn/jYrnRPArHwAcmLoJZxyho=
-github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
-github.com/go-playground/validator/v10 v10.11.1 h1:prmOlTVv+YjZjmRmNSF3VmspqJIxJWXmqUsHwfTRRkQ=
-github.com/go-playground/validator/v10 v10.11.1/go.mod h1:i+3WkQ1FvaUjjxh1kSvIA4dMGDBiPU55YFDl0WbKdWU=
+github.com/go-openapi/swag v0.22.4 h1:QLMzNJnMGPRNDCbySlcj1x01tzU8/9LTTL9hZZZogBU=
+github.com/go-openapi/swag v0.22.4/go.mod h1:UzaqsxGiab7freDnrUUra0MwWfN/q7tE4j+VcZ0yl14=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.18.0 h1:BvolUXjp4zuvkZ5YN5t7ebzbhlUtPsPm2S9NAZ5nl9U=
+github.com/go-playground/validator/v10 v10.18.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/gocarina/gocsv v0.0.0-20231116093920-b87c2d0e983a h1:RYfmiM0zluBJOiPDJseKLEN4BapJ42uSi9SZBQ2YyiA=
+github.com/gocarina/gocsv v0.0.0-20231116093920-b87c2d0e983a/go.mod h1:5YoVOkjYAQumqlV356Hj3xeYh4BdZuLE0/nRkf2NKkI=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hashicorp/hcl/v2 v2.15.0 h1:CPDXO6+uORPjKflkWCCwoWc9uRp+zSIPcCQ+BrxV7m8=
-github.com/hashicorp/hcl/v2 v2.15.0/go.mod h1:JRmR89jycNkrrqnMmvPDMd56n1rQJ2Q6KocSLCMCXng=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/schema v1.2.1 h1:tjDxcmdb+siIqkTNoV+qRH2mjYdr2hHe5MKXbp61ziM=
+github.com/gorilla/schema v1.2.1/go.mod h1:Dg5SSm5PV60mhF2NFaTV1xuYYj8tV8NOPRo4FggUMnM=
+github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
+github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
+github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
+github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hashicorp/hcl/v2 v2.19.1 h1://i05Jqznmb2EXqa39Nsvyan2o5XyMowW5fnCKW5RPI=
+github.com/hashicorp/hcl/v2 v2.19.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE=
+github.com/hay-kot/httpkit v0.0.6 h1:BidC4UrkS7zRhoTdpKLeF8ODJPKcOZkJ2tk2t2ZIQjQ=
+github.com/hay-kot/httpkit v0.0.6/go.mod h1:1s/OJwWRyH6tBtTw76jTp6kwBYvjswziXaokPQH7eKQ=
+github.com/hay-kot/httpkit v0.0.7 h1:KxGi+MwXFavfFUfJEMpye5cnMef9TlFu3v7UZipUB8U=
+github.com/hay-kot/httpkit v0.0.7/go.mod h1:AD22YluZrvBDxmtB3Pw2SOyp3A2PZqcmBZa0+COrhoU=
+github.com/hay-kot/httpkit v0.0.8 h1:n+Z5z35YZcdD9cGwbnIPRbrgDw9LY6lqakH4zYr5z+A=
+github.com/hay-kot/httpkit v0.0.8/go.mod h1:AD22YluZrvBDxmtB3Pw2SOyp3A2PZqcmBZa0+COrhoU=
+github.com/hay-kot/httpkit v0.0.9 h1:hu2TPY9awmIYWXxWGubaXl2U61pPvaVsm9YwboBRGu0=
+github.com/hay-kot/httpkit v0.0.9/go.mod h1:AD22YluZrvBDxmtB3Pw2SOyp3A2PZqcmBZa0+COrhoU=
+github.com/jarcoal/httpmock v1.3.0 h1:2RJ8GP0IIaWwcC9Fp2BmVi8Kog3v2Hn7VXM3fTd+nuc=
+github.com/jarcoal/httpmock v1.3.0/go.mod h1:3yb8rc4BI7TCBhFY8ng0gjuLKJNquuDNiPaZjnENuYg=
github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
-github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
-github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
-github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
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-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
-github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
-github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+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-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
+github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
+github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/olahol/melody v1.1.4 h1:RQHfKZkQmDxI0+SLZRNBCn4LiXdqxLKRGSkT8Dyoe/E=
+github.com/olahol/melody v1.1.4/go.mod h1:GgkTl6Y7yWj/HtfD48Q5vLKPVoZOH+Qqgfa7CvJgJM4=
+github.com/onsi/ginkgo/v2 v2.9.2 h1:BA2GMJOtfGAfagzYtrAlufIP0lq6QERkFmHLMLPwFSU=
+github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts=
+github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
+github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
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/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
-github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
-github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.28.0 h1:MirSo27VyNi7RJYP3078AA1+Cyzd2GB66qy3aUHvsWY=
-github.com/rs/zerolog v1.28.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0=
+github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
-github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/swaggo/files v1.0.0 h1:1gGXVIeUFCS/dta17rnP0iOpr6CXFwKD7EO5ID233e4=
-github.com/swaggo/files v1.0.0/go.mod h1:N59U6URJLyU1PQgFqPM7wXLMhJx7QAolnvfQkqO13kc=
-github.com/swaggo/http-swagger v1.3.3 h1:Hu5Z0L9ssyBLofaama21iYaF2VbWyA8jdohaaCGpHsc=
-github.com/swaggo/http-swagger v1.3.3/go.mod h1:sE+4PjD89IxMPm77FnkDz0sdO+p5lbXzrVWT6OTVVGo=
-github.com/swaggo/swag v1.8.9 h1:kHtaBe/Ob9AZzAANfcn5c6RyCke9gG9QpH0jky0I/sA=
-github.com/swaggo/swag v1.8.9/go.mod h1:ezQVUUhly8dludpVk+/PuwJWvLLanB13ygV5Pr9enSk=
-github.com/yeqown/go-qrcode/v2 v2.2.1 h1:Jc1Q916fwC05R8C7mpWDbrT9tyLPaLLKDABoC5XBCe8=
-github.com/yeqown/go-qrcode/v2 v2.2.1/go.mod h1:2Qsk2APUCPne0TsRo40DIkI5MYnbzYKCnKGEFWrxd24=
-github.com/yeqown/go-qrcode/writer/standard v1.2.1 h1:FMRZiur5yApUIe4fqtqmcdl/XQTZAZWt2DhkPx4VIW0=
-github.com/yeqown/go-qrcode/writer/standard v1.2.1/go.mod h1:ZelyDFiVymrauRjUn454iF7bjsabmB1vixkDA5kq2bw=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/swaggo/files/v2 v2.0.0 h1:hmAt8Dkynw7Ssz46F6pn8ok6YmGZqHSVLZ+HQM7i0kw=
+github.com/swaggo/files/v2 v2.0.0/go.mod h1:24kk2Y9NYEJ5lHuCra6iVwkMjIekMCaFq/0JQj66kyM=
+github.com/swaggo/http-swagger/v2 v2.0.2 h1:FKCdLsl+sFCx60KFsyM0rDarwiUSZ8DqbfSyIKC9OBg=
+github.com/swaggo/http-swagger/v2 v2.0.2/go.mod h1:r7/GBkAWIfK6E/OLnE8fXnviHiDeAHmgIyooa4xm3AQ=
+github.com/swaggo/swag v1.16.3 h1:PnCYjPCah8FK4I26l2F/KQ4yz3sILcVUN3cTlBFA9Pg=
+github.com/swaggo/swag v1.16.3/go.mod h1:DImHIuOFXKpMFAQjcC7FG4m3Dg4+QuUgUzJmKjI/gRk=
+github.com/yeqown/go-qrcode/v2 v2.2.2 h1:0comk6jEwi0oWNhKEmzx4JI+Q7XIneAApmFSMKWmSVc=
+github.com/yeqown/go-qrcode/v2 v2.2.2/go.mod h1:2Qsk2APUCPne0TsRo40DIkI5MYnbzYKCnKGEFWrxd24=
+github.com/yeqown/go-qrcode/writer/standard v1.2.2 h1:gyzunKXgC0ZUpKqQFUImbAEwewAiwNCkxFEKZV80Kt4=
+github.com/yeqown/go-qrcode/writer/standard v1.2.2/go.mod h1:bbVRiBJSRPj4UBZP/biLG7JSd9kHqXjErk1eakAMnRA=
github.com/yeqown/reedsolomon v1.0.0 h1:x1h/Ej/uJnNu8jaX7GLHBWmZKCAWjEJTetkqaabr4B0=
github.com/yeqown/reedsolomon v1.0.0/go.mod h1:P76zpcn2TCuL0ul1Fso373qHRc69LKwAw/Iy6g1WiiM=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/zclconf/go-cty v1.12.1 h1:PcupnljUm9EIvbgSHQnHhUr3fO6oFmkOrvs2BAFNXXY=
-github.com/zclconf/go-cty v1.12.1/go.mod h1:s9IfD1LK5ccNMSWCVFCE2rJfHiZgi7JijgeWIMfhLvA=
-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.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.5.0 h1:U/0M97KRkSFvyD/3FSmdP5W5swImpNgle/EHFhOsQPE=
-golang.org/x/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
-golang.org/x/image v0.0.0-20200927104501-e162460cd6b5 h1:QelT11PB4FXiDEXucrfNckHoFxwt8USGY1ajP1ZF5lM=
-golang.org/x/image v0.0.0-20200927104501-e162460cd6b5/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
-golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-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-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
-golang.org/x/net v0.5.0 h1:GyT4nK/YDHSqa1c4753ouYCDajOYKTja9Xb/OHtgvSw=
-golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
-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/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-20210423082822-04245dca01da/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-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/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=
+github.com/zclconf/go-cty v1.14.1 h1:t9fyA35fwjjUMcmL5hLER+e/rEPqrbCK1/OSE4SI9KA=
+github.com/zclconf/go-cty v1.14.1/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/image v0.14.0 h1:tNgSxAFe3jC4uYqvZdTr84SZoM1KfwdC9SKIFrLjFn4=
+golang.org/x/image v0.14.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
+golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=
+golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
-golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-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.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
-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.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.6.0 h1:3XmdazWV+ubf7QgHSTWeykHOci5oeekaGJBLkrkaw4k=
-golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-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.4.0 h1:7mTAgkunk3fr4GAloyyCasadO6h9zSsQZbwvcaIciV4=
-golang.org/x/tools v0.4.0/go.mod h1:UE5sM2OK9E/d67R0ANs2xJizIymRP5gJU295PvKXxjQ=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc=
+golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
+google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
+google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI=
+modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4=
+modernc.org/libc v1.41.0 h1:g9YAc6BkKlgORsUWj+JwqoB1wU3o4DE3bM3yvA3k+Gk=
+modernc.org/libc v1.41.0/go.mod h1:w0eszPsiXoOnoMJgrXjglgLuDy/bt5RR4y3QzUUeodY=
+modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
+modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
+modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
+modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
+modernc.org/sqlite v1.29.2 h1:xgBSyA3gemwgP31PWFfFjtBorQNYpeypGdoSDjXhrgI=
+modernc.org/sqlite v1.29.2/go.mod h1:hG41jCYxOAOoO6BRK66AdRlmOcDzXf7qnwlwjUIOqa0=
+modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA=
+modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
diff --git a/backend/internal/core/currencies/currencies.go b/backend/internal/core/currencies/currencies.go
new file mode 100644
index 0000000..4cc8766
--- /dev/null
+++ b/backend/internal/core/currencies/currencies.go
@@ -0,0 +1,104 @@
+// Package currencies provides a shared definition of currencies. This uses a global
+// variable to hold the currencies.
+package currencies
+
+import (
+ "bytes"
+ _ "embed"
+ "encoding/json"
+ "io"
+ "slices"
+ "strings"
+ "sync"
+)
+
+//go:embed currencies.json
+var defaults []byte
+
+type CollectorFunc func() ([]Currency, error)
+
+func CollectJSON(reader io.Reader) CollectorFunc {
+ return func() ([]Currency, error) {
+ var currencies []Currency
+ err := json.NewDecoder(reader).Decode(¤cies)
+ if err != nil {
+ return nil, err
+ }
+
+ return currencies, nil
+ }
+}
+
+func CollectDefaults() CollectorFunc {
+ return CollectJSON(bytes.NewReader(defaults))
+}
+
+func CollectionCurrencies(collectors ...CollectorFunc) ([]Currency, error) {
+ out := make([]Currency, 0, len(collectors))
+ for i := range collectors {
+ c, err := collectors[i]()
+ if err != nil {
+ return nil, err
+ }
+
+ out = append(out, c...)
+ }
+
+ return out, nil
+}
+
+type Currency struct {
+ Name string `json:"name"`
+ Code string `json:"code"`
+ Local string `json:"local"`
+ Symbol string `json:"symbol"`
+}
+
+type CurrencyRegistry struct {
+ mu sync.RWMutex
+ registry map[string]Currency
+}
+
+func NewCurrencyService(currencies []Currency) *CurrencyRegistry {
+ registry := make(map[string]Currency, len(currencies))
+ for i := range currencies {
+ registry[currencies[i].Code] = currencies[i]
+ }
+
+ return &CurrencyRegistry{
+ registry: registry,
+ }
+}
+
+func (cs *CurrencyRegistry) Slice() []Currency {
+ cs.mu.RLock()
+ defer cs.mu.RUnlock()
+
+ out := make([]Currency, 0, len(cs.registry))
+ for key := range cs.registry {
+ out = append(out, cs.registry[key])
+ }
+
+ slices.SortFunc(out, func(a, b Currency) int {
+ if a.Name < b.Name {
+ return -1
+ }
+
+ if a.Name > b.Name {
+ return 1
+ }
+
+ return 0
+ })
+
+ return out
+}
+
+func (cs *CurrencyRegistry) IsSupported(code string) bool {
+ upper := strings.ToUpper(code)
+
+ cs.mu.RLock()
+ defer cs.mu.RUnlock()
+ _, ok := cs.registry[upper]
+ return ok
+}
diff --git a/backend/internal/core/currencies/currencies.json b/backend/internal/core/currencies/currencies.json
new file mode 100644
index 0000000..c7b2630
--- /dev/null
+++ b/backend/internal/core/currencies/currencies.json
@@ -0,0 +1,638 @@
+[
+ {
+ "code": "USD",
+ "local": "United States",
+ "symbol": "$",
+ "name": "United States Dollar"
+ },
+ {
+ "code": "AED",
+ "local": "United Arab Emirates",
+ "symbol": "د.إ",
+ "name": "United Arab Emirates Dirham"
+ },
+ {
+ "code": "AFN",
+ "local": "Afghanistan",
+ "symbol": "؋",
+ "name": "Afghan Afghani"
+ },
+ {
+ "code": "ALL",
+ "local": "Albania",
+ "symbol": "L",
+ "name": "Albanian Lek"
+ },
+ {
+ "code": "AMD",
+ "local": "Armenia",
+ "symbol": "֏",
+ "name": "Armenian Dram"
+ },
+ {
+ "code": "ANG",
+ "local": "Netherlands Antilles",
+ "symbol": "ƒ",
+ "name": "Netherlands Antillean Guilder"
+ },
+ {
+ "code": "AOA",
+ "local": "Angola",
+ "symbol": "Kz",
+ "name": "Angolan Kwanza"
+ },
+ {
+ "code": "ARS",
+ "local": "Argentina",
+ "symbol": "$",
+ "name": "Argentine Peso"
+ },
+ {
+ "code": "AUD",
+ "local": "Australia",
+ "symbol": "A$",
+ "name": "Australian Dollar"
+ },
+ {
+ "code": "AWG",
+ "local": "Aruba",
+ "symbol": "ƒ",
+ "name": "Aruban Florin"
+ },
+ {
+ "code": "AZN",
+ "local": "Azerbaijan",
+ "symbol": "₼",
+ "name": "Azerbaijani Manat"
+ },
+ {
+ "code": "BAM",
+ "local": "Bosnia and Herzegovina",
+ "symbol": "KM",
+ "name": "Bosnia and Herzegovina Convertible Mark"
+ },
+ {
+ "code": "BBD",
+ "local": "Barbados",
+ "symbol": "Bds$",
+ "name": "Barbadian Dollar"
+ },
+ {
+ "code": "BDT",
+ "local": "Bangladesh",
+ "symbol": "৳",
+ "name": "Bangladeshi Taka"
+ },
+ {
+ "code": "BGN",
+ "local": "Bulgaria",
+ "symbol": "лв",
+ "name": "Bulgarian lev"
+ },
+ {
+ "code": "BHD",
+ "local": "Bahrain",
+ "symbol": "ب.د",
+ "name": "Bahraini Dinar"
+ },
+ {
+ "code": "BIF",
+ "local": "Burundi",
+ "symbol": "FBu",
+ "name": "Burundian Franc"
+ },
+ {
+ "code": "BMD",
+ "local": "Bermuda",
+ "symbol": "BD$",
+ "name": "Bermudian Dollar"
+ },
+ {
+ "code": "BND",
+ "local": "Brunei",
+ "symbol": "B$",
+ "name": "Brunei Dollar"
+ },
+ {
+ "code": "BOB",
+ "local": "Bolivia",
+ "symbol": "Bs.",
+ "name": "Bolivian Boliviano"
+ },
+ {
+ "code": "BRL",
+ "local": "Brazil",
+ "symbol": "R$",
+ "name": "Brazilian Real"
+ },
+ {
+ "code": "BSD",
+ "local": "Bahamas",
+ "symbol": "B$",
+ "name": "Bahamian Dollar"
+ },
+ {
+ "code": "BTN",
+ "local": "Bhutan",
+ "symbol": "Nu.",
+ "name": "Bhutanese Ngultrum"
+ },
+ {
+ "code": "BWP",
+ "local": "Botswana",
+ "symbol": "P",
+ "name": "Botswana Pula"
+ },
+ {
+ "code": "BYN",
+ "local": "Belarus",
+ "symbol": "Br",
+ "name": "Belarusian Ruble"
+ },
+ {
+ "code": "BZD",
+ "local": "Belize",
+ "symbol": "BZ$",
+ "name": "Belize Dollar"
+ },
+ {
+ "code": "CAD",
+ "local": "Canada",
+ "symbol": "C$",
+ "name": "Canadian Dollar"
+ },
+ {
+ "code": "CDF",
+ "local": "Democratic Republic of the Congo",
+ "symbol": "FC",
+ "name": "Congolese Franc"
+ },
+ {
+ "code": "CHF",
+ "local": "Switzerland",
+ "symbol": "CHF",
+ "name": "Swiss Franc"
+ },
+ {
+ "code": "CLP",
+ "local": "Chile",
+ "symbol": "CL$",
+ "name": "Chilean Peso"
+ },
+ {
+ "code": "CNY",
+ "local": "China",
+ "symbol": "¥",
+ "name": "Chinese Yuan"
+ },
+ {
+ "code": "COP",
+ "local": "Colombia",
+ "symbol": "COL$",
+ "name": "Colombian Peso"
+ },
+ {
+ "code": "CRC",
+ "local": "Costa Rica",
+ "symbol": "₡",
+ "name": "Costa Rican Colón"
+ },
+ {
+ "code": "CUP",
+ "local": "Cuba",
+ "symbol": "₱",
+ "name": "Cuban Peso"
+ },
+ {
+ "code": "CVE",
+ "local": "Cape Verde",
+ "symbol": "$",
+ "name": "Cape Verdean Escudo"
+ },
+ {
+ "code": "CZK",
+ "local": "Czech Republic",
+ "symbol": "Kč",
+ "name": "Czech Koruna"
+ },
+ {
+ "code": "DJF",
+ "local": "Djibouti",
+ "symbol": "Fdj",
+ "name": "Djiboutian Franc"
+ },
+ {
+ "code": "DKK",
+ "local": "Denmark",
+ "symbol": "kr",
+ "name": "Danish Krone"
+ },
+ {
+ "code": "DOP",
+ "local": "Dominican Republic",
+ "symbol": "RD$",
+ "name": "Dominican Peso"
+ },
+ {
+ "code": "DZD",
+ "local": "Algeria",
+ "symbol": "د.ج",
+ "name": "Algerian Dinar"
+ },
+ {
+ "code": "EGP",
+ "local": "Egypt",
+ "symbol": "£",
+ "name": "Egyptian Pound"
+ },
+ {
+ "code": "ERN",
+ "local": "Eritrea",
+ "symbol": "Nfk",
+ "name": "Eritrean Nakfa"
+ },
+ {
+ "code": "ETB",
+ "local": "Ethiopia",
+ "symbol": "Br",
+ "name": "Ethiopian Birr"
+ },
+ {
+ "code": "EUR",
+ "local": "Eurozone",
+ "symbol": "€",
+ "name": "Euro"
+ },
+ {
+ "code": "FJD",
+ "local": "Fiji",
+ "symbol": "FJ$",
+ "name": "Fijian Dollar"
+ },
+ {
+ "code": "FKP",
+ "local": "Falkland Islands",
+ "symbol": "£",
+ "name": "Falkland Islands Pound"
+ },
+ {
+ "code": "FOK",
+ "local": "Faroe Islands",
+ "symbol": "kr",
+ "name": "Faroese Króna"
+ },
+ {
+ "code": "GBP",
+ "local": "United Kingdom",
+ "symbol": "£",
+ "name": "British Pound Sterling"
+ },
+ {
+ "code": "GEL",
+ "local": "Georgia",
+ "symbol": "₾",
+ "name": "Georgian Lari"
+ },
+ {
+ "code": "GGP",
+ "local": "Guernsey",
+ "symbol": "£",
+ "name": "Guernsey Pound"
+ },
+ {
+ "code": "GHS",
+ "local": "Ghana",
+ "symbol": "GH₵",
+ "name": "Ghanaian Cedi"
+ },
+ {
+ "code": "GIP",
+ "local": "Gibraltar",
+ "symbol": "£",
+ "name": "Gibraltar Pound"
+ },
+ {
+ "code": "GMD",
+ "local": "Gambia",
+ "symbol": "D",
+ "name": "Gambian Dalasi"
+ },
+ {
+ "code": "GNF",
+ "local": "Guinea",
+ "symbol": "FG",
+ "name": "Guinean Franc"
+ },
+ {
+ "code": "GTQ",
+ "local": "Guatemala",
+ "symbol": "Q",
+ "name": "Guatemalan Quetzal"
+ },
+ {
+ "code": "GYD",
+ "local": "Guyana",
+ "symbol": "GY$",
+ "name": "Guyanese Dollar"
+ },
+ {
+ "code": "HKD",
+ "local": "Hong Kong",
+ "symbol": "HK$",
+ "name": "Hong Kong Dollar"
+ },
+ {
+ "code": "HNL",
+ "local": "Honduras",
+ "symbol": "L",
+ "name": "Honduran Lempira"
+ },
+ {
+ "code": "HRK",
+ "local": "Croatia",
+ "symbol": "kn",
+ "name": "Croatian Kuna"
+ },
+ {
+ "code": "HTG",
+ "local": "Haiti",
+ "symbol": "G",
+ "name": "Haitian Gourde"
+ },
+ {
+ "code": "HUF",
+ "local": "Hungary",
+ "symbol": "Ft",
+ "name": "Hungarian Forint"
+ },
+ {
+ "code": "IDR",
+ "local": "Indonesia",
+ "symbol": "Rp",
+ "name": "Indonesian Rupiah"
+ },
+ {
+ "code": "ILS",
+ "local": "Israel",
+ "symbol": "₪",
+ "name": "Israeli New Shekel"
+ },
+ {
+ "code": "IMP",
+ "local": "Isle of Man",
+ "symbol": "£",
+ "name": "Manx Pound"
+ },
+ {
+ "code": "INR",
+ "local": "India",
+ "symbol": "₹",
+ "name": "Indian Rupee"
+ },
+ {
+ "code": "IQD",
+ "local": "Iraq",
+ "symbol": "ع.د",
+ "name": "Iraqi Dinar"
+ },
+ {
+ "code": "IRR",
+ "local": "Iran",
+ "symbol": "﷼",
+ "name": "Iranian Rial"
+ },
+ {
+ "code": "ISK",
+ "local": "Iceland",
+ "symbol": "kr",
+ "name": "Icelandic Króna"
+ },
+ {
+ "code": "JEP",
+ "local": "Jersey",
+ "symbol": "£",
+ "name": "Jersey Pound"
+ },
+ {
+ "code": "JMD",
+ "local": "Jamaica",
+ "symbol": "J$",
+ "name": "Jamaican Dollar"
+ },
+ {
+ "code": "JOD",
+ "local": "Jordan",
+ "symbol": "د.ا",
+ "name": "Jordanian Dinar"
+ },
+ {
+ "code": "JPY",
+ "local": "Japan",
+ "symbol": "¥",
+ "name": "Japanese Yen"
+ },
+ {
+ "code": "KES",
+ "local": "Kenya",
+ "symbol": "KSh",
+ "name": "Kenyan Shilling"
+ },
+ {
+ "code": "KGS",
+ "local": "Kyrgyzstan",
+ "symbol": "с",
+ "name": "Kyrgyzstani Som"
+ },
+ {
+ "code": "KHR",
+ "local": "Cambodia",
+ "symbol": "៛",
+ "name": "Cambodian Riel"
+ },
+ {
+ "code": "KID",
+ "local": "Kiribati",
+ "symbol": "$",
+ "name": "Kiribati Dollar"
+ },
+ {
+ "code": "KMF",
+ "local": "Comoros",
+ "symbol": "CF",
+ "name": "Comorian Franc"
+ },
+ {
+ "code": "KRW",
+ "local": "South Korea",
+ "symbol": "₩",
+ "name": "South Korean Won"
+ },
+ {
+ "code": "KWD",
+ "local": "Kuwait",
+ "symbol": "د.ك",
+ "name": "Kuwaiti Dinar"
+ },
+ {
+ "code": "KYD",
+ "local": "Cayman Islands",
+ "symbol": "CI$",
+ "name": "Cayman Islands Dollar"
+ },
+ {
+ "code": "KZT",
+ "local": "Kazakhstan",
+ "symbol": "₸",
+ "name": "Kazakhstani Tenge"
+ },
+ {
+ "code": "LAK",
+ "local": "Laos",
+ "symbol": "₭",
+ "name": "Lao Kip"
+ },
+ {
+ "code": "LBP",
+ "local": "Lebanon",
+ "symbol": "ل.ل",
+ "name": "Lebanese Pound"
+ },
+ {
+ "code": "LKR",
+ "local": "Sri Lanka",
+ "symbol": "₨",
+ "name": "Sri Lankan Rupee"
+ },
+ {
+ "code": "LRD",
+ "local": "Liberia",
+ "symbol": "L$",
+ "name": "Liberian Dollar"
+ },
+ {
+ "code": "LSL",
+ "local": "Lesotho",
+ "symbol": "M",
+ "name": "Lesotho Loti"
+ },
+ {
+ "code": "LYD",
+ "local": "Libya",
+ "symbol": "ل.د",
+ "name": "Libyan Dinar"
+ },
+ {
+ "code": "MAD",
+ "local": "Morocco",
+ "symbol": "د.م.",
+ "name": "Moroccan Dirham"
+ },
+ {
+ "code": "MDL",
+ "local": "Moldova",
+ "symbol": "lei",
+ "name": "Moldovan Leu"
+ },
+ {
+ "code": "MGA",
+ "local": "Madagascar",
+ "symbol": "Ar",
+ "name": "Malagasy Ariary"
+ },
+ {
+ "code": "MKD",
+ "local": "North Macedonia",
+ "symbol": "ден",
+ "name": "Macedonian Denar"
+ },
+ {
+ "code": "MMK",
+ "local": "Myanmar",
+ "symbol": "K",
+ "name": "Myanmar Kyat"
+ },
+ {
+ "code": "MNT",
+ "local": "Mongolia",
+ "symbol": "₮",
+ "name": "Mongolian Tugrik"
+ },
+ {
+ "code": "MOP",
+ "local": "Macau",
+ "symbol": "MOP$",
+ "name": "Macanese Pataca"
+ },
+ {
+ "code": "MRU",
+ "local": "Mauritania",
+ "symbol": "UM",
+ "name": "Mauritanian Ouguiya"
+ },
+ {
+ "code": "MUR",
+ "local": "Mauritius",
+ "symbol": "₨",
+ "name": "Mauritian Rupee"
+ },
+ {
+ "code": "MVR",
+ "local": "Maldives",
+ "symbol": "Rf",
+ "name": "Maldivian Rufiyaa"
+ },
+ {
+ "code": "MWK",
+ "local": "Malawi",
+ "symbol": "MK",
+ "name": "Malawian Kwacha"
+ },
+ {
+ "code": "MXN",
+ "local": "Mexico",
+ "symbol": "Mex$",
+ "name": "Mexican Peso"
+ },
+ {
+ "code": "MYR",
+ "local": "Malaysia",
+ "symbol": "RM",
+ "name": "Malaysian Ringgit"
+ },
+ {
+ "code": "MZN",
+ "local": "Mozambique",
+ "symbol": "MT",
+ "name": "Mozambican Metical"
+ },
+ {
+ "code": "NAD",
+ "local": "Namibia",
+ "symbol": "N$",
+ "name": "Namibian Dollar"
+ },
+ {
+ "code": "NGN",
+ "local": "Nigeria",
+ "symbol": "₦",
+ "name": "Nigerian Naira"
+ },
+ {
+ "code": "NIO",
+ "local": "Nicaragua",
+ "symbol": "C$",
+ "name": "Nicaraguan Córdoba"
+ },
+ {
+ "code": "NOK",
+ "local": "Norway",
+ "symbol": "kr",
+ "name": "Norwegian Krone"
+ },
+ {
+ "code": "UAH",
+ "local": "Ukraine",
+ "symbol": "₴",
+ "name": "Ukrainian Hryvnia"
+ }
+]
diff --git a/backend/internal/core/services/all.go b/backend/internal/core/services/all.go
index 43deb52..3c03a4e 100644
--- a/backend/internal/core/services/all.go
+++ b/backend/internal/core/services/all.go
@@ -1,17 +1,24 @@
+// Package services provides the core business logic for the application.
package services
-import "github.com/hay-kot/homebox/backend/internal/data/repo"
+import (
+ "github.com/hay-kot/homebox/backend/internal/core/currencies"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+)
type AllServices struct {
- User *UserService
- Group *GroupService
- Items *ItemService
+ User *UserService
+ Group *GroupService
+ Items *ItemService
+ BackgroundService *BackgroundService
+ Currencies *currencies.CurrencyRegistry
}
type OptionsFunc func(*options)
type options struct {
autoIncrementAssetID bool
+ currencies []currencies.Currency
}
func WithAutoIncrementAssetID(v bool) func(*options) {
@@ -20,13 +27,27 @@ func WithAutoIncrementAssetID(v bool) func(*options) {
}
}
+func WithCurrencies(v []currencies.Currency) func(*options) {
+ return func(o *options) {
+ o.currencies = v
+ }
+}
+
func New(repos *repo.AllRepos, opts ...OptionsFunc) *AllServices {
if repos == nil {
panic("repos cannot be nil")
}
+ defaultCurrencies, err := currencies.CollectionCurrencies(
+ currencies.CollectDefaults(),
+ )
+ if err != nil {
+ panic("failed to collect default currencies")
+ }
+
options := &options{
autoIncrementAssetID: true,
+ currencies: defaultCurrencies,
}
for _, opt := range opts {
@@ -40,5 +61,7 @@ func New(repos *repo.AllRepos, opts ...OptionsFunc) *AllServices {
repo: repos,
autoIncrementAssetID: options.autoIncrementAssetID,
},
+ BackgroundService: &BackgroundService{repos},
+ Currencies: currencies.NewCurrencyService(options.currencies),
}
}
diff --git a/backend/internal/core/services/main_test.go b/backend/internal/core/services/main_test.go
index e1f7282..ecb07b0 100644
--- a/backend/internal/core/services/main_test.go
+++ b/backend/internal/core/services/main_test.go
@@ -3,11 +3,11 @@ package services
import (
"context"
"log"
- "math/rand"
"os"
"testing"
- "time"
+ "github.com/hay-kot/homebox/backend/internal/core/currencies"
+ "github.com/hay-kot/homebox/backend/internal/core/services/reporting/eventbus"
"github.com/hay-kot/homebox/backend/internal/data/ent"
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/hay-kot/homebox/backend/pkgs/faker"
@@ -15,7 +15,8 @@ import (
)
var (
- fk = faker.NewFaker()
+ fk = faker.NewFaker()
+ tbus = eventbus.New()
tCtx = Context{}
tClient *ent.Client
@@ -49,8 +50,6 @@ func bootstrap() {
}
func TestMain(m *testing.M) {
- rand.Seed(int64(time.Now().Unix()))
-
client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
if err != nil {
log.Fatalf("failed opening connection to sqlite: %v", err)
@@ -62,9 +61,14 @@ func TestMain(m *testing.M) {
}
tClient = client
- tRepos = repo.New(tClient, os.TempDir()+"/homebox")
- tSvc = New(tRepos)
- defer client.Close()
+ tRepos = repo.New(tClient, tbus, os.TempDir()+"/homebox")
+
+ defaults, _ := currencies.CollectionCurrencies(
+ currencies.CollectDefaults(),
+ )
+
+ tSvc = New(tRepos, WithCurrencies(defaults))
+ defer func() { _ = client.Close() }()
bootstrap()
tCtx = Context{
diff --git a/backend/internal/core/services/reporting/.testdata/import/fields.csv b/backend/internal/core/services/reporting/.testdata/import/fields.csv
new file mode 100644
index 0000000..28c3c17
--- /dev/null
+++ b/backend/internal/core/services/reporting/.testdata/import/fields.csv
@@ -0,0 +1,5 @@
+HB.location,HB.name,HB.quantity,HB.description,HB.field.Custom Field 1,HB.field.Custom Field 2,HB.field.Custom Field 3
+loc,Item 1,1,Description 1,Value 1[1],Value 1[2],Value 1[3]
+loc,Item 2,2,Description 2,Value 2[1],Value 2[2],Value 2[3]
+loc,Item 3,3,Description 3,Value 3[1],Value 3[2],Value 3[3]
+
diff --git a/backend/internal/core/services/reporting/.testdata/import/minimal.csv b/backend/internal/core/services/reporting/.testdata/import/minimal.csv
new file mode 100644
index 0000000..be39ad2
--- /dev/null
+++ b/backend/internal/core/services/reporting/.testdata/import/minimal.csv
@@ -0,0 +1,4 @@
+HB.location,HB.name,HB.quantity,HB.description
+loc,Item 1,1,Description 1
+loc,Item 2,2,Description 2
+loc,Item 3,3,Description 3
\ No newline at end of file
diff --git a/backend/internal/core/services/reporting/.testdata/import/types.csv b/backend/internal/core/services/reporting/.testdata/import/types.csv
new file mode 100644
index 0000000..96ff236
--- /dev/null
+++ b/backend/internal/core/services/reporting/.testdata/import/types.csv
@@ -0,0 +1,4 @@
+HB.name,HB.asset_id,HB.location,HB.labels
+Item 1,1,Path / To / Location 1,L1 ; L2 ; L3
+Item 2,000-002,Path /To/ Location 2,L1;L2;L3
+Item 3,1000-003,Path / To /Location 3 , L1;L2; L3
\ No newline at end of file
diff --git a/backend/internal/core/services/reporting/bill_of_materials.go b/backend/internal/core/services/reporting/bill_of_materials.go
new file mode 100644
index 0000000..4147d4b
--- /dev/null
+++ b/backend/internal/core/services/reporting/bill_of_materials.go
@@ -0,0 +1,42 @@
+package reporting
+
+import (
+ "github.com/gocarina/gocsv"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/hay-kot/homebox/backend/internal/data/types"
+)
+
+// =================================================================================================
+
+type BillOfMaterialsEntry struct {
+ PurchaseDate types.Date `csv:"Purchase Date"`
+ Name string `csv:"Name"`
+ Description string `csv:"Description"`
+ Manufacturer string `csv:"Manufacturer"`
+ SerialNumber string `csv:"Serial Number"`
+ ModelNumber string `csv:"Model Number"`
+ Quantity int `csv:"Quantity"`
+ Price float64 `csv:"Price"`
+ TotalPrice float64 `csv:"Total Price"`
+}
+
+// BillOfMaterialsTSV returns a byte slice of the Bill of Materials for a given GID in TSV format
+// See BillOfMaterialsEntry for the format of the output
+func BillOfMaterialsTSV(entities []repo.ItemOut) ([]byte, error) {
+ bomEntries := make([]BillOfMaterialsEntry, len(entities))
+ for i, entity := range entities {
+ bomEntries[i] = BillOfMaterialsEntry{
+ PurchaseDate: entity.PurchaseTime,
+ Name: entity.Name,
+ Description: entity.Description,
+ Manufacturer: entity.Manufacturer,
+ SerialNumber: entity.SerialNumber,
+ ModelNumber: entity.ModelNumber,
+ Quantity: entity.Quantity,
+ Price: entity.PurchasePrice,
+ TotalPrice: entity.PurchasePrice * float64(entity.Quantity),
+ }
+ }
+
+ return gocsv.MarshalBytes(&bomEntries)
+}
diff --git a/backend/internal/core/services/reporting/eventbus/eventbus.go b/backend/internal/core/services/reporting/eventbus/eventbus.go
new file mode 100644
index 0000000..581bc38
--- /dev/null
+++ b/backend/internal/core/services/reporting/eventbus/eventbus.go
@@ -0,0 +1,91 @@
+// Package eventbus provides an interface for event bus.
+package eventbus
+
+import (
+ "context"
+ "sync"
+
+ "github.com/google/uuid"
+)
+
+type Event string
+
+const (
+ EventLabelMutation Event = "label.mutation"
+ EventLocationMutation Event = "location.mutation"
+ EventItemMutation Event = "item.mutation"
+)
+
+type GroupMutationEvent struct {
+ GID uuid.UUID
+}
+
+type eventData struct {
+ event Event
+ data any
+}
+
+type EventBus struct {
+ started bool
+ ch chan eventData
+
+ mu sync.RWMutex
+ subscribers map[Event][]func(any)
+}
+
+func New() *EventBus {
+ return &EventBus{
+ ch: make(chan eventData, 100),
+ subscribers: map[Event][]func(any){
+ EventLabelMutation: {},
+ EventLocationMutation: {},
+ EventItemMutation: {},
+ },
+ }
+}
+
+func (e *EventBus) Run(ctx context.Context) error {
+ if e.started {
+ panic("event bus already started")
+ }
+
+ e.started = true
+
+ for {
+ select {
+ case <-ctx.Done():
+ return nil
+ case event := <-e.ch:
+ e.mu.RLock()
+ arr, ok := e.subscribers[event.event]
+ e.mu.RUnlock()
+
+ if !ok {
+ continue
+ }
+
+ for _, fn := range arr {
+ fn(event.data)
+ }
+ }
+ }
+}
+
+func (e *EventBus) Publish(event Event, data any) {
+ e.ch <- eventData{
+ event: event,
+ data: data,
+ }
+}
+
+func (e *EventBus) Subscribe(event Event, fn func(any)) {
+ e.mu.Lock()
+ defer e.mu.Unlock()
+
+ arr, ok := e.subscribers[event]
+ if !ok {
+ panic("event not found")
+ }
+
+ e.subscribers[event] = append(arr, fn)
+}
diff --git a/backend/internal/core/services/reporting/import.go b/backend/internal/core/services/reporting/import.go
new file mode 100644
index 0000000..6f01b1b
--- /dev/null
+++ b/backend/internal/core/services/reporting/import.go
@@ -0,0 +1,94 @@
+// Package reporting provides a way to import CSV files into the database.
+package reporting
+
+import (
+ "bytes"
+ "encoding/csv"
+ "errors"
+ "io"
+ "strings"
+)
+
+var (
+ ErrNoHomeboxHeaders = errors.New("no headers found")
+ ErrMissingRequiredHeaders = errors.New("missing required headers `HB.location` or `HB.name`")
+)
+
+// determineSeparator determines the separator used in the CSV file
+// It returns the separator as a rune and an error if it could not be determined
+//
+// It is assumed that the first row is the header row and that the separator is the same
+// for all rows.
+//
+// Supported separators are `,` and `\t`
+func determineSeparator(data []byte) (rune, error) {
+ // First row
+ firstRow := bytes.Split(data, []byte("\n"))[0]
+
+ // find first comma or /t
+ comma := bytes.IndexByte(firstRow, ',')
+ tab := bytes.IndexByte(firstRow, '\t')
+
+ switch {
+ case comma == -1 && tab == -1:
+ return 0, errors.New("could not determine separator")
+ case tab > comma:
+ return '\t', nil
+ default:
+ return ',', nil
+ }
+}
+
+// readRawCsv reads a CSV file and returns the raw data as a 2D string array
+// It determines the separator used in the CSV file and returns an error if
+// it could not be determined
+func readRawCsv(r io.Reader) ([][]string, error) {
+ data, err := io.ReadAll(r)
+ if err != nil {
+ return nil, err
+ }
+
+ reader := csv.NewReader(bytes.NewReader(data))
+
+ // Determine separator
+ sep, err := determineSeparator(data)
+ if err != nil {
+ return nil, err
+ }
+
+ reader.Comma = sep
+
+ return reader.ReadAll()
+}
+
+// parseHeaders parses the homebox headers from the CSV file and returns a map of the headers
+// and their column index as well as a list of the field headers (HB.field.*) in the order
+// they appear in the CSV file
+//
+// It returns an error if no homebox headers are found
+func parseHeaders(headers []string) (hbHeaders map[string]int, fieldHeaders []string, err error) {
+ hbHeaders = map[string]int{} // initialize map
+
+ for col, h := range headers {
+ if strings.HasPrefix(h, "HB.field.") {
+ fieldHeaders = append(fieldHeaders, h)
+ }
+
+ if strings.HasPrefix(h, "HB.") {
+ hbHeaders[h] = col
+ }
+ }
+
+ required := []string{"HB.location", "HB.name"}
+ for _, h := range required {
+ if _, ok := hbHeaders[h]; !ok {
+ return nil, nil, ErrMissingRequiredHeaders
+ }
+ }
+
+ if len(hbHeaders) == 0 {
+ return nil, nil, ErrNoHomeboxHeaders
+ }
+
+ return hbHeaders, fieldHeaders, nil
+}
diff --git a/backend/internal/core/services/reporting/io_row.go b/backend/internal/core/services/reporting/io_row.go
new file mode 100644
index 0000000..c80e00d
--- /dev/null
+++ b/backend/internal/core/services/reporting/io_row.go
@@ -0,0 +1,95 @@
+package reporting
+
+import (
+ "strings"
+
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/hay-kot/homebox/backend/internal/data/types"
+)
+
+type ExportItemFields struct {
+ Name string
+ Value string
+}
+
+type ExportTSVRow struct {
+ ImportRef string `csv:"HB.import_ref"`
+ Location LocationString `csv:"HB.location"`
+ LabelStr LabelString `csv:"HB.labels"`
+ AssetID repo.AssetID `csv:"HB.asset_id"`
+ Archived bool `csv:"HB.archived"`
+
+ Name string `csv:"HB.name"`
+ Quantity int `csv:"HB.quantity"`
+ Description string `csv:"HB.description"`
+ Insured bool `csv:"HB.insured"`
+ Notes string `csv:"HB.notes"`
+
+ PurchasePrice float64 `csv:"HB.purchase_price"`
+ PurchaseFrom string `csv:"HB.purchase_from"`
+ PurchaseTime types.Date `csv:"HB.purchase_time"`
+
+ Manufacturer string `csv:"HB.manufacturer"`
+ ModelNumber string `csv:"HB.model_number"`
+ SerialNumber string `csv:"HB.serial_number"`
+
+ LifetimeWarranty bool `csv:"HB.lifetime_warranty"`
+ WarrantyExpires types.Date `csv:"HB.warranty_expires"`
+ WarrantyDetails string `csv:"HB.warranty_details"`
+
+ SoldTo string `csv:"HB.sold_to"`
+ SoldPrice float64 `csv:"HB.sold_price"`
+ SoldTime types.Date `csv:"HB.sold_time"`
+ SoldNotes string `csv:"HB.sold_notes"`
+
+ Fields []ExportItemFields `csv:"-"`
+}
+
+// ============================================================================
+
+// LabelString is a string slice that is used to represent a list of labels.
+//
+// For example, a list of labels "Important; Work" would be represented as a
+// LabelString with the following values:
+//
+// LabelString{"Important", "Work"}
+type LabelString []string
+
+func parseLabelString(s string) LabelString {
+ v, _ := parseSeparatedString(s, ";")
+ return v
+}
+
+func (ls LabelString) String() string {
+ return strings.Join(ls, "; ")
+}
+
+// ============================================================================
+
+// LocationString is a string slice that is used to represent a location
+// hierarchy.
+//
+// For example, a location hierarchy of "Home / Bedroom / Desk" would be
+// represented as a LocationString with the following values:
+//
+// LocationString{"Home", "Bedroom", "Desk"}
+type LocationString []string
+
+func parseLocationString(s string) LocationString {
+ v, _ := parseSeparatedString(s, "/")
+ return v
+}
+
+func (csf LocationString) String() string {
+ return strings.Join(csf, " / ")
+}
+
+func fromPathSlice(s []repo.ItemPath) LocationString {
+ v := make(LocationString, len(s))
+
+ for i := range s {
+ v[i] = s[i].Name
+ }
+
+ return v
+}
diff --git a/backend/internal/core/services/reporting/io_sheet.go b/backend/internal/core/services/reporting/io_sheet.go
new file mode 100644
index 0000000..5877f3e
--- /dev/null
+++ b/backend/internal/core/services/reporting/io_sheet.go
@@ -0,0 +1,322 @@
+package reporting
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+
+ "github.com/google/uuid"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/hay-kot/homebox/backend/internal/data/types"
+ "github.com/rs/zerolog/log"
+)
+
+// IOSheet is the representation of a CSV/TSV sheet that is used for importing/exporting
+// items from homebox. It is used to read/write the data from/to a CSV/TSV file given
+// the standard format of the file.
+//
+// See ExportTSVRow for the format of the data in the sheet.
+type IOSheet struct {
+ headers []string
+ custom []int
+ index map[string]int
+ Rows []ExportTSVRow
+}
+
+func (s *IOSheet) indexHeaders() {
+ s.index = make(map[string]int)
+
+ for i, h := range s.headers {
+ if strings.HasPrefix(h, "HB.field") {
+ s.custom = append(s.custom, i)
+ }
+
+ if strings.HasPrefix(h, "HB.") {
+ s.index[h] = i
+ }
+ }
+}
+
+func (s *IOSheet) GetColumn(str string) (col int, ok bool) {
+ if s.index == nil {
+ s.indexHeaders()
+ }
+
+ col, ok = s.index[str]
+ return
+}
+
+// Read reads a CSV/TSV and populates the "Rows" field with the data from the sheet
+// Custom Fields are supported via the `HB.field.*` headers. The `HB.field.*` the "Name"
+// of the field is the part after the `HB.field.` prefix. Additionally, Custom Fields with
+// no value are excluded from the row.Fields slice, this includes empty strings.
+//
+// Note That
+// - the first row is assumed to be the header
+// - at least 1 row of data is required
+// - rows and columns must be rectangular (i.e. all rows must have the same number of columns)
+func (s *IOSheet) Read(data io.Reader) error {
+ sheet, err := readRawCsv(data)
+ if err != nil {
+ return err
+ }
+
+ if len(sheet) < 2 {
+ return fmt.Errorf("sheet must have at least 1 row of data (header + 1)")
+ }
+
+ s.headers = sheet[0]
+ s.Rows = make([]ExportTSVRow, len(sheet)-1)
+
+ for i, row := range sheet[1:] {
+ if len(row) != len(s.headers) {
+ return fmt.Errorf("row has %d columns, expected %d", len(row), len(s.headers))
+ }
+
+ rowData := ExportTSVRow{}
+
+ st := reflect.TypeOf(ExportTSVRow{})
+
+ for i := 0; i < st.NumField(); i++ {
+ field := st.Field(i)
+ tag := field.Tag.Get("csv")
+ if tag == "" || tag == "-" {
+ continue
+ }
+
+ col, ok := s.GetColumn(tag)
+ if !ok {
+ continue
+ }
+
+ val := row[col]
+
+ var v interface{}
+
+ switch field.Type {
+ case reflect.TypeOf(""):
+ v = val
+ case reflect.TypeOf(int(0)):
+ v = parseInt(val)
+ case reflect.TypeOf(bool(false)):
+ v = parseBool(val)
+ case reflect.TypeOf(float64(0)):
+ v = parseFloat(val)
+
+ // Custom Types
+ case reflect.TypeOf(types.Date{}):
+ v = types.DateFromString(val)
+ case reflect.TypeOf(repo.AssetID(0)):
+ v, _ = repo.ParseAssetID(val)
+ case reflect.TypeOf(LocationString{}):
+ v = parseLocationString(val)
+ case reflect.TypeOf(LabelString{}):
+ v = parseLabelString(val)
+ }
+
+ log.Debug().
+ Str("tag", tag).
+ Interface("val", v).
+ Str("type", fmt.Sprintf("%T", v)).
+ Msg("parsed value")
+
+ // Nil values are not allowed at the moment. This may change.
+ if v == nil {
+ return fmt.Errorf("could not convert %q to %s", val, field.Type)
+ }
+
+ ptrField := reflect.ValueOf(&rowData).Elem().Field(i)
+ ptrField.Set(reflect.ValueOf(v))
+ }
+
+ for _, col := range s.custom {
+ colName := strings.TrimPrefix(s.headers[col], "HB.field.")
+ customVal := row[col]
+ if customVal == "" {
+ continue
+ }
+
+ rowData.Fields = append(rowData.Fields, ExportItemFields{
+ Name: colName,
+ Value: customVal,
+ })
+ }
+
+ s.Rows[i] = rowData
+ }
+
+ return nil
+}
+
+// ReadItems writes the sheet to a writer.
+func (s *IOSheet) ReadItems(ctx context.Context, items []repo.ItemOut, GID uuid.UUID, repos *repo.AllRepos) error {
+ s.Rows = make([]ExportTSVRow, len(items))
+
+ extraHeaders := map[string]struct{}{}
+
+ for i := range items {
+ item := items[i]
+
+ // TODO: Support fetching nested locations
+ locID := item.Location.ID
+
+ locPaths, err := repos.Locations.PathForLoc(context.Background(), GID, locID)
+ if err != nil {
+ log.Error().Err(err).Msg("could not get location path")
+ return err
+ }
+
+ locString := fromPathSlice(locPaths)
+
+ labelString := make([]string, len(item.Labels))
+
+ for i, l := range item.Labels {
+ labelString[i] = l.Name
+ }
+
+ customFields := make([]ExportItemFields, len(item.Fields))
+
+ for i, f := range item.Fields {
+ extraHeaders[f.Name] = struct{}{}
+
+ customFields[i] = ExportItemFields{
+ Name: f.Name,
+ Value: f.TextValue,
+ }
+ }
+
+ s.Rows[i] = ExportTSVRow{
+ // fill struct
+ Location: locString,
+ LabelStr: labelString,
+
+ ImportRef: item.ImportRef,
+ AssetID: item.AssetID,
+ Name: item.Name,
+ Quantity: item.Quantity,
+ Description: item.Description,
+ Insured: item.Insured,
+ Archived: item.Archived,
+
+ PurchasePrice: item.PurchasePrice,
+ PurchaseFrom: item.PurchaseFrom,
+ PurchaseTime: item.PurchaseTime,
+
+ Manufacturer: item.Manufacturer,
+ ModelNumber: item.ModelNumber,
+ SerialNumber: item.SerialNumber,
+
+ LifetimeWarranty: item.LifetimeWarranty,
+ WarrantyExpires: item.WarrantyExpires,
+ WarrantyDetails: item.WarrantyDetails,
+
+ SoldTo: item.SoldTo,
+ SoldTime: item.SoldTime,
+ SoldPrice: item.SoldPrice,
+ SoldNotes: item.SoldNotes,
+
+ Fields: customFields,
+ }
+ }
+
+ // Extract and sort additional headers for deterministic output
+ customHeaders := make([]string, 0, len(extraHeaders))
+
+ for k := range extraHeaders {
+ customHeaders = append(customHeaders, k)
+ }
+
+ sort.Strings(customHeaders)
+
+ st := reflect.TypeOf(ExportTSVRow{})
+
+ // Write headers
+ for i := 0; i < st.NumField(); i++ {
+ field := st.Field(i)
+ tag := field.Tag.Get("csv")
+ if tag == "" || tag == "-" {
+ continue
+ }
+
+ s.headers = append(s.headers, tag)
+ }
+
+ for _, h := range customHeaders {
+ s.headers = append(s.headers, "HB.field."+h)
+ }
+
+ return nil
+}
+
+// TSV writes the current sheet to a writer in TSV format.
+func (s *IOSheet) TSV() ([][]string, error) {
+ memcsv := make([][]string, len(s.Rows)+1)
+
+ memcsv[0] = s.headers
+
+ // use struct tags in rows to dertmine column order
+ for i, row := range s.Rows {
+ rowIdx := i + 1
+
+ memcsv[rowIdx] = make([]string, len(s.headers))
+
+ st := reflect.TypeOf(row)
+
+ for i := 0; i < st.NumField(); i++ {
+ field := st.Field(i)
+ tag := field.Tag.Get("csv")
+ if tag == "" || tag == "-" {
+ continue
+ }
+
+ col, ok := s.GetColumn(tag)
+ if !ok {
+ continue
+ }
+
+ val := reflect.ValueOf(row).Field(i)
+
+ var v string
+
+ switch field.Type {
+ case reflect.TypeOf(""):
+ v = val.String()
+ case reflect.TypeOf(int(0)):
+ v = strconv.Itoa(int(val.Int()))
+ case reflect.TypeOf(bool(false)):
+ v = strconv.FormatBool(val.Bool())
+ case reflect.TypeOf(float64(0)):
+ v = strconv.FormatFloat(val.Float(), 'f', -1, 64)
+
+ // Custom Types
+ case reflect.TypeOf(types.Date{}):
+ v = val.Interface().(types.Date).String()
+ case reflect.TypeOf(repo.AssetID(0)):
+ v = val.Interface().(repo.AssetID).String()
+ case reflect.TypeOf(LocationString{}):
+ v = val.Interface().(LocationString).String()
+ case reflect.TypeOf(LabelString{}):
+ v = val.Interface().(LabelString).String()
+ default:
+ log.Debug().Str("type", field.Type.String()).Msg("unknown type")
+ }
+
+ memcsv[rowIdx][col] = v
+ }
+
+ for _, f := range row.Fields {
+ col, ok := s.GetColumn("HB.field." + f.Name)
+ if !ok {
+ continue
+ }
+
+ memcsv[i+1][col] = f.Value
+ }
+ }
+
+ return memcsv, nil
+}
diff --git a/backend/internal/core/services/reporting/io_sheet_test.go b/backend/internal/core/services/reporting/io_sheet_test.go
new file mode 100644
index 0000000..f056e31
--- /dev/null
+++ b/backend/internal/core/services/reporting/io_sheet_test.go
@@ -0,0 +1,221 @@
+package reporting
+
+import (
+ "bytes"
+ "reflect"
+ "testing"
+
+ _ "embed"
+
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+var (
+ //go:embed .testdata/import/minimal.csv
+ minimalImportCSV []byte
+
+ //go:embed .testdata/import/fields.csv
+ customFieldImportCSV []byte
+
+ //go:embed .testdata/import/types.csv
+ customTypesImportCSV []byte
+)
+
+func TestSheet_Read(t *testing.T) {
+ tests := []struct {
+ name string
+ data []byte
+ want []ExportTSVRow
+ wantErr bool
+ }{
+ {
+ name: "minimal import",
+ data: minimalImportCSV,
+ want: []ExportTSVRow{
+ {Location: LocationString{"loc"}, Name: "Item 1", Quantity: 1, Description: "Description 1"},
+ {Location: LocationString{"loc"}, Name: "Item 2", Quantity: 2, Description: "Description 2"},
+ {Location: LocationString{"loc"}, Name: "Item 3", Quantity: 3, Description: "Description 3"},
+ },
+ },
+ {
+ name: "custom field import",
+ data: customFieldImportCSV,
+ want: []ExportTSVRow{
+ {
+ Location: LocationString{"loc"}, Name: "Item 1", Quantity: 1, Description: "Description 1",
+ Fields: []ExportItemFields{
+ {Name: "Custom Field 1", Value: "Value 1[1]"},
+ {Name: "Custom Field 2", Value: "Value 1[2]"},
+ {Name: "Custom Field 3", Value: "Value 1[3]"},
+ },
+ },
+ {
+ Location: LocationString{"loc"}, Name: "Item 2", Quantity: 2, Description: "Description 2",
+ Fields: []ExportItemFields{
+ {Name: "Custom Field 1", Value: "Value 2[1]"},
+ {Name: "Custom Field 2", Value: "Value 2[2]"},
+ {Name: "Custom Field 3", Value: "Value 2[3]"},
+ },
+ },
+ {
+ Location: LocationString{"loc"}, Name: "Item 3", Quantity: 3, Description: "Description 3",
+ Fields: []ExportItemFields{
+ {Name: "Custom Field 1", Value: "Value 3[1]"},
+ {Name: "Custom Field 2", Value: "Value 3[2]"},
+ {Name: "Custom Field 3", Value: "Value 3[3]"},
+ },
+ },
+ },
+ },
+ {
+ name: "custom types import",
+ data: customTypesImportCSV,
+ want: []ExportTSVRow{
+ {
+ Name: "Item 1",
+ AssetID: repo.AssetID(1),
+ Location: LocationString{"Path", "To", "Location 1"},
+ LabelStr: LabelString{"L1", "L2", "L3"},
+ },
+ {
+ Name: "Item 2",
+ AssetID: repo.AssetID(2),
+ Location: LocationString{"Path", "To", "Location 2"},
+ LabelStr: LabelString{"L1", "L2", "L3"},
+ },
+ {
+ Name: "Item 3",
+ AssetID: repo.AssetID(1000003),
+ Location: LocationString{"Path", "To", "Location 3"},
+ LabelStr: LabelString{"L1", "L2", "L3"},
+ },
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ reader := bytes.NewReader(tt.data)
+
+ sheet := &IOSheet{}
+ err := sheet.Read(reader)
+
+ switch {
+ case tt.wantErr:
+ require.Error(t, err)
+ default:
+ require.NoError(t, err)
+ assert.ElementsMatch(t, tt.want, sheet.Rows)
+ }
+ })
+ }
+}
+
+func Test_parseHeaders(t *testing.T) {
+ tests := []struct {
+ name string
+ rawHeaders []string
+ wantHbHeaders map[string]int
+ wantFieldHeaders []string
+ wantErr bool
+ }{
+ {
+ name: "no hombox headers",
+ rawHeaders: []string{"Header 1", "Header 2", "Header 3"},
+ wantHbHeaders: nil,
+ wantFieldHeaders: nil,
+ wantErr: true,
+ },
+ {
+ name: "field headers only",
+ rawHeaders: []string{"HB.location", "HB.name", "HB.field.1", "HB.field.2", "HB.field.3"},
+ wantHbHeaders: map[string]int{
+ "HB.location": 0,
+ "HB.name": 1,
+ "HB.field.1": 2,
+ "HB.field.2": 3,
+ "HB.field.3": 4,
+ },
+ wantFieldHeaders: []string{"HB.field.1", "HB.field.2", "HB.field.3"},
+ wantErr: false,
+ },
+ {
+ name: "mixed headers",
+ rawHeaders: []string{"Header 1", "HB.name", "Header 2", "HB.field.2", "Header 3", "HB.field.3", "HB.location"},
+ wantHbHeaders: map[string]int{
+ "HB.name": 1,
+ "HB.field.2": 3,
+ "HB.field.3": 5,
+ "HB.location": 6,
+ },
+ wantFieldHeaders: []string{"HB.field.2", "HB.field.3"},
+ wantErr: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ gotHbHeaders, gotFieldHeaders, err := parseHeaders(tt.rawHeaders)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("parseHeaders() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(gotHbHeaders, tt.wantHbHeaders) {
+ t.Errorf("parseHeaders() gotHbHeaders = %v, want %v", gotHbHeaders, tt.wantHbHeaders)
+ }
+ if !reflect.DeepEqual(gotFieldHeaders, tt.wantFieldHeaders) {
+ t.Errorf("parseHeaders() gotFieldHeaders = %v, want %v", gotFieldHeaders, tt.wantFieldHeaders)
+ }
+ })
+ }
+}
+
+func Test_determineSeparator(t *testing.T) {
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ args args
+ want rune
+ wantErr bool
+ }{
+ {
+ name: "comma",
+ args: args{
+ data: []byte("a,b,c"),
+ },
+ want: ',',
+ wantErr: false,
+ },
+ {
+ name: "tab",
+ args: args{
+ data: []byte("a\tb\tc"),
+ },
+ want: '\t',
+ wantErr: false,
+ },
+ {
+ name: "invalid",
+ args: args{
+ data: []byte("a;b;c"),
+ },
+ want: 0,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := determineSeparator(tt.args.data)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("determineSeparator() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("determineSeparator() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/backend/internal/core/services/reporting/value_parsers.go b/backend/internal/core/services/reporting/value_parsers.go
new file mode 100644
index 0000000..7410396
--- /dev/null
+++ b/backend/internal/core/services/reporting/value_parsers.go
@@ -0,0 +1,38 @@
+package reporting
+
+import (
+ "strconv"
+ "strings"
+)
+
+func parseSeparatedString(s string, sep string) ([]string, error) {
+ list := strings.Split(s, sep)
+
+ csf := make([]string, 0, len(list))
+ for _, s := range list {
+ trimmed := strings.TrimSpace(s)
+ if trimmed != "" {
+ csf = append(csf, trimmed)
+ }
+ }
+
+ return csf, nil
+}
+
+func parseFloat(s string) float64 {
+ if s == "" {
+ return 0
+ }
+ f, _ := strconv.ParseFloat(s, 64)
+ return f
+}
+
+func parseBool(s string) bool {
+ b, _ := strconv.ParseBool(s)
+ return b
+}
+
+func parseInt(s string) int {
+ i, _ := strconv.Atoi(s)
+ return i
+}
diff --git a/backend/internal/core/services/reporting/value_parsers_test.go b/backend/internal/core/services/reporting/value_parsers_test.go
new file mode 100644
index 0000000..bcd7431
--- /dev/null
+++ b/backend/internal/core/services/reporting/value_parsers_test.go
@@ -0,0 +1,65 @@
+package reporting
+
+import (
+ "reflect"
+ "testing"
+)
+
+func Test_parseSeparatedString(t *testing.T) {
+ type args struct {
+ s string
+ sep string
+ }
+ tests := []struct {
+ name string
+ args args
+ want []string
+ wantErr bool
+ }{
+ {
+ name: "comma",
+ args: args{
+ s: "a,b,c",
+ sep: ",",
+ },
+ want: []string{"a", "b", "c"},
+ wantErr: false,
+ },
+ {
+ name: "trimmed comma",
+ args: args{
+ s: "a, b, c",
+ sep: ",",
+ },
+ want: []string{"a", "b", "c"},
+ },
+ {
+ name: "excessive whitespace",
+ args: args{
+ s: " a, b, c ",
+ sep: ",",
+ },
+ want: []string{"a", "b", "c"},
+ },
+ {
+ name: "empty",
+ args: args{
+ s: "",
+ sep: ",",
+ },
+ want: []string{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got, err := parseSeparatedString(tt.args.s, tt.args.sep)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("parseSeparatedString() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("parseSeparatedString() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/backend/internal/core/services/service_background.go b/backend/internal/core/services/service_background.go
new file mode 100644
index 0000000..21ae4c3
--- /dev/null
+++ b/backend/internal/core/services/service_background.go
@@ -0,0 +1,81 @@
+package services
+
+import (
+ "context"
+ "strings"
+ "time"
+
+ "github.com/containrrr/shoutrrr"
+ "github.com/hay-kot/homebox/backend/internal/data/repo"
+ "github.com/hay-kot/homebox/backend/internal/data/types"
+ "github.com/rs/zerolog/log"
+)
+
+type BackgroundService struct {
+ repos *repo.AllRepos
+}
+
+func (svc *BackgroundService) SendNotifiersToday(ctx context.Context) error {
+ // Get All Groups
+ groups, err := svc.repos.Groups.GetAllGroups(ctx)
+ if err != nil {
+ return err
+ }
+
+ today := types.DateFromTime(time.Now())
+
+ for i := range groups {
+ group := groups[i]
+
+ entries, err := svc.repos.MaintEntry.GetScheduled(ctx, group.ID, today)
+ if err != nil {
+ return err
+ }
+
+ if len(entries) == 0 {
+ log.Debug().
+ Str("group_name", group.Name).
+ Str("group_id", group.ID.String()).
+ Msg("No scheduled maintenance for today")
+ continue
+ }
+
+ notifiers, err := svc.repos.Notifiers.GetByGroup(ctx, group.ID)
+ if err != nil {
+ return err
+ }
+
+ urls := make([]string, len(notifiers))
+ for i := range notifiers {
+ urls[i] = notifiers[i].URL
+ }
+
+ bldr := strings.Builder{}
+
+ bldr.WriteString("Homebox Maintenance for (")
+ bldr.WriteString(today.String())
+ bldr.WriteString("):\n")
+
+ for i := range entries {
+ entry := entries[i]
+ bldr.WriteString(" - ")
+ bldr.WriteString(entry.Name)
+ bldr.WriteString("\n")
+ }
+
+ var sendErrs []error
+ for i := range urls {
+ err := shoutrrr.Send(urls[i], bldr.String())
+
+ if err != nil {
+ sendErrs = append(sendErrs, err)
+ }
+ }
+
+ if len(sendErrs) > 0 {
+ return sendErrs[0]
+ }
+ }
+
+ return nil
+}
diff --git a/backend/internal/core/services/service_items.go b/backend/internal/core/services/service_items.go
index df37e67..4d510e5 100644
--- a/backend/internal/core/services/service_items.go
+++ b/backend/internal/core/services/service_items.go
@@ -3,10 +3,13 @@ package services
import (
"context"
"errors"
+ "fmt"
+ "io"
+ "strings"
"github.com/google/uuid"
+ "github.com/hay-kot/homebox/backend/internal/core/services/reporting"
"github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/rs/zerolog/log"
)
var (
@@ -29,7 +32,7 @@ func (svc *ItemService) Create(ctx Context, item repo.ItemCreate) (repo.ItemOut,
return repo.ItemOut{}, err
}
- item.AssetID = repo.AssetID(highest + 1)
+ item.AssetID = highest + 1
}
return svc.repo.Items.Create(ctx, ctx.GID, item)
@@ -37,7 +40,6 @@ func (svc *ItemService) Create(ctx Context, item repo.ItemCreate) (repo.ItemOut,
func (svc *ItemService) EnsureAssetID(ctx context.Context, GID uuid.UUID) (int, error) {
items, err := svc.repo.Items.GetAllZeroAssetID(ctx, GID)
-
if err != nil {
return 0, err
}
@@ -51,7 +53,7 @@ func (svc *ItemService) EnsureAssetID(ctx context.Context, GID uuid.UUID) (int,
for _, item := range items {
highest++
- err = svc.repo.Items.SetAssetID(ctx, GID, item.ID, repo.AssetID(highest))
+ err = svc.repo.Items.SetAssetID(ctx, GID, item.ID, highest)
if err != nil {
return 0, err
}
@@ -61,190 +63,293 @@ func (svc *ItemService) EnsureAssetID(ctx context.Context, GID uuid.UUID) (int,
return finished, nil
}
-func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data [][]string) (int, error) {
- loaded := []csvRow{}
- // Skip first row
- for _, row := range data[1:] {
- // Skip empty rows
- if len(row) == 0 {
- continue
- }
-
- if len(row) != NumOfCols {
- return 0, ErrInvalidCsv
- }
-
- r := newCsvRow(row)
- loaded = append(loaded, r)
- }
-
- // validate rows
- var errMap = map[int][]error{}
- var hasErr bool
- for i, r := range loaded {
-
- errs := r.validate()
-
- if len(errs) > 0 {
- hasErr = true
- lineNum := i + 2
-
- errMap[lineNum] = errs
- }
- }
-
- if hasErr {
- for lineNum, errs := range errMap {
- for _, err := range errs {
- log.Error().Err(err).Int("line", lineNum).Msg("csv import error")
- }
- }
- }
-
- // Bootstrap the locations and labels so we can reuse the created IDs for the items
- locations := map[string]uuid.UUID{}
- existingLocation, err := svc.repo.Locations.GetAll(ctx, GID, repo.LocationQuery{})
+func (svc *ItemService) EnsureImportRef(ctx context.Context, GID uuid.UUID) (int, error) {
+ ids, err := svc.repo.Items.GetAllZeroImportRef(ctx, GID)
if err != nil {
return 0, err
}
- for _, loc := range existingLocation {
- locations[loc.Name] = loc.ID
+
+ finished := 0
+ for _, itemID := range ids {
+ ref := uuid.New().String()[0:8]
+
+ err = svc.repo.Items.Patch(ctx, GID, itemID, repo.ItemPatch{ImportRef: &ref})
+ if err != nil {
+ return 0, err
+ }
+
+ finished++
}
- labels := map[string]uuid.UUID{}
- existingLabels, err := svc.repo.Labels.GetAll(ctx, GID)
+ return finished, nil
+}
+
+func serializeLocation[T ~[]string](location T) string {
+ return strings.Join(location, "/")
+}
+
+// CsvImport imports items from a CSV file. using the standard defined format.
+//
+// CsvImport applies the following rules/operations
+//
+// 1. If the item does not exist, it is created.
+// 2. If the item has a ImportRef and it exists it is skipped
+// 3. Locations and Labels are created if they do not exist.
+func (svc *ItemService) CsvImport(ctx context.Context, GID uuid.UUID, data io.Reader) (int, error) {
+ sheet := reporting.IOSheet{}
+
+ err := sheet.Read(data)
if err != nil {
return 0, err
}
- for _, label := range existingLabels {
- labels[label.Name] = label.ID
- }
- for _, row := range loaded {
+ // ========================================
+ // Labels
- // Locations
- if _, exists := locations[row.Location]; !exists {
- result, err := svc.repo.Locations.Create(ctx, GID, repo.LocationCreate{
- Name: row.Location,
- Description: "",
- })
- if err != nil {
- return 0, err
- }
- locations[row.Location] = result.ID
+ labelMap := make(map[string]uuid.UUID)
+ {
+ labels, err := svc.repo.Labels.GetAll(ctx, GID)
+ if err != nil {
+ return 0, err
}
- // Labels
-
- for _, label := range row.getLabels() {
- if _, exists := labels[label]; exists {
- continue
- }
- result, err := svc.repo.Labels.Create(ctx, GID, repo.LabelCreate{
- Name: label,
- Description: "",
- })
- if err != nil {
- return 0, err
- }
- labels[label] = result.ID
+ for _, label := range labels {
+ labelMap[label.Name] = label.ID
}
}
- highest := repo.AssetID(-1)
+ // ========================================
+ // Locations
+
+ locationMap := make(map[string]uuid.UUID)
+ {
+ locations, err := svc.repo.Locations.Tree(ctx, GID, repo.TreeQuery{WithItems: false})
+ if err != nil {
+ return 0, err
+ }
+
+ // Traverse the tree and build a map of location full paths to IDs
+ // where the full path is the location name joined by slashes.
+ var traverse func(location *repo.TreeItem, path []string)
+ traverse = func(location *repo.TreeItem, path []string) {
+ path = append(path, location.Name)
+
+ locationMap[serializeLocation(path)] = location.ID
+
+ for _, child := range location.Children {
+ traverse(child, path)
+ }
+ }
+
+ for _, location := range locations {
+ traverse(&location, []string{})
+ }
+ }
+
+ // ========================================
+ // Import items
+
+ // Asset ID Pre-Check
+ highestAID := repo.AssetID(-1)
if svc.autoIncrementAssetID {
- highest, err = svc.repo.Items.GetHighestAssetID(ctx, GID)
+ highestAID, err = svc.repo.Items.GetHighestAssetID(ctx, GID)
if err != nil {
return 0, err
}
}
- // Create the items
- var count int
- for _, row := range loaded {
- // Check Import Ref
- if row.Item.ImportRef != "" {
- exists, err := svc.repo.Items.CheckRef(ctx, GID, row.Item.ImportRef)
- if exists {
- continue
- }
+ finished := 0
+
+ for i := range sheet.Rows {
+ row := sheet.Rows[i]
+
+ createRequired := true
+
+ // ========================================
+ // Preflight check for existing item
+ if row.ImportRef != "" {
+ exists, err := svc.repo.Items.CheckRef(ctx, GID, row.ImportRef)
if err != nil {
- log.Err(err).Msg("error checking import ref")
+ return 0, fmt.Errorf("error checking for existing item with ref %q: %w", row.ImportRef, err)
+ }
+
+ if exists {
+ createRequired = false
}
}
- locationID := locations[row.Location]
- labelIDs := []uuid.UUID{}
- for _, label := range row.getLabels() {
- labelIDs = append(labelIDs, labels[label])
+ // ========================================
+ // Pre-Create Labels as necessary
+ labelIds := make([]uuid.UUID, len(row.LabelStr))
+
+ for j := range row.LabelStr {
+ label := row.LabelStr[j]
+
+ id, ok := labelMap[label]
+ if !ok {
+ newLabel, err := svc.repo.Labels.Create(ctx, GID, repo.LabelCreate{Name: label})
+ if err != nil {
+ return 0, err
+ }
+ id = newLabel.ID
+ }
+
+ labelIds[j] = id
+ labelMap[label] = id
}
- log.Info().
- Str("name", row.Item.Name).
- Str("location", row.Location).
- Msgf("Creating Item: %s", row.Item.Name)
+ // ========================================
+ // Pre-Create Locations as necessary
+ path := serializeLocation(row.Location)
- data := repo.ItemCreate{
- ImportRef: row.Item.ImportRef,
- Name: row.Item.Name,
- Description: row.Item.Description,
- LabelIDs: labelIDs,
- LocationID: locationID,
+ locationID, ok := locationMap[path]
+ if !ok { // Traverse the path of LocationStr and check each path element to see if it exists already, if not create it.
+ paths := []string{}
+ for i, pathElement := range row.Location {
+ paths = append(paths, pathElement)
+ path := serializeLocation(paths)
+
+ locationID, ok = locationMap[path]
+ if !ok {
+ parentID := uuid.Nil
+
+ // Get the parent ID
+ if i > 0 {
+ parentPath := serializeLocation(row.Location[:i])
+ parentID = locationMap[parentPath]
+ }
+
+ newLocation, err := svc.repo.Locations.Create(ctx, GID, repo.LocationCreate{
+ ParentID: parentID,
+ Name: pathElement,
+ })
+ if err != nil {
+ return 0, err
+ }
+ locationID = newLocation.ID
+ }
+
+ locationMap[path] = locationID
+ }
+
+ locationID, ok = locationMap[path]
+ if !ok {
+ return 0, errors.New("failed to create location")
+ }
}
- if svc.autoIncrementAssetID {
- highest++
- data.AssetID = highest
+ var effAID repo.AssetID
+ if svc.autoIncrementAssetID && row.AssetID.Nil() {
+ effAID = highestAID + 1
+ highestAID++
+ } else {
+ effAID = row.AssetID
}
- result, err := svc.repo.Items.Create(ctx, GID, data)
+ // ========================================
+ // Create Item
+ var item repo.ItemOut
+ switch {
+ case createRequired:
+ newItem := repo.ItemCreate{
+ ImportRef: row.ImportRef,
+ Name: row.Name,
+ Description: row.Description,
+ AssetID: effAID,
+ LocationID: locationID,
+ LabelIDs: labelIds,
+ }
- if err != nil {
- return count, err
+ item, err = svc.repo.Items.Create(ctx, GID, newItem)
+ if err != nil {
+ return 0, err
+ }
+ default:
+ item, err = svc.repo.Items.GetByRef(ctx, GID, row.ImportRef)
+ if err != nil {
+ return 0, err
+ }
}
- // Update the item with the rest of the data
- _, err = svc.repo.Items.UpdateByGroup(ctx, GID, repo.ItemUpdate{
- // Edges
+ if item.ID == uuid.Nil {
+ panic("item ID is nil on import - this should never happen")
+ }
+
+ fields := make([]repo.ItemField, len(row.Fields))
+ for i := range row.Fields {
+ fields[i] = repo.ItemField{
+ Name: row.Fields[i].Name,
+ Type: "text",
+ TextValue: row.Fields[i].Value,
+ }
+ }
+
+ updateItem := repo.ItemUpdate{
+ ID: item.ID,
+ LabelIDs: labelIds,
LocationID: locationID,
- LabelIDs: labelIDs,
- AssetID: data.AssetID,
- // General Fields
- ID: result.ID,
- Name: result.Name,
- Description: result.Description,
- Insured: row.Item.Insured,
- Notes: row.Item.Notes,
- Quantity: row.Item.Quantity,
+ Name: row.Name,
+ Description: row.Description,
+ AssetID: effAID,
+ Insured: row.Insured,
+ Quantity: row.Quantity,
+ Archived: row.Archived,
- // Identifies the item as imported
- SerialNumber: row.Item.SerialNumber,
- ModelNumber: row.Item.ModelNumber,
- Manufacturer: row.Item.Manufacturer,
+ PurchasePrice: row.PurchasePrice,
+ PurchaseFrom: row.PurchaseFrom,
+ PurchaseTime: row.PurchaseTime,
- // Purchase
- PurchaseFrom: row.Item.PurchaseFrom,
- PurchasePrice: row.Item.PurchasePrice,
- PurchaseTime: row.Item.PurchaseTime,
+ Manufacturer: row.Manufacturer,
+ ModelNumber: row.ModelNumber,
+ SerialNumber: row.SerialNumber,
- // Warranty
- LifetimeWarranty: row.Item.LifetimeWarranty,
- WarrantyExpires: row.Item.WarrantyExpires,
- WarrantyDetails: row.Item.WarrantyDetails,
+ LifetimeWarranty: row.LifetimeWarranty,
+ WarrantyExpires: row.WarrantyExpires,
+ WarrantyDetails: row.WarrantyDetails,
- SoldTo: row.Item.SoldTo,
- SoldPrice: row.Item.SoldPrice,
- SoldTime: row.Item.SoldTime,
- SoldNotes: row.Item.SoldNotes,
- })
+ SoldTo: row.SoldTo,
+ SoldTime: row.SoldTime,
+ SoldPrice: row.SoldPrice,
+ SoldNotes: row.SoldNotes,
- if err != nil {
- return count, err
+ Notes: row.Notes,
+ Fields: fields,
}
- count++
+ item, err = svc.repo.Items.UpdateByGroup(ctx, GID, updateItem)
+ if err != nil {
+ return 0, err
+ }
+
+ finished++
}
- return count, nil
+
+ return finished, nil
+}
+
+func (svc *ItemService) ExportTSV(ctx context.Context, GID uuid.UUID) ([][]string, error) {
+ items, err := svc.repo.Items.GetAll(ctx, GID)
+ if err != nil {
+ return nil, err
+ }
+
+ sheet := reporting.IOSheet{}
+
+ err = sheet.ReadItems(ctx, items, GID, svc.repo)
+ if err != nil {
+ return nil, err
+ }
+
+ return sheet.TSV()
+}
+
+func (svc *ItemService) ExportBillOfMaterialsTSV(ctx context.Context, GID uuid.UUID) ([]byte, error) {
+ items, err := svc.repo.Items.GetAll(ctx, GID)
+ if err != nil {
+ return nil, err
+ }
+
+ return reporting.BillOfMaterialsTSV(items)
}
diff --git a/backend/internal/core/services/service_items_attachments.go b/backend/internal/core/services/service_items_attachments.go
index 4a7b197..43835c6 100644
--- a/backend/internal/core/services/service_items_attachments.go
+++ b/backend/internal/core/services/service_items_attachments.go
@@ -12,8 +12,8 @@ import (
"github.com/rs/zerolog/log"
)
-func (svc *ItemService) AttachmentPath(ctx context.Context, attachmentId uuid.UUID) (*ent.Document, error) {
- attachment, err := svc.repo.Attachments.Get(ctx, attachmentId)
+func (svc *ItemService) AttachmentPath(ctx context.Context, attachmentID uuid.UUID) (*ent.Document, error) {
+ attachment, err := svc.repo.Attachments.Get(ctx, attachmentID)
if err != nil {
return nil, err
}
@@ -21,9 +21,9 @@ func (svc *ItemService) AttachmentPath(ctx context.Context, attachmentId uuid.UU
return attachment.Edges.Document, nil
}
-func (svc *ItemService) AttachmentUpdate(ctx Context, itemId uuid.UUID, data *repo.ItemAttachmentUpdate) (repo.ItemOut, error) {
+func (svc *ItemService) AttachmentUpdate(ctx Context, itemID uuid.UUID, data *repo.ItemAttachmentUpdate) (repo.ItemOut, error) {
// Update Attachment
- attachment, err := svc.repo.Attachments.Update(ctx, data.ID, attachment.Type(data.Type))
+ attachment, err := svc.repo.Attachments.Update(ctx, data.ID, data)
if err != nil {
return repo.ItemOut{}, err
}
@@ -35,15 +35,15 @@ func (svc *ItemService) AttachmentUpdate(ctx Context, itemId uuid.UUID, data *re
return repo.ItemOut{}, err
}
- return svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemId)
+ return svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemID)
}
// AttachmentAdd adds an attachment to an item by creating an entry in the Documents table and linking it to the Attachment
// Table and Items table. The file provided via the reader is stored on the file system based on the provided
// relative path during construction of the service.
-func (svc *ItemService) AttachmentAdd(ctx Context, itemId uuid.UUID, filename string, attachmentType attachment.Type, file io.Reader) (repo.ItemOut, error) {
+func (svc *ItemService) AttachmentAdd(ctx Context, itemID uuid.UUID, filename string, attachmentType attachment.Type, file io.Reader) (repo.ItemOut, error) {
// Get the Item
- _, err := svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemId)
+ _, err := svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemID)
if err != nil {
return repo.ItemOut{}, err
}
@@ -56,29 +56,29 @@ func (svc *ItemService) AttachmentAdd(ctx Context, itemId uuid.UUID, filename st
}
// Create the attachment
- _, err = svc.repo.Attachments.Create(ctx, itemId, doc.ID, attachmentType)
+ _, err = svc.repo.Attachments.Create(ctx, itemID, doc.ID, attachmentType)
if err != nil {
log.Err(err).Msg("failed to create attachment")
return repo.ItemOut{}, err
}
- return svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemId)
+ return svc.repo.Items.GetOneByGroup(ctx, ctx.GID, itemID)
}
-func (svc *ItemService) AttachmentDelete(ctx context.Context, gid, itemId, attachmentId uuid.UUID) error {
+func (svc *ItemService) AttachmentDelete(ctx context.Context, gid, itemID, attachmentID uuid.UUID) error {
// Get the Item
- _, err := svc.repo.Items.GetOneByGroup(ctx, gid, itemId)
+ _, err := svc.repo.Items.GetOneByGroup(ctx, gid, itemID)
if err != nil {
return err
}
- attachment, err := svc.repo.Attachments.Get(ctx, attachmentId)
+ attachment, err := svc.repo.Attachments.Get(ctx, attachmentID)
if err != nil {
return err
}
// Delete the attachment
- err = svc.repo.Attachments.Delete(ctx, attachmentId)
+ err = svc.repo.Attachments.Delete(ctx, attachmentID)
if err != nil {
return err
}
diff --git a/backend/internal/core/services/service_items_attachments_test.go b/backend/internal/core/services/service_items_attachments_test.go
index 14e822e..4e2315e 100644
--- a/backend/internal/core/services/service_items_attachments_test.go
+++ b/backend/internal/core/services/service_items_attachments_test.go
@@ -9,6 +9,7 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/repo"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
)
func TestItemService_AddAttachment(t *testing.T) {
@@ -23,7 +24,7 @@ func TestItemService_AddAttachment(t *testing.T) {
Description: "test",
Name: "test",
})
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, loc)
itmC := repo.ItemCreate{
@@ -33,11 +34,11 @@ func TestItemService_AddAttachment(t *testing.T) {
}
itm, err := svc.repo.Items.Create(context.Background(), tGroup.ID, itmC)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, itm)
t.Cleanup(func() {
err := svc.repo.Items.Delete(context.Background(), itm.ID)
- assert.NoError(t, err)
+ require.NoError(t, err)
})
contents := fk.Str(1000)
@@ -45,7 +46,7 @@ func TestItemService_AddAttachment(t *testing.T) {
// Setup
afterAttachment, err := svc.AttachmentAdd(tCtx, itm.ID, "testfile.txt", "attachment", reader)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.NotNil(t, afterAttachment)
// Check that the file exists
@@ -56,7 +57,6 @@ func TestItemService_AddAttachment(t *testing.T) {
// Check that the file contents are correct
bts, err := os.ReadFile(storedPath)
- assert.NoError(t, err)
+ require.NoError(t, err)
assert.Equal(t, contents, string(bts))
-
}
diff --git a/backend/internal/core/services/service_items_csv.go b/backend/internal/core/services/service_items_csv.go
deleted file mode 100644
index 147da67..0000000
--- a/backend/internal/core/services/service_items_csv.go
+++ /dev/null
@@ -1,159 +0,0 @@
-package services
-
-import (
- "bytes"
- "encoding/csv"
- "errors"
- "io"
- "strconv"
- "strings"
- "time"
-
- "github.com/hay-kot/homebox/backend/internal/data/repo"
-)
-
-func determineSeparator(data []byte) (rune, error) {
- // First row
- firstRow := bytes.Split(data, []byte("\n"))[0]
-
- // find first comma or /t
- comma := bytes.IndexByte(firstRow, ',')
- tab := bytes.IndexByte(firstRow, '\t')
-
- switch {
- case comma == -1 && tab == -1:
- return 0, errors.New("could not determine separator")
- case tab > comma:
- return '\t', nil
- default:
- return ',', nil
- }
-}
-
-func ReadCsv(r io.Reader) ([][]string, error) {
- data, err := io.ReadAll(r)
- if err != nil {
- return nil, err
- }
-
- reader := csv.NewReader(bytes.NewReader(data))
-
- // Determine separator
- sep, err := determineSeparator(data)
-
- if err != nil {
- return nil, err
- }
-
- reader.Comma = sep
-
- return reader.ReadAll()
-}
-
-var ErrInvalidCsv = errors.New("invalid csv")
-
-const NumOfCols = 21
-
-func parseFloat(s string) float64 {
- if s == "" {
- return 0
- }
- f, _ := strconv.ParseFloat(s, 64)
- return f
-}
-
-func parseDate(s string) time.Time {
- if s == "" {
- return time.Time{}
- }
-
- p, _ := time.Parse("01/02/2006", s)
- return p
-}
-
-func parseBool(s string) bool {
- switch strings.ToLower(s) {
- case "true", "yes", "1":
- return true
- default:
- return false
- }
-}
-
-func parseInt(s string) int {
- i, _ := strconv.Atoi(s)
- return i
-}
-
-type csvRow struct {
- Item repo.ItemOut
- Location string
- LabelStr string
-}
-
-func newCsvRow(row []string) csvRow {
- return csvRow{
- Location: row[1],
- LabelStr: row[2],
- Item: repo.ItemOut{
- ItemSummary: repo.ItemSummary{
- ImportRef: row[0],
- Quantity: parseInt(row[3]),
- Name: row[4],
- Description: row[5],
- Insured: parseBool(row[6]),
- PurchasePrice: parseFloat(row[12]),
- },
- SerialNumber: row[7],
- ModelNumber: row[8],
- Manufacturer: row[9],
- Notes: row[10],
- PurchaseFrom: row[11],
- PurchaseTime: parseDate(row[13]),
- LifetimeWarranty: parseBool(row[14]),
- WarrantyExpires: parseDate(row[15]),
- WarrantyDetails: row[16],
- SoldTo: row[17],
- SoldPrice: parseFloat(row[18]),
- SoldTime: parseDate(row[19]),
- SoldNotes: row[20],
- },
- }
-}
-
-func (c csvRow) getLabels() []string {
- split := strings.Split(c.LabelStr, ";")
-
- // Trim each
- for i, s := range split {
- split[i] = strings.TrimSpace(s)
- }
-
- // Remove empty
- for i, s := range split {
- if s == "" {
- split = append(split[:i], split[i+1:]...)
- }
- }
-
- return split
-}
-
-func (c csvRow) validate() []error {
- var errs []error
-
- add := func(err error) {
- errs = append(errs, err)
- }
-
- required := func(s string, name string) {
- if s == "" {
- add(errors.New(name + " is required"))
- }
- }
-
- required(c.Location, "Location")
- required(c.Item.Name, "Name")
-
- return errs
-}
diff --git a/backend/internal/core/services/service_items_csv_test.go b/backend/internal/core/services/service_items_csv_test.go
deleted file mode 100644
index 675a1a9..0000000
--- a/backend/internal/core/services/service_items_csv_test.go
+++ /dev/null
@@ -1,164 +0,0 @@
-package services
-
-import (
- "bytes"
- _ "embed"
- "encoding/csv"
- "fmt"
- "reflect"
- "testing"
- "time"
-
- "github.com/stretchr/testify/assert"
-)
-
-//go:embed testdata/import.csv
-var CSVData_Comma []byte
-
-//go:embed testdata/import.tsv
-var CSVData_Tab []byte
-
-func loadcsv() [][]string {
- reader := csv.NewReader(bytes.NewReader(CSVData_Comma))
-
- records, err := reader.ReadAll()
- if err != nil {
- panic(err)
- }
-
- return records
-}
-
-func Test_CorrectDateParsing(t *testing.T) {
- t.Parallel()
-
- expected := []time.Time{
- time.Date(2021, 10, 13, 0, 0, 0, 0, time.UTC),
- time.Date(2021, 10, 15, 0, 0, 0, 0, time.UTC),
- time.Date(2021, 10, 13, 0, 0, 0, 0, time.UTC),
- time.Date(2020, 10, 21, 0, 0, 0, 0, time.UTC),
- time.Date(2020, 10, 14, 0, 0, 0, 0, time.UTC),
- time.Date(2020, 9, 30, 0, 0, 0, 0, time.UTC),
- }
-
- records := loadcsv()
-
- for i, record := range records {
- if i == 0 {
- continue
- }
- entity := newCsvRow(record)
- expected := expected[i-1]
-
- assert.Equal(t, expected, entity.Item.PurchaseTime, fmt.Sprintf("Failed on row %d", i))
- assert.Equal(t, expected, entity.Item.WarrantyExpires, fmt.Sprintf("Failed on row %d", i))
- assert.Equal(t, expected, entity.Item.SoldTime, fmt.Sprintf("Failed on row %d", i))
- }
-}
-
-func Test_csvRow_getLabels(t *testing.T) {
- type fields struct {
- LabelStr string
- }
- tests := []struct {
- name string
- fields fields
- want []string
- }{
- {
- name: "basic test",
- fields: fields{
- LabelStr: "IOT;Home Assistant;Z-Wave",
- },
- want: []string{"IOT", "Home Assistant", "Z-Wave"},
- },
- {
- name: "no labels",
- fields: fields{
- LabelStr: "",
- },
- want: []string{},
- },
- {
- name: "single label",
- fields: fields{
- LabelStr: "IOT",
- },
- want: []string{"IOT"},
- },
- {
- name: "trailing semicolon",
- fields: fields{
- LabelStr: "IOT;",
- },
- want: []string{"IOT"},
- },
-
- {
- name: "whitespace",
- fields: fields{
- LabelStr: " IOT; Home Assistant; Z-Wave ",
- },
- want: []string{"IOT", "Home Assistant", "Z-Wave"},
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- c := csvRow{
- LabelStr: tt.fields.LabelStr,
- }
- if got := c.getLabels(); !reflect.DeepEqual(got, tt.want) {
- t.Errorf("csvRow.getLabels() = %v, want %v", got, tt.want)
- }
- })
- }
-}
-
-func Test_determineSeparator(t *testing.T) {
- type args struct {
- data []byte
- }
- tests := []struct {
- name string
- args args
- want rune
- wantErr bool
- }{
- {
- name: "comma",
- args: args{
- data: CSVData_Comma,
- },
- want: ',',
- wantErr: false,
- },
- {
- name: "tab",
- args: args{
- data: CSVData_Tab,
- },
- want: '\t',
- wantErr: false,
- },
- {
- name: "invalid",
- args: args{
- data: []byte("a;b;c"),
- },
- want: 0,
- wantErr: true,
- },
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- got, err := determineSeparator(tt.args.data)
- if (err != nil) != tt.wantErr {
- t.Errorf("determineSeparator() error = %v, wantErr %v", err, tt.wantErr)
- return
- }
- if got != tt.want {
- t.Errorf("determineSeparator() = %v, want %v", got, tt.want)
- }
- })
- }
-}
diff --git a/backend/internal/core/services/service_items_test.go b/backend/internal/core/services/service_items_test.go
deleted file mode 100644
index 105c842..0000000
--- a/backend/internal/core/services/service_items_test.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package services
-
-import (
- "context"
- "testing"
-
- "github.com/google/uuid"
- "github.com/hay-kot/homebox/backend/internal/data/repo"
- "github.com/stretchr/testify/assert"
-)
-
-func TestItemService_CsvImport(t *testing.T) {
- data := loadcsv()
- svc := &ItemService{
- repo: tRepos,
- }
- count, err := svc.CsvImport(context.Background(), tGroup.ID, data)
- assert.Equal(t, 6, count)
- assert.NoError(t, err)
-
- // Check import refs are deduplicated
- count, err = svc.CsvImport(context.Background(), tGroup.ID, data)
- assert.Equal(t, 0, count)
- assert.NoError(t, err)
-
- items, err := svc.repo.Items.GetAll(context.Background(), tGroup.ID)
- assert.NoError(t, err)
- t.Cleanup(func() {
- for _, item := range items {
- err := svc.repo.Items.Delete(context.Background(), item.ID)
- assert.NoError(t, err)
- }
- })
-
- assert.Equal(t, len(items), 6)
-
- dataCsv := []csvRow{}
- for _, item := range data {
- dataCsv = append(dataCsv, newCsvRow(item))
- }
-
- allLocation, err := tRepos.Locations.GetAll(context.Background(), tGroup.ID, repo.LocationQuery{})
- assert.NoError(t, err)
- locNames := []string{}
- for _, loc := range allLocation {
- locNames = append(locNames, loc.Name)
- }
-
- allLabels, err := tRepos.Labels.GetAll(context.Background(), tGroup.ID)
- assert.NoError(t, err)
- labelNames := []string{}
- for _, label := range allLabels {
- labelNames = append(labelNames, label.Name)
- }
-
- ids := []uuid.UUID{}
- t.Cleanup((func() {
- for _, id := range ids {
- err := svc.repo.Items.Delete(context.Background(), id)
- assert.NoError(t, err)
- }
- }))
-
- for _, item := range items {
- assert.Contains(t, locNames, item.Location.Name)
- for _, label := range item.Labels {
- assert.Contains(t, labelNames, label.Name)
- }
-
- for _, csvRow := range dataCsv {
- if csvRow.Item.Name == item.Name {
- assert.Equal(t, csvRow.Item.Description, item.Description)
- assert.Equal(t, csvRow.Item.Quantity, item.Quantity)
- assert.Equal(t, csvRow.Item.Insured, item.Insured)
- }
- }
- }
-}
diff --git a/backend/internal/core/services/service_user.go b/backend/internal/core/services/service_user.go
index 6d3bc6e..d86c39b 100644
--- a/backend/internal/core/services/service_user.go
+++ b/backend/internal/core/services/service_user.go
@@ -16,7 +16,7 @@ var (
oneWeek = time.Hour * 24 * 7
ErrorInvalidLogin = errors.New("invalid username or password")
ErrorInvalidToken = errors.New("invalid token")
- ErrorTokenIdMismatch = errors.New("token id mismatch")
+ ErrorTokenIDMismatch = errors.New("token id mismatch")
)
type UserService struct {
@@ -51,21 +51,25 @@ func (svc *UserService) RegisterUser(ctx context.Context, data UserRegistration)
Msg("Registering new user")
var (
- err error
- group repo.Group
- token repo.GroupInvitation
- isOwner = false
+ err error
+ group repo.Group
+ token repo.GroupInvitation
+
+ // creatingGroup is true if the user is creating a new group.
+ creatingGroup = false
)
switch data.GroupToken {
case "":
- isOwner = true
+ log.Debug().Msg("creating new group")
+ creatingGroup = true
group, err = svc.repos.Groups.GroupCreate(ctx, "Home")
if err != nil {
log.Err(err).Msg("Failed to create group")
return repo.UserOut{}, err
}
default:
+ log.Debug().Msg("joining existing group")
token, err = svc.repos.Groups.InvitationGet(ctx, hasher.HashToken(data.GroupToken))
if err != nil {
log.Err(err).Msg("Failed to get invitation token")
@@ -81,30 +85,37 @@ func (svc *UserService) RegisterUser(ctx context.Context, data UserRegistration)
Password: hashed,
IsSuperuser: false,
GroupID: group.ID,
- IsOwner: isOwner,
+ IsOwner: creatingGroup,
}
usr, err := svc.repos.Users.Create(ctx, usrCreate)
if err != nil {
return repo.UserOut{}, err
}
+ log.Debug().Msg("user created")
- for _, label := range defaultLabels() {
- _, err := svc.repos.Labels.Create(ctx, group.ID, label)
- if err != nil {
- return repo.UserOut{}, err
+ // Create the default labels and locations for the group.
+ if creatingGroup {
+ log.Debug().Msg("creating default labels")
+ for _, label := range defaultLabels() {
+ _, err := svc.repos.Labels.Create(ctx, usr.GroupID, label)
+ if err != nil {
+ return repo.UserOut{}, err
+ }
+ }
+
+ log.Debug().Msg("creating default locations")
+ for _, location := range defaultLocations() {
+ _, err := svc.repos.Locations.Create(ctx, usr.GroupID, location)
+ if err != nil {
+ return repo.UserOut{}, err
+ }
}
}
- for _, location := range defaultLocations() {
- _, err := svc.repos.Locations.Create(ctx, group.ID, location)
- if err != nil {
- return repo.UserOut{}, err
- }
- }
-
- // Decrement the invitation token if it was used
+ // Decrement the invitation token if it was used.
if token.ID != uuid.Nil {
+ log.Debug().Msg("decrementing invitation token")
err = svc.repos.Groups.InvitationUpdate(ctx, token.ID, token.Uses-1)
if err != nil {
log.Err(err).Msg("Failed to update invitation token")
@@ -127,19 +138,24 @@ func (svc *UserService) UpdateSelf(ctx context.Context, ID uuid.UUID, data repo.
return repo.UserOut{}, err
}
- return svc.repos.Users.GetOneId(ctx, ID)
+ return svc.repos.Users.GetOneID(ctx, ID)
}
// ============================================================================
// User Authentication
-func (svc *UserService) createSessionToken(ctx context.Context, userId uuid.UUID) (UserAuthTokenDetail, error) {
-
+func (svc *UserService) createSessionToken(ctx context.Context, userID uuid.UUID, extendedSession bool) (UserAuthTokenDetail, error) {
attachmentToken := hasher.GenerateToken()
+
+ expiresAt := time.Now().Add(oneWeek)
+ if extendedSession {
+ expiresAt = time.Now().Add(oneWeek * 4)
+ }
+
attachmentData := repo.UserAuthTokenCreate{
- UserID: userId,
+ UserID: userID,
TokenHash: attachmentToken.Hash,
- ExpiresAt: time.Now().Add(oneWeek),
+ ExpiresAt: expiresAt,
}
_, err := svc.repos.AuthTokens.CreateToken(ctx, attachmentData, authroles.RoleAttachments)
@@ -149,9 +165,9 @@ func (svc *UserService) createSessionToken(ctx context.Context, userId uuid.UUID
userToken := hasher.GenerateToken()
data := repo.UserAuthTokenCreate{
- UserID: userId,
+ UserID: userID,
TokenHash: userToken.Hash,
- ExpiresAt: time.Now().Add(oneWeek),
+ ExpiresAt: expiresAt,
}
created, err := svc.repos.AuthTokens.CreateToken(ctx, data, authroles.RoleUser)
@@ -166,9 +182,8 @@ func (svc *UserService) createSessionToken(ctx context.Context, userId uuid.UUID
}, nil
}
-func (svc *UserService) Login(ctx context.Context, username, password string) (UserAuthTokenDetail, error) {
+func (svc *UserService) Login(ctx context.Context, username, password string, extendedSession bool) (UserAuthTokenDetail, error) {
usr, err := svc.repos.Users.GetOneEmail(ctx, username)
-
if err != nil {
// SECURITY: Perform hash to ensure response times are the same
hasher.CheckPasswordHash("not-a-real-password", "not-a-real-password")
@@ -179,7 +194,7 @@ func (svc *UserService) Login(ctx context.Context, username, password string) (U
return UserAuthTokenDetail{}, ErrorInvalidLogin
}
- return svc.createSessionToken(ctx, usr.ID)
+ return svc.createSessionToken(ctx, usr.ID, extendedSession)
}
func (svc *UserService) Logout(ctx context.Context, token string) error {
@@ -192,12 +207,11 @@ func (svc *UserService) RenewToken(ctx context.Context, token string) (UserAuthT
hash := hasher.HashToken(token)
dbToken, err := svc.repos.AuthTokens.GetUserFromToken(ctx, hash)
-
if err != nil {
return UserAuthTokenDetail{}, ErrorInvalidToken
}
- return svc.createSessionToken(ctx, dbToken.ID)
+ return svc.createSessionToken(ctx, dbToken.ID, false)
}
// DeleteSelf deletes the user that is currently logged based of the provided UUID
@@ -208,7 +222,7 @@ func (svc *UserService) DeleteSelf(ctx context.Context, ID uuid.UUID) error {
}
func (svc *UserService) ChangePassword(ctx Context, current string, new string) (ok bool) {
- usr, err := svc.repos.Users.GetOneId(ctx, ctx.UID)
+ usr, err := svc.repos.Users.GetOneID(ctx, ctx.UID)
if err != nil {
return false
}
diff --git a/backend/internal/core/services/testdata/import.csv b/backend/internal/core/services/testdata/import.csv
deleted file mode 100644
index 08bd9c8..0000000
--- a/backend/internal/core/services/testdata/import.csv
+++ /dev/null
@@ -1,7 +0,0 @@
-Import Ref,Location,Labels,Quantity,Name,Description,Insured,Serial Number,Mode Number,Manufacturer,Notes,Purchase From,Purchased Price,Purchased Time,Lifetime Warranty,Warranty Expires,Warranty Details,Sold To,Sold Price,Sold Time,Sold Notes
-A,Garage,IOT;Home Assistant; Z-Wave,1,Zooz Universal Relay ZEN17,Description 1,TRUE,,ZEN17,Zooz,,Amazon,39.95,10/13/2021,,10/13/2021,,,,10/13/2021,
-B,Living Room,IOT;Home Assistant; Z-Wave,1,Zooz Motion Sensor,Description 2,FALSE,,ZSE18,Zooz,,Amazon,29.95,10/15/2021,,10/15/2021,,,,10/15/2021,
-C,Office,IOT;Home Assistant; Z-Wave,1,Zooz 110v Power Switch,Description 3,TRUE,,ZEN15,Zooz,,Amazon,39.95,10/13/2021,,10/13/2021,,,,10/13/2021,
-D,Downstairs,IOT;Home Assistant; Z-Wave,1,Ecolink Z-Wave PIR Motion Sensor,Description 4,FALSE,,PIRZWAVE2.5-ECO,Ecolink,,Amazon,35.58,10/21/2020,,10/21/2020,,,,10/21/2020,
-E,Entry,IOT;Home Assistant; Z-Wave,1,Yale Security Touchscreen Deadbolt,Description 5,TRUE,,YRD226ZW2619,Yale,,Amazon,120.39,10/14/2020,,10/14/2020,,,,10/14/2020,
-F,Kitchen,IOT;Home Assistant; Z-Wave,1,Smart Rocker Light Dimmer,Description 6,FALSE,,39351,Honeywell,,Amazon,65.98,09/30/2020,,09/30/2020,,,,09/30/2020,
\ No newline at end of file
diff --git a/backend/internal/core/services/testdata/import.tsv b/backend/internal/core/services/testdata/import.tsv
deleted file mode 100644
index 503c777..0000000
--- a/backend/internal/core/services/testdata/import.tsv
+++ /dev/null
@@ -1,7 +0,0 @@
-Import Ref Location Labels Quantity Name Description Insured Serial Number Mode Number Manufacturer Notes Purchase From Purchased Price Purchased Time Lifetime Warranty Warranty Expires Warranty Details Sold To Sold Price Sold Time Sold Notes
-A Garage IOT;Home Assistant; Z-Wave 1 Zooz Universal Relay ZEN17 Description 1 TRUE ZEN17 Zooz Amazon 39.95 10/13/2021 10/13/2021 10/13/2021
-B Living Room IOT;Home Assistant; Z-Wave 1 Zooz Motion Sensor Description 2 FALSE ZSE18 Zooz Amazon 29.95 10/15/2021 10/15/2021 10/15/2021
-C Office IOT;Home Assistant; Z-Wave 1 Zooz 110v Power Switch Description 3 TRUE ZEN15 Zooz Amazon 39.95 10/13/2021 10/13/2021 10/13/2021
-D Downstairs IOT;Home Assistant; Z-Wave 1 Ecolink Z-Wave PIR Motion Sensor Description 4 FALSE PIRZWAVE2.5-ECO Ecolink Amazon 35.58 10/21/2020 10/21/2020 10/21/2020
-E Entry IOT;Home Assistant; Z-Wave 1 Yale Security Touchscreen Deadbolt Description 5 TRUE YRD226ZW2619 Yale Amazon 120.39 10/14/2020 10/14/2020 10/14/2020
-F Kitchen IOT;Home Assistant; Z-Wave 1 Smart Rocker Light Dimmer Description 6 FALSE 39351 Honeywell Amazon 65.98 09/30/2020 09/30/2020 09/30/2020
\ No newline at end of file
diff --git a/backend/internal/data/ent/attachment.go b/backend/internal/data/ent/attachment.go
index e5f738a..bfb7de2 100644
--- a/backend/internal/data/ent/attachment.go
+++ b/backend/internal/data/ent/attachment.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/attachment"
@@ -25,11 +26,14 @@ type Attachment struct {
UpdatedAt time.Time `json:"updated_at,omitempty"`
// Type holds the value of the "type" field.
Type attachment.Type `json:"type,omitempty"`
+ // Primary holds the value of the "primary" field.
+ Primary bool `json:"primary,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the AttachmentQuery when eager-loading is set.
Edges AttachmentEdges `json:"edges"`
document_attachments *uuid.UUID
item_attachments *uuid.UUID
+ selectValues sql.SelectValues
}
// AttachmentEdges holds the relations/edges for other nodes in the graph.
@@ -74,6 +78,8 @@ func (*Attachment) scanValues(columns []string) ([]any, error) {
values := make([]any, len(columns))
for i := range columns {
switch columns[i] {
+ case attachment.FieldPrimary:
+ values[i] = new(sql.NullBool)
case attachment.FieldType:
values[i] = new(sql.NullString)
case attachment.FieldCreatedAt, attachment.FieldUpdatedAt:
@@ -85,7 +91,7 @@ func (*Attachment) scanValues(columns []string) ([]any, error) {
case attachment.ForeignKeys[1]: // item_attachments
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type Attachment", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -123,6 +129,12 @@ func (a *Attachment) assignValues(columns []string, values []any) error {
} else if value.Valid {
a.Type = attachment.Type(value.String)
}
+ case attachment.FieldPrimary:
+ if value, ok := values[i].(*sql.NullBool); !ok {
+ return fmt.Errorf("unexpected type %T for field primary", values[i])
+ } else if value.Valid {
+ a.Primary = value.Bool
+ }
case attachment.ForeignKeys[0]:
if value, ok := values[i].(*sql.NullScanner); !ok {
return fmt.Errorf("unexpected type %T for field document_attachments", values[i])
@@ -137,26 +149,34 @@ func (a *Attachment) assignValues(columns []string, values []any) error {
a.item_attachments = new(uuid.UUID)
*a.item_attachments = *value.S.(*uuid.UUID)
}
+ default:
+ a.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the Attachment.
+// This includes values selected through modifiers, order, etc.
+func (a *Attachment) Value(name string) (ent.Value, error) {
+ return a.selectValues.Get(name)
+}
+
// QueryItem queries the "item" edge of the Attachment entity.
func (a *Attachment) QueryItem() *ItemQuery {
- return (&AttachmentClient{config: a.config}).QueryItem(a)
+ return NewAttachmentClient(a.config).QueryItem(a)
}
// QueryDocument queries the "document" edge of the Attachment entity.
func (a *Attachment) QueryDocument() *DocumentQuery {
- return (&AttachmentClient{config: a.config}).QueryDocument(a)
+ return NewAttachmentClient(a.config).QueryDocument(a)
}
// Update returns a builder for updating this Attachment.
// Note that you need to call Attachment.Unwrap() before calling this method if this Attachment
// was returned from a transaction, and the transaction was committed or rolled back.
func (a *Attachment) Update() *AttachmentUpdateOne {
- return (&AttachmentClient{config: a.config}).UpdateOne(a)
+ return NewAttachmentClient(a.config).UpdateOne(a)
}
// Unwrap unwraps the Attachment entity that was returned from a transaction after it was closed,
@@ -183,15 +203,12 @@ func (a *Attachment) String() string {
builder.WriteString(", ")
builder.WriteString("type=")
builder.WriteString(fmt.Sprintf("%v", a.Type))
+ builder.WriteString(", ")
+ builder.WriteString("primary=")
+ builder.WriteString(fmt.Sprintf("%v", a.Primary))
builder.WriteByte(')')
return builder.String()
}
// Attachments is a parsable slice of Attachment.
type Attachments []*Attachment
-
-func (a Attachments) config(cfg config) {
- for _i := range a {
- a[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/attachment/attachment.go b/backend/internal/data/ent/attachment/attachment.go
index f7aef63..4bbac72 100644
--- a/backend/internal/data/ent/attachment/attachment.go
+++ b/backend/internal/data/ent/attachment/attachment.go
@@ -6,6 +6,8 @@ import (
"fmt"
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -20,6 +22,8 @@ const (
FieldUpdatedAt = "updated_at"
// FieldType holds the string denoting the type field in the database.
FieldType = "type"
+ // FieldPrimary holds the string denoting the primary field in the database.
+ FieldPrimary = "primary"
// EdgeItem holds the string denoting the item edge name in mutations.
EdgeItem = "item"
// EdgeDocument holds the string denoting the document edge name in mutations.
@@ -48,6 +52,7 @@ var Columns = []string{
FieldCreatedAt,
FieldUpdatedAt,
FieldType,
+ FieldPrimary,
}
// ForeignKeys holds the SQL foreign-keys that are owned by the "attachments"
@@ -79,6 +84,8 @@ var (
DefaultUpdatedAt func() time.Time
// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
UpdateDefaultUpdatedAt func() time.Time
+ // DefaultPrimary holds the default value on creation for the "primary" field.
+ DefaultPrimary bool
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
@@ -111,3 +118,59 @@ func TypeValidator(_type Type) error {
return fmt.Errorf("attachment: invalid enum value for type field: %q", _type)
}
}
+
+// OrderOption defines the ordering options for the Attachment queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByPrimary orders the results by the primary field.
+func ByPrimary(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPrimary, opts...).ToFunc()
+}
+
+// ByItemField orders the results by item field.
+func ByItemField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByDocumentField orders the results by document field.
+func ByDocumentField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newDocumentStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newItemStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
+ )
+}
+func newDocumentStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(DocumentInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, DocumentTable, DocumentColumn),
+ )
+}
diff --git a/backend/internal/data/ent/attachment/where.go b/backend/internal/data/ent/attachment/where.go
index dd1981f..f6950f3 100644
--- a/backend/internal/data/ent/attachment/where.go
+++ b/backend/internal/data/ent/attachment/where.go
@@ -66,6 +66,11 @@ func UpdatedAt(v time.Time) predicate.Attachment {
return predicate.Attachment(sql.FieldEQ(FieldUpdatedAt, v))
}
+// Primary applies equality check predicate on the "primary" field. It's identical to PrimaryEQ.
+func Primary(v bool) predicate.Attachment {
+ return predicate.Attachment(sql.FieldEQ(FieldPrimary, v))
+}
+
// CreatedAtEQ applies the EQ predicate on the "created_at" field.
func CreatedAtEQ(v time.Time) predicate.Attachment {
return predicate.Attachment(sql.FieldEQ(FieldCreatedAt, v))
@@ -166,6 +171,16 @@ func TypeNotIn(vs ...Type) predicate.Attachment {
return predicate.Attachment(sql.FieldNotIn(FieldType, vs...))
}
+// PrimaryEQ applies the EQ predicate on the "primary" field.
+func PrimaryEQ(v bool) predicate.Attachment {
+ return predicate.Attachment(sql.FieldEQ(FieldPrimary, v))
+}
+
+// PrimaryNEQ applies the NEQ predicate on the "primary" field.
+func PrimaryNEQ(v bool) predicate.Attachment {
+ return predicate.Attachment(sql.FieldNEQ(FieldPrimary, v))
+}
+
// HasItem applies the HasEdge predicate on the "item" edge.
func HasItem() predicate.Attachment {
return predicate.Attachment(func(s *sql.Selector) {
@@ -180,11 +195,7 @@ func HasItem() predicate.Attachment {
// HasItemWith applies the HasEdge predicate on the "item" edge with a given conditions (other predicates).
func HasItemWith(preds ...predicate.Item) predicate.Attachment {
return predicate.Attachment(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
- )
+ step := newItemStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -207,11 +218,7 @@ func HasDocument() predicate.Attachment {
// HasDocumentWith applies the HasEdge predicate on the "document" edge with a given conditions (other predicates).
func HasDocumentWith(preds ...predicate.Document) predicate.Attachment {
return predicate.Attachment(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(DocumentInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, DocumentTable, DocumentColumn),
- )
+ step := newDocumentStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -222,32 +229,15 @@ func HasDocumentWith(preds ...predicate.Document) predicate.Attachment {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Attachment) predicate.Attachment {
- return predicate.Attachment(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Attachment(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Attachment) predicate.Attachment {
- return predicate.Attachment(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Attachment(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Attachment) predicate.Attachment {
- return predicate.Attachment(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Attachment(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/attachment_create.go b/backend/internal/data/ent/attachment_create.go
index 2be195e..d1a0b5b 100644
--- a/backend/internal/data/ent/attachment_create.go
+++ b/backend/internal/data/ent/attachment_create.go
@@ -65,6 +65,20 @@ func (ac *AttachmentCreate) SetNillableType(a *attachment.Type) *AttachmentCreat
return ac
}
+// SetPrimary sets the "primary" field.
+func (ac *AttachmentCreate) SetPrimary(b bool) *AttachmentCreate {
+ ac.mutation.SetPrimary(b)
+ return ac
+}
+
+// SetNillablePrimary sets the "primary" field if the given value is not nil.
+func (ac *AttachmentCreate) SetNillablePrimary(b *bool) *AttachmentCreate {
+ if b != nil {
+ ac.SetPrimary(*b)
+ }
+ return ac
+}
+
// SetID sets the "id" field.
func (ac *AttachmentCreate) SetID(u uuid.UUID) *AttachmentCreate {
ac.mutation.SetID(u)
@@ -109,7 +123,7 @@ func (ac *AttachmentCreate) Mutation() *AttachmentMutation {
// Save creates the Attachment in the database.
func (ac *AttachmentCreate) Save(ctx context.Context) (*Attachment, error) {
ac.defaults()
- return withHooks[*Attachment, AttachmentMutation](ctx, ac.sqlSave, ac.mutation, ac.hooks)
+ return withHooks(ctx, ac.sqlSave, ac.mutation, ac.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -148,6 +162,10 @@ func (ac *AttachmentCreate) defaults() {
v := attachment.DefaultType
ac.mutation.SetType(v)
}
+ if _, ok := ac.mutation.Primary(); !ok {
+ v := attachment.DefaultPrimary
+ ac.mutation.SetPrimary(v)
+ }
if _, ok := ac.mutation.ID(); !ok {
v := attachment.DefaultID()
ac.mutation.SetID(v)
@@ -170,6 +188,9 @@ func (ac *AttachmentCreate) check() error {
return &ValidationError{Name: "type", err: fmt.Errorf(`ent: validator failed for field "Attachment.type": %w`, err)}
}
}
+ if _, ok := ac.mutation.Primary(); !ok {
+ return &ValidationError{Name: "primary", err: errors.New(`ent: missing required field "Attachment.primary"`)}
+ }
if _, ok := ac.mutation.ItemID(); !ok {
return &ValidationError{Name: "item", err: errors.New(`ent: missing required edge "Attachment.item"`)}
}
@@ -205,13 +226,7 @@ func (ac *AttachmentCreate) sqlSave(ctx context.Context) (*Attachment, error) {
func (ac *AttachmentCreate) createSpec() (*Attachment, *sqlgraph.CreateSpec) {
var (
_node = &Attachment{config: ac.config}
- _spec = &sqlgraph.CreateSpec{
- Table: attachment.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(attachment.Table, sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID))
)
if id, ok := ac.mutation.ID(); ok {
_node.ID = id
@@ -229,6 +244,10 @@ func (ac *AttachmentCreate) createSpec() (*Attachment, *sqlgraph.CreateSpec) {
_spec.SetField(attachment.FieldType, field.TypeEnum, value)
_node.Type = value
}
+ if value, ok := ac.mutation.Primary(); ok {
+ _spec.SetField(attachment.FieldPrimary, field.TypeBool, value)
+ _node.Primary = value
+ }
if nodes := ac.mutation.ItemIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -237,10 +256,7 @@ func (ac *AttachmentCreate) createSpec() (*Attachment, *sqlgraph.CreateSpec) {
Columns: []string{attachment.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -257,10 +273,7 @@ func (ac *AttachmentCreate) createSpec() (*Attachment, *sqlgraph.CreateSpec) {
Columns: []string{attachment.DocumentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -275,11 +288,15 @@ func (ac *AttachmentCreate) createSpec() (*Attachment, *sqlgraph.CreateSpec) {
// AttachmentCreateBulk is the builder for creating many Attachment entities in bulk.
type AttachmentCreateBulk struct {
config
+ err error
builders []*AttachmentCreate
}
// Save creates the Attachment entities in the database.
func (acb *AttachmentCreateBulk) Save(ctx context.Context) ([]*Attachment, error) {
+ if acb.err != nil {
+ return nil, acb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(acb.builders))
nodes := make([]*Attachment, len(acb.builders))
mutators := make([]Mutator, len(acb.builders))
@@ -296,8 +313,8 @@ func (acb *AttachmentCreateBulk) Save(ctx context.Context) ([]*Attachment, error
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, acb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/attachment_delete.go b/backend/internal/data/ent/attachment_delete.go
index a018a8e..1be608a 100644
--- a/backend/internal/data/ent/attachment_delete.go
+++ b/backend/internal/data/ent/attachment_delete.go
@@ -27,7 +27,7 @@ func (ad *AttachmentDelete) Where(ps ...predicate.Attachment) *AttachmentDelete
// Exec executes the deletion query and returns how many vertices were deleted.
func (ad *AttachmentDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, AttachmentMutation](ctx, ad.sqlExec, ad.mutation, ad.hooks)
+ return withHooks(ctx, ad.sqlExec, ad.mutation, ad.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (ad *AttachmentDelete) ExecX(ctx context.Context) int {
}
func (ad *AttachmentDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: attachment.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(attachment.Table, sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID))
if ps := ad.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type AttachmentDeleteOne struct {
ad *AttachmentDelete
}
+// Where appends a list predicates to the AttachmentDelete builder.
+func (ado *AttachmentDeleteOne) Where(ps ...predicate.Attachment) *AttachmentDeleteOne {
+ ado.ad.mutation.Where(ps...)
+ return ado
+}
+
// Exec executes the deletion query.
func (ado *AttachmentDeleteOne) Exec(ctx context.Context) error {
n, err := ado.ad.Exec(ctx)
@@ -84,5 +82,7 @@ func (ado *AttachmentDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ado *AttachmentDeleteOne) ExecX(ctx context.Context) {
- ado.ad.ExecX(ctx)
+ if err := ado.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/attachment_query.go b/backend/internal/data/ent/attachment_query.go
index 2e250c2..976e436 100644
--- a/backend/internal/data/ent/attachment_query.go
+++ b/backend/internal/data/ent/attachment_query.go
@@ -20,11 +20,8 @@ import (
// AttachmentQuery is the builder for querying Attachment entities.
type AttachmentQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []attachment.OrderOption
inters []Interceptor
predicates []predicate.Attachment
withItem *ItemQuery
@@ -43,25 +40,25 @@ func (aq *AttachmentQuery) Where(ps ...predicate.Attachment) *AttachmentQuery {
// Limit the number of records to be returned by this query.
func (aq *AttachmentQuery) Limit(limit int) *AttachmentQuery {
- aq.limit = &limit
+ aq.ctx.Limit = &limit
return aq
}
// Offset to start from.
func (aq *AttachmentQuery) Offset(offset int) *AttachmentQuery {
- aq.offset = &offset
+ aq.ctx.Offset = &offset
return aq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (aq *AttachmentQuery) Unique(unique bool) *AttachmentQuery {
- aq.unique = &unique
+ aq.ctx.Unique = &unique
return aq
}
// Order specifies how the records should be ordered.
-func (aq *AttachmentQuery) Order(o ...OrderFunc) *AttachmentQuery {
+func (aq *AttachmentQuery) Order(o ...attachment.OrderOption) *AttachmentQuery {
aq.order = append(aq.order, o...)
return aq
}
@@ -113,7 +110,7 @@ func (aq *AttachmentQuery) QueryDocument() *DocumentQuery {
// First returns the first Attachment entity from the query.
// Returns a *NotFoundError when no Attachment was found.
func (aq *AttachmentQuery) First(ctx context.Context) (*Attachment, error) {
- nodes, err := aq.Limit(1).All(newQueryContext(ctx, TypeAttachment, "First"))
+ nodes, err := aq.Limit(1).All(setContextOp(ctx, aq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -136,7 +133,7 @@ func (aq *AttachmentQuery) FirstX(ctx context.Context) *Attachment {
// Returns a *NotFoundError when no Attachment ID was found.
func (aq *AttachmentQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = aq.Limit(1).IDs(newQueryContext(ctx, TypeAttachment, "FirstID")); err != nil {
+ if ids, err = aq.Limit(1).IDs(setContextOp(ctx, aq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -159,7 +156,7 @@ func (aq *AttachmentQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Attachment entity is found.
// Returns a *NotFoundError when no Attachment entities are found.
func (aq *AttachmentQuery) Only(ctx context.Context) (*Attachment, error) {
- nodes, err := aq.Limit(2).All(newQueryContext(ctx, TypeAttachment, "Only"))
+ nodes, err := aq.Limit(2).All(setContextOp(ctx, aq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -187,7 +184,7 @@ func (aq *AttachmentQuery) OnlyX(ctx context.Context) *Attachment {
// Returns a *NotFoundError when no entities are found.
func (aq *AttachmentQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = aq.Limit(2).IDs(newQueryContext(ctx, TypeAttachment, "OnlyID")); err != nil {
+ if ids, err = aq.Limit(2).IDs(setContextOp(ctx, aq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -212,7 +209,7 @@ func (aq *AttachmentQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Attachments.
func (aq *AttachmentQuery) All(ctx context.Context) ([]*Attachment, error) {
- ctx = newQueryContext(ctx, TypeAttachment, "All")
+ ctx = setContextOp(ctx, aq.ctx, "All")
if err := aq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -230,10 +227,12 @@ func (aq *AttachmentQuery) AllX(ctx context.Context) []*Attachment {
}
// IDs executes the query and returns a list of Attachment IDs.
-func (aq *AttachmentQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeAttachment, "IDs")
- if err := aq.Select(attachment.FieldID).Scan(ctx, &ids); err != nil {
+func (aq *AttachmentQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if aq.ctx.Unique == nil && aq.path != nil {
+ aq.Unique(true)
+ }
+ ctx = setContextOp(ctx, aq.ctx, "IDs")
+ if err = aq.Select(attachment.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -250,7 +249,7 @@ func (aq *AttachmentQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (aq *AttachmentQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeAttachment, "Count")
+ ctx = setContextOp(ctx, aq.ctx, "Count")
if err := aq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -268,7 +267,7 @@ func (aq *AttachmentQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (aq *AttachmentQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeAttachment, "Exist")
+ ctx = setContextOp(ctx, aq.ctx, "Exist")
switch _, err := aq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -296,17 +295,15 @@ func (aq *AttachmentQuery) Clone() *AttachmentQuery {
}
return &AttachmentQuery{
config: aq.config,
- limit: aq.limit,
- offset: aq.offset,
- order: append([]OrderFunc{}, aq.order...),
+ ctx: aq.ctx.Clone(),
+ order: append([]attachment.OrderOption{}, aq.order...),
inters: append([]Interceptor{}, aq.inters...),
predicates: append([]predicate.Attachment{}, aq.predicates...),
withItem: aq.withItem.Clone(),
withDocument: aq.withDocument.Clone(),
// clone intermediate query.
- sql: aq.sql.Clone(),
- path: aq.path,
- unique: aq.unique,
+ sql: aq.sql.Clone(),
+ path: aq.path,
}
}
@@ -347,9 +344,9 @@ func (aq *AttachmentQuery) WithDocument(opts ...func(*DocumentQuery)) *Attachmen
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (aq *AttachmentQuery) GroupBy(field string, fields ...string) *AttachmentGroupBy {
- aq.fields = append([]string{field}, fields...)
+ aq.ctx.Fields = append([]string{field}, fields...)
grbuild := &AttachmentGroupBy{build: aq}
- grbuild.flds = &aq.fields
+ grbuild.flds = &aq.ctx.Fields
grbuild.label = attachment.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -368,10 +365,10 @@ func (aq *AttachmentQuery) GroupBy(field string, fields ...string) *AttachmentGr
// Select(attachment.FieldCreatedAt).
// Scan(ctx, &v)
func (aq *AttachmentQuery) Select(fields ...string) *AttachmentSelect {
- aq.fields = append(aq.fields, fields...)
+ aq.ctx.Fields = append(aq.ctx.Fields, fields...)
sbuild := &AttachmentSelect{AttachmentQuery: aq}
sbuild.label = attachment.Label
- sbuild.flds, sbuild.scan = &aq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &aq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -391,7 +388,7 @@ func (aq *AttachmentQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range aq.fields {
+ for _, f := range aq.ctx.Fields {
if !attachment.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -468,6 +465,9 @@ func (aq *AttachmentQuery) loadItem(ctx context.Context, query *ItemQuery, nodes
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(item.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -497,6 +497,9 @@ func (aq *AttachmentQuery) loadDocument(ctx context.Context, query *DocumentQuer
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(document.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -516,30 +519,22 @@ func (aq *AttachmentQuery) loadDocument(ctx context.Context, query *DocumentQuer
func (aq *AttachmentQuery) sqlCount(ctx context.Context) (int, error) {
_spec := aq.querySpec()
- _spec.Node.Columns = aq.fields
- if len(aq.fields) > 0 {
- _spec.Unique = aq.unique != nil && *aq.unique
+ _spec.Node.Columns = aq.ctx.Fields
+ if len(aq.ctx.Fields) > 0 {
+ _spec.Unique = aq.ctx.Unique != nil && *aq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, aq.driver, _spec)
}
func (aq *AttachmentQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: attachment.Table,
- Columns: attachment.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
- },
- From: aq.sql,
- Unique: true,
- }
- if unique := aq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(attachment.Table, attachment.Columns, sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID))
+ _spec.From = aq.sql
+ if unique := aq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if aq.path != nil {
+ _spec.Unique = true
}
- if fields := aq.fields; len(fields) > 0 {
+ if fields := aq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, attachment.FieldID)
for i := range fields {
@@ -555,10 +550,10 @@ func (aq *AttachmentQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := aq.limit; limit != nil {
+ if limit := aq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := aq.offset; offset != nil {
+ if offset := aq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := aq.order; len(ps) > 0 {
@@ -574,7 +569,7 @@ func (aq *AttachmentQuery) querySpec() *sqlgraph.QuerySpec {
func (aq *AttachmentQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(aq.driver.Dialect())
t1 := builder.Table(attachment.Table)
- columns := aq.fields
+ columns := aq.ctx.Fields
if len(columns) == 0 {
columns = attachment.Columns
}
@@ -583,7 +578,7 @@ func (aq *AttachmentQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = aq.sql
selector.Select(selector.Columns(columns...)...)
}
- if aq.unique != nil && *aq.unique {
+ if aq.ctx.Unique != nil && *aq.ctx.Unique {
selector.Distinct()
}
for _, p := range aq.predicates {
@@ -592,12 +587,12 @@ func (aq *AttachmentQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range aq.order {
p(selector)
}
- if offset := aq.offset; offset != nil {
+ if offset := aq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := aq.limit; limit != nil {
+ if limit := aq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -617,7 +612,7 @@ func (agb *AttachmentGroupBy) Aggregate(fns ...AggregateFunc) *AttachmentGroupBy
// Scan applies the selector query and scans the result into the given value.
func (agb *AttachmentGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAttachment, "GroupBy")
+ ctx = setContextOp(ctx, agb.build.ctx, "GroupBy")
if err := agb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -665,7 +660,7 @@ func (as *AttachmentSelect) Aggregate(fns ...AggregateFunc) *AttachmentSelect {
// Scan applies the selector query and scans the result into the given value.
func (as *AttachmentSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAttachment, "Select")
+ ctx = setContextOp(ctx, as.ctx, "Select")
if err := as.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/attachment_update.go b/backend/internal/data/ent/attachment_update.go
index a54ad5a..bdf10a5 100644
--- a/backend/internal/data/ent/attachment_update.go
+++ b/backend/internal/data/ent/attachment_update.go
@@ -51,6 +51,20 @@ func (au *AttachmentUpdate) SetNillableType(a *attachment.Type) *AttachmentUpdat
return au
}
+// SetPrimary sets the "primary" field.
+func (au *AttachmentUpdate) SetPrimary(b bool) *AttachmentUpdate {
+ au.mutation.SetPrimary(b)
+ return au
+}
+
+// SetNillablePrimary sets the "primary" field if the given value is not nil.
+func (au *AttachmentUpdate) SetNillablePrimary(b *bool) *AttachmentUpdate {
+ if b != nil {
+ au.SetPrimary(*b)
+ }
+ return au
+}
+
// SetItemID sets the "item" edge to the Item entity by ID.
func (au *AttachmentUpdate) SetItemID(id uuid.UUID) *AttachmentUpdate {
au.mutation.SetItemID(id)
@@ -93,7 +107,7 @@ func (au *AttachmentUpdate) ClearDocument() *AttachmentUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (au *AttachmentUpdate) Save(ctx context.Context) (int, error) {
au.defaults()
- return withHooks[int, AttachmentMutation](ctx, au.sqlSave, au.mutation, au.hooks)
+ return withHooks(ctx, au.sqlSave, au.mutation, au.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -146,16 +160,7 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := au.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: attachment.Table,
- Columns: attachment.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(attachment.Table, attachment.Columns, sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID))
if ps := au.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -169,6 +174,9 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
if value, ok := au.mutation.GetType(); ok {
_spec.SetField(attachment.FieldType, field.TypeEnum, value)
}
+ if value, ok := au.mutation.Primary(); ok {
+ _spec.SetField(attachment.FieldPrimary, field.TypeBool, value)
+ }
if au.mutation.ItemCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -177,10 +185,7 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{attachment.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -193,10 +198,7 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{attachment.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -212,10 +214,7 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{attachment.DocumentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -228,10 +227,7 @@ func (au *AttachmentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{attachment.DocumentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -279,6 +275,20 @@ func (auo *AttachmentUpdateOne) SetNillableType(a *attachment.Type) *AttachmentU
return auo
}
+// SetPrimary sets the "primary" field.
+func (auo *AttachmentUpdateOne) SetPrimary(b bool) *AttachmentUpdateOne {
+ auo.mutation.SetPrimary(b)
+ return auo
+}
+
+// SetNillablePrimary sets the "primary" field if the given value is not nil.
+func (auo *AttachmentUpdateOne) SetNillablePrimary(b *bool) *AttachmentUpdateOne {
+ if b != nil {
+ auo.SetPrimary(*b)
+ }
+ return auo
+}
+
// SetItemID sets the "item" edge to the Item entity by ID.
func (auo *AttachmentUpdateOne) SetItemID(id uuid.UUID) *AttachmentUpdateOne {
auo.mutation.SetItemID(id)
@@ -318,6 +328,12 @@ func (auo *AttachmentUpdateOne) ClearDocument() *AttachmentUpdateOne {
return auo
}
+// Where appends a list predicates to the AttachmentUpdate builder.
+func (auo *AttachmentUpdateOne) Where(ps ...predicate.Attachment) *AttachmentUpdateOne {
+ auo.mutation.Where(ps...)
+ return auo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (auo *AttachmentUpdateOne) Select(field string, fields ...string) *AttachmentUpdateOne {
@@ -328,7 +344,7 @@ func (auo *AttachmentUpdateOne) Select(field string, fields ...string) *Attachme
// Save executes the query and returns the updated Attachment entity.
func (auo *AttachmentUpdateOne) Save(ctx context.Context) (*Attachment, error) {
auo.defaults()
- return withHooks[*Attachment, AttachmentMutation](ctx, auo.sqlSave, auo.mutation, auo.hooks)
+ return withHooks(ctx, auo.sqlSave, auo.mutation, auo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -381,16 +397,7 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
if err := auo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: attachment.Table,
- Columns: attachment.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(attachment.Table, attachment.Columns, sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID))
id, ok := auo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Attachment.id" for update`)}
@@ -421,6 +428,9 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
if value, ok := auo.mutation.GetType(); ok {
_spec.SetField(attachment.FieldType, field.TypeEnum, value)
}
+ if value, ok := auo.mutation.Primary(); ok {
+ _spec.SetField(attachment.FieldPrimary, field.TypeBool, value)
+ }
if auo.mutation.ItemCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -429,10 +439,7 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
Columns: []string{attachment.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -445,10 +452,7 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
Columns: []string{attachment.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -464,10 +468,7 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
Columns: []string{attachment.DocumentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -480,10 +481,7 @@ func (auo *AttachmentUpdateOne) sqlSave(ctx context.Context) (_node *Attachment,
Columns: []string{attachment.DocumentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/authroles.go b/backend/internal/data/ent/authroles.go
index cfd2be4..4daa0f6 100644
--- a/backend/internal/data/ent/authroles.go
+++ b/backend/internal/data/ent/authroles.go
@@ -6,6 +6,7 @@ import (
"fmt"
"strings"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/authroles"
@@ -23,6 +24,7 @@ type AuthRoles struct {
// The values are being populated by the AuthRolesQuery when eager-loading is set.
Edges AuthRolesEdges `json:"edges"`
auth_tokens_roles *uuid.UUID
+ selectValues sql.SelectValues
}
// AuthRolesEdges holds the relations/edges for other nodes in the graph.
@@ -59,7 +61,7 @@ func (*AuthRoles) scanValues(columns []string) ([]any, error) {
case authroles.ForeignKeys[0]: // auth_tokens_roles
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type AuthRoles", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -92,21 +94,29 @@ func (ar *AuthRoles) assignValues(columns []string, values []any) error {
ar.auth_tokens_roles = new(uuid.UUID)
*ar.auth_tokens_roles = *value.S.(*uuid.UUID)
}
+ default:
+ ar.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the AuthRoles.
+// This includes values selected through modifiers, order, etc.
+func (ar *AuthRoles) Value(name string) (ent.Value, error) {
+ return ar.selectValues.Get(name)
+}
+
// QueryToken queries the "token" edge of the AuthRoles entity.
func (ar *AuthRoles) QueryToken() *AuthTokensQuery {
- return (&AuthRolesClient{config: ar.config}).QueryToken(ar)
+ return NewAuthRolesClient(ar.config).QueryToken(ar)
}
// Update returns a builder for updating this AuthRoles.
// Note that you need to call AuthRoles.Unwrap() before calling this method if this AuthRoles
// was returned from a transaction, and the transaction was committed or rolled back.
func (ar *AuthRoles) Update() *AuthRolesUpdateOne {
- return (&AuthRolesClient{config: ar.config}).UpdateOne(ar)
+ return NewAuthRolesClient(ar.config).UpdateOne(ar)
}
// Unwrap unwraps the AuthRoles entity that was returned from a transaction after it was closed,
@@ -133,9 +143,3 @@ func (ar *AuthRoles) String() string {
// AuthRolesSlice is a parsable slice of AuthRoles.
type AuthRolesSlice []*AuthRoles
-
-func (ar AuthRolesSlice) config(cfg config) {
- for _i := range ar {
- ar[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/authroles/authroles.go b/backend/internal/data/ent/authroles/authroles.go
index b414e60..bb5e87a 100644
--- a/backend/internal/data/ent/authroles/authroles.go
+++ b/backend/internal/data/ent/authroles/authroles.go
@@ -4,6 +4,9 @@ package authroles
import (
"fmt"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
)
const (
@@ -79,3 +82,30 @@ func RoleValidator(r Role) error {
return fmt.Errorf("authroles: invalid enum value for role field: %q", r)
}
}
+
+// OrderOption defines the ordering options for the AuthRoles queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByRole orders the results by the role field.
+func ByRole(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldRole, opts...).ToFunc()
+}
+
+// ByTokenField orders the results by token field.
+func ByTokenField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTokenStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newTokenStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TokenInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2O, true, TokenTable, TokenColumn),
+ )
+}
diff --git a/backend/internal/data/ent/authroles/where.go b/backend/internal/data/ent/authroles/where.go
index 53978b0..bb5b54a 100644
--- a/backend/internal/data/ent/authroles/where.go
+++ b/backend/internal/data/ent/authroles/where.go
@@ -87,11 +87,7 @@ func HasToken() predicate.AuthRoles {
// HasTokenWith applies the HasEdge predicate on the "token" edge with a given conditions (other predicates).
func HasTokenWith(preds ...predicate.AuthTokens) predicate.AuthRoles {
return predicate.AuthRoles(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(TokenInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2O, true, TokenTable, TokenColumn),
- )
+ step := newTokenStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -102,32 +98,15 @@ func HasTokenWith(preds ...predicate.AuthTokens) predicate.AuthRoles {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.AuthRoles) predicate.AuthRoles {
- return predicate.AuthRoles(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.AuthRoles(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.AuthRoles) predicate.AuthRoles {
- return predicate.AuthRoles(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.AuthRoles(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.AuthRoles) predicate.AuthRoles {
- return predicate.AuthRoles(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.AuthRoles(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/authroles_create.go b/backend/internal/data/ent/authroles_create.go
index 383b8c3..19e594f 100644
--- a/backend/internal/data/ent/authroles_create.go
+++ b/backend/internal/data/ent/authroles_create.go
@@ -62,7 +62,7 @@ func (arc *AuthRolesCreate) Mutation() *AuthRolesMutation {
// Save creates the AuthRoles in the database.
func (arc *AuthRolesCreate) Save(ctx context.Context) (*AuthRoles, error) {
arc.defaults()
- return withHooks[*AuthRoles, AuthRolesMutation](ctx, arc.sqlSave, arc.mutation, arc.hooks)
+ return withHooks(ctx, arc.sqlSave, arc.mutation, arc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -129,13 +129,7 @@ func (arc *AuthRolesCreate) sqlSave(ctx context.Context) (*AuthRoles, error) {
func (arc *AuthRolesCreate) createSpec() (*AuthRoles, *sqlgraph.CreateSpec) {
var (
_node = &AuthRoles{config: arc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: authroles.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(authroles.Table, sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt))
)
if value, ok := arc.mutation.Role(); ok {
_spec.SetField(authroles.FieldRole, field.TypeEnum, value)
@@ -149,10 +143,7 @@ func (arc *AuthRolesCreate) createSpec() (*AuthRoles, *sqlgraph.CreateSpec) {
Columns: []string{authroles.TokenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -167,11 +158,15 @@ func (arc *AuthRolesCreate) createSpec() (*AuthRoles, *sqlgraph.CreateSpec) {
// AuthRolesCreateBulk is the builder for creating many AuthRoles entities in bulk.
type AuthRolesCreateBulk struct {
config
+ err error
builders []*AuthRolesCreate
}
// Save creates the AuthRoles entities in the database.
func (arcb *AuthRolesCreateBulk) Save(ctx context.Context) ([]*AuthRoles, error) {
+ if arcb.err != nil {
+ return nil, arcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(arcb.builders))
nodes := make([]*AuthRoles, len(arcb.builders))
mutators := make([]Mutator, len(arcb.builders))
@@ -188,8 +183,8 @@ func (arcb *AuthRolesCreateBulk) Save(ctx context.Context) ([]*AuthRoles, error)
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, arcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/authroles_delete.go b/backend/internal/data/ent/authroles_delete.go
index 4bafec2..68a0dfc 100644
--- a/backend/internal/data/ent/authroles_delete.go
+++ b/backend/internal/data/ent/authroles_delete.go
@@ -27,7 +27,7 @@ func (ard *AuthRolesDelete) Where(ps ...predicate.AuthRoles) *AuthRolesDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (ard *AuthRolesDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, AuthRolesMutation](ctx, ard.sqlExec, ard.mutation, ard.hooks)
+ return withHooks(ctx, ard.sqlExec, ard.mutation, ard.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (ard *AuthRolesDelete) ExecX(ctx context.Context) int {
}
func (ard *AuthRolesDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authroles.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(authroles.Table, sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt))
if ps := ard.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type AuthRolesDeleteOne struct {
ard *AuthRolesDelete
}
+// Where appends a list predicates to the AuthRolesDelete builder.
+func (ardo *AuthRolesDeleteOne) Where(ps ...predicate.AuthRoles) *AuthRolesDeleteOne {
+ ardo.ard.mutation.Where(ps...)
+ return ardo
+}
+
// Exec executes the deletion query.
func (ardo *AuthRolesDeleteOne) Exec(ctx context.Context) error {
n, err := ardo.ard.Exec(ctx)
@@ -84,5 +82,7 @@ func (ardo *AuthRolesDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ardo *AuthRolesDeleteOne) ExecX(ctx context.Context) {
- ardo.ard.ExecX(ctx)
+ if err := ardo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/authroles_query.go b/backend/internal/data/ent/authroles_query.go
index fa3e290..bf47577 100644
--- a/backend/internal/data/ent/authroles_query.go
+++ b/backend/internal/data/ent/authroles_query.go
@@ -19,11 +19,8 @@ import (
// AuthRolesQuery is the builder for querying AuthRoles entities.
type AuthRolesQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []authroles.OrderOption
inters []Interceptor
predicates []predicate.AuthRoles
withToken *AuthTokensQuery
@@ -41,25 +38,25 @@ func (arq *AuthRolesQuery) Where(ps ...predicate.AuthRoles) *AuthRolesQuery {
// Limit the number of records to be returned by this query.
func (arq *AuthRolesQuery) Limit(limit int) *AuthRolesQuery {
- arq.limit = &limit
+ arq.ctx.Limit = &limit
return arq
}
// Offset to start from.
func (arq *AuthRolesQuery) Offset(offset int) *AuthRolesQuery {
- arq.offset = &offset
+ arq.ctx.Offset = &offset
return arq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (arq *AuthRolesQuery) Unique(unique bool) *AuthRolesQuery {
- arq.unique = &unique
+ arq.ctx.Unique = &unique
return arq
}
// Order specifies how the records should be ordered.
-func (arq *AuthRolesQuery) Order(o ...OrderFunc) *AuthRolesQuery {
+func (arq *AuthRolesQuery) Order(o ...authroles.OrderOption) *AuthRolesQuery {
arq.order = append(arq.order, o...)
return arq
}
@@ -89,7 +86,7 @@ func (arq *AuthRolesQuery) QueryToken() *AuthTokensQuery {
// First returns the first AuthRoles entity from the query.
// Returns a *NotFoundError when no AuthRoles was found.
func (arq *AuthRolesQuery) First(ctx context.Context) (*AuthRoles, error) {
- nodes, err := arq.Limit(1).All(newQueryContext(ctx, TypeAuthRoles, "First"))
+ nodes, err := arq.Limit(1).All(setContextOp(ctx, arq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -112,7 +109,7 @@ func (arq *AuthRolesQuery) FirstX(ctx context.Context) *AuthRoles {
// Returns a *NotFoundError when no AuthRoles ID was found.
func (arq *AuthRolesQuery) FirstID(ctx context.Context) (id int, err error) {
var ids []int
- if ids, err = arq.Limit(1).IDs(newQueryContext(ctx, TypeAuthRoles, "FirstID")); err != nil {
+ if ids, err = arq.Limit(1).IDs(setContextOp(ctx, arq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -135,7 +132,7 @@ func (arq *AuthRolesQuery) FirstIDX(ctx context.Context) int {
// Returns a *NotSingularError when more than one AuthRoles entity is found.
// Returns a *NotFoundError when no AuthRoles entities are found.
func (arq *AuthRolesQuery) Only(ctx context.Context) (*AuthRoles, error) {
- nodes, err := arq.Limit(2).All(newQueryContext(ctx, TypeAuthRoles, "Only"))
+ nodes, err := arq.Limit(2).All(setContextOp(ctx, arq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -163,7 +160,7 @@ func (arq *AuthRolesQuery) OnlyX(ctx context.Context) *AuthRoles {
// Returns a *NotFoundError when no entities are found.
func (arq *AuthRolesQuery) OnlyID(ctx context.Context) (id int, err error) {
var ids []int
- if ids, err = arq.Limit(2).IDs(newQueryContext(ctx, TypeAuthRoles, "OnlyID")); err != nil {
+ if ids, err = arq.Limit(2).IDs(setContextOp(ctx, arq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -188,7 +185,7 @@ func (arq *AuthRolesQuery) OnlyIDX(ctx context.Context) int {
// All executes the query and returns a list of AuthRolesSlice.
func (arq *AuthRolesQuery) All(ctx context.Context) ([]*AuthRoles, error) {
- ctx = newQueryContext(ctx, TypeAuthRoles, "All")
+ ctx = setContextOp(ctx, arq.ctx, "All")
if err := arq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -206,10 +203,12 @@ func (arq *AuthRolesQuery) AllX(ctx context.Context) []*AuthRoles {
}
// IDs executes the query and returns a list of AuthRoles IDs.
-func (arq *AuthRolesQuery) IDs(ctx context.Context) ([]int, error) {
- var ids []int
- ctx = newQueryContext(ctx, TypeAuthRoles, "IDs")
- if err := arq.Select(authroles.FieldID).Scan(ctx, &ids); err != nil {
+func (arq *AuthRolesQuery) IDs(ctx context.Context) (ids []int, err error) {
+ if arq.ctx.Unique == nil && arq.path != nil {
+ arq.Unique(true)
+ }
+ ctx = setContextOp(ctx, arq.ctx, "IDs")
+ if err = arq.Select(authroles.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -226,7 +225,7 @@ func (arq *AuthRolesQuery) IDsX(ctx context.Context) []int {
// Count returns the count of the given query.
func (arq *AuthRolesQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeAuthRoles, "Count")
+ ctx = setContextOp(ctx, arq.ctx, "Count")
if err := arq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -244,7 +243,7 @@ func (arq *AuthRolesQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (arq *AuthRolesQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeAuthRoles, "Exist")
+ ctx = setContextOp(ctx, arq.ctx, "Exist")
switch _, err := arq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -272,16 +271,14 @@ func (arq *AuthRolesQuery) Clone() *AuthRolesQuery {
}
return &AuthRolesQuery{
config: arq.config,
- limit: arq.limit,
- offset: arq.offset,
- order: append([]OrderFunc{}, arq.order...),
+ ctx: arq.ctx.Clone(),
+ order: append([]authroles.OrderOption{}, arq.order...),
inters: append([]Interceptor{}, arq.inters...),
predicates: append([]predicate.AuthRoles{}, arq.predicates...),
withToken: arq.withToken.Clone(),
// clone intermediate query.
- sql: arq.sql.Clone(),
- path: arq.path,
- unique: arq.unique,
+ sql: arq.sql.Clone(),
+ path: arq.path,
}
}
@@ -311,9 +308,9 @@ func (arq *AuthRolesQuery) WithToken(opts ...func(*AuthTokensQuery)) *AuthRolesQ
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (arq *AuthRolesQuery) GroupBy(field string, fields ...string) *AuthRolesGroupBy {
- arq.fields = append([]string{field}, fields...)
+ arq.ctx.Fields = append([]string{field}, fields...)
grbuild := &AuthRolesGroupBy{build: arq}
- grbuild.flds = &arq.fields
+ grbuild.flds = &arq.ctx.Fields
grbuild.label = authroles.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -332,10 +329,10 @@ func (arq *AuthRolesQuery) GroupBy(field string, fields ...string) *AuthRolesGro
// Select(authroles.FieldRole).
// Scan(ctx, &v)
func (arq *AuthRolesQuery) Select(fields ...string) *AuthRolesSelect {
- arq.fields = append(arq.fields, fields...)
+ arq.ctx.Fields = append(arq.ctx.Fields, fields...)
sbuild := &AuthRolesSelect{AuthRolesQuery: arq}
sbuild.label = authroles.Label
- sbuild.flds, sbuild.scan = &arq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &arq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -355,7 +352,7 @@ func (arq *AuthRolesQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range arq.fields {
+ for _, f := range arq.ctx.Fields {
if !authroles.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -425,6 +422,9 @@ func (arq *AuthRolesQuery) loadToken(ctx context.Context, query *AuthTokensQuery
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(authtokens.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -444,30 +444,22 @@ func (arq *AuthRolesQuery) loadToken(ctx context.Context, query *AuthTokensQuery
func (arq *AuthRolesQuery) sqlCount(ctx context.Context) (int, error) {
_spec := arq.querySpec()
- _spec.Node.Columns = arq.fields
- if len(arq.fields) > 0 {
- _spec.Unique = arq.unique != nil && *arq.unique
+ _spec.Node.Columns = arq.ctx.Fields
+ if len(arq.ctx.Fields) > 0 {
+ _spec.Unique = arq.ctx.Unique != nil && *arq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, arq.driver, _spec)
}
func (arq *AuthRolesQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: authroles.Table,
- Columns: authroles.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
- },
- From: arq.sql,
- Unique: true,
- }
- if unique := arq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(authroles.Table, authroles.Columns, sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt))
+ _spec.From = arq.sql
+ if unique := arq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if arq.path != nil {
+ _spec.Unique = true
}
- if fields := arq.fields; len(fields) > 0 {
+ if fields := arq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, authroles.FieldID)
for i := range fields {
@@ -483,10 +475,10 @@ func (arq *AuthRolesQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := arq.limit; limit != nil {
+ if limit := arq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := arq.offset; offset != nil {
+ if offset := arq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := arq.order; len(ps) > 0 {
@@ -502,7 +494,7 @@ func (arq *AuthRolesQuery) querySpec() *sqlgraph.QuerySpec {
func (arq *AuthRolesQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(arq.driver.Dialect())
t1 := builder.Table(authroles.Table)
- columns := arq.fields
+ columns := arq.ctx.Fields
if len(columns) == 0 {
columns = authroles.Columns
}
@@ -511,7 +503,7 @@ func (arq *AuthRolesQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = arq.sql
selector.Select(selector.Columns(columns...)...)
}
- if arq.unique != nil && *arq.unique {
+ if arq.ctx.Unique != nil && *arq.ctx.Unique {
selector.Distinct()
}
for _, p := range arq.predicates {
@@ -520,12 +512,12 @@ func (arq *AuthRolesQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range arq.order {
p(selector)
}
- if offset := arq.offset; offset != nil {
+ if offset := arq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := arq.limit; limit != nil {
+ if limit := arq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -545,7 +537,7 @@ func (argb *AuthRolesGroupBy) Aggregate(fns ...AggregateFunc) *AuthRolesGroupBy
// Scan applies the selector query and scans the result into the given value.
func (argb *AuthRolesGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAuthRoles, "GroupBy")
+ ctx = setContextOp(ctx, argb.build.ctx, "GroupBy")
if err := argb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -593,7 +585,7 @@ func (ars *AuthRolesSelect) Aggregate(fns ...AggregateFunc) *AuthRolesSelect {
// Scan applies the selector query and scans the result into the given value.
func (ars *AuthRolesSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAuthRoles, "Select")
+ ctx = setContextOp(ctx, ars.ctx, "Select")
if err := ars.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/authroles_update.go b/backend/internal/data/ent/authroles_update.go
index dea7b76..fbec4f9 100644
--- a/backend/internal/data/ent/authroles_update.go
+++ b/backend/internal/data/ent/authroles_update.go
@@ -75,7 +75,7 @@ func (aru *AuthRolesUpdate) ClearToken() *AuthRolesUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (aru *AuthRolesUpdate) Save(ctx context.Context) (int, error) {
- return withHooks[int, AuthRolesMutation](ctx, aru.sqlSave, aru.mutation, aru.hooks)
+ return withHooks(ctx, aru.sqlSave, aru.mutation, aru.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -114,16 +114,7 @@ func (aru *AuthRolesUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := aru.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authroles.Table,
- Columns: authroles.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(authroles.Table, authroles.Columns, sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt))
if ps := aru.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -142,10 +133,7 @@ func (aru *AuthRolesUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authroles.TokenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -158,10 +146,7 @@ func (aru *AuthRolesUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authroles.TokenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -233,6 +218,12 @@ func (aruo *AuthRolesUpdateOne) ClearToken() *AuthRolesUpdateOne {
return aruo
}
+// Where appends a list predicates to the AuthRolesUpdate builder.
+func (aruo *AuthRolesUpdateOne) Where(ps ...predicate.AuthRoles) *AuthRolesUpdateOne {
+ aruo.mutation.Where(ps...)
+ return aruo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (aruo *AuthRolesUpdateOne) Select(field string, fields ...string) *AuthRolesUpdateOne {
@@ -242,7 +233,7 @@ func (aruo *AuthRolesUpdateOne) Select(field string, fields ...string) *AuthRole
// Save executes the query and returns the updated AuthRoles entity.
func (aruo *AuthRolesUpdateOne) Save(ctx context.Context) (*AuthRoles, error) {
- return withHooks[*AuthRoles, AuthRolesMutation](ctx, aruo.sqlSave, aruo.mutation, aruo.hooks)
+ return withHooks(ctx, aruo.sqlSave, aruo.mutation, aruo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -281,16 +272,7 @@ func (aruo *AuthRolesUpdateOne) sqlSave(ctx context.Context) (_node *AuthRoles,
if err := aruo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authroles.Table,
- Columns: authroles.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(authroles.Table, authroles.Columns, sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt))
id, ok := aruo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "AuthRoles.id" for update`)}
@@ -326,10 +308,7 @@ func (aruo *AuthRolesUpdateOne) sqlSave(ctx context.Context) (_node *AuthRoles,
Columns: []string{authroles.TokenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -342,10 +321,7 @@ func (aruo *AuthRolesUpdateOne) sqlSave(ctx context.Context) (_node *AuthRoles,
Columns: []string{authroles.TokenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/authtokens.go b/backend/internal/data/ent/authtokens.go
index 8945152..14299ba 100644
--- a/backend/internal/data/ent/authtokens.go
+++ b/backend/internal/data/ent/authtokens.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/authroles"
@@ -31,6 +32,7 @@ type AuthTokens struct {
// The values are being populated by the AuthTokensQuery when eager-loading is set.
Edges AuthTokensEdges `json:"edges"`
user_auth_tokens *uuid.UUID
+ selectValues sql.SelectValues
}
// AuthTokensEdges holds the relations/edges for other nodes in the graph.
@@ -84,7 +86,7 @@ func (*AuthTokens) scanValues(columns []string) ([]any, error) {
case authtokens.ForeignKeys[0]: // user_auth_tokens
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type AuthTokens", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -135,26 +137,34 @@ func (at *AuthTokens) assignValues(columns []string, values []any) error {
at.user_auth_tokens = new(uuid.UUID)
*at.user_auth_tokens = *value.S.(*uuid.UUID)
}
+ default:
+ at.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the AuthTokens.
+// This includes values selected through modifiers, order, etc.
+func (at *AuthTokens) Value(name string) (ent.Value, error) {
+ return at.selectValues.Get(name)
+}
+
// QueryUser queries the "user" edge of the AuthTokens entity.
func (at *AuthTokens) QueryUser() *UserQuery {
- return (&AuthTokensClient{config: at.config}).QueryUser(at)
+ return NewAuthTokensClient(at.config).QueryUser(at)
}
// QueryRoles queries the "roles" edge of the AuthTokens entity.
func (at *AuthTokens) QueryRoles() *AuthRolesQuery {
- return (&AuthTokensClient{config: at.config}).QueryRoles(at)
+ return NewAuthTokensClient(at.config).QueryRoles(at)
}
// Update returns a builder for updating this AuthTokens.
// Note that you need to call AuthTokens.Unwrap() before calling this method if this AuthTokens
// was returned from a transaction, and the transaction was committed or rolled back.
func (at *AuthTokens) Update() *AuthTokensUpdateOne {
- return (&AuthTokensClient{config: at.config}).UpdateOne(at)
+ return NewAuthTokensClient(at.config).UpdateOne(at)
}
// Unwrap unwraps the AuthTokens entity that was returned from a transaction after it was closed,
@@ -190,9 +200,3 @@ func (at *AuthTokens) String() string {
// AuthTokensSlice is a parsable slice of AuthTokens.
type AuthTokensSlice []*AuthTokens
-
-func (at AuthTokensSlice) config(cfg config) {
- for _i := range at {
- at[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/authtokens/authtokens.go b/backend/internal/data/ent/authtokens/authtokens.go
index 2d809f4..ff555df 100644
--- a/backend/internal/data/ent/authtokens/authtokens.go
+++ b/backend/internal/data/ent/authtokens/authtokens.go
@@ -5,6 +5,8 @@ package authtokens
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -85,3 +87,54 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the AuthTokens queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByExpiresAt orders the results by the expires_at field.
+func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByRolesField orders the results by roles field.
+func ByRolesField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newRolesStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newUserStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UserInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+ )
+}
+func newRolesStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(RolesInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2O, false, RolesTable, RolesColumn),
+ )
+}
diff --git a/backend/internal/data/ent/authtokens/where.go b/backend/internal/data/ent/authtokens/where.go
index fc2983f..d3642d8 100644
--- a/backend/internal/data/ent/authtokens/where.go
+++ b/backend/internal/data/ent/authtokens/where.go
@@ -250,11 +250,7 @@ func HasUser() predicate.AuthTokens {
// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
func HasUserWith(preds ...predicate.User) predicate.AuthTokens {
return predicate.AuthTokens(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(UserInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
- )
+ step := newUserStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -277,11 +273,7 @@ func HasRoles() predicate.AuthTokens {
// HasRolesWith applies the HasEdge predicate on the "roles" edge with a given conditions (other predicates).
func HasRolesWith(preds ...predicate.AuthRoles) predicate.AuthTokens {
return predicate.AuthTokens(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(RolesInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2O, false, RolesTable, RolesColumn),
- )
+ step := newRolesStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -292,32 +284,15 @@ func HasRolesWith(preds ...predicate.AuthRoles) predicate.AuthTokens {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.AuthTokens) predicate.AuthTokens {
- return predicate.AuthTokens(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.AuthTokens(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.AuthTokens) predicate.AuthTokens {
- return predicate.AuthTokens(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.AuthTokens(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.AuthTokens) predicate.AuthTokens {
- return predicate.AuthTokens(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.AuthTokens(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/authtokens_create.go b/backend/internal/data/ent/authtokens_create.go
index d6632bb..afddb3b 100644
--- a/backend/internal/data/ent/authtokens_create.go
+++ b/backend/internal/data/ent/authtokens_create.go
@@ -131,7 +131,7 @@ func (atc *AuthTokensCreate) Mutation() *AuthTokensMutation {
// Save creates the AuthTokens in the database.
func (atc *AuthTokensCreate) Save(ctx context.Context) (*AuthTokens, error) {
atc.defaults()
- return withHooks[*AuthTokens, AuthTokensMutation](ctx, atc.sqlSave, atc.mutation, atc.hooks)
+ return withHooks(ctx, atc.sqlSave, atc.mutation, atc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -219,13 +219,7 @@ func (atc *AuthTokensCreate) sqlSave(ctx context.Context) (*AuthTokens, error) {
func (atc *AuthTokensCreate) createSpec() (*AuthTokens, *sqlgraph.CreateSpec) {
var (
_node = &AuthTokens{config: atc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: authtokens.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(authtokens.Table, sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID))
)
if id, ok := atc.mutation.ID(); ok {
_node.ID = id
@@ -255,10 +249,7 @@ func (atc *AuthTokensCreate) createSpec() (*AuthTokens, *sqlgraph.CreateSpec) {
Columns: []string{authtokens.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -275,10 +266,7 @@ func (atc *AuthTokensCreate) createSpec() (*AuthTokens, *sqlgraph.CreateSpec) {
Columns: []string{authtokens.RolesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
@@ -292,11 +280,15 @@ func (atc *AuthTokensCreate) createSpec() (*AuthTokens, *sqlgraph.CreateSpec) {
// AuthTokensCreateBulk is the builder for creating many AuthTokens entities in bulk.
type AuthTokensCreateBulk struct {
config
+ err error
builders []*AuthTokensCreate
}
// Save creates the AuthTokens entities in the database.
func (atcb *AuthTokensCreateBulk) Save(ctx context.Context) ([]*AuthTokens, error) {
+ if atcb.err != nil {
+ return nil, atcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(atcb.builders))
nodes := make([]*AuthTokens, len(atcb.builders))
mutators := make([]Mutator, len(atcb.builders))
@@ -313,8 +305,8 @@ func (atcb *AuthTokensCreateBulk) Save(ctx context.Context) ([]*AuthTokens, erro
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, atcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/authtokens_delete.go b/backend/internal/data/ent/authtokens_delete.go
index 680d83c..4c29851 100644
--- a/backend/internal/data/ent/authtokens_delete.go
+++ b/backend/internal/data/ent/authtokens_delete.go
@@ -27,7 +27,7 @@ func (atd *AuthTokensDelete) Where(ps ...predicate.AuthTokens) *AuthTokensDelete
// Exec executes the deletion query and returns how many vertices were deleted.
func (atd *AuthTokensDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, AuthTokensMutation](ctx, atd.sqlExec, atd.mutation, atd.hooks)
+ return withHooks(ctx, atd.sqlExec, atd.mutation, atd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (atd *AuthTokensDelete) ExecX(ctx context.Context) int {
}
func (atd *AuthTokensDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authtokens.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(authtokens.Table, sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID))
if ps := atd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type AuthTokensDeleteOne struct {
atd *AuthTokensDelete
}
+// Where appends a list predicates to the AuthTokensDelete builder.
+func (atdo *AuthTokensDeleteOne) Where(ps ...predicate.AuthTokens) *AuthTokensDeleteOne {
+ atdo.atd.mutation.Where(ps...)
+ return atdo
+}
+
// Exec executes the deletion query.
func (atdo *AuthTokensDeleteOne) Exec(ctx context.Context) error {
n, err := atdo.atd.Exec(ctx)
@@ -84,5 +82,7 @@ func (atdo *AuthTokensDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (atdo *AuthTokensDeleteOne) ExecX(ctx context.Context) {
- atdo.atd.ExecX(ctx)
+ if err := atdo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/authtokens_query.go b/backend/internal/data/ent/authtokens_query.go
index 6a62190..238ab88 100644
--- a/backend/internal/data/ent/authtokens_query.go
+++ b/backend/internal/data/ent/authtokens_query.go
@@ -21,11 +21,8 @@ import (
// AuthTokensQuery is the builder for querying AuthTokens entities.
type AuthTokensQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []authtokens.OrderOption
inters []Interceptor
predicates []predicate.AuthTokens
withUser *UserQuery
@@ -44,25 +41,25 @@ func (atq *AuthTokensQuery) Where(ps ...predicate.AuthTokens) *AuthTokensQuery {
// Limit the number of records to be returned by this query.
func (atq *AuthTokensQuery) Limit(limit int) *AuthTokensQuery {
- atq.limit = &limit
+ atq.ctx.Limit = &limit
return atq
}
// Offset to start from.
func (atq *AuthTokensQuery) Offset(offset int) *AuthTokensQuery {
- atq.offset = &offset
+ atq.ctx.Offset = &offset
return atq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (atq *AuthTokensQuery) Unique(unique bool) *AuthTokensQuery {
- atq.unique = &unique
+ atq.ctx.Unique = &unique
return atq
}
// Order specifies how the records should be ordered.
-func (atq *AuthTokensQuery) Order(o ...OrderFunc) *AuthTokensQuery {
+func (atq *AuthTokensQuery) Order(o ...authtokens.OrderOption) *AuthTokensQuery {
atq.order = append(atq.order, o...)
return atq
}
@@ -114,7 +111,7 @@ func (atq *AuthTokensQuery) QueryRoles() *AuthRolesQuery {
// First returns the first AuthTokens entity from the query.
// Returns a *NotFoundError when no AuthTokens was found.
func (atq *AuthTokensQuery) First(ctx context.Context) (*AuthTokens, error) {
- nodes, err := atq.Limit(1).All(newQueryContext(ctx, TypeAuthTokens, "First"))
+ nodes, err := atq.Limit(1).All(setContextOp(ctx, atq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -137,7 +134,7 @@ func (atq *AuthTokensQuery) FirstX(ctx context.Context) *AuthTokens {
// Returns a *NotFoundError when no AuthTokens ID was found.
func (atq *AuthTokensQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = atq.Limit(1).IDs(newQueryContext(ctx, TypeAuthTokens, "FirstID")); err != nil {
+ if ids, err = atq.Limit(1).IDs(setContextOp(ctx, atq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -160,7 +157,7 @@ func (atq *AuthTokensQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one AuthTokens entity is found.
// Returns a *NotFoundError when no AuthTokens entities are found.
func (atq *AuthTokensQuery) Only(ctx context.Context) (*AuthTokens, error) {
- nodes, err := atq.Limit(2).All(newQueryContext(ctx, TypeAuthTokens, "Only"))
+ nodes, err := atq.Limit(2).All(setContextOp(ctx, atq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -188,7 +185,7 @@ func (atq *AuthTokensQuery) OnlyX(ctx context.Context) *AuthTokens {
// Returns a *NotFoundError when no entities are found.
func (atq *AuthTokensQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = atq.Limit(2).IDs(newQueryContext(ctx, TypeAuthTokens, "OnlyID")); err != nil {
+ if ids, err = atq.Limit(2).IDs(setContextOp(ctx, atq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -213,7 +210,7 @@ func (atq *AuthTokensQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of AuthTokensSlice.
func (atq *AuthTokensQuery) All(ctx context.Context) ([]*AuthTokens, error) {
- ctx = newQueryContext(ctx, TypeAuthTokens, "All")
+ ctx = setContextOp(ctx, atq.ctx, "All")
if err := atq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -231,10 +228,12 @@ func (atq *AuthTokensQuery) AllX(ctx context.Context) []*AuthTokens {
}
// IDs executes the query and returns a list of AuthTokens IDs.
-func (atq *AuthTokensQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeAuthTokens, "IDs")
- if err := atq.Select(authtokens.FieldID).Scan(ctx, &ids); err != nil {
+func (atq *AuthTokensQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if atq.ctx.Unique == nil && atq.path != nil {
+ atq.Unique(true)
+ }
+ ctx = setContextOp(ctx, atq.ctx, "IDs")
+ if err = atq.Select(authtokens.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -251,7 +250,7 @@ func (atq *AuthTokensQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (atq *AuthTokensQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeAuthTokens, "Count")
+ ctx = setContextOp(ctx, atq.ctx, "Count")
if err := atq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -269,7 +268,7 @@ func (atq *AuthTokensQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (atq *AuthTokensQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeAuthTokens, "Exist")
+ ctx = setContextOp(ctx, atq.ctx, "Exist")
switch _, err := atq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -297,17 +296,15 @@ func (atq *AuthTokensQuery) Clone() *AuthTokensQuery {
}
return &AuthTokensQuery{
config: atq.config,
- limit: atq.limit,
- offset: atq.offset,
- order: append([]OrderFunc{}, atq.order...),
+ ctx: atq.ctx.Clone(),
+ order: append([]authtokens.OrderOption{}, atq.order...),
inters: append([]Interceptor{}, atq.inters...),
predicates: append([]predicate.AuthTokens{}, atq.predicates...),
withUser: atq.withUser.Clone(),
withRoles: atq.withRoles.Clone(),
// clone intermediate query.
- sql: atq.sql.Clone(),
- path: atq.path,
- unique: atq.unique,
+ sql: atq.sql.Clone(),
+ path: atq.path,
}
}
@@ -348,9 +345,9 @@ func (atq *AuthTokensQuery) WithRoles(opts ...func(*AuthRolesQuery)) *AuthTokens
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (atq *AuthTokensQuery) GroupBy(field string, fields ...string) *AuthTokensGroupBy {
- atq.fields = append([]string{field}, fields...)
+ atq.ctx.Fields = append([]string{field}, fields...)
grbuild := &AuthTokensGroupBy{build: atq}
- grbuild.flds = &atq.fields
+ grbuild.flds = &atq.ctx.Fields
grbuild.label = authtokens.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -369,10 +366,10 @@ func (atq *AuthTokensQuery) GroupBy(field string, fields ...string) *AuthTokensG
// Select(authtokens.FieldCreatedAt).
// Scan(ctx, &v)
func (atq *AuthTokensQuery) Select(fields ...string) *AuthTokensSelect {
- atq.fields = append(atq.fields, fields...)
+ atq.ctx.Fields = append(atq.ctx.Fields, fields...)
sbuild := &AuthTokensSelect{AuthTokensQuery: atq}
sbuild.label = authtokens.Label
- sbuild.flds, sbuild.scan = &atq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &atq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -392,7 +389,7 @@ func (atq *AuthTokensQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range atq.fields {
+ for _, f := range atq.ctx.Fields {
if !authtokens.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -469,6 +466,9 @@ func (atq *AuthTokensQuery) loadUser(ctx context.Context, query *UserQuery, node
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(user.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -494,7 +494,7 @@ func (atq *AuthTokensQuery) loadRoles(ctx context.Context, query *AuthRolesQuery
}
query.withFKs = true
query.Where(predicate.AuthRoles(func(s *sql.Selector) {
- s.Where(sql.InValues(authtokens.RolesColumn, fks...))
+ s.Where(sql.InValues(s.C(authtokens.RolesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -507,7 +507,7 @@ func (atq *AuthTokensQuery) loadRoles(ctx context.Context, query *AuthRolesQuery
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "auth_tokens_roles" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "auth_tokens_roles" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -516,30 +516,22 @@ func (atq *AuthTokensQuery) loadRoles(ctx context.Context, query *AuthRolesQuery
func (atq *AuthTokensQuery) sqlCount(ctx context.Context) (int, error) {
_spec := atq.querySpec()
- _spec.Node.Columns = atq.fields
- if len(atq.fields) > 0 {
- _spec.Unique = atq.unique != nil && *atq.unique
+ _spec.Node.Columns = atq.ctx.Fields
+ if len(atq.ctx.Fields) > 0 {
+ _spec.Unique = atq.ctx.Unique != nil && *atq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, atq.driver, _spec)
}
func (atq *AuthTokensQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: authtokens.Table,
- Columns: authtokens.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
- },
- From: atq.sql,
- Unique: true,
- }
- if unique := atq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(authtokens.Table, authtokens.Columns, sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID))
+ _spec.From = atq.sql
+ if unique := atq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if atq.path != nil {
+ _spec.Unique = true
}
- if fields := atq.fields; len(fields) > 0 {
+ if fields := atq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, authtokens.FieldID)
for i := range fields {
@@ -555,10 +547,10 @@ func (atq *AuthTokensQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := atq.limit; limit != nil {
+ if limit := atq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := atq.offset; offset != nil {
+ if offset := atq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := atq.order; len(ps) > 0 {
@@ -574,7 +566,7 @@ func (atq *AuthTokensQuery) querySpec() *sqlgraph.QuerySpec {
func (atq *AuthTokensQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(atq.driver.Dialect())
t1 := builder.Table(authtokens.Table)
- columns := atq.fields
+ columns := atq.ctx.Fields
if len(columns) == 0 {
columns = authtokens.Columns
}
@@ -583,7 +575,7 @@ func (atq *AuthTokensQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = atq.sql
selector.Select(selector.Columns(columns...)...)
}
- if atq.unique != nil && *atq.unique {
+ if atq.ctx.Unique != nil && *atq.ctx.Unique {
selector.Distinct()
}
for _, p := range atq.predicates {
@@ -592,12 +584,12 @@ func (atq *AuthTokensQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range atq.order {
p(selector)
}
- if offset := atq.offset; offset != nil {
+ if offset := atq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := atq.limit; limit != nil {
+ if limit := atq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -617,7 +609,7 @@ func (atgb *AuthTokensGroupBy) Aggregate(fns ...AggregateFunc) *AuthTokensGroupB
// Scan applies the selector query and scans the result into the given value.
func (atgb *AuthTokensGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAuthTokens, "GroupBy")
+ ctx = setContextOp(ctx, atgb.build.ctx, "GroupBy")
if err := atgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -665,7 +657,7 @@ func (ats *AuthTokensSelect) Aggregate(fns ...AggregateFunc) *AuthTokensSelect {
// Scan applies the selector query and scans the result into the given value.
func (ats *AuthTokensSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeAuthTokens, "Select")
+ ctx = setContextOp(ctx, ats.ctx, "Select")
if err := ats.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/authtokens_update.go b/backend/internal/data/ent/authtokens_update.go
index c058ee3..776888e 100644
--- a/backend/internal/data/ent/authtokens_update.go
+++ b/backend/internal/data/ent/authtokens_update.go
@@ -115,7 +115,7 @@ func (atu *AuthTokensUpdate) ClearRoles() *AuthTokensUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (atu *AuthTokensUpdate) Save(ctx context.Context) (int, error) {
atu.defaults()
- return withHooks[int, AuthTokensMutation](ctx, atu.sqlSave, atu.mutation, atu.hooks)
+ return withHooks(ctx, atu.sqlSave, atu.mutation, atu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -149,16 +149,7 @@ func (atu *AuthTokensUpdate) defaults() {
}
func (atu *AuthTokensUpdate) sqlSave(ctx context.Context) (n int, err error) {
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authtokens.Table,
- Columns: authtokens.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(authtokens.Table, authtokens.Columns, sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID))
if ps := atu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -183,10 +174,7 @@ func (atu *AuthTokensUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authtokens.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -199,10 +187,7 @@ func (atu *AuthTokensUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authtokens.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -218,10 +203,7 @@ func (atu *AuthTokensUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authtokens.RolesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -234,10 +216,7 @@ func (atu *AuthTokensUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{authtokens.RolesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
@@ -346,6 +325,12 @@ func (atuo *AuthTokensUpdateOne) ClearRoles() *AuthTokensUpdateOne {
return atuo
}
+// Where appends a list predicates to the AuthTokensUpdate builder.
+func (atuo *AuthTokensUpdateOne) Where(ps ...predicate.AuthTokens) *AuthTokensUpdateOne {
+ atuo.mutation.Where(ps...)
+ return atuo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (atuo *AuthTokensUpdateOne) Select(field string, fields ...string) *AuthTokensUpdateOne {
@@ -356,7 +341,7 @@ func (atuo *AuthTokensUpdateOne) Select(field string, fields ...string) *AuthTok
// Save executes the query and returns the updated AuthTokens entity.
func (atuo *AuthTokensUpdateOne) Save(ctx context.Context) (*AuthTokens, error) {
atuo.defaults()
- return withHooks[*AuthTokens, AuthTokensMutation](ctx, atuo.sqlSave, atuo.mutation, atuo.hooks)
+ return withHooks(ctx, atuo.sqlSave, atuo.mutation, atuo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -390,16 +375,7 @@ func (atuo *AuthTokensUpdateOne) defaults() {
}
func (atuo *AuthTokensUpdateOne) sqlSave(ctx context.Context) (_node *AuthTokens, err error) {
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: authtokens.Table,
- Columns: authtokens.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: authtokens.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(authtokens.Table, authtokens.Columns, sqlgraph.NewFieldSpec(authtokens.FieldID, field.TypeUUID))
id, ok := atuo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "AuthTokens.id" for update`)}
@@ -441,10 +417,7 @@ func (atuo *AuthTokensUpdateOne) sqlSave(ctx context.Context) (_node *AuthTokens
Columns: []string{authtokens.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -457,10 +430,7 @@ func (atuo *AuthTokensUpdateOne) sqlSave(ctx context.Context) (_node *AuthTokens
Columns: []string{authtokens.UserColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -476,10 +446,7 @@ func (atuo *AuthTokensUpdateOne) sqlSave(ctx context.Context) (_node *AuthTokens
Columns: []string{authtokens.RolesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -492,10 +459,7 @@ func (atuo *AuthTokensUpdateOne) sqlSave(ctx context.Context) (_node *AuthTokens
Columns: []string{authtokens.RolesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeInt,
- Column: authroles.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(authroles.FieldID, field.TypeInt),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/client.go b/backend/internal/data/ent/client.go
index bcbd962..2fb9b53 100644
--- a/backend/internal/data/ent/client.go
+++ b/backend/internal/data/ent/client.go
@@ -7,10 +7,15 @@ import (
"errors"
"fmt"
"log"
+ "reflect"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/migrate"
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/hay-kot/homebox/backend/internal/data/ent/attachment"
"github.com/hay-kot/homebox/backend/internal/data/ent/authroles"
"github.com/hay-kot/homebox/backend/internal/data/ent/authtokens"
@@ -22,11 +27,8 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
"github.com/hay-kot/homebox/backend/internal/data/ent/maintenanceentry"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
-
- "entgo.io/ent/dialect"
- "entgo.io/ent/dialect/sql"
- "entgo.io/ent/dialect/sql/sqlgraph"
)
// Client is the client that holds all ent builders.
@@ -56,15 +58,15 @@ type Client struct {
Location *LocationClient
// MaintenanceEntry is the client for interacting with the MaintenanceEntry builders.
MaintenanceEntry *MaintenanceEntryClient
+ // Notifier is the client for interacting with the Notifier builders.
+ Notifier *NotifierClient
// User is the client for interacting with the User builders.
User *UserClient
}
// NewClient creates a new client configured with the given options.
func NewClient(opts ...Option) *Client {
- cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
- cfg.options(opts...)
- client := &Client{config: cfg}
+ client := &Client{config: newConfig(opts...)}
client.init()
return client
}
@@ -82,9 +84,66 @@ func (c *Client) init() {
c.Label = NewLabelClient(c.config)
c.Location = NewLocationClient(c.config)
c.MaintenanceEntry = NewMaintenanceEntryClient(c.config)
+ c.Notifier = NewNotifierClient(c.config)
c.User = NewUserClient(c.config)
}
+type (
+ // config is the configuration for the client and its builder.
+ config struct {
+ // driver used for executing database requests.
+ driver dialect.Driver
+ // debug enable a debug logging.
+ debug bool
+ // log used for logging on debug mode.
+ log func(...any)
+ // hooks to execute on mutations.
+ hooks *hooks
+ // interceptors to execute on queries.
+ inters *inters
+ }
+ // Option function to configure the client.
+ Option func(*config)
+)
+
+// newConfig creates a new config for the client.
+func newConfig(opts ...Option) config {
+ cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
+ cfg.options(opts...)
+ return cfg
+}
+
+// options applies the options on the config object.
+func (c *config) options(opts ...Option) {
+ for _, opt := range opts {
+ opt(c)
+ }
+ if c.debug {
+ c.driver = dialect.Debug(c.driver, c.log)
+ }
+}
+
+// Debug enables debug logging on the ent.Driver.
+func Debug() Option {
+ return func(c *config) {
+ c.debug = true
+ }
+}
+
+// Log sets the logging function for debug mode.
+func Log(fn func(...any)) Option {
+ return func(c *config) {
+ c.log = fn
+ }
+}
+
+// Driver configures the client driver.
+func Driver(driver dialect.Driver) Option {
+ return func(c *config) {
+ c.driver = driver
+ }
+}
+
// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
@@ -101,11 +160,14 @@ func Open(driverName, dataSourceName string, options ...Option) (*Client, error)
}
}
+// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
+var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")
+
// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
if _, ok := c.driver.(*txDriver); ok {
- return nil, errors.New("ent: cannot start a transaction within a transaction")
+ return nil, ErrTxStarted
}
tx, err := newTx(ctx, c.driver)
if err != nil {
@@ -127,6 +189,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
Label: NewLabelClient(cfg),
Location: NewLocationClient(cfg),
MaintenanceEntry: NewMaintenanceEntryClient(cfg),
+ Notifier: NewNotifierClient(cfg),
User: NewUserClient(cfg),
}, nil
}
@@ -158,6 +221,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
Label: NewLabelClient(cfg),
Location: NewLocationClient(cfg),
MaintenanceEntry: NewMaintenanceEntryClient(cfg),
+ Notifier: NewNotifierClient(cfg),
User: NewUserClient(cfg),
}, nil
}
@@ -187,35 +251,25 @@ func (c *Client) Close() error {
// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
- c.Attachment.Use(hooks...)
- c.AuthRoles.Use(hooks...)
- c.AuthTokens.Use(hooks...)
- c.Document.Use(hooks...)
- c.Group.Use(hooks...)
- c.GroupInvitationToken.Use(hooks...)
- c.Item.Use(hooks...)
- c.ItemField.Use(hooks...)
- c.Label.Use(hooks...)
- c.Location.Use(hooks...)
- c.MaintenanceEntry.Use(hooks...)
- c.User.Use(hooks...)
+ for _, n := range []interface{ Use(...Hook) }{
+ c.Attachment, c.AuthRoles, c.AuthTokens, c.Document, c.Group,
+ c.GroupInvitationToken, c.Item, c.ItemField, c.Label, c.Location,
+ c.MaintenanceEntry, c.Notifier, c.User,
+ } {
+ n.Use(hooks...)
+ }
}
// Intercept adds the query interceptors to all the entity clients.
// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
func (c *Client) Intercept(interceptors ...Interceptor) {
- c.Attachment.Intercept(interceptors...)
- c.AuthRoles.Intercept(interceptors...)
- c.AuthTokens.Intercept(interceptors...)
- c.Document.Intercept(interceptors...)
- c.Group.Intercept(interceptors...)
- c.GroupInvitationToken.Intercept(interceptors...)
- c.Item.Intercept(interceptors...)
- c.ItemField.Intercept(interceptors...)
- c.Label.Intercept(interceptors...)
- c.Location.Intercept(interceptors...)
- c.MaintenanceEntry.Intercept(interceptors...)
- c.User.Intercept(interceptors...)
+ for _, n := range []interface{ Intercept(...Interceptor) }{
+ c.Attachment, c.AuthRoles, c.AuthTokens, c.Document, c.Group,
+ c.GroupInvitationToken, c.Item, c.ItemField, c.Label, c.Location,
+ c.MaintenanceEntry, c.Notifier, c.User,
+ } {
+ n.Intercept(interceptors...)
+ }
}
// Mutate implements the ent.Mutator interface.
@@ -243,6 +297,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
return c.Location.mutate(ctx, m)
case *MaintenanceEntryMutation:
return c.MaintenanceEntry.mutate(ctx, m)
+ case *NotifierMutation:
+ return c.Notifier.mutate(ctx, m)
case *UserMutation:
return c.User.mutate(ctx, m)
default:
@@ -266,7 +322,7 @@ func (c *AttachmentClient) Use(hooks ...Hook) {
c.hooks.Attachment = append(c.hooks.Attachment, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `attachment.Intercept(f(g(h())))`.
func (c *AttachmentClient) Intercept(interceptors ...Interceptor) {
c.inters.Attachment = append(c.inters.Attachment, interceptors...)
@@ -283,6 +339,21 @@ func (c *AttachmentClient) CreateBulk(builders ...*AttachmentCreate) *Attachment
return &AttachmentCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AttachmentClient) MapCreateBulk(slice any, setFunc func(*AttachmentCreate, int)) *AttachmentCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &AttachmentCreateBulk{err: fmt.Errorf("calling to AttachmentClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*AttachmentCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &AttachmentCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Attachment.
func (c *AttachmentClient) Update() *AttachmentUpdate {
mutation := newAttachmentMutation(c.config, OpUpdate)
@@ -324,6 +395,7 @@ func (c *AttachmentClient) DeleteOneID(id uuid.UUID) *AttachmentDeleteOne {
func (c *AttachmentClient) Query() *AttachmentQuery {
return &AttachmentQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeAttachment},
inters: c.Interceptors(),
}
}
@@ -415,7 +487,7 @@ func (c *AuthRolesClient) Use(hooks ...Hook) {
c.hooks.AuthRoles = append(c.hooks.AuthRoles, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `authroles.Intercept(f(g(h())))`.
func (c *AuthRolesClient) Intercept(interceptors ...Interceptor) {
c.inters.AuthRoles = append(c.inters.AuthRoles, interceptors...)
@@ -432,6 +504,21 @@ func (c *AuthRolesClient) CreateBulk(builders ...*AuthRolesCreate) *AuthRolesCre
return &AuthRolesCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AuthRolesClient) MapCreateBulk(slice any, setFunc func(*AuthRolesCreate, int)) *AuthRolesCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &AuthRolesCreateBulk{err: fmt.Errorf("calling to AuthRolesClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*AuthRolesCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &AuthRolesCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for AuthRoles.
func (c *AuthRolesClient) Update() *AuthRolesUpdate {
mutation := newAuthRolesMutation(c.config, OpUpdate)
@@ -473,6 +560,7 @@ func (c *AuthRolesClient) DeleteOneID(id int) *AuthRolesDeleteOne {
func (c *AuthRolesClient) Query() *AuthRolesQuery {
return &AuthRolesQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeAuthRoles},
inters: c.Interceptors(),
}
}
@@ -548,7 +636,7 @@ func (c *AuthTokensClient) Use(hooks ...Hook) {
c.hooks.AuthTokens = append(c.hooks.AuthTokens, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `authtokens.Intercept(f(g(h())))`.
func (c *AuthTokensClient) Intercept(interceptors ...Interceptor) {
c.inters.AuthTokens = append(c.inters.AuthTokens, interceptors...)
@@ -565,6 +653,21 @@ func (c *AuthTokensClient) CreateBulk(builders ...*AuthTokensCreate) *AuthTokens
return &AuthTokensCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AuthTokensClient) MapCreateBulk(slice any, setFunc func(*AuthTokensCreate, int)) *AuthTokensCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &AuthTokensCreateBulk{err: fmt.Errorf("calling to AuthTokensClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*AuthTokensCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &AuthTokensCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for AuthTokens.
func (c *AuthTokensClient) Update() *AuthTokensUpdate {
mutation := newAuthTokensMutation(c.config, OpUpdate)
@@ -606,6 +709,7 @@ func (c *AuthTokensClient) DeleteOneID(id uuid.UUID) *AuthTokensDeleteOne {
func (c *AuthTokensClient) Query() *AuthTokensQuery {
return &AuthTokensQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeAuthTokens},
inters: c.Interceptors(),
}
}
@@ -697,7 +801,7 @@ func (c *DocumentClient) Use(hooks ...Hook) {
c.hooks.Document = append(c.hooks.Document, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `document.Intercept(f(g(h())))`.
func (c *DocumentClient) Intercept(interceptors ...Interceptor) {
c.inters.Document = append(c.inters.Document, interceptors...)
@@ -714,6 +818,21 @@ func (c *DocumentClient) CreateBulk(builders ...*DocumentCreate) *DocumentCreate
return &DocumentCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *DocumentClient) MapCreateBulk(slice any, setFunc func(*DocumentCreate, int)) *DocumentCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &DocumentCreateBulk{err: fmt.Errorf("calling to DocumentClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*DocumentCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &DocumentCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Document.
func (c *DocumentClient) Update() *DocumentUpdate {
mutation := newDocumentMutation(c.config, OpUpdate)
@@ -755,6 +874,7 @@ func (c *DocumentClient) DeleteOneID(id uuid.UUID) *DocumentDeleteOne {
func (c *DocumentClient) Query() *DocumentQuery {
return &DocumentQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeDocument},
inters: c.Interceptors(),
}
}
@@ -846,7 +966,7 @@ func (c *GroupClient) Use(hooks ...Hook) {
c.hooks.Group = append(c.hooks.Group, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `group.Intercept(f(g(h())))`.
func (c *GroupClient) Intercept(interceptors ...Interceptor) {
c.inters.Group = append(c.inters.Group, interceptors...)
@@ -863,6 +983,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk {
return &GroupCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*GroupCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &GroupCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Group.
func (c *GroupClient) Update() *GroupUpdate {
mutation := newGroupMutation(c.config, OpUpdate)
@@ -904,6 +1039,7 @@ func (c *GroupClient) DeleteOneID(id uuid.UUID) *GroupDeleteOne {
func (c *GroupClient) Query() *GroupQuery {
return &GroupQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeGroup},
inters: c.Interceptors(),
}
}
@@ -1018,6 +1154,22 @@ func (c *GroupClient) QueryInvitationTokens(gr *Group) *GroupInvitationTokenQuer
return query
}
+// QueryNotifiers queries the notifiers edge of a Group.
+func (c *GroupClient) QueryNotifiers(gr *Group) *NotifierQuery {
+ query := (&NotifierClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := gr.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(group.Table, group.FieldID, id),
+ sqlgraph.To(notifier.Table, notifier.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, group.NotifiersTable, group.NotifiersColumn),
+ )
+ fromV = sqlgraph.Neighbors(gr.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
// Hooks returns the client hooks.
func (c *GroupClient) Hooks() []Hook {
return c.hooks.Group
@@ -1059,7 +1211,7 @@ func (c *GroupInvitationTokenClient) Use(hooks ...Hook) {
c.hooks.GroupInvitationToken = append(c.hooks.GroupInvitationToken, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `groupinvitationtoken.Intercept(f(g(h())))`.
func (c *GroupInvitationTokenClient) Intercept(interceptors ...Interceptor) {
c.inters.GroupInvitationToken = append(c.inters.GroupInvitationToken, interceptors...)
@@ -1076,6 +1228,21 @@ func (c *GroupInvitationTokenClient) CreateBulk(builders ...*GroupInvitationToke
return &GroupInvitationTokenCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *GroupInvitationTokenClient) MapCreateBulk(slice any, setFunc func(*GroupInvitationTokenCreate, int)) *GroupInvitationTokenCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &GroupInvitationTokenCreateBulk{err: fmt.Errorf("calling to GroupInvitationTokenClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*GroupInvitationTokenCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &GroupInvitationTokenCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for GroupInvitationToken.
func (c *GroupInvitationTokenClient) Update() *GroupInvitationTokenUpdate {
mutation := newGroupInvitationTokenMutation(c.config, OpUpdate)
@@ -1117,6 +1284,7 @@ func (c *GroupInvitationTokenClient) DeleteOneID(id uuid.UUID) *GroupInvitationT
func (c *GroupInvitationTokenClient) Query() *GroupInvitationTokenQuery {
return &GroupInvitationTokenQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeGroupInvitationToken},
inters: c.Interceptors(),
}
}
@@ -1192,7 +1360,7 @@ func (c *ItemClient) Use(hooks ...Hook) {
c.hooks.Item = append(c.hooks.Item, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `item.Intercept(f(g(h())))`.
func (c *ItemClient) Intercept(interceptors ...Interceptor) {
c.inters.Item = append(c.inters.Item, interceptors...)
@@ -1209,6 +1377,21 @@ func (c *ItemClient) CreateBulk(builders ...*ItemCreate) *ItemCreateBulk {
return &ItemCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ItemClient) MapCreateBulk(slice any, setFunc func(*ItemCreate, int)) *ItemCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &ItemCreateBulk{err: fmt.Errorf("calling to ItemClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*ItemCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &ItemCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Item.
func (c *ItemClient) Update() *ItemUpdate {
mutation := newItemMutation(c.config, OpUpdate)
@@ -1250,6 +1433,7 @@ func (c *ItemClient) DeleteOneID(id uuid.UUID) *ItemDeleteOne {
func (c *ItemClient) Query() *ItemQuery {
return &ItemQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeItem},
inters: c.Interceptors(),
}
}
@@ -1268,6 +1452,22 @@ func (c *ItemClient) GetX(ctx context.Context, id uuid.UUID) *Item {
return obj
}
+// QueryGroup queries the group edge of a Item.
+func (c *ItemClient) QueryGroup(i *Item) *GroupQuery {
+ query := (&GroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := i.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(item.Table, item.FieldID, id),
+ sqlgraph.To(group.Table, group.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
+ )
+ fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
// QueryParent queries the parent edge of a Item.
func (c *ItemClient) QueryParent(i *Item) *ItemQuery {
query := (&ItemClient{config: c.config}).Query()
@@ -1300,22 +1500,6 @@ func (c *ItemClient) QueryChildren(i *Item) *ItemQuery {
return query
}
-// QueryGroup queries the group edge of a Item.
-func (c *ItemClient) QueryGroup(i *Item) *GroupQuery {
- query := (&GroupClient{config: c.config}).Query()
- query.path = func(context.Context) (fromV *sql.Selector, _ error) {
- id := i.ID
- step := sqlgraph.NewStep(
- sqlgraph.From(item.Table, item.FieldID, id),
- sqlgraph.To(group.Table, group.FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
- )
- fromV = sqlgraph.Neighbors(i.driver.Dialect(), step)
- return fromV, nil
- }
- return query
-}
-
// QueryLabel queries the label edge of a Item.
func (c *ItemClient) QueryLabel(i *Item) *LabelQuery {
query := (&LabelClient{config: c.config}).Query()
@@ -1437,7 +1621,7 @@ func (c *ItemFieldClient) Use(hooks ...Hook) {
c.hooks.ItemField = append(c.hooks.ItemField, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `itemfield.Intercept(f(g(h())))`.
func (c *ItemFieldClient) Intercept(interceptors ...Interceptor) {
c.inters.ItemField = append(c.inters.ItemField, interceptors...)
@@ -1454,6 +1638,21 @@ func (c *ItemFieldClient) CreateBulk(builders ...*ItemFieldCreate) *ItemFieldCre
return &ItemFieldCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ItemFieldClient) MapCreateBulk(slice any, setFunc func(*ItemFieldCreate, int)) *ItemFieldCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &ItemFieldCreateBulk{err: fmt.Errorf("calling to ItemFieldClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*ItemFieldCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &ItemFieldCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for ItemField.
func (c *ItemFieldClient) Update() *ItemFieldUpdate {
mutation := newItemFieldMutation(c.config, OpUpdate)
@@ -1495,6 +1694,7 @@ func (c *ItemFieldClient) DeleteOneID(id uuid.UUID) *ItemFieldDeleteOne {
func (c *ItemFieldClient) Query() *ItemFieldQuery {
return &ItemFieldQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeItemField},
inters: c.Interceptors(),
}
}
@@ -1570,7 +1770,7 @@ func (c *LabelClient) Use(hooks ...Hook) {
c.hooks.Label = append(c.hooks.Label, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `label.Intercept(f(g(h())))`.
func (c *LabelClient) Intercept(interceptors ...Interceptor) {
c.inters.Label = append(c.inters.Label, interceptors...)
@@ -1587,6 +1787,21 @@ func (c *LabelClient) CreateBulk(builders ...*LabelCreate) *LabelCreateBulk {
return &LabelCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *LabelClient) MapCreateBulk(slice any, setFunc func(*LabelCreate, int)) *LabelCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &LabelCreateBulk{err: fmt.Errorf("calling to LabelClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*LabelCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &LabelCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Label.
func (c *LabelClient) Update() *LabelUpdate {
mutation := newLabelMutation(c.config, OpUpdate)
@@ -1628,6 +1843,7 @@ func (c *LabelClient) DeleteOneID(id uuid.UUID) *LabelDeleteOne {
func (c *LabelClient) Query() *LabelQuery {
return &LabelQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeLabel},
inters: c.Interceptors(),
}
}
@@ -1719,7 +1935,7 @@ func (c *LocationClient) Use(hooks ...Hook) {
c.hooks.Location = append(c.hooks.Location, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `location.Intercept(f(g(h())))`.
func (c *LocationClient) Intercept(interceptors ...Interceptor) {
c.inters.Location = append(c.inters.Location, interceptors...)
@@ -1736,6 +1952,21 @@ func (c *LocationClient) CreateBulk(builders ...*LocationCreate) *LocationCreate
return &LocationCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *LocationClient) MapCreateBulk(slice any, setFunc func(*LocationCreate, int)) *LocationCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &LocationCreateBulk{err: fmt.Errorf("calling to LocationClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*LocationCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &LocationCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for Location.
func (c *LocationClient) Update() *LocationUpdate {
mutation := newLocationMutation(c.config, OpUpdate)
@@ -1777,6 +2008,7 @@ func (c *LocationClient) DeleteOneID(id uuid.UUID) *LocationDeleteOne {
func (c *LocationClient) Query() *LocationQuery {
return &LocationQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeLocation},
inters: c.Interceptors(),
}
}
@@ -1795,6 +2027,22 @@ func (c *LocationClient) GetX(ctx context.Context, id uuid.UUID) *Location {
return obj
}
+// QueryGroup queries the group edge of a Location.
+func (c *LocationClient) QueryGroup(l *Location) *GroupQuery {
+ query := (&GroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := l.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(location.Table, location.FieldID, id),
+ sqlgraph.To(group.Table, group.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
+ )
+ fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
// QueryParent queries the parent edge of a Location.
func (c *LocationClient) QueryParent(l *Location) *LocationQuery {
query := (&LocationClient{config: c.config}).Query()
@@ -1827,22 +2075,6 @@ func (c *LocationClient) QueryChildren(l *Location) *LocationQuery {
return query
}
-// QueryGroup queries the group edge of a Location.
-func (c *LocationClient) QueryGroup(l *Location) *GroupQuery {
- query := (&GroupClient{config: c.config}).Query()
- query.path = func(context.Context) (fromV *sql.Selector, _ error) {
- id := l.ID
- step := sqlgraph.NewStep(
- sqlgraph.From(location.Table, location.FieldID, id),
- sqlgraph.To(group.Table, group.FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
- )
- fromV = sqlgraph.Neighbors(l.driver.Dialect(), step)
- return fromV, nil
- }
- return query
-}
-
// QueryItems queries the items edge of a Location.
func (c *LocationClient) QueryItems(l *Location) *ItemQuery {
query := (&ItemClient{config: c.config}).Query()
@@ -1900,7 +2132,7 @@ func (c *MaintenanceEntryClient) Use(hooks ...Hook) {
c.hooks.MaintenanceEntry = append(c.hooks.MaintenanceEntry, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `maintenanceentry.Intercept(f(g(h())))`.
func (c *MaintenanceEntryClient) Intercept(interceptors ...Interceptor) {
c.inters.MaintenanceEntry = append(c.inters.MaintenanceEntry, interceptors...)
@@ -1917,6 +2149,21 @@ func (c *MaintenanceEntryClient) CreateBulk(builders ...*MaintenanceEntryCreate)
return &MaintenanceEntryCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *MaintenanceEntryClient) MapCreateBulk(slice any, setFunc func(*MaintenanceEntryCreate, int)) *MaintenanceEntryCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &MaintenanceEntryCreateBulk{err: fmt.Errorf("calling to MaintenanceEntryClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*MaintenanceEntryCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &MaintenanceEntryCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for MaintenanceEntry.
func (c *MaintenanceEntryClient) Update() *MaintenanceEntryUpdate {
mutation := newMaintenanceEntryMutation(c.config, OpUpdate)
@@ -1958,6 +2205,7 @@ func (c *MaintenanceEntryClient) DeleteOneID(id uuid.UUID) *MaintenanceEntryDele
func (c *MaintenanceEntryClient) Query() *MaintenanceEntryQuery {
return &MaintenanceEntryQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeMaintenanceEntry},
inters: c.Interceptors(),
}
}
@@ -2017,6 +2265,171 @@ func (c *MaintenanceEntryClient) mutate(ctx context.Context, m *MaintenanceEntry
}
}
+// NotifierClient is a client for the Notifier schema.
+type NotifierClient struct {
+ config
+}
+
+// NewNotifierClient returns a client for the Notifier from the given config.
+func NewNotifierClient(c config) *NotifierClient {
+ return &NotifierClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `notifier.Hooks(f(g(h())))`.
+func (c *NotifierClient) Use(hooks ...Hook) {
+ c.hooks.Notifier = append(c.hooks.Notifier, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `notifier.Intercept(f(g(h())))`.
+func (c *NotifierClient) Intercept(interceptors ...Interceptor) {
+ c.inters.Notifier = append(c.inters.Notifier, interceptors...)
+}
+
+// Create returns a builder for creating a Notifier entity.
+func (c *NotifierClient) Create() *NotifierCreate {
+ mutation := newNotifierMutation(c.config, OpCreate)
+ return &NotifierCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Notifier entities.
+func (c *NotifierClient) CreateBulk(builders ...*NotifierCreate) *NotifierCreateBulk {
+ return &NotifierCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *NotifierClient) MapCreateBulk(slice any, setFunc func(*NotifierCreate, int)) *NotifierCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &NotifierCreateBulk{err: fmt.Errorf("calling to NotifierClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*NotifierCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &NotifierCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Notifier.
+func (c *NotifierClient) Update() *NotifierUpdate {
+ mutation := newNotifierMutation(c.config, OpUpdate)
+ return &NotifierUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *NotifierClient) UpdateOne(n *Notifier) *NotifierUpdateOne {
+ mutation := newNotifierMutation(c.config, OpUpdateOne, withNotifier(n))
+ return &NotifierUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *NotifierClient) UpdateOneID(id uuid.UUID) *NotifierUpdateOne {
+ mutation := newNotifierMutation(c.config, OpUpdateOne, withNotifierID(id))
+ return &NotifierUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Notifier.
+func (c *NotifierClient) Delete() *NotifierDelete {
+ mutation := newNotifierMutation(c.config, OpDelete)
+ return &NotifierDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *NotifierClient) DeleteOne(n *Notifier) *NotifierDeleteOne {
+ return c.DeleteOneID(n.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *NotifierClient) DeleteOneID(id uuid.UUID) *NotifierDeleteOne {
+ builder := c.Delete().Where(notifier.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &NotifierDeleteOne{builder}
+}
+
+// Query returns a query builder for Notifier.
+func (c *NotifierClient) Query() *NotifierQuery {
+ return &NotifierQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeNotifier},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a Notifier entity by its id.
+func (c *NotifierClient) Get(ctx context.Context, id uuid.UUID) (*Notifier, error) {
+ return c.Query().Where(notifier.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *NotifierClient) GetX(ctx context.Context, id uuid.UUID) *Notifier {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryGroup queries the group edge of a Notifier.
+func (c *NotifierClient) QueryGroup(n *Notifier) *GroupQuery {
+ query := (&GroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := n.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(notifier.Table, notifier.FieldID, id),
+ sqlgraph.To(group.Table, group.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, notifier.GroupTable, notifier.GroupColumn),
+ )
+ fromV = sqlgraph.Neighbors(n.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryUser queries the user edge of a Notifier.
+func (c *NotifierClient) QueryUser(n *Notifier) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := n.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(notifier.Table, notifier.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, notifier.UserTable, notifier.UserColumn),
+ )
+ fromV = sqlgraph.Neighbors(n.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *NotifierClient) Hooks() []Hook {
+ return c.hooks.Notifier
+}
+
+// Interceptors returns the client interceptors.
+func (c *NotifierClient) Interceptors() []Interceptor {
+ return c.inters.Notifier
+}
+
+func (c *NotifierClient) mutate(ctx context.Context, m *NotifierMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&NotifierCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&NotifierUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&NotifierUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&NotifierDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("ent: unknown Notifier mutation op: %q", m.Op())
+ }
+}
+
// UserClient is a client for the User schema.
type UserClient struct {
config
@@ -2033,7 +2446,7 @@ func (c *UserClient) Use(hooks ...Hook) {
c.hooks.User = append(c.hooks.User, hooks...)
}
-// Use adds a list of query interceptors to the interceptors stack.
+// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`.
func (c *UserClient) Intercept(interceptors ...Interceptor) {
c.inters.User = append(c.inters.User, interceptors...)
@@ -2050,6 +2463,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk {
return &UserCreateBulk{config: c.config, builders: builders}
}
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*UserCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &UserCreateBulk{config: c.config, builders: builders}
+}
+
// Update returns an update builder for User.
func (c *UserClient) Update() *UserUpdate {
mutation := newUserMutation(c.config, OpUpdate)
@@ -2091,6 +2519,7 @@ func (c *UserClient) DeleteOneID(id uuid.UUID) *UserDeleteOne {
func (c *UserClient) Query() *UserQuery {
return &UserQuery{
config: c.config,
+ ctx: &QueryContext{Type: TypeUser},
inters: c.Interceptors(),
}
}
@@ -2141,6 +2570,22 @@ func (c *UserClient) QueryAuthTokens(u *User) *AuthTokensQuery {
return query
}
+// QueryNotifiers queries the notifiers edge of a User.
+func (c *UserClient) QueryNotifiers(u *User) *NotifierQuery {
+ query := (&NotifierClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := u.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(notifier.Table, notifier.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, user.NotifiersTable, user.NotifiersColumn),
+ )
+ fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
// Hooks returns the client hooks.
func (c *UserClient) Hooks() []Hook {
return c.hooks.User
@@ -2165,3 +2610,15 @@ func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error)
return nil, fmt.Errorf("ent: unknown User mutation op: %q", m.Op())
}
}
+
+// hooks and interceptors per client, for fast access.
+type (
+ hooks struct {
+ Attachment, AuthRoles, AuthTokens, Document, Group, GroupInvitationToken, Item,
+ ItemField, Label, Location, MaintenanceEntry, Notifier, User []ent.Hook
+ }
+ inters struct {
+ Attachment, AuthRoles, AuthTokens, Document, Group, GroupInvitationToken, Item,
+ ItemField, Label, Location, MaintenanceEntry, Notifier, User []ent.Interceptor
+ }
+)
diff --git a/backend/internal/data/ent/config.go b/backend/internal/data/ent/config.go
deleted file mode 100644
index c4dc769..0000000
--- a/backend/internal/data/ent/config.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
- "entgo.io/ent"
- "entgo.io/ent/dialect"
-)
-
-// Option function to configure the client.
-type Option func(*config)
-
-// Config is the configuration for the client and its builder.
-type config struct {
- // driver used for executing database requests.
- driver dialect.Driver
- // debug enable a debug logging.
- debug bool
- // log used for logging on debug mode.
- log func(...any)
- // hooks to execute on mutations.
- hooks *hooks
- // interceptors to execute on queries.
- inters *inters
-}
-
-// hooks and interceptors per client, for fast access.
-type (
- hooks struct {
- Attachment []ent.Hook
- AuthRoles []ent.Hook
- AuthTokens []ent.Hook
- Document []ent.Hook
- Group []ent.Hook
- GroupInvitationToken []ent.Hook
- Item []ent.Hook
- ItemField []ent.Hook
- Label []ent.Hook
- Location []ent.Hook
- MaintenanceEntry []ent.Hook
- User []ent.Hook
- }
- inters struct {
- Attachment []ent.Interceptor
- AuthRoles []ent.Interceptor
- AuthTokens []ent.Interceptor
- Document []ent.Interceptor
- Group []ent.Interceptor
- GroupInvitationToken []ent.Interceptor
- Item []ent.Interceptor
- ItemField []ent.Interceptor
- Label []ent.Interceptor
- Location []ent.Interceptor
- MaintenanceEntry []ent.Interceptor
- User []ent.Interceptor
- }
-)
-
-// Options applies the options on the config object.
-func (c *config) options(opts ...Option) {
- for _, opt := range opts {
- opt(c)
- }
- if c.debug {
- c.driver = dialect.Debug(c.driver, c.log)
- }
-}
-
-// Debug enables debug logging on the ent.Driver.
-func Debug() Option {
- return func(c *config) {
- c.debug = true
- }
-}
-
-// Log sets the logging function for debug mode.
-func Log(fn func(...any)) Option {
- return func(c *config) {
- c.log = fn
- }
-}
-
-// Driver configures the client driver.
-func Driver(driver dialect.Driver) Option {
- return func(c *config) {
- c.driver = driver
- }
-}
diff --git a/backend/internal/data/ent/context.go b/backend/internal/data/ent/context.go
deleted file mode 100644
index 7811bfa..0000000
--- a/backend/internal/data/ent/context.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Code generated by ent, DO NOT EDIT.
-
-package ent
-
-import (
- "context"
-)
-
-type clientCtxKey struct{}
-
-// FromContext returns a Client stored inside a context, or nil if there isn't one.
-func FromContext(ctx context.Context) *Client {
- c, _ := ctx.Value(clientCtxKey{}).(*Client)
- return c
-}
-
-// NewContext returns a new context with the given Client attached.
-func NewContext(parent context.Context, c *Client) context.Context {
- return context.WithValue(parent, clientCtxKey{}, c)
-}
-
-type txCtxKey struct{}
-
-// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
-func TxFromContext(ctx context.Context) *Tx {
- tx, _ := ctx.Value(txCtxKey{}).(*Tx)
- return tx
-}
-
-// NewTxContext returns a new context with the given Tx attached.
-func NewTxContext(parent context.Context, tx *Tx) context.Context {
- return context.WithValue(parent, txCtxKey{}, tx)
-}
diff --git a/backend/internal/data/ent/document.go b/backend/internal/data/ent/document.go
index 50c1612..3141bac 100644
--- a/backend/internal/data/ent/document.go
+++ b/backend/internal/data/ent/document.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/document"
@@ -30,6 +31,7 @@ type Document struct {
// The values are being populated by the DocumentQuery when eager-loading is set.
Edges DocumentEdges `json:"edges"`
group_documents *uuid.UUID
+ selectValues sql.SelectValues
}
// DocumentEdges holds the relations/edges for other nodes in the graph.
@@ -79,7 +81,7 @@ func (*Document) scanValues(columns []string) ([]any, error) {
case document.ForeignKeys[0]: // group_documents
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type Document", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -130,26 +132,34 @@ func (d *Document) assignValues(columns []string, values []any) error {
d.group_documents = new(uuid.UUID)
*d.group_documents = *value.S.(*uuid.UUID)
}
+ default:
+ d.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the Document.
+// This includes values selected through modifiers, order, etc.
+func (d *Document) Value(name string) (ent.Value, error) {
+ return d.selectValues.Get(name)
+}
+
// QueryGroup queries the "group" edge of the Document entity.
func (d *Document) QueryGroup() *GroupQuery {
- return (&DocumentClient{config: d.config}).QueryGroup(d)
+ return NewDocumentClient(d.config).QueryGroup(d)
}
// QueryAttachments queries the "attachments" edge of the Document entity.
func (d *Document) QueryAttachments() *AttachmentQuery {
- return (&DocumentClient{config: d.config}).QueryAttachments(d)
+ return NewDocumentClient(d.config).QueryAttachments(d)
}
// Update returns a builder for updating this Document.
// Note that you need to call Document.Unwrap() before calling this method if this Document
// was returned from a transaction, and the transaction was committed or rolled back.
func (d *Document) Update() *DocumentUpdateOne {
- return (&DocumentClient{config: d.config}).UpdateOne(d)
+ return NewDocumentClient(d.config).UpdateOne(d)
}
// Unwrap unwraps the Document entity that was returned from a transaction after it was closed,
@@ -185,9 +195,3 @@ func (d *Document) String() string {
// Documents is a parsable slice of Document.
type Documents []*Document
-
-func (d Documents) config(cfg config) {
- for _i := range d {
- d[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/document/document.go b/backend/internal/data/ent/document/document.go
index b6a15eb..95380f4 100644
--- a/backend/internal/data/ent/document/document.go
+++ b/backend/internal/data/ent/document/document.go
@@ -5,6 +5,8 @@ package document
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -87,3 +89,66 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the Document queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByTitle orders the results by the title field.
+func ByTitle(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldTitle, opts...).ToFunc()
+}
+
+// ByPath orders the results by the path field.
+func ByPath(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPath, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByAttachmentsCount orders the results by attachments count.
+func ByAttachmentsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newAttachmentsStep(), opts...)
+ }
+}
+
+// ByAttachments orders the results by attachments terms.
+func ByAttachments(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newAttachmentsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+}
+func newAttachmentsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(AttachmentsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
+ )
+}
diff --git a/backend/internal/data/ent/document/where.go b/backend/internal/data/ent/document/where.go
index 614cf4e..3e491ad 100644
--- a/backend/internal/data/ent/document/where.go
+++ b/backend/internal/data/ent/document/where.go
@@ -300,11 +300,7 @@ func HasGroup() predicate.Document {
// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
func HasGroupWith(preds ...predicate.Group) predicate.Document {
return predicate.Document(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(GroupInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
+ step := newGroupStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -327,11 +323,7 @@ func HasAttachments() predicate.Document {
// HasAttachmentsWith applies the HasEdge predicate on the "attachments" edge with a given conditions (other predicates).
func HasAttachmentsWith(preds ...predicate.Attachment) predicate.Document {
return predicate.Document(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(AttachmentsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
- )
+ step := newAttachmentsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -342,32 +334,15 @@ func HasAttachmentsWith(preds ...predicate.Attachment) predicate.Document {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Document) predicate.Document {
- return predicate.Document(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Document(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Document) predicate.Document {
- return predicate.Document(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Document(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Document) predicate.Document {
- return predicate.Document(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Document(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/document_create.go b/backend/internal/data/ent/document_create.go
index 81f5e8c..fe61e98 100644
--- a/backend/internal/data/ent/document_create.go
+++ b/backend/internal/data/ent/document_create.go
@@ -111,7 +111,7 @@ func (dc *DocumentCreate) Mutation() *DocumentMutation {
// Save creates the Document in the database.
func (dc *DocumentCreate) Save(ctx context.Context) (*Document, error) {
dc.defaults()
- return withHooks[*Document, DocumentMutation](ctx, dc.sqlSave, dc.mutation, dc.hooks)
+ return withHooks(ctx, dc.sqlSave, dc.mutation, dc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -208,13 +208,7 @@ func (dc *DocumentCreate) sqlSave(ctx context.Context) (*Document, error) {
func (dc *DocumentCreate) createSpec() (*Document, *sqlgraph.CreateSpec) {
var (
_node = &Document{config: dc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: document.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(document.Table, sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID))
)
if id, ok := dc.mutation.ID(); ok {
_node.ID = id
@@ -244,10 +238,7 @@ func (dc *DocumentCreate) createSpec() (*Document, *sqlgraph.CreateSpec) {
Columns: []string{document.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -264,10 +255,7 @@ func (dc *DocumentCreate) createSpec() (*Document, *sqlgraph.CreateSpec) {
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -281,11 +269,15 @@ func (dc *DocumentCreate) createSpec() (*Document, *sqlgraph.CreateSpec) {
// DocumentCreateBulk is the builder for creating many Document entities in bulk.
type DocumentCreateBulk struct {
config
+ err error
builders []*DocumentCreate
}
// Save creates the Document entities in the database.
func (dcb *DocumentCreateBulk) Save(ctx context.Context) ([]*Document, error) {
+ if dcb.err != nil {
+ return nil, dcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(dcb.builders))
nodes := make([]*Document, len(dcb.builders))
mutators := make([]Mutator, len(dcb.builders))
@@ -302,8 +294,8 @@ func (dcb *DocumentCreateBulk) Save(ctx context.Context) ([]*Document, error) {
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, dcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/document_delete.go b/backend/internal/data/ent/document_delete.go
index 000ab1c..5901c03 100644
--- a/backend/internal/data/ent/document_delete.go
+++ b/backend/internal/data/ent/document_delete.go
@@ -27,7 +27,7 @@ func (dd *DocumentDelete) Where(ps ...predicate.Document) *DocumentDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (dd *DocumentDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, DocumentMutation](ctx, dd.sqlExec, dd.mutation, dd.hooks)
+ return withHooks(ctx, dd.sqlExec, dd.mutation, dd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (dd *DocumentDelete) ExecX(ctx context.Context) int {
}
func (dd *DocumentDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: document.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(document.Table, sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID))
if ps := dd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type DocumentDeleteOne struct {
dd *DocumentDelete
}
+// Where appends a list predicates to the DocumentDelete builder.
+func (ddo *DocumentDeleteOne) Where(ps ...predicate.Document) *DocumentDeleteOne {
+ ddo.dd.mutation.Where(ps...)
+ return ddo
+}
+
// Exec executes the deletion query.
func (ddo *DocumentDeleteOne) Exec(ctx context.Context) error {
n, err := ddo.dd.Exec(ctx)
@@ -84,5 +82,7 @@ func (ddo *DocumentDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ddo *DocumentDeleteOne) ExecX(ctx context.Context) {
- ddo.dd.ExecX(ctx)
+ if err := ddo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/document_query.go b/backend/internal/data/ent/document_query.go
index 51b407c..34f4801 100644
--- a/backend/internal/data/ent/document_query.go
+++ b/backend/internal/data/ent/document_query.go
@@ -21,11 +21,8 @@ import (
// DocumentQuery is the builder for querying Document entities.
type DocumentQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []document.OrderOption
inters []Interceptor
predicates []predicate.Document
withGroup *GroupQuery
@@ -44,25 +41,25 @@ func (dq *DocumentQuery) Where(ps ...predicate.Document) *DocumentQuery {
// Limit the number of records to be returned by this query.
func (dq *DocumentQuery) Limit(limit int) *DocumentQuery {
- dq.limit = &limit
+ dq.ctx.Limit = &limit
return dq
}
// Offset to start from.
func (dq *DocumentQuery) Offset(offset int) *DocumentQuery {
- dq.offset = &offset
+ dq.ctx.Offset = &offset
return dq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (dq *DocumentQuery) Unique(unique bool) *DocumentQuery {
- dq.unique = &unique
+ dq.ctx.Unique = &unique
return dq
}
// Order specifies how the records should be ordered.
-func (dq *DocumentQuery) Order(o ...OrderFunc) *DocumentQuery {
+func (dq *DocumentQuery) Order(o ...document.OrderOption) *DocumentQuery {
dq.order = append(dq.order, o...)
return dq
}
@@ -114,7 +111,7 @@ func (dq *DocumentQuery) QueryAttachments() *AttachmentQuery {
// First returns the first Document entity from the query.
// Returns a *NotFoundError when no Document was found.
func (dq *DocumentQuery) First(ctx context.Context) (*Document, error) {
- nodes, err := dq.Limit(1).All(newQueryContext(ctx, TypeDocument, "First"))
+ nodes, err := dq.Limit(1).All(setContextOp(ctx, dq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -137,7 +134,7 @@ func (dq *DocumentQuery) FirstX(ctx context.Context) *Document {
// Returns a *NotFoundError when no Document ID was found.
func (dq *DocumentQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = dq.Limit(1).IDs(newQueryContext(ctx, TypeDocument, "FirstID")); err != nil {
+ if ids, err = dq.Limit(1).IDs(setContextOp(ctx, dq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -160,7 +157,7 @@ func (dq *DocumentQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Document entity is found.
// Returns a *NotFoundError when no Document entities are found.
func (dq *DocumentQuery) Only(ctx context.Context) (*Document, error) {
- nodes, err := dq.Limit(2).All(newQueryContext(ctx, TypeDocument, "Only"))
+ nodes, err := dq.Limit(2).All(setContextOp(ctx, dq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -188,7 +185,7 @@ func (dq *DocumentQuery) OnlyX(ctx context.Context) *Document {
// Returns a *NotFoundError when no entities are found.
func (dq *DocumentQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = dq.Limit(2).IDs(newQueryContext(ctx, TypeDocument, "OnlyID")); err != nil {
+ if ids, err = dq.Limit(2).IDs(setContextOp(ctx, dq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -213,7 +210,7 @@ func (dq *DocumentQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Documents.
func (dq *DocumentQuery) All(ctx context.Context) ([]*Document, error) {
- ctx = newQueryContext(ctx, TypeDocument, "All")
+ ctx = setContextOp(ctx, dq.ctx, "All")
if err := dq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -231,10 +228,12 @@ func (dq *DocumentQuery) AllX(ctx context.Context) []*Document {
}
// IDs executes the query and returns a list of Document IDs.
-func (dq *DocumentQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeDocument, "IDs")
- if err := dq.Select(document.FieldID).Scan(ctx, &ids); err != nil {
+func (dq *DocumentQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if dq.ctx.Unique == nil && dq.path != nil {
+ dq.Unique(true)
+ }
+ ctx = setContextOp(ctx, dq.ctx, "IDs")
+ if err = dq.Select(document.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -251,7 +250,7 @@ func (dq *DocumentQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (dq *DocumentQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeDocument, "Count")
+ ctx = setContextOp(ctx, dq.ctx, "Count")
if err := dq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -269,7 +268,7 @@ func (dq *DocumentQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (dq *DocumentQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeDocument, "Exist")
+ ctx = setContextOp(ctx, dq.ctx, "Exist")
switch _, err := dq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -297,17 +296,15 @@ func (dq *DocumentQuery) Clone() *DocumentQuery {
}
return &DocumentQuery{
config: dq.config,
- limit: dq.limit,
- offset: dq.offset,
- order: append([]OrderFunc{}, dq.order...),
+ ctx: dq.ctx.Clone(),
+ order: append([]document.OrderOption{}, dq.order...),
inters: append([]Interceptor{}, dq.inters...),
predicates: append([]predicate.Document{}, dq.predicates...),
withGroup: dq.withGroup.Clone(),
withAttachments: dq.withAttachments.Clone(),
// clone intermediate query.
- sql: dq.sql.Clone(),
- path: dq.path,
- unique: dq.unique,
+ sql: dq.sql.Clone(),
+ path: dq.path,
}
}
@@ -348,9 +345,9 @@ func (dq *DocumentQuery) WithAttachments(opts ...func(*AttachmentQuery)) *Docume
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (dq *DocumentQuery) GroupBy(field string, fields ...string) *DocumentGroupBy {
- dq.fields = append([]string{field}, fields...)
+ dq.ctx.Fields = append([]string{field}, fields...)
grbuild := &DocumentGroupBy{build: dq}
- grbuild.flds = &dq.fields
+ grbuild.flds = &dq.ctx.Fields
grbuild.label = document.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -369,10 +366,10 @@ func (dq *DocumentQuery) GroupBy(field string, fields ...string) *DocumentGroupB
// Select(document.FieldCreatedAt).
// Scan(ctx, &v)
func (dq *DocumentQuery) Select(fields ...string) *DocumentSelect {
- dq.fields = append(dq.fields, fields...)
+ dq.ctx.Fields = append(dq.ctx.Fields, fields...)
sbuild := &DocumentSelect{DocumentQuery: dq}
sbuild.label = document.Label
- sbuild.flds, sbuild.scan = &dq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &dq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -392,7 +389,7 @@ func (dq *DocumentQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range dq.fields {
+ for _, f := range dq.ctx.Fields {
if !document.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -470,6 +467,9 @@ func (dq *DocumentQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(group.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -498,7 +498,7 @@ func (dq *DocumentQuery) loadAttachments(ctx context.Context, query *AttachmentQ
}
query.withFKs = true
query.Where(predicate.Attachment(func(s *sql.Selector) {
- s.Where(sql.InValues(document.AttachmentsColumn, fks...))
+ s.Where(sql.InValues(s.C(document.AttachmentsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -511,7 +511,7 @@ func (dq *DocumentQuery) loadAttachments(ctx context.Context, query *AttachmentQ
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "document_attachments" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "document_attachments" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -520,30 +520,22 @@ func (dq *DocumentQuery) loadAttachments(ctx context.Context, query *AttachmentQ
func (dq *DocumentQuery) sqlCount(ctx context.Context) (int, error) {
_spec := dq.querySpec()
- _spec.Node.Columns = dq.fields
- if len(dq.fields) > 0 {
- _spec.Unique = dq.unique != nil && *dq.unique
+ _spec.Node.Columns = dq.ctx.Fields
+ if len(dq.ctx.Fields) > 0 {
+ _spec.Unique = dq.ctx.Unique != nil && *dq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, dq.driver, _spec)
}
func (dq *DocumentQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: document.Table,
- Columns: document.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
- },
- From: dq.sql,
- Unique: true,
- }
- if unique := dq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(document.Table, document.Columns, sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID))
+ _spec.From = dq.sql
+ if unique := dq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if dq.path != nil {
+ _spec.Unique = true
}
- if fields := dq.fields; len(fields) > 0 {
+ if fields := dq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, document.FieldID)
for i := range fields {
@@ -559,10 +551,10 @@ func (dq *DocumentQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := dq.limit; limit != nil {
+ if limit := dq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := dq.offset; offset != nil {
+ if offset := dq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := dq.order; len(ps) > 0 {
@@ -578,7 +570,7 @@ func (dq *DocumentQuery) querySpec() *sqlgraph.QuerySpec {
func (dq *DocumentQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(dq.driver.Dialect())
t1 := builder.Table(document.Table)
- columns := dq.fields
+ columns := dq.ctx.Fields
if len(columns) == 0 {
columns = document.Columns
}
@@ -587,7 +579,7 @@ func (dq *DocumentQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = dq.sql
selector.Select(selector.Columns(columns...)...)
}
- if dq.unique != nil && *dq.unique {
+ if dq.ctx.Unique != nil && *dq.ctx.Unique {
selector.Distinct()
}
for _, p := range dq.predicates {
@@ -596,12 +588,12 @@ func (dq *DocumentQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range dq.order {
p(selector)
}
- if offset := dq.offset; offset != nil {
+ if offset := dq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := dq.limit; limit != nil {
+ if limit := dq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -621,7 +613,7 @@ func (dgb *DocumentGroupBy) Aggregate(fns ...AggregateFunc) *DocumentGroupBy {
// Scan applies the selector query and scans the result into the given value.
func (dgb *DocumentGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeDocument, "GroupBy")
+ ctx = setContextOp(ctx, dgb.build.ctx, "GroupBy")
if err := dgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -669,7 +661,7 @@ func (ds *DocumentSelect) Aggregate(fns ...AggregateFunc) *DocumentSelect {
// Scan applies the selector query and scans the result into the given value.
func (ds *DocumentSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeDocument, "Select")
+ ctx = setContextOp(ctx, ds.ctx, "Select")
if err := ds.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/document_update.go b/backend/internal/data/ent/document_update.go
index e685bda..23e6d9c 100644
--- a/backend/internal/data/ent/document_update.go
+++ b/backend/internal/data/ent/document_update.go
@@ -43,12 +43,28 @@ func (du *DocumentUpdate) SetTitle(s string) *DocumentUpdate {
return du
}
+// SetNillableTitle sets the "title" field if the given value is not nil.
+func (du *DocumentUpdate) SetNillableTitle(s *string) *DocumentUpdate {
+ if s != nil {
+ du.SetTitle(*s)
+ }
+ return du
+}
+
// SetPath sets the "path" field.
func (du *DocumentUpdate) SetPath(s string) *DocumentUpdate {
du.mutation.SetPath(s)
return du
}
+// SetNillablePath sets the "path" field if the given value is not nil.
+func (du *DocumentUpdate) SetNillablePath(s *string) *DocumentUpdate {
+ if s != nil {
+ du.SetPath(*s)
+ }
+ return du
+}
+
// SetGroupID sets the "group" edge to the Group entity by ID.
func (du *DocumentUpdate) SetGroupID(id uuid.UUID) *DocumentUpdate {
du.mutation.SetGroupID(id)
@@ -110,7 +126,7 @@ func (du *DocumentUpdate) RemoveAttachments(a ...*Attachment) *DocumentUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (du *DocumentUpdate) Save(ctx context.Context) (int, error) {
du.defaults()
- return withHooks[int, DocumentMutation](ctx, du.sqlSave, du.mutation, du.hooks)
+ return withHooks(ctx, du.sqlSave, du.mutation, du.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -165,16 +181,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := du.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: document.Table,
- Columns: document.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(document.Table, document.Columns, sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID))
if ps := du.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -199,10 +206,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{document.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -215,10 +219,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{document.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -234,10 +235,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -250,10 +248,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -269,10 +264,7 @@ func (du *DocumentUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -312,12 +304,28 @@ func (duo *DocumentUpdateOne) SetTitle(s string) *DocumentUpdateOne {
return duo
}
+// SetNillableTitle sets the "title" field if the given value is not nil.
+func (duo *DocumentUpdateOne) SetNillableTitle(s *string) *DocumentUpdateOne {
+ if s != nil {
+ duo.SetTitle(*s)
+ }
+ return duo
+}
+
// SetPath sets the "path" field.
func (duo *DocumentUpdateOne) SetPath(s string) *DocumentUpdateOne {
duo.mutation.SetPath(s)
return duo
}
+// SetNillablePath sets the "path" field if the given value is not nil.
+func (duo *DocumentUpdateOne) SetNillablePath(s *string) *DocumentUpdateOne {
+ if s != nil {
+ duo.SetPath(*s)
+ }
+ return duo
+}
+
// SetGroupID sets the "group" edge to the Group entity by ID.
func (duo *DocumentUpdateOne) SetGroupID(id uuid.UUID) *DocumentUpdateOne {
duo.mutation.SetGroupID(id)
@@ -376,6 +384,12 @@ func (duo *DocumentUpdateOne) RemoveAttachments(a ...*Attachment) *DocumentUpdat
return duo.RemoveAttachmentIDs(ids...)
}
+// Where appends a list predicates to the DocumentUpdate builder.
+func (duo *DocumentUpdateOne) Where(ps ...predicate.Document) *DocumentUpdateOne {
+ duo.mutation.Where(ps...)
+ return duo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (duo *DocumentUpdateOne) Select(field string, fields ...string) *DocumentUpdateOne {
@@ -386,7 +400,7 @@ func (duo *DocumentUpdateOne) Select(field string, fields ...string) *DocumentUp
// Save executes the query and returns the updated Document entity.
func (duo *DocumentUpdateOne) Save(ctx context.Context) (*Document, error) {
duo.defaults()
- return withHooks[*Document, DocumentMutation](ctx, duo.sqlSave, duo.mutation, duo.hooks)
+ return withHooks(ctx, duo.sqlSave, duo.mutation, duo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -441,16 +455,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
if err := duo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: document.Table,
- Columns: document.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(document.Table, document.Columns, sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID))
id, ok := duo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Document.id" for update`)}
@@ -492,10 +497,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
Columns: []string{document.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -508,10 +510,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
Columns: []string{document.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -527,10 +526,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -543,10 +539,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -562,10 +555,7 @@ func (duo *DocumentUpdateOne) sqlSave(ctx context.Context) (_node *Document, err
Columns: []string{document.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/ent.go b/backend/internal/data/ent/ent.go
index d9a0cae..6e52ac8 100644
--- a/backend/internal/data/ent/ent.go
+++ b/backend/internal/data/ent/ent.go
@@ -7,6 +7,7 @@ import (
"errors"
"fmt"
"reflect"
+ "sync"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
@@ -22,6 +23,7 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
"github.com/hay-kot/homebox/backend/internal/data/ent/maintenanceentry"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
)
@@ -31,6 +33,7 @@ type (
Hook = ent.Hook
Value = ent.Value
Query = ent.Query
+ QueryContext = ent.QueryContext
Querier = ent.Querier
QuerierFunc = ent.QuerierFunc
Interceptor = ent.Interceptor
@@ -43,45 +46,68 @@ type (
MutateFunc = ent.MutateFunc
)
+type clientCtxKey struct{}
+
+// FromContext returns a Client stored inside a context, or nil if there isn't one.
+func FromContext(ctx context.Context) *Client {
+ c, _ := ctx.Value(clientCtxKey{}).(*Client)
+ return c
+}
+
+// NewContext returns a new context with the given Client attached.
+func NewContext(parent context.Context, c *Client) context.Context {
+ return context.WithValue(parent, clientCtxKey{}, c)
+}
+
+type txCtxKey struct{}
+
+// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
+func TxFromContext(ctx context.Context) *Tx {
+ tx, _ := ctx.Value(txCtxKey{}).(*Tx)
+ return tx
+}
+
+// NewTxContext returns a new context with the given Tx attached.
+func NewTxContext(parent context.Context, tx *Tx) context.Context {
+ return context.WithValue(parent, txCtxKey{}, tx)
+}
+
// OrderFunc applies an ordering on the sql selector.
+// Deprecated: Use Asc/Desc functions or the package builders instead.
type OrderFunc func(*sql.Selector)
-// columnChecker returns a function indicates if the column exists in the given column.
-func columnChecker(table string) func(string) error {
- checks := map[string]func(string) bool{
- attachment.Table: attachment.ValidColumn,
- authroles.Table: authroles.ValidColumn,
- authtokens.Table: authtokens.ValidColumn,
- document.Table: document.ValidColumn,
- group.Table: group.ValidColumn,
- groupinvitationtoken.Table: groupinvitationtoken.ValidColumn,
- item.Table: item.ValidColumn,
- itemfield.Table: itemfield.ValidColumn,
- label.Table: label.ValidColumn,
- location.Table: location.ValidColumn,
- maintenanceentry.Table: maintenanceentry.ValidColumn,
- user.Table: user.ValidColumn,
- }
- check, ok := checks[table]
- if !ok {
- return func(string) error {
- return fmt.Errorf("unknown table %q", table)
- }
- }
- return func(column string) error {
- if !check(column) {
- return fmt.Errorf("unknown column %q for table %q", column, table)
- }
- return nil
- }
+var (
+ initCheck sync.Once
+ columnCheck sql.ColumnCheck
+)
+
+// columnChecker checks if the column exists in the given table.
+func checkColumn(table, column string) error {
+ initCheck.Do(func() {
+ columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
+ attachment.Table: attachment.ValidColumn,
+ authroles.Table: authroles.ValidColumn,
+ authtokens.Table: authtokens.ValidColumn,
+ document.Table: document.ValidColumn,
+ group.Table: group.ValidColumn,
+ groupinvitationtoken.Table: groupinvitationtoken.ValidColumn,
+ item.Table: item.ValidColumn,
+ itemfield.Table: itemfield.ValidColumn,
+ label.Table: label.ValidColumn,
+ location.Table: location.ValidColumn,
+ maintenanceentry.Table: maintenanceentry.ValidColumn,
+ notifier.Table: notifier.ValidColumn,
+ user.Table: user.ValidColumn,
+ })
+ })
+ return columnCheck(table, column)
}
// Asc applies the given fields in ASC order.
-func Asc(fields ...string) OrderFunc {
+func Asc(fields ...string) func(*sql.Selector) {
return func(s *sql.Selector) {
- check := columnChecker(s.TableName())
for _, f := range fields {
- if err := check(f); err != nil {
+ if err := checkColumn(s.TableName(), f); err != nil {
s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
}
s.OrderBy(sql.Asc(s.C(f)))
@@ -90,11 +116,10 @@ func Asc(fields ...string) OrderFunc {
}
// Desc applies the given fields in DESC order.
-func Desc(fields ...string) OrderFunc {
+func Desc(fields ...string) func(*sql.Selector) {
return func(s *sql.Selector) {
- check := columnChecker(s.TableName())
for _, f := range fields {
- if err := check(f); err != nil {
+ if err := checkColumn(s.TableName(), f); err != nil {
s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
}
s.OrderBy(sql.Desc(s.C(f)))
@@ -126,8 +151,7 @@ func Count() AggregateFunc {
// Max applies the "max" aggregation function on the given field of each group.
func Max(field string) AggregateFunc {
return func(s *sql.Selector) string {
- check := columnChecker(s.TableName())
- if err := check(field); err != nil {
+ if err := checkColumn(s.TableName(), field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
@@ -138,8 +162,7 @@ func Max(field string) AggregateFunc {
// Mean applies the "mean" aggregation function on the given field of each group.
func Mean(field string) AggregateFunc {
return func(s *sql.Selector) string {
- check := columnChecker(s.TableName())
- if err := check(field); err != nil {
+ if err := checkColumn(s.TableName(), field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
@@ -150,8 +173,7 @@ func Mean(field string) AggregateFunc {
// Min applies the "min" aggregation function on the given field of each group.
func Min(field string) AggregateFunc {
return func(s *sql.Selector) string {
- check := columnChecker(s.TableName())
- if err := check(field); err != nil {
+ if err := checkColumn(s.TableName(), field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
@@ -162,8 +184,7 @@ func Min(field string) AggregateFunc {
// Sum applies the "sum" aggregation function on the given field of each group.
func Sum(field string) AggregateFunc {
return func(s *sql.Selector) string {
- check := columnChecker(s.TableName())
- if err := check(field); err != nil {
+ if err := checkColumn(s.TableName(), field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
@@ -500,7 +521,7 @@ func withHooks[V Value, M any, PM interface {
return exec(ctx)
}
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
- mutationT, ok := m.(PM)
+ mutationT, ok := any(m).(PM)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
@@ -525,10 +546,11 @@ func withHooks[V Value, M any, PM interface {
return nv, nil
}
-// newQueryContext returns a new context with the given QueryContext attached in case it does not exist.
-func newQueryContext(ctx context.Context, typ, op string) context.Context {
+// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
+func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
if ent.QueryFromContext(ctx) == nil {
- ctx = ent.NewQueryContext(ctx, &ent.QueryContext{Type: typ, Op: op})
+ qc.Op = op
+ ctx = ent.NewQueryContext(ctx, qc)
}
return ctx
}
diff --git a/backend/internal/data/ent/group.go b/backend/internal/data/ent/group.go
index 8140104..69c67de 100644
--- a/backend/internal/data/ent/group.go
+++ b/backend/internal/data/ent/group.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/group"
@@ -24,10 +25,11 @@ type Group struct {
// Name holds the value of the "name" field.
Name string `json:"name,omitempty"`
// Currency holds the value of the "currency" field.
- Currency group.Currency `json:"currency,omitempty"`
+ Currency string `json:"currency,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the GroupQuery when eager-loading is set.
- Edges GroupEdges `json:"edges"`
+ Edges GroupEdges `json:"edges"`
+ selectValues sql.SelectValues
}
// GroupEdges holds the relations/edges for other nodes in the graph.
@@ -44,9 +46,11 @@ type GroupEdges struct {
Documents []*Document `json:"documents,omitempty"`
// InvitationTokens holds the value of the invitation_tokens edge.
InvitationTokens []*GroupInvitationToken `json:"invitation_tokens,omitempty"`
+ // Notifiers holds the value of the notifiers edge.
+ Notifiers []*Notifier `json:"notifiers,omitempty"`
// loadedTypes holds the information for reporting if a
// type was loaded (or requested) in eager-loading or not.
- loadedTypes [6]bool
+ loadedTypes [7]bool
}
// UsersOrErr returns the Users value or an error if the edge
@@ -103,6 +107,15 @@ func (e GroupEdges) InvitationTokensOrErr() ([]*GroupInvitationToken, error) {
return nil, &NotLoadedError{edge: "invitation_tokens"}
}
+// NotifiersOrErr returns the Notifiers value or an error if the edge
+// was not loaded in eager-loading.
+func (e GroupEdges) NotifiersOrErr() ([]*Notifier, error) {
+ if e.loadedTypes[6] {
+ return e.Notifiers, nil
+ }
+ return nil, &NotLoadedError{edge: "notifiers"}
+}
+
// scanValues returns the types for scanning values from sql.Rows.
func (*Group) scanValues(columns []string) ([]any, error) {
values := make([]any, len(columns))
@@ -115,7 +128,7 @@ func (*Group) scanValues(columns []string) ([]any, error) {
case group.FieldID:
values[i] = new(uuid.UUID)
default:
- return nil, fmt.Errorf("unexpected column %q for type Group", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -157,48 +170,61 @@ func (gr *Group) assignValues(columns []string, values []any) error {
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field currency", values[i])
} else if value.Valid {
- gr.Currency = group.Currency(value.String)
+ gr.Currency = value.String
}
+ default:
+ gr.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the Group.
+// This includes values selected through modifiers, order, etc.
+func (gr *Group) Value(name string) (ent.Value, error) {
+ return gr.selectValues.Get(name)
+}
+
// QueryUsers queries the "users" edge of the Group entity.
func (gr *Group) QueryUsers() *UserQuery {
- return (&GroupClient{config: gr.config}).QueryUsers(gr)
+ return NewGroupClient(gr.config).QueryUsers(gr)
}
// QueryLocations queries the "locations" edge of the Group entity.
func (gr *Group) QueryLocations() *LocationQuery {
- return (&GroupClient{config: gr.config}).QueryLocations(gr)
+ return NewGroupClient(gr.config).QueryLocations(gr)
}
// QueryItems queries the "items" edge of the Group entity.
func (gr *Group) QueryItems() *ItemQuery {
- return (&GroupClient{config: gr.config}).QueryItems(gr)
+ return NewGroupClient(gr.config).QueryItems(gr)
}
// QueryLabels queries the "labels" edge of the Group entity.
func (gr *Group) QueryLabels() *LabelQuery {
- return (&GroupClient{config: gr.config}).QueryLabels(gr)
+ return NewGroupClient(gr.config).QueryLabels(gr)
}
// QueryDocuments queries the "documents" edge of the Group entity.
func (gr *Group) QueryDocuments() *DocumentQuery {
- return (&GroupClient{config: gr.config}).QueryDocuments(gr)
+ return NewGroupClient(gr.config).QueryDocuments(gr)
}
// QueryInvitationTokens queries the "invitation_tokens" edge of the Group entity.
func (gr *Group) QueryInvitationTokens() *GroupInvitationTokenQuery {
- return (&GroupClient{config: gr.config}).QueryInvitationTokens(gr)
+ return NewGroupClient(gr.config).QueryInvitationTokens(gr)
+}
+
+// QueryNotifiers queries the "notifiers" edge of the Group entity.
+func (gr *Group) QueryNotifiers() *NotifierQuery {
+ return NewGroupClient(gr.config).QueryNotifiers(gr)
}
// Update returns a builder for updating this Group.
// Note that you need to call Group.Unwrap() before calling this method if this Group
// was returned from a transaction, and the transaction was committed or rolled back.
func (gr *Group) Update() *GroupUpdateOne {
- return (&GroupClient{config: gr.config}).UpdateOne(gr)
+ return NewGroupClient(gr.config).UpdateOne(gr)
}
// Unwrap unwraps the Group entity that was returned from a transaction after it was closed,
@@ -227,16 +253,10 @@ func (gr *Group) String() string {
builder.WriteString(gr.Name)
builder.WriteString(", ")
builder.WriteString("currency=")
- builder.WriteString(fmt.Sprintf("%v", gr.Currency))
+ builder.WriteString(gr.Currency)
builder.WriteByte(')')
return builder.String()
}
// Groups is a parsable slice of Group.
type Groups []*Group
-
-func (gr Groups) config(cfg config) {
- for _i := range gr {
- gr[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/group/group.go b/backend/internal/data/ent/group/group.go
index 379a114..32cb101 100644
--- a/backend/internal/data/ent/group/group.go
+++ b/backend/internal/data/ent/group/group.go
@@ -3,9 +3,10 @@
package group
import (
- "fmt"
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -34,6 +35,8 @@ const (
EdgeDocuments = "documents"
// EdgeInvitationTokens holds the string denoting the invitation_tokens edge name in mutations.
EdgeInvitationTokens = "invitation_tokens"
+ // EdgeNotifiers holds the string denoting the notifiers edge name in mutations.
+ EdgeNotifiers = "notifiers"
// Table holds the table name of the group in the database.
Table = "groups"
// UsersTable is the table that holds the users relation/edge.
@@ -78,6 +81,13 @@ const (
InvitationTokensInverseTable = "group_invitation_tokens"
// InvitationTokensColumn is the table column denoting the invitation_tokens relation/edge.
InvitationTokensColumn = "group_invitation_tokens"
+ // NotifiersTable is the table that holds the notifiers relation/edge.
+ NotifiersTable = "notifiers"
+ // NotifiersInverseTable is the table name for the Notifier entity.
+ // It exists in this package in order to avoid circular dependency with the "notifier" package.
+ NotifiersInverseTable = "notifiers"
+ // NotifiersColumn is the table column denoting the notifiers relation/edge.
+ NotifiersColumn = "group_id"
)
// Columns holds all SQL columns for group fields.
@@ -108,41 +118,183 @@ var (
UpdateDefaultUpdatedAt func() time.Time
// NameValidator is a validator for the "name" field. It is called by the builders before save.
NameValidator func(string) error
+ // DefaultCurrency holds the default value on creation for the "currency" field.
+ DefaultCurrency string
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
-// Currency defines the type for the "currency" enum field.
-type Currency string
+// OrderOption defines the ordering options for the Group queries.
+type OrderOption func(*sql.Selector)
-// CurrencyUsd is the default value of the Currency enum.
-const DefaultCurrency = CurrencyUsd
-
-// Currency values.
-const (
- CurrencyUsd Currency = "usd"
- CurrencyEur Currency = "eur"
- CurrencyGbp Currency = "gbp"
- CurrencyJpy Currency = "jpy"
- CurrencyZar Currency = "zar"
- CurrencyAud Currency = "aud"
- CurrencyNok Currency = "nok"
- CurrencySek Currency = "sek"
- CurrencyDkk Currency = "dkk"
- CurrencyInr Currency = "inr"
- CurrencyRmb Currency = "rmb"
-)
-
-func (c Currency) String() string {
- return string(c)
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
}
-// CurrencyValidator is a validator for the "currency" field enum values. It is called by the builders before save.
-func CurrencyValidator(c Currency) error {
- switch c {
- case CurrencyUsd, CurrencyEur, CurrencyGbp, CurrencyJpy, CurrencyZar, CurrencyAud, CurrencyNok, CurrencySek, CurrencyDkk, CurrencyInr, CurrencyRmb:
- return nil
- default:
- return fmt.Errorf("group: invalid enum value for currency field: %q", c)
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByCurrency orders the results by the currency field.
+func ByCurrency(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCurrency, opts...).ToFunc()
+}
+
+// ByUsersCount orders the results by users count.
+func ByUsersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newUsersStep(), opts...)
}
}
+
+// ByUsers orders the results by users terms.
+func ByUsers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUsersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByLocationsCount orders the results by locations count.
+func ByLocationsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newLocationsStep(), opts...)
+ }
+}
+
+// ByLocations orders the results by locations terms.
+func ByLocations(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newLocationsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByItemsCount orders the results by items count.
+func ByItemsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newItemsStep(), opts...)
+ }
+}
+
+// ByItems orders the results by items terms.
+func ByItems(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByLabelsCount orders the results by labels count.
+func ByLabelsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newLabelsStep(), opts...)
+ }
+}
+
+// ByLabels orders the results by labels terms.
+func ByLabels(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newLabelsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByDocumentsCount orders the results by documents count.
+func ByDocumentsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newDocumentsStep(), opts...)
+ }
+}
+
+// ByDocuments orders the results by documents terms.
+func ByDocuments(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newDocumentsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByInvitationTokensCount orders the results by invitation_tokens count.
+func ByInvitationTokensCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newInvitationTokensStep(), opts...)
+ }
+}
+
+// ByInvitationTokens orders the results by invitation_tokens terms.
+func ByInvitationTokens(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newInvitationTokensStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByNotifiersCount orders the results by notifiers count.
+func ByNotifiersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newNotifiersStep(), opts...)
+ }
+}
+
+// ByNotifiers orders the results by notifiers terms.
+func ByNotifiers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newNotifiersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newUsersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UsersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, UsersTable, UsersColumn),
+ )
+}
+func newLocationsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(LocationsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, LocationsTable, LocationsColumn),
+ )
+}
+func newItemsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, ItemsTable, ItemsColumn),
+ )
+}
+func newLabelsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(LabelsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, LabelsTable, LabelsColumn),
+ )
+}
+func newDocumentsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(DocumentsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, DocumentsTable, DocumentsColumn),
+ )
+}
+func newInvitationTokensStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(InvitationTokensInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, InvitationTokensTable, InvitationTokensColumn),
+ )
+}
+func newNotifiersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(NotifiersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, NotifiersTable, NotifiersColumn),
+ )
+}
diff --git a/backend/internal/data/ent/group/where.go b/backend/internal/data/ent/group/where.go
index e6d434b..d18faa7 100644
--- a/backend/internal/data/ent/group/where.go
+++ b/backend/internal/data/ent/group/where.go
@@ -71,6 +71,11 @@ func Name(v string) predicate.Group {
return predicate.Group(sql.FieldEQ(FieldName, v))
}
+// Currency applies equality check predicate on the "currency" field. It's identical to CurrencyEQ.
+func Currency(v string) predicate.Group {
+ return predicate.Group(sql.FieldEQ(FieldCurrency, v))
+}
+
// CreatedAtEQ applies the EQ predicate on the "created_at" field.
func CreatedAtEQ(v time.Time) predicate.Group {
return predicate.Group(sql.FieldEQ(FieldCreatedAt, v))
@@ -217,25 +222,70 @@ func NameContainsFold(v string) predicate.Group {
}
// CurrencyEQ applies the EQ predicate on the "currency" field.
-func CurrencyEQ(v Currency) predicate.Group {
+func CurrencyEQ(v string) predicate.Group {
return predicate.Group(sql.FieldEQ(FieldCurrency, v))
}
// CurrencyNEQ applies the NEQ predicate on the "currency" field.
-func CurrencyNEQ(v Currency) predicate.Group {
+func CurrencyNEQ(v string) predicate.Group {
return predicate.Group(sql.FieldNEQ(FieldCurrency, v))
}
// CurrencyIn applies the In predicate on the "currency" field.
-func CurrencyIn(vs ...Currency) predicate.Group {
+func CurrencyIn(vs ...string) predicate.Group {
return predicate.Group(sql.FieldIn(FieldCurrency, vs...))
}
// CurrencyNotIn applies the NotIn predicate on the "currency" field.
-func CurrencyNotIn(vs ...Currency) predicate.Group {
+func CurrencyNotIn(vs ...string) predicate.Group {
return predicate.Group(sql.FieldNotIn(FieldCurrency, vs...))
}
+// CurrencyGT applies the GT predicate on the "currency" field.
+func CurrencyGT(v string) predicate.Group {
+ return predicate.Group(sql.FieldGT(FieldCurrency, v))
+}
+
+// CurrencyGTE applies the GTE predicate on the "currency" field.
+func CurrencyGTE(v string) predicate.Group {
+ return predicate.Group(sql.FieldGTE(FieldCurrency, v))
+}
+
+// CurrencyLT applies the LT predicate on the "currency" field.
+func CurrencyLT(v string) predicate.Group {
+ return predicate.Group(sql.FieldLT(FieldCurrency, v))
+}
+
+// CurrencyLTE applies the LTE predicate on the "currency" field.
+func CurrencyLTE(v string) predicate.Group {
+ return predicate.Group(sql.FieldLTE(FieldCurrency, v))
+}
+
+// CurrencyContains applies the Contains predicate on the "currency" field.
+func CurrencyContains(v string) predicate.Group {
+ return predicate.Group(sql.FieldContains(FieldCurrency, v))
+}
+
+// CurrencyHasPrefix applies the HasPrefix predicate on the "currency" field.
+func CurrencyHasPrefix(v string) predicate.Group {
+ return predicate.Group(sql.FieldHasPrefix(FieldCurrency, v))
+}
+
+// CurrencyHasSuffix applies the HasSuffix predicate on the "currency" field.
+func CurrencyHasSuffix(v string) predicate.Group {
+ return predicate.Group(sql.FieldHasSuffix(FieldCurrency, v))
+}
+
+// CurrencyEqualFold applies the EqualFold predicate on the "currency" field.
+func CurrencyEqualFold(v string) predicate.Group {
+ return predicate.Group(sql.FieldEqualFold(FieldCurrency, v))
+}
+
+// CurrencyContainsFold applies the ContainsFold predicate on the "currency" field.
+func CurrencyContainsFold(v string) predicate.Group {
+ return predicate.Group(sql.FieldContainsFold(FieldCurrency, v))
+}
+
// HasUsers applies the HasEdge predicate on the "users" edge.
func HasUsers() predicate.Group {
return predicate.Group(func(s *sql.Selector) {
@@ -250,11 +300,7 @@ func HasUsers() predicate.Group {
// HasUsersWith applies the HasEdge predicate on the "users" edge with a given conditions (other predicates).
func HasUsersWith(preds ...predicate.User) predicate.Group {
return predicate.Group(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(UsersInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, UsersTable, UsersColumn),
- )
+ step := newUsersStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -277,11 +323,7 @@ func HasLocations() predicate.Group {
// HasLocationsWith applies the HasEdge predicate on the "locations" edge with a given conditions (other predicates).
func HasLocationsWith(preds ...predicate.Location) predicate.Group {
return predicate.Group(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(LocationsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, LocationsTable, LocationsColumn),
- )
+ step := newLocationsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -304,11 +346,7 @@ func HasItems() predicate.Group {
// HasItemsWith applies the HasEdge predicate on the "items" edge with a given conditions (other predicates).
func HasItemsWith(preds ...predicate.Item) predicate.Group {
return predicate.Group(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, ItemsTable, ItemsColumn),
- )
+ step := newItemsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -331,11 +369,7 @@ func HasLabels() predicate.Group {
// HasLabelsWith applies the HasEdge predicate on the "labels" edge with a given conditions (other predicates).
func HasLabelsWith(preds ...predicate.Label) predicate.Group {
return predicate.Group(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(LabelsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, LabelsTable, LabelsColumn),
- )
+ step := newLabelsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -358,11 +392,7 @@ func HasDocuments() predicate.Group {
// HasDocumentsWith applies the HasEdge predicate on the "documents" edge with a given conditions (other predicates).
func HasDocumentsWith(preds ...predicate.Document) predicate.Group {
return predicate.Group(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(DocumentsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, DocumentsTable, DocumentsColumn),
- )
+ step := newDocumentsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -384,12 +414,31 @@ func HasInvitationTokens() predicate.Group {
// HasInvitationTokensWith applies the HasEdge predicate on the "invitation_tokens" edge with a given conditions (other predicates).
func HasInvitationTokensWith(preds ...predicate.GroupInvitationToken) predicate.Group {
+ return predicate.Group(func(s *sql.Selector) {
+ step := newInvitationTokensStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasNotifiers applies the HasEdge predicate on the "notifiers" edge.
+func HasNotifiers() predicate.Group {
return predicate.Group(func(s *sql.Selector) {
step := sqlgraph.NewStep(
sqlgraph.From(Table, FieldID),
- sqlgraph.To(InvitationTokensInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, InvitationTokensTable, InvitationTokensColumn),
+ sqlgraph.Edge(sqlgraph.O2M, false, NotifiersTable, NotifiersColumn),
)
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasNotifiersWith applies the HasEdge predicate on the "notifiers" edge with a given conditions (other predicates).
+func HasNotifiersWith(preds ...predicate.Notifier) predicate.Group {
+ return predicate.Group(func(s *sql.Selector) {
+ step := newNotifiersStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -400,32 +449,15 @@ func HasInvitationTokensWith(preds ...predicate.GroupInvitationToken) predicate.
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Group) predicate.Group {
- return predicate.Group(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Group(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Group) predicate.Group {
- return predicate.Group(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Group(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Group) predicate.Group {
- return predicate.Group(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Group(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/group_create.go b/backend/internal/data/ent/group_create.go
index b13c358..be56ba0 100644
--- a/backend/internal/data/ent/group_create.go
+++ b/backend/internal/data/ent/group_create.go
@@ -17,6 +17,7 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/item"
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
)
@@ -62,15 +63,15 @@ func (gc *GroupCreate) SetName(s string) *GroupCreate {
}
// SetCurrency sets the "currency" field.
-func (gc *GroupCreate) SetCurrency(gr group.Currency) *GroupCreate {
- gc.mutation.SetCurrency(gr)
+func (gc *GroupCreate) SetCurrency(s string) *GroupCreate {
+ gc.mutation.SetCurrency(s)
return gc
}
// SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (gc *GroupCreate) SetNillableCurrency(gr *group.Currency) *GroupCreate {
- if gr != nil {
- gc.SetCurrency(*gr)
+func (gc *GroupCreate) SetNillableCurrency(s *string) *GroupCreate {
+ if s != nil {
+ gc.SetCurrency(*s)
}
return gc
}
@@ -179,6 +180,21 @@ func (gc *GroupCreate) AddInvitationTokens(g ...*GroupInvitationToken) *GroupCre
return gc.AddInvitationTokenIDs(ids...)
}
+// AddNotifierIDs adds the "notifiers" edge to the Notifier entity by IDs.
+func (gc *GroupCreate) AddNotifierIDs(ids ...uuid.UUID) *GroupCreate {
+ gc.mutation.AddNotifierIDs(ids...)
+ return gc
+}
+
+// AddNotifiers adds the "notifiers" edges to the Notifier entity.
+func (gc *GroupCreate) AddNotifiers(n ...*Notifier) *GroupCreate {
+ ids := make([]uuid.UUID, len(n))
+ for i := range n {
+ ids[i] = n[i].ID
+ }
+ return gc.AddNotifierIDs(ids...)
+}
+
// Mutation returns the GroupMutation object of the builder.
func (gc *GroupCreate) Mutation() *GroupMutation {
return gc.mutation
@@ -187,7 +203,7 @@ func (gc *GroupCreate) Mutation() *GroupMutation {
// Save creates the Group in the database.
func (gc *GroupCreate) Save(ctx context.Context) (*Group, error) {
gc.defaults()
- return withHooks[*Group, GroupMutation](ctx, gc.sqlSave, gc.mutation, gc.hooks)
+ return withHooks(ctx, gc.sqlSave, gc.mutation, gc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -251,11 +267,6 @@ func (gc *GroupCreate) check() error {
if _, ok := gc.mutation.Currency(); !ok {
return &ValidationError{Name: "currency", err: errors.New(`ent: missing required field "Group.currency"`)}
}
- if v, ok := gc.mutation.Currency(); ok {
- if err := group.CurrencyValidator(v); err != nil {
- return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
- }
- }
return nil
}
@@ -285,13 +296,7 @@ func (gc *GroupCreate) sqlSave(ctx context.Context) (*Group, error) {
func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
var (
_node = &Group{config: gc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: group.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(group.Table, sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID))
)
if id, ok := gc.mutation.ID(); ok {
_node.ID = id
@@ -310,7 +315,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
_node.Name = value
}
if value, ok := gc.mutation.Currency(); ok {
- _spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+ _spec.SetField(group.FieldCurrency, field.TypeString, value)
_node.Currency = value
}
if nodes := gc.mutation.UsersIDs(); len(nodes) > 0 {
@@ -321,10 +326,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -340,10 +342,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -359,10 +358,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -378,10 +374,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -397,10 +390,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -416,10 +406,23 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := gc.mutation.NotifiersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -433,11 +436,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
// GroupCreateBulk is the builder for creating many Group entities in bulk.
type GroupCreateBulk struct {
config
+ err error
builders []*GroupCreate
}
// Save creates the Group entities in the database.
func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) {
+ if gcb.err != nil {
+ return nil, gcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(gcb.builders))
nodes := make([]*Group, len(gcb.builders))
mutators := make([]Mutator, len(gcb.builders))
@@ -454,8 +461,8 @@ func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) {
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, gcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/group_delete.go b/backend/internal/data/ent/group_delete.go
index 5ecc7d1..b8c3e59 100644
--- a/backend/internal/data/ent/group_delete.go
+++ b/backend/internal/data/ent/group_delete.go
@@ -27,7 +27,7 @@ func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (gd *GroupDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, GroupMutation](ctx, gd.sqlExec, gd.mutation, gd.hooks)
+ return withHooks(ctx, gd.sqlExec, gd.mutation, gd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (gd *GroupDelete) ExecX(ctx context.Context) int {
}
func (gd *GroupDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: group.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(group.Table, sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID))
if ps := gd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type GroupDeleteOne struct {
gd *GroupDelete
}
+// Where appends a list predicates to the GroupDelete builder.
+func (gdo *GroupDeleteOne) Where(ps ...predicate.Group) *GroupDeleteOne {
+ gdo.gd.mutation.Where(ps...)
+ return gdo
+}
+
// Exec executes the deletion query.
func (gdo *GroupDeleteOne) Exec(ctx context.Context) error {
n, err := gdo.gd.Exec(ctx)
@@ -84,5 +82,7 @@ func (gdo *GroupDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (gdo *GroupDeleteOne) ExecX(ctx context.Context) {
- gdo.gd.ExecX(ctx)
+ if err := gdo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/group_query.go b/backend/internal/data/ent/group_query.go
index 701ee01..f17bd3b 100644
--- a/backend/internal/data/ent/group_query.go
+++ b/backend/internal/data/ent/group_query.go
@@ -18,6 +18,7 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/item"
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/predicate"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
)
@@ -25,11 +26,8 @@ import (
// GroupQuery is the builder for querying Group entities.
type GroupQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []group.OrderOption
inters []Interceptor
predicates []predicate.Group
withUsers *UserQuery
@@ -38,6 +36,7 @@ type GroupQuery struct {
withLabels *LabelQuery
withDocuments *DocumentQuery
withInvitationTokens *GroupInvitationTokenQuery
+ withNotifiers *NotifierQuery
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
@@ -51,25 +50,25 @@ func (gq *GroupQuery) Where(ps ...predicate.Group) *GroupQuery {
// Limit the number of records to be returned by this query.
func (gq *GroupQuery) Limit(limit int) *GroupQuery {
- gq.limit = &limit
+ gq.ctx.Limit = &limit
return gq
}
// Offset to start from.
func (gq *GroupQuery) Offset(offset int) *GroupQuery {
- gq.offset = &offset
+ gq.ctx.Offset = &offset
return gq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (gq *GroupQuery) Unique(unique bool) *GroupQuery {
- gq.unique = &unique
+ gq.ctx.Unique = &unique
return gq
}
// Order specifies how the records should be ordered.
-func (gq *GroupQuery) Order(o ...OrderFunc) *GroupQuery {
+func (gq *GroupQuery) Order(o ...group.OrderOption) *GroupQuery {
gq.order = append(gq.order, o...)
return gq
}
@@ -206,10 +205,32 @@ func (gq *GroupQuery) QueryInvitationTokens() *GroupInvitationTokenQuery {
return query
}
+// QueryNotifiers chains the current query on the "notifiers" edge.
+func (gq *GroupQuery) QueryNotifiers() *NotifierQuery {
+ query := (&NotifierClient{config: gq.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := gq.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := gq.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(group.Table, group.FieldID, selector),
+ sqlgraph.To(notifier.Table, notifier.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, group.NotifiersTable, group.NotifiersColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(gq.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
// First returns the first Group entity from the query.
// Returns a *NotFoundError when no Group was found.
func (gq *GroupQuery) First(ctx context.Context) (*Group, error) {
- nodes, err := gq.Limit(1).All(newQueryContext(ctx, TypeGroup, "First"))
+ nodes, err := gq.Limit(1).All(setContextOp(ctx, gq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -232,7 +253,7 @@ func (gq *GroupQuery) FirstX(ctx context.Context) *Group {
// Returns a *NotFoundError when no Group ID was found.
func (gq *GroupQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = gq.Limit(1).IDs(newQueryContext(ctx, TypeGroup, "FirstID")); err != nil {
+ if ids, err = gq.Limit(1).IDs(setContextOp(ctx, gq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -255,7 +276,7 @@ func (gq *GroupQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Group entity is found.
// Returns a *NotFoundError when no Group entities are found.
func (gq *GroupQuery) Only(ctx context.Context) (*Group, error) {
- nodes, err := gq.Limit(2).All(newQueryContext(ctx, TypeGroup, "Only"))
+ nodes, err := gq.Limit(2).All(setContextOp(ctx, gq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -283,7 +304,7 @@ func (gq *GroupQuery) OnlyX(ctx context.Context) *Group {
// Returns a *NotFoundError when no entities are found.
func (gq *GroupQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = gq.Limit(2).IDs(newQueryContext(ctx, TypeGroup, "OnlyID")); err != nil {
+ if ids, err = gq.Limit(2).IDs(setContextOp(ctx, gq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -308,7 +329,7 @@ func (gq *GroupQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Groups.
func (gq *GroupQuery) All(ctx context.Context) ([]*Group, error) {
- ctx = newQueryContext(ctx, TypeGroup, "All")
+ ctx = setContextOp(ctx, gq.ctx, "All")
if err := gq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -326,10 +347,12 @@ func (gq *GroupQuery) AllX(ctx context.Context) []*Group {
}
// IDs executes the query and returns a list of Group IDs.
-func (gq *GroupQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeGroup, "IDs")
- if err := gq.Select(group.FieldID).Scan(ctx, &ids); err != nil {
+func (gq *GroupQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if gq.ctx.Unique == nil && gq.path != nil {
+ gq.Unique(true)
+ }
+ ctx = setContextOp(ctx, gq.ctx, "IDs")
+ if err = gq.Select(group.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -346,7 +369,7 @@ func (gq *GroupQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (gq *GroupQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeGroup, "Count")
+ ctx = setContextOp(ctx, gq.ctx, "Count")
if err := gq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -364,7 +387,7 @@ func (gq *GroupQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (gq *GroupQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeGroup, "Exist")
+ ctx = setContextOp(ctx, gq.ctx, "Exist")
switch _, err := gq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -392,9 +415,8 @@ func (gq *GroupQuery) Clone() *GroupQuery {
}
return &GroupQuery{
config: gq.config,
- limit: gq.limit,
- offset: gq.offset,
- order: append([]OrderFunc{}, gq.order...),
+ ctx: gq.ctx.Clone(),
+ order: append([]group.OrderOption{}, gq.order...),
inters: append([]Interceptor{}, gq.inters...),
predicates: append([]predicate.Group{}, gq.predicates...),
withUsers: gq.withUsers.Clone(),
@@ -403,10 +425,10 @@ func (gq *GroupQuery) Clone() *GroupQuery {
withLabels: gq.withLabels.Clone(),
withDocuments: gq.withDocuments.Clone(),
withInvitationTokens: gq.withInvitationTokens.Clone(),
+ withNotifiers: gq.withNotifiers.Clone(),
// clone intermediate query.
- sql: gq.sql.Clone(),
- path: gq.path,
- unique: gq.unique,
+ sql: gq.sql.Clone(),
+ path: gq.path,
}
}
@@ -476,6 +498,17 @@ func (gq *GroupQuery) WithInvitationTokens(opts ...func(*GroupInvitationTokenQue
return gq
}
+// WithNotifiers tells the query-builder to eager-load the nodes that are connected to
+// the "notifiers" edge. The optional arguments are used to configure the query builder of the edge.
+func (gq *GroupQuery) WithNotifiers(opts ...func(*NotifierQuery)) *GroupQuery {
+ query := (&NotifierClient{config: gq.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ gq.withNotifiers = query
+ return gq
+}
+
// GroupBy is used to group vertices by one or more fields/columns.
// It is often used with aggregate functions, like: count, max, mean, min, sum.
//
@@ -491,9 +524,9 @@ func (gq *GroupQuery) WithInvitationTokens(opts ...func(*GroupInvitationTokenQue
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy {
- gq.fields = append([]string{field}, fields...)
+ gq.ctx.Fields = append([]string{field}, fields...)
grbuild := &GroupGroupBy{build: gq}
- grbuild.flds = &gq.fields
+ grbuild.flds = &gq.ctx.Fields
grbuild.label = group.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -512,10 +545,10 @@ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy {
// Select(group.FieldCreatedAt).
// Scan(ctx, &v)
func (gq *GroupQuery) Select(fields ...string) *GroupSelect {
- gq.fields = append(gq.fields, fields...)
+ gq.ctx.Fields = append(gq.ctx.Fields, fields...)
sbuild := &GroupSelect{GroupQuery: gq}
sbuild.label = group.Label
- sbuild.flds, sbuild.scan = &gq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &gq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -535,7 +568,7 @@ func (gq *GroupQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range gq.fields {
+ for _, f := range gq.ctx.Fields {
if !group.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -554,13 +587,14 @@ func (gq *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group,
var (
nodes = []*Group{}
_spec = gq.querySpec()
- loadedTypes = [6]bool{
+ loadedTypes = [7]bool{
gq.withUsers != nil,
gq.withLocations != nil,
gq.withItems != nil,
gq.withLabels != nil,
gq.withDocuments != nil,
gq.withInvitationTokens != nil,
+ gq.withNotifiers != nil,
}
)
_spec.ScanValues = func(columns []string) ([]any, error) {
@@ -625,6 +659,13 @@ func (gq *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group,
return nil, err
}
}
+ if query := gq.withNotifiers; query != nil {
+ if err := gq.loadNotifiers(ctx, query, nodes,
+ func(n *Group) { n.Edges.Notifiers = []*Notifier{} },
+ func(n *Group, e *Notifier) { n.Edges.Notifiers = append(n.Edges.Notifiers, e) }); err != nil {
+ return nil, err
+ }
+ }
return nodes, nil
}
@@ -640,7 +681,7 @@ func (gq *GroupQuery) loadUsers(ctx context.Context, query *UserQuery, nodes []*
}
query.withFKs = true
query.Where(predicate.User(func(s *sql.Selector) {
- s.Where(sql.InValues(group.UsersColumn, fks...))
+ s.Where(sql.InValues(s.C(group.UsersColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -653,7 +694,7 @@ func (gq *GroupQuery) loadUsers(ctx context.Context, query *UserQuery, nodes []*
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_users" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_users" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -671,7 +712,7 @@ func (gq *GroupQuery) loadLocations(ctx context.Context, query *LocationQuery, n
}
query.withFKs = true
query.Where(predicate.Location(func(s *sql.Selector) {
- s.Where(sql.InValues(group.LocationsColumn, fks...))
+ s.Where(sql.InValues(s.C(group.LocationsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -684,7 +725,7 @@ func (gq *GroupQuery) loadLocations(ctx context.Context, query *LocationQuery, n
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_locations" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_locations" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -702,7 +743,7 @@ func (gq *GroupQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*
}
query.withFKs = true
query.Where(predicate.Item(func(s *sql.Selector) {
- s.Where(sql.InValues(group.ItemsColumn, fks...))
+ s.Where(sql.InValues(s.C(group.ItemsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -715,7 +756,7 @@ func (gq *GroupQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_items" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_items" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -733,7 +774,7 @@ func (gq *GroupQuery) loadLabels(ctx context.Context, query *LabelQuery, nodes [
}
query.withFKs = true
query.Where(predicate.Label(func(s *sql.Selector) {
- s.Where(sql.InValues(group.LabelsColumn, fks...))
+ s.Where(sql.InValues(s.C(group.LabelsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -746,7 +787,7 @@ func (gq *GroupQuery) loadLabels(ctx context.Context, query *LabelQuery, nodes [
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_labels" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_labels" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -764,7 +805,7 @@ func (gq *GroupQuery) loadDocuments(ctx context.Context, query *DocumentQuery, n
}
query.withFKs = true
query.Where(predicate.Document(func(s *sql.Selector) {
- s.Where(sql.InValues(group.DocumentsColumn, fks...))
+ s.Where(sql.InValues(s.C(group.DocumentsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -777,7 +818,7 @@ func (gq *GroupQuery) loadDocuments(ctx context.Context, query *DocumentQuery, n
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_documents" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_documents" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -795,7 +836,7 @@ func (gq *GroupQuery) loadInvitationTokens(ctx context.Context, query *GroupInvi
}
query.withFKs = true
query.Where(predicate.GroupInvitationToken(func(s *sql.Selector) {
- s.Where(sql.InValues(group.InvitationTokensColumn, fks...))
+ s.Where(sql.InValues(s.C(group.InvitationTokensColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -808,7 +849,37 @@ func (gq *GroupQuery) loadInvitationTokens(ctx context.Context, query *GroupInvi
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_invitation_tokens" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "group_invitation_tokens" returned %v for node %v`, *fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+func (gq *GroupQuery) loadNotifiers(ctx context.Context, query *NotifierQuery, nodes []*Group, init func(*Group), assign func(*Group, *Notifier)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*Group)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(notifier.FieldGroupID)
+ }
+ query.Where(predicate.Notifier(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(group.NotifiersColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.GroupID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "group_id" returned %v for node %v`, fk, n.ID)
}
assign(node, n)
}
@@ -817,30 +888,22 @@ func (gq *GroupQuery) loadInvitationTokens(ctx context.Context, query *GroupInvi
func (gq *GroupQuery) sqlCount(ctx context.Context) (int, error) {
_spec := gq.querySpec()
- _spec.Node.Columns = gq.fields
- if len(gq.fields) > 0 {
- _spec.Unique = gq.unique != nil && *gq.unique
+ _spec.Node.Columns = gq.ctx.Fields
+ if len(gq.ctx.Fields) > 0 {
+ _spec.Unique = gq.ctx.Unique != nil && *gq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, gq.driver, _spec)
}
func (gq *GroupQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: group.Table,
- Columns: group.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- From: gq.sql,
- Unique: true,
- }
- if unique := gq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID))
+ _spec.From = gq.sql
+ if unique := gq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if gq.path != nil {
+ _spec.Unique = true
}
- if fields := gq.fields; len(fields) > 0 {
+ if fields := gq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, group.FieldID)
for i := range fields {
@@ -856,10 +919,10 @@ func (gq *GroupQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := gq.limit; limit != nil {
+ if limit := gq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := gq.offset; offset != nil {
+ if offset := gq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := gq.order; len(ps) > 0 {
@@ -875,7 +938,7 @@ func (gq *GroupQuery) querySpec() *sqlgraph.QuerySpec {
func (gq *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(gq.driver.Dialect())
t1 := builder.Table(group.Table)
- columns := gq.fields
+ columns := gq.ctx.Fields
if len(columns) == 0 {
columns = group.Columns
}
@@ -884,7 +947,7 @@ func (gq *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = gq.sql
selector.Select(selector.Columns(columns...)...)
}
- if gq.unique != nil && *gq.unique {
+ if gq.ctx.Unique != nil && *gq.ctx.Unique {
selector.Distinct()
}
for _, p := range gq.predicates {
@@ -893,12 +956,12 @@ func (gq *GroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range gq.order {
p(selector)
}
- if offset := gq.offset; offset != nil {
+ if offset := gq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := gq.limit; limit != nil {
+ if limit := gq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -918,7 +981,7 @@ func (ggb *GroupGroupBy) Aggregate(fns ...AggregateFunc) *GroupGroupBy {
// Scan applies the selector query and scans the result into the given value.
func (ggb *GroupGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeGroup, "GroupBy")
+ ctx = setContextOp(ctx, ggb.build.ctx, "GroupBy")
if err := ggb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -966,7 +1029,7 @@ func (gs *GroupSelect) Aggregate(fns ...AggregateFunc) *GroupSelect {
// Scan applies the selector query and scans the result into the given value.
func (gs *GroupSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeGroup, "Select")
+ ctx = setContextOp(ctx, gs.ctx, "Select")
if err := gs.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/group_update.go b/backend/internal/data/ent/group_update.go
index e4263bf..fdb11a3 100644
--- a/backend/internal/data/ent/group_update.go
+++ b/backend/internal/data/ent/group_update.go
@@ -18,6 +18,7 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/item"
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/predicate"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
)
@@ -47,16 +48,24 @@ func (gu *GroupUpdate) SetName(s string) *GroupUpdate {
return gu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (gu *GroupUpdate) SetNillableName(s *string) *GroupUpdate {
+ if s != nil {
+ gu.SetName(*s)
+ }
+ return gu
+}
+
// SetCurrency sets the "currency" field.
-func (gu *GroupUpdate) SetCurrency(gr group.Currency) *GroupUpdate {
- gu.mutation.SetCurrency(gr)
+func (gu *GroupUpdate) SetCurrency(s string) *GroupUpdate {
+ gu.mutation.SetCurrency(s)
return gu
}
// SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (gu *GroupUpdate) SetNillableCurrency(gr *group.Currency) *GroupUpdate {
- if gr != nil {
- gu.SetCurrency(*gr)
+func (gu *GroupUpdate) SetNillableCurrency(s *string) *GroupUpdate {
+ if s != nil {
+ gu.SetCurrency(*s)
}
return gu
}
@@ -151,6 +160,21 @@ func (gu *GroupUpdate) AddInvitationTokens(g ...*GroupInvitationToken) *GroupUpd
return gu.AddInvitationTokenIDs(ids...)
}
+// AddNotifierIDs adds the "notifiers" edge to the Notifier entity by IDs.
+func (gu *GroupUpdate) AddNotifierIDs(ids ...uuid.UUID) *GroupUpdate {
+ gu.mutation.AddNotifierIDs(ids...)
+ return gu
+}
+
+// AddNotifiers adds the "notifiers" edges to the Notifier entity.
+func (gu *GroupUpdate) AddNotifiers(n ...*Notifier) *GroupUpdate {
+ ids := make([]uuid.UUID, len(n))
+ for i := range n {
+ ids[i] = n[i].ID
+ }
+ return gu.AddNotifierIDs(ids...)
+}
+
// Mutation returns the GroupMutation object of the builder.
func (gu *GroupUpdate) Mutation() *GroupMutation {
return gu.mutation
@@ -282,10 +306,31 @@ func (gu *GroupUpdate) RemoveInvitationTokens(g ...*GroupInvitationToken) *Group
return gu.RemoveInvitationTokenIDs(ids...)
}
+// ClearNotifiers clears all "notifiers" edges to the Notifier entity.
+func (gu *GroupUpdate) ClearNotifiers() *GroupUpdate {
+ gu.mutation.ClearNotifiers()
+ return gu
+}
+
+// RemoveNotifierIDs removes the "notifiers" edge to Notifier entities by IDs.
+func (gu *GroupUpdate) RemoveNotifierIDs(ids ...uuid.UUID) *GroupUpdate {
+ gu.mutation.RemoveNotifierIDs(ids...)
+ return gu
+}
+
+// RemoveNotifiers removes "notifiers" edges to Notifier entities.
+func (gu *GroupUpdate) RemoveNotifiers(n ...*Notifier) *GroupUpdate {
+ ids := make([]uuid.UUID, len(n))
+ for i := range n {
+ ids[i] = n[i].ID
+ }
+ return gu.RemoveNotifierIDs(ids...)
+}
+
// Save executes the query and returns the number of nodes affected by the update operation.
func (gu *GroupUpdate) Save(ctx context.Context) (int, error) {
gu.defaults()
- return withHooks[int, GroupMutation](ctx, gu.sqlSave, gu.mutation, gu.hooks)
+ return withHooks(ctx, gu.sqlSave, gu.mutation, gu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -325,11 +370,6 @@ func (gu *GroupUpdate) check() error {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "Group.name": %w`, err)}
}
}
- if v, ok := gu.mutation.Currency(); ok {
- if err := group.CurrencyValidator(v); err != nil {
- return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
- }
- }
return nil
}
@@ -337,16 +377,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := gu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: group.Table,
- Columns: group.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID))
if ps := gu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -361,7 +392,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
_spec.SetField(group.FieldName, field.TypeString, value)
}
if value, ok := gu.mutation.Currency(); ok {
- _spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+ _spec.SetField(group.FieldCurrency, field.TypeString, value)
}
if gu.mutation.UsersCleared() {
edge := &sqlgraph.EdgeSpec{
@@ -371,10 +402,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -387,10 +415,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -406,10 +431,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -425,10 +447,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -441,10 +460,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -460,10 +476,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -479,10 +492,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -495,10 +505,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -514,10 +521,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -533,10 +537,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -549,10 +550,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -568,10 +566,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -587,10 +582,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -603,10 +595,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -622,10 +611,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -641,10 +627,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -657,10 +640,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -676,10 +656,52 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if gu.mutation.NotifiersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := gu.mutation.RemovedNotifiersIDs(); len(nodes) > 0 && !gu.mutation.NotifiersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := gu.mutation.NotifiersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -719,16 +741,24 @@ func (guo *GroupUpdateOne) SetName(s string) *GroupUpdateOne {
return guo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (guo *GroupUpdateOne) SetNillableName(s *string) *GroupUpdateOne {
+ if s != nil {
+ guo.SetName(*s)
+ }
+ return guo
+}
+
// SetCurrency sets the "currency" field.
-func (guo *GroupUpdateOne) SetCurrency(gr group.Currency) *GroupUpdateOne {
- guo.mutation.SetCurrency(gr)
+func (guo *GroupUpdateOne) SetCurrency(s string) *GroupUpdateOne {
+ guo.mutation.SetCurrency(s)
return guo
}
// SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (guo *GroupUpdateOne) SetNillableCurrency(gr *group.Currency) *GroupUpdateOne {
- if gr != nil {
- guo.SetCurrency(*gr)
+func (guo *GroupUpdateOne) SetNillableCurrency(s *string) *GroupUpdateOne {
+ if s != nil {
+ guo.SetCurrency(*s)
}
return guo
}
@@ -823,6 +853,21 @@ func (guo *GroupUpdateOne) AddInvitationTokens(g ...*GroupInvitationToken) *Grou
return guo.AddInvitationTokenIDs(ids...)
}
+// AddNotifierIDs adds the "notifiers" edge to the Notifier entity by IDs.
+func (guo *GroupUpdateOne) AddNotifierIDs(ids ...uuid.UUID) *GroupUpdateOne {
+ guo.mutation.AddNotifierIDs(ids...)
+ return guo
+}
+
+// AddNotifiers adds the "notifiers" edges to the Notifier entity.
+func (guo *GroupUpdateOne) AddNotifiers(n ...*Notifier) *GroupUpdateOne {
+ ids := make([]uuid.UUID, len(n))
+ for i := range n {
+ ids[i] = n[i].ID
+ }
+ return guo.AddNotifierIDs(ids...)
+}
+
// Mutation returns the GroupMutation object of the builder.
func (guo *GroupUpdateOne) Mutation() *GroupMutation {
return guo.mutation
@@ -954,6 +999,33 @@ func (guo *GroupUpdateOne) RemoveInvitationTokens(g ...*GroupInvitationToken) *G
return guo.RemoveInvitationTokenIDs(ids...)
}
+// ClearNotifiers clears all "notifiers" edges to the Notifier entity.
+func (guo *GroupUpdateOne) ClearNotifiers() *GroupUpdateOne {
+ guo.mutation.ClearNotifiers()
+ return guo
+}
+
+// RemoveNotifierIDs removes the "notifiers" edge to Notifier entities by IDs.
+func (guo *GroupUpdateOne) RemoveNotifierIDs(ids ...uuid.UUID) *GroupUpdateOne {
+ guo.mutation.RemoveNotifierIDs(ids...)
+ return guo
+}
+
+// RemoveNotifiers removes "notifiers" edges to Notifier entities.
+func (guo *GroupUpdateOne) RemoveNotifiers(n ...*Notifier) *GroupUpdateOne {
+ ids := make([]uuid.UUID, len(n))
+ for i := range n {
+ ids[i] = n[i].ID
+ }
+ return guo.RemoveNotifierIDs(ids...)
+}
+
+// Where appends a list predicates to the GroupUpdate builder.
+func (guo *GroupUpdateOne) Where(ps ...predicate.Group) *GroupUpdateOne {
+ guo.mutation.Where(ps...)
+ return guo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (guo *GroupUpdateOne) Select(field string, fields ...string) *GroupUpdateOne {
@@ -964,7 +1036,7 @@ func (guo *GroupUpdateOne) Select(field string, fields ...string) *GroupUpdateOn
// Save executes the query and returns the updated Group entity.
func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error) {
guo.defaults()
- return withHooks[*Group, GroupMutation](ctx, guo.sqlSave, guo.mutation, guo.hooks)
+ return withHooks(ctx, guo.sqlSave, guo.mutation, guo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -1004,11 +1076,6 @@ func (guo *GroupUpdateOne) check() error {
return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "Group.name": %w`, err)}
}
}
- if v, ok := guo.mutation.Currency(); ok {
- if err := group.CurrencyValidator(v); err != nil {
- return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
- }
- }
return nil
}
@@ -1016,16 +1083,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
if err := guo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: group.Table,
- Columns: group.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(group.Table, group.Columns, sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID))
id, ok := guo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Group.id" for update`)}
@@ -1057,7 +1115,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
_spec.SetField(group.FieldName, field.TypeString, value)
}
if value, ok := guo.mutation.Currency(); ok {
- _spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+ _spec.SetField(group.FieldCurrency, field.TypeString, value)
}
if guo.mutation.UsersCleared() {
edge := &sqlgraph.EdgeSpec{
@@ -1067,10 +1125,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1083,10 +1138,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1102,10 +1154,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.UsersColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: user.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1121,10 +1170,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1137,10 +1183,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1156,10 +1199,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LocationsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1175,10 +1215,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1191,10 +1228,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1210,10 +1244,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1229,10 +1260,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1245,10 +1273,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1264,10 +1289,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.LabelsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1283,10 +1305,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1299,10 +1318,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1318,10 +1334,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.DocumentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: document.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(document.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1337,10 +1350,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1353,10 +1363,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1372,10 +1379,52 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
Columns: []string{group.InvitationTokensColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if guo.mutation.NotifiersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := guo.mutation.RemovedNotifiersIDs(); len(nodes) > 0 && !guo.mutation.NotifiersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := guo.mutation.NotifiersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: group.NotifiersTable,
+ Columns: []string{group.NotifiersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(notifier.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/groupinvitationtoken.go b/backend/internal/data/ent/groupinvitationtoken.go
index 248e40f..d715cc6 100644
--- a/backend/internal/data/ent/groupinvitationtoken.go
+++ b/backend/internal/data/ent/groupinvitationtoken.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/group"
@@ -32,6 +33,7 @@ type GroupInvitationToken struct {
// The values are being populated by the GroupInvitationTokenQuery when eager-loading is set.
Edges GroupInvitationTokenEdges `json:"edges"`
group_invitation_tokens *uuid.UUID
+ selectValues sql.SelectValues
}
// GroupInvitationTokenEdges holds the relations/edges for other nodes in the graph.
@@ -72,7 +74,7 @@ func (*GroupInvitationToken) scanValues(columns []string) ([]any, error) {
case groupinvitationtoken.ForeignKeys[0]: // group_invitation_tokens
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type GroupInvitationToken", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -129,21 +131,29 @@ func (git *GroupInvitationToken) assignValues(columns []string, values []any) er
git.group_invitation_tokens = new(uuid.UUID)
*git.group_invitation_tokens = *value.S.(*uuid.UUID)
}
+ default:
+ git.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the GroupInvitationToken.
+// This includes values selected through modifiers, order, etc.
+func (git *GroupInvitationToken) Value(name string) (ent.Value, error) {
+ return git.selectValues.Get(name)
+}
+
// QueryGroup queries the "group" edge of the GroupInvitationToken entity.
func (git *GroupInvitationToken) QueryGroup() *GroupQuery {
- return (&GroupInvitationTokenClient{config: git.config}).QueryGroup(git)
+ return NewGroupInvitationTokenClient(git.config).QueryGroup(git)
}
// Update returns a builder for updating this GroupInvitationToken.
// Note that you need to call GroupInvitationToken.Unwrap() before calling this method if this GroupInvitationToken
// was returned from a transaction, and the transaction was committed or rolled back.
func (git *GroupInvitationToken) Update() *GroupInvitationTokenUpdateOne {
- return (&GroupInvitationTokenClient{config: git.config}).UpdateOne(git)
+ return NewGroupInvitationTokenClient(git.config).UpdateOne(git)
}
// Unwrap unwraps the GroupInvitationToken entity that was returned from a transaction after it was closed,
@@ -182,9 +192,3 @@ func (git *GroupInvitationToken) String() string {
// GroupInvitationTokens is a parsable slice of GroupInvitationToken.
type GroupInvitationTokens []*GroupInvitationToken
-
-func (git GroupInvitationTokens) config(cfg config) {
- for _i := range git {
- git[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/groupinvitationtoken/groupinvitationtoken.go b/backend/internal/data/ent/groupinvitationtoken/groupinvitationtoken.go
index 1daea17..748d739 100644
--- a/backend/internal/data/ent/groupinvitationtoken/groupinvitationtoken.go
+++ b/backend/internal/data/ent/groupinvitationtoken/groupinvitationtoken.go
@@ -5,6 +5,8 @@ package groupinvitationtoken
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -81,3 +83,45 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the GroupInvitationToken queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByExpiresAt orders the results by the expires_at field.
+func ByExpiresAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldExpiresAt, opts...).ToFunc()
+}
+
+// ByUses orders the results by the uses field.
+func ByUses(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUses, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+}
diff --git a/backend/internal/data/ent/groupinvitationtoken/where.go b/backend/internal/data/ent/groupinvitationtoken/where.go
index 2d81adc..d462df0 100644
--- a/backend/internal/data/ent/groupinvitationtoken/where.go
+++ b/backend/internal/data/ent/groupinvitationtoken/where.go
@@ -295,11 +295,7 @@ func HasGroup() predicate.GroupInvitationToken {
// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
func HasGroupWith(preds ...predicate.Group) predicate.GroupInvitationToken {
return predicate.GroupInvitationToken(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(GroupInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
+ step := newGroupStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -310,32 +306,15 @@ func HasGroupWith(preds ...predicate.Group) predicate.GroupInvitationToken {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.GroupInvitationToken) predicate.GroupInvitationToken {
- return predicate.GroupInvitationToken(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.GroupInvitationToken(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.GroupInvitationToken) predicate.GroupInvitationToken {
- return predicate.GroupInvitationToken(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.GroupInvitationToken(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.GroupInvitationToken) predicate.GroupInvitationToken {
- return predicate.GroupInvitationToken(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.GroupInvitationToken(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/groupinvitationtoken_create.go b/backend/internal/data/ent/groupinvitationtoken_create.go
index 01cd1c8..1d5859f 100644
--- a/backend/internal/data/ent/groupinvitationtoken_create.go
+++ b/backend/internal/data/ent/groupinvitationtoken_create.go
@@ -125,7 +125,7 @@ func (gitc *GroupInvitationTokenCreate) Mutation() *GroupInvitationTokenMutation
// Save creates the GroupInvitationToken in the database.
func (gitc *GroupInvitationTokenCreate) Save(ctx context.Context) (*GroupInvitationToken, error) {
gitc.defaults()
- return withHooks[*GroupInvitationToken, GroupInvitationTokenMutation](ctx, gitc.sqlSave, gitc.mutation, gitc.hooks)
+ return withHooks(ctx, gitc.sqlSave, gitc.mutation, gitc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -220,13 +220,7 @@ func (gitc *GroupInvitationTokenCreate) sqlSave(ctx context.Context) (*GroupInvi
func (gitc *GroupInvitationTokenCreate) createSpec() (*GroupInvitationToken, *sqlgraph.CreateSpec) {
var (
_node = &GroupInvitationToken{config: gitc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: groupinvitationtoken.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(groupinvitationtoken.Table, sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID))
)
if id, ok := gitc.mutation.ID(); ok {
_node.ID = id
@@ -260,10 +254,7 @@ func (gitc *GroupInvitationTokenCreate) createSpec() (*GroupInvitationToken, *sq
Columns: []string{groupinvitationtoken.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -278,11 +269,15 @@ func (gitc *GroupInvitationTokenCreate) createSpec() (*GroupInvitationToken, *sq
// GroupInvitationTokenCreateBulk is the builder for creating many GroupInvitationToken entities in bulk.
type GroupInvitationTokenCreateBulk struct {
config
+ err error
builders []*GroupInvitationTokenCreate
}
// Save creates the GroupInvitationToken entities in the database.
func (gitcb *GroupInvitationTokenCreateBulk) Save(ctx context.Context) ([]*GroupInvitationToken, error) {
+ if gitcb.err != nil {
+ return nil, gitcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(gitcb.builders))
nodes := make([]*GroupInvitationToken, len(gitcb.builders))
mutators := make([]Mutator, len(gitcb.builders))
@@ -299,8 +294,8 @@ func (gitcb *GroupInvitationTokenCreateBulk) Save(ctx context.Context) ([]*Group
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, gitcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/groupinvitationtoken_delete.go b/backend/internal/data/ent/groupinvitationtoken_delete.go
index 1da616e..5878fdf 100644
--- a/backend/internal/data/ent/groupinvitationtoken_delete.go
+++ b/backend/internal/data/ent/groupinvitationtoken_delete.go
@@ -27,7 +27,7 @@ func (gitd *GroupInvitationTokenDelete) Where(ps ...predicate.GroupInvitationTok
// Exec executes the deletion query and returns how many vertices were deleted.
func (gitd *GroupInvitationTokenDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, GroupInvitationTokenMutation](ctx, gitd.sqlExec, gitd.mutation, gitd.hooks)
+ return withHooks(ctx, gitd.sqlExec, gitd.mutation, gitd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (gitd *GroupInvitationTokenDelete) ExecX(ctx context.Context) int {
}
func (gitd *GroupInvitationTokenDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: groupinvitationtoken.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(groupinvitationtoken.Table, sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID))
if ps := gitd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type GroupInvitationTokenDeleteOne struct {
gitd *GroupInvitationTokenDelete
}
+// Where appends a list predicates to the GroupInvitationTokenDelete builder.
+func (gitdo *GroupInvitationTokenDeleteOne) Where(ps ...predicate.GroupInvitationToken) *GroupInvitationTokenDeleteOne {
+ gitdo.gitd.mutation.Where(ps...)
+ return gitdo
+}
+
// Exec executes the deletion query.
func (gitdo *GroupInvitationTokenDeleteOne) Exec(ctx context.Context) error {
n, err := gitdo.gitd.Exec(ctx)
@@ -84,5 +82,7 @@ func (gitdo *GroupInvitationTokenDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (gitdo *GroupInvitationTokenDeleteOne) ExecX(ctx context.Context) {
- gitdo.gitd.ExecX(ctx)
+ if err := gitdo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/groupinvitationtoken_query.go b/backend/internal/data/ent/groupinvitationtoken_query.go
index 8c84dca..89de054 100644
--- a/backend/internal/data/ent/groupinvitationtoken_query.go
+++ b/backend/internal/data/ent/groupinvitationtoken_query.go
@@ -19,11 +19,8 @@ import (
// GroupInvitationTokenQuery is the builder for querying GroupInvitationToken entities.
type GroupInvitationTokenQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []groupinvitationtoken.OrderOption
inters []Interceptor
predicates []predicate.GroupInvitationToken
withGroup *GroupQuery
@@ -41,25 +38,25 @@ func (gitq *GroupInvitationTokenQuery) Where(ps ...predicate.GroupInvitationToke
// Limit the number of records to be returned by this query.
func (gitq *GroupInvitationTokenQuery) Limit(limit int) *GroupInvitationTokenQuery {
- gitq.limit = &limit
+ gitq.ctx.Limit = &limit
return gitq
}
// Offset to start from.
func (gitq *GroupInvitationTokenQuery) Offset(offset int) *GroupInvitationTokenQuery {
- gitq.offset = &offset
+ gitq.ctx.Offset = &offset
return gitq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (gitq *GroupInvitationTokenQuery) Unique(unique bool) *GroupInvitationTokenQuery {
- gitq.unique = &unique
+ gitq.ctx.Unique = &unique
return gitq
}
// Order specifies how the records should be ordered.
-func (gitq *GroupInvitationTokenQuery) Order(o ...OrderFunc) *GroupInvitationTokenQuery {
+func (gitq *GroupInvitationTokenQuery) Order(o ...groupinvitationtoken.OrderOption) *GroupInvitationTokenQuery {
gitq.order = append(gitq.order, o...)
return gitq
}
@@ -89,7 +86,7 @@ func (gitq *GroupInvitationTokenQuery) QueryGroup() *GroupQuery {
// First returns the first GroupInvitationToken entity from the query.
// Returns a *NotFoundError when no GroupInvitationToken was found.
func (gitq *GroupInvitationTokenQuery) First(ctx context.Context) (*GroupInvitationToken, error) {
- nodes, err := gitq.Limit(1).All(newQueryContext(ctx, TypeGroupInvitationToken, "First"))
+ nodes, err := gitq.Limit(1).All(setContextOp(ctx, gitq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -112,7 +109,7 @@ func (gitq *GroupInvitationTokenQuery) FirstX(ctx context.Context) *GroupInvitat
// Returns a *NotFoundError when no GroupInvitationToken ID was found.
func (gitq *GroupInvitationTokenQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = gitq.Limit(1).IDs(newQueryContext(ctx, TypeGroupInvitationToken, "FirstID")); err != nil {
+ if ids, err = gitq.Limit(1).IDs(setContextOp(ctx, gitq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -135,7 +132,7 @@ func (gitq *GroupInvitationTokenQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one GroupInvitationToken entity is found.
// Returns a *NotFoundError when no GroupInvitationToken entities are found.
func (gitq *GroupInvitationTokenQuery) Only(ctx context.Context) (*GroupInvitationToken, error) {
- nodes, err := gitq.Limit(2).All(newQueryContext(ctx, TypeGroupInvitationToken, "Only"))
+ nodes, err := gitq.Limit(2).All(setContextOp(ctx, gitq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -163,7 +160,7 @@ func (gitq *GroupInvitationTokenQuery) OnlyX(ctx context.Context) *GroupInvitati
// Returns a *NotFoundError when no entities are found.
func (gitq *GroupInvitationTokenQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = gitq.Limit(2).IDs(newQueryContext(ctx, TypeGroupInvitationToken, "OnlyID")); err != nil {
+ if ids, err = gitq.Limit(2).IDs(setContextOp(ctx, gitq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -188,7 +185,7 @@ func (gitq *GroupInvitationTokenQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of GroupInvitationTokens.
func (gitq *GroupInvitationTokenQuery) All(ctx context.Context) ([]*GroupInvitationToken, error) {
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "All")
+ ctx = setContextOp(ctx, gitq.ctx, "All")
if err := gitq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -206,10 +203,12 @@ func (gitq *GroupInvitationTokenQuery) AllX(ctx context.Context) []*GroupInvitat
}
// IDs executes the query and returns a list of GroupInvitationToken IDs.
-func (gitq *GroupInvitationTokenQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "IDs")
- if err := gitq.Select(groupinvitationtoken.FieldID).Scan(ctx, &ids); err != nil {
+func (gitq *GroupInvitationTokenQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if gitq.ctx.Unique == nil && gitq.path != nil {
+ gitq.Unique(true)
+ }
+ ctx = setContextOp(ctx, gitq.ctx, "IDs")
+ if err = gitq.Select(groupinvitationtoken.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -226,7 +225,7 @@ func (gitq *GroupInvitationTokenQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (gitq *GroupInvitationTokenQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "Count")
+ ctx = setContextOp(ctx, gitq.ctx, "Count")
if err := gitq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -244,7 +243,7 @@ func (gitq *GroupInvitationTokenQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (gitq *GroupInvitationTokenQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "Exist")
+ ctx = setContextOp(ctx, gitq.ctx, "Exist")
switch _, err := gitq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -272,16 +271,14 @@ func (gitq *GroupInvitationTokenQuery) Clone() *GroupInvitationTokenQuery {
}
return &GroupInvitationTokenQuery{
config: gitq.config,
- limit: gitq.limit,
- offset: gitq.offset,
- order: append([]OrderFunc{}, gitq.order...),
+ ctx: gitq.ctx.Clone(),
+ order: append([]groupinvitationtoken.OrderOption{}, gitq.order...),
inters: append([]Interceptor{}, gitq.inters...),
predicates: append([]predicate.GroupInvitationToken{}, gitq.predicates...),
withGroup: gitq.withGroup.Clone(),
// clone intermediate query.
- sql: gitq.sql.Clone(),
- path: gitq.path,
- unique: gitq.unique,
+ sql: gitq.sql.Clone(),
+ path: gitq.path,
}
}
@@ -311,9 +308,9 @@ func (gitq *GroupInvitationTokenQuery) WithGroup(opts ...func(*GroupQuery)) *Gro
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (gitq *GroupInvitationTokenQuery) GroupBy(field string, fields ...string) *GroupInvitationTokenGroupBy {
- gitq.fields = append([]string{field}, fields...)
+ gitq.ctx.Fields = append([]string{field}, fields...)
grbuild := &GroupInvitationTokenGroupBy{build: gitq}
- grbuild.flds = &gitq.fields
+ grbuild.flds = &gitq.ctx.Fields
grbuild.label = groupinvitationtoken.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -332,10 +329,10 @@ func (gitq *GroupInvitationTokenQuery) GroupBy(field string, fields ...string) *
// Select(groupinvitationtoken.FieldCreatedAt).
// Scan(ctx, &v)
func (gitq *GroupInvitationTokenQuery) Select(fields ...string) *GroupInvitationTokenSelect {
- gitq.fields = append(gitq.fields, fields...)
+ gitq.ctx.Fields = append(gitq.ctx.Fields, fields...)
sbuild := &GroupInvitationTokenSelect{GroupInvitationTokenQuery: gitq}
sbuild.label = groupinvitationtoken.Label
- sbuild.flds, sbuild.scan = &gitq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &gitq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -355,7 +352,7 @@ func (gitq *GroupInvitationTokenQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range gitq.fields {
+ for _, f := range gitq.ctx.Fields {
if !groupinvitationtoken.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -425,6 +422,9 @@ func (gitq *GroupInvitationTokenQuery) loadGroup(ctx context.Context, query *Gro
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(group.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -444,30 +444,22 @@ func (gitq *GroupInvitationTokenQuery) loadGroup(ctx context.Context, query *Gro
func (gitq *GroupInvitationTokenQuery) sqlCount(ctx context.Context) (int, error) {
_spec := gitq.querySpec()
- _spec.Node.Columns = gitq.fields
- if len(gitq.fields) > 0 {
- _spec.Unique = gitq.unique != nil && *gitq.unique
+ _spec.Node.Columns = gitq.ctx.Fields
+ if len(gitq.ctx.Fields) > 0 {
+ _spec.Unique = gitq.ctx.Unique != nil && *gitq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, gitq.driver, _spec)
}
func (gitq *GroupInvitationTokenQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: groupinvitationtoken.Table,
- Columns: groupinvitationtoken.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
- },
- From: gitq.sql,
- Unique: true,
- }
- if unique := gitq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(groupinvitationtoken.Table, groupinvitationtoken.Columns, sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID))
+ _spec.From = gitq.sql
+ if unique := gitq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if gitq.path != nil {
+ _spec.Unique = true
}
- if fields := gitq.fields; len(fields) > 0 {
+ if fields := gitq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, groupinvitationtoken.FieldID)
for i := range fields {
@@ -483,10 +475,10 @@ func (gitq *GroupInvitationTokenQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := gitq.limit; limit != nil {
+ if limit := gitq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := gitq.offset; offset != nil {
+ if offset := gitq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := gitq.order; len(ps) > 0 {
@@ -502,7 +494,7 @@ func (gitq *GroupInvitationTokenQuery) querySpec() *sqlgraph.QuerySpec {
func (gitq *GroupInvitationTokenQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(gitq.driver.Dialect())
t1 := builder.Table(groupinvitationtoken.Table)
- columns := gitq.fields
+ columns := gitq.ctx.Fields
if len(columns) == 0 {
columns = groupinvitationtoken.Columns
}
@@ -511,7 +503,7 @@ func (gitq *GroupInvitationTokenQuery) sqlQuery(ctx context.Context) *sql.Select
selector = gitq.sql
selector.Select(selector.Columns(columns...)...)
}
- if gitq.unique != nil && *gitq.unique {
+ if gitq.ctx.Unique != nil && *gitq.ctx.Unique {
selector.Distinct()
}
for _, p := range gitq.predicates {
@@ -520,12 +512,12 @@ func (gitq *GroupInvitationTokenQuery) sqlQuery(ctx context.Context) *sql.Select
for _, p := range gitq.order {
p(selector)
}
- if offset := gitq.offset; offset != nil {
+ if offset := gitq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := gitq.limit; limit != nil {
+ if limit := gitq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -545,7 +537,7 @@ func (gitgb *GroupInvitationTokenGroupBy) Aggregate(fns ...AggregateFunc) *Group
// Scan applies the selector query and scans the result into the given value.
func (gitgb *GroupInvitationTokenGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "GroupBy")
+ ctx = setContextOp(ctx, gitgb.build.ctx, "GroupBy")
if err := gitgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -593,7 +585,7 @@ func (gits *GroupInvitationTokenSelect) Aggregate(fns ...AggregateFunc) *GroupIn
// Scan applies the selector query and scans the result into the given value.
func (gits *GroupInvitationTokenSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeGroupInvitationToken, "Select")
+ ctx = setContextOp(ctx, gits.ctx, "Select")
if err := gits.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/groupinvitationtoken_update.go b/backend/internal/data/ent/groupinvitationtoken_update.go
index ac7cfd2..3e0db91 100644
--- a/backend/internal/data/ent/groupinvitationtoken_update.go
+++ b/backend/internal/data/ent/groupinvitationtoken_update.go
@@ -110,7 +110,7 @@ func (gitu *GroupInvitationTokenUpdate) ClearGroup() *GroupInvitationTokenUpdate
// Save executes the query and returns the number of nodes affected by the update operation.
func (gitu *GroupInvitationTokenUpdate) Save(ctx context.Context) (int, error) {
gitu.defaults()
- return withHooks[int, GroupInvitationTokenMutation](ctx, gitu.sqlSave, gitu.mutation, gitu.hooks)
+ return withHooks(ctx, gitu.sqlSave, gitu.mutation, gitu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -144,16 +144,7 @@ func (gitu *GroupInvitationTokenUpdate) defaults() {
}
func (gitu *GroupInvitationTokenUpdate) sqlSave(ctx context.Context) (n int, err error) {
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: groupinvitationtoken.Table,
- Columns: groupinvitationtoken.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(groupinvitationtoken.Table, groupinvitationtoken.Columns, sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID))
if ps := gitu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -184,10 +175,7 @@ func (gitu *GroupInvitationTokenUpdate) sqlSave(ctx context.Context) (n int, err
Columns: []string{groupinvitationtoken.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -200,10 +188,7 @@ func (gitu *GroupInvitationTokenUpdate) sqlSave(ctx context.Context) (n int, err
Columns: []string{groupinvitationtoken.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -308,6 +293,12 @@ func (gituo *GroupInvitationTokenUpdateOne) ClearGroup() *GroupInvitationTokenUp
return gituo
}
+// Where appends a list predicates to the GroupInvitationTokenUpdate builder.
+func (gituo *GroupInvitationTokenUpdateOne) Where(ps ...predicate.GroupInvitationToken) *GroupInvitationTokenUpdateOne {
+ gituo.mutation.Where(ps...)
+ return gituo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (gituo *GroupInvitationTokenUpdateOne) Select(field string, fields ...string) *GroupInvitationTokenUpdateOne {
@@ -318,7 +309,7 @@ func (gituo *GroupInvitationTokenUpdateOne) Select(field string, fields ...strin
// Save executes the query and returns the updated GroupInvitationToken entity.
func (gituo *GroupInvitationTokenUpdateOne) Save(ctx context.Context) (*GroupInvitationToken, error) {
gituo.defaults()
- return withHooks[*GroupInvitationToken, GroupInvitationTokenMutation](ctx, gituo.sqlSave, gituo.mutation, gituo.hooks)
+ return withHooks(ctx, gituo.sqlSave, gituo.mutation, gituo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -352,16 +343,7 @@ func (gituo *GroupInvitationTokenUpdateOne) defaults() {
}
func (gituo *GroupInvitationTokenUpdateOne) sqlSave(ctx context.Context) (_node *GroupInvitationToken, err error) {
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: groupinvitationtoken.Table,
- Columns: groupinvitationtoken.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: groupinvitationtoken.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(groupinvitationtoken.Table, groupinvitationtoken.Columns, sqlgraph.NewFieldSpec(groupinvitationtoken.FieldID, field.TypeUUID))
id, ok := gituo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "GroupInvitationToken.id" for update`)}
@@ -409,10 +391,7 @@ func (gituo *GroupInvitationTokenUpdateOne) sqlSave(ctx context.Context) (_node
Columns: []string{groupinvitationtoken.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -425,10 +404,7 @@ func (gituo *GroupInvitationTokenUpdateOne) sqlSave(ctx context.Context) (_node
Columns: []string{groupinvitationtoken.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/has_id.go b/backend/internal/data/ent/has_id.go
index 875ba0d..0877caa 100644
--- a/backend/internal/data/ent/has_id.go
+++ b/backend/internal/data/ent/has_id.go
@@ -48,6 +48,10 @@ func (me *MaintenanceEntry) GetID() uuid.UUID {
return me.ID
}
+func (n *Notifier) GetID() uuid.UUID {
+ return n.ID
+}
+
func (u *User) GetID() uuid.UUID {
return u.ID
}
diff --git a/backend/internal/data/ent/hook/hook.go b/backend/internal/data/ent/hook/hook.go
index f4fb2ca..4648b23 100644
--- a/backend/internal/data/ent/hook/hook.go
+++ b/backend/internal/data/ent/hook/hook.go
@@ -141,6 +141,18 @@ func (f MaintenanceEntryFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.V
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MaintenanceEntryMutation", m)
}
+// The NotifierFunc type is an adapter to allow the use of ordinary
+// function as Notifier mutator.
+type NotifierFunc func(context.Context, *ent.NotifierMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f NotifierFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+ if mv, ok := m.(*ent.NotifierMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.NotifierMutation", m)
+}
+
// The UserFunc type is an adapter to allow the use of ordinary
// function as User mutator.
type UserFunc func(context.Context, *ent.UserMutation) (ent.Value, error)
diff --git a/backend/internal/data/ent/item.go b/backend/internal/data/ent/item.go
index bcca2c7..7b2be8a 100644
--- a/backend/internal/data/ent/item.go
+++ b/backend/internal/data/ent/item.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/group"
@@ -71,16 +72,17 @@ type Item struct {
group_items *uuid.UUID
item_children *uuid.UUID
location_items *uuid.UUID
+ selectValues sql.SelectValues
}
// ItemEdges holds the relations/edges for other nodes in the graph.
type ItemEdges struct {
+ // Group holds the value of the group edge.
+ Group *Group `json:"group,omitempty"`
// Parent holds the value of the parent edge.
Parent *Item `json:"parent,omitempty"`
// Children holds the value of the children edge.
Children []*Item `json:"children,omitempty"`
- // Group holds the value of the group edge.
- Group *Group `json:"group,omitempty"`
// Label holds the value of the label edge.
Label []*Label `json:"label,omitempty"`
// Location holds the value of the location edge.
@@ -96,10 +98,23 @@ type ItemEdges struct {
loadedTypes [8]bool
}
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ItemEdges) GroupOrErr() (*Group, error) {
+ if e.loadedTypes[0] {
+ if e.Group == nil {
+ // Edge was loaded but was not found.
+ return nil, &NotFoundError{label: group.Label}
+ }
+ return e.Group, nil
+ }
+ return nil, &NotLoadedError{edge: "group"}
+}
+
// ParentOrErr returns the Parent value or an error if the edge
// was not loaded in eager-loading, or loaded but was not found.
func (e ItemEdges) ParentOrErr() (*Item, error) {
- if e.loadedTypes[0] {
+ if e.loadedTypes[1] {
if e.Parent == nil {
// Edge was loaded but was not found.
return nil, &NotFoundError{label: item.Label}
@@ -112,25 +127,12 @@ func (e ItemEdges) ParentOrErr() (*Item, error) {
// ChildrenOrErr returns the Children value or an error if the edge
// was not loaded in eager-loading.
func (e ItemEdges) ChildrenOrErr() ([]*Item, error) {
- if e.loadedTypes[1] {
+ if e.loadedTypes[2] {
return e.Children, nil
}
return nil, &NotLoadedError{edge: "children"}
}
-// GroupOrErr returns the Group value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e ItemEdges) GroupOrErr() (*Group, error) {
- if e.loadedTypes[2] {
- if e.Group == nil {
- // Edge was loaded but was not found.
- return nil, &NotFoundError{label: group.Label}
- }
- return e.Group, nil
- }
- return nil, &NotLoadedError{edge: "group"}
-}
-
// LabelOrErr returns the Label value or an error if the edge
// was not loaded in eager-loading.
func (e ItemEdges) LabelOrErr() ([]*Label, error) {
@@ -204,7 +206,7 @@ func (*Item) scanValues(columns []string) ([]any, error) {
case item.ForeignKeys[2]: // location_items
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type Item", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -383,56 +385,64 @@ func (i *Item) assignValues(columns []string, values []any) error {
i.location_items = new(uuid.UUID)
*i.location_items = *value.S.(*uuid.UUID)
}
+ default:
+ i.selectValues.Set(columns[j], values[j])
}
}
return nil
}
-// QueryParent queries the "parent" edge of the Item entity.
-func (i *Item) QueryParent() *ItemQuery {
- return (&ItemClient{config: i.config}).QueryParent(i)
-}
-
-// QueryChildren queries the "children" edge of the Item entity.
-func (i *Item) QueryChildren() *ItemQuery {
- return (&ItemClient{config: i.config}).QueryChildren(i)
+// Value returns the ent.Value that was dynamically selected and assigned to the Item.
+// This includes values selected through modifiers, order, etc.
+func (i *Item) Value(name string) (ent.Value, error) {
+ return i.selectValues.Get(name)
}
// QueryGroup queries the "group" edge of the Item entity.
func (i *Item) QueryGroup() *GroupQuery {
- return (&ItemClient{config: i.config}).QueryGroup(i)
+ return NewItemClient(i.config).QueryGroup(i)
+}
+
+// QueryParent queries the "parent" edge of the Item entity.
+func (i *Item) QueryParent() *ItemQuery {
+ return NewItemClient(i.config).QueryParent(i)
+}
+
+// QueryChildren queries the "children" edge of the Item entity.
+func (i *Item) QueryChildren() *ItemQuery {
+ return NewItemClient(i.config).QueryChildren(i)
}
// QueryLabel queries the "label" edge of the Item entity.
func (i *Item) QueryLabel() *LabelQuery {
- return (&ItemClient{config: i.config}).QueryLabel(i)
+ return NewItemClient(i.config).QueryLabel(i)
}
// QueryLocation queries the "location" edge of the Item entity.
func (i *Item) QueryLocation() *LocationQuery {
- return (&ItemClient{config: i.config}).QueryLocation(i)
+ return NewItemClient(i.config).QueryLocation(i)
}
// QueryFields queries the "fields" edge of the Item entity.
func (i *Item) QueryFields() *ItemFieldQuery {
- return (&ItemClient{config: i.config}).QueryFields(i)
+ return NewItemClient(i.config).QueryFields(i)
}
// QueryMaintenanceEntries queries the "maintenance_entries" edge of the Item entity.
func (i *Item) QueryMaintenanceEntries() *MaintenanceEntryQuery {
- return (&ItemClient{config: i.config}).QueryMaintenanceEntries(i)
+ return NewItemClient(i.config).QueryMaintenanceEntries(i)
}
// QueryAttachments queries the "attachments" edge of the Item entity.
func (i *Item) QueryAttachments() *AttachmentQuery {
- return (&ItemClient{config: i.config}).QueryAttachments(i)
+ return NewItemClient(i.config).QueryAttachments(i)
}
// Update returns a builder for updating this Item.
// Note that you need to call Item.Unwrap() before calling this method if this Item
// was returned from a transaction, and the transaction was committed or rolled back.
func (i *Item) Update() *ItemUpdateOne {
- return (&ItemClient{config: i.config}).UpdateOne(i)
+ return NewItemClient(i.config).UpdateOne(i)
}
// Unwrap unwraps the Item entity that was returned from a transaction after it was closed,
@@ -525,9 +535,3 @@ func (i *Item) String() string {
// Items is a parsable slice of Item.
type Items []*Item
-
-func (i Items) config(cfg config) {
- for _i := range i {
- i[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/item/item.go b/backend/internal/data/ent/item/item.go
index 2cb7f6d..bd04679 100644
--- a/backend/internal/data/ent/item/item.go
+++ b/backend/internal/data/ent/item/item.go
@@ -5,6 +5,8 @@ package item
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -59,12 +61,12 @@ const (
FieldSoldPrice = "sold_price"
// FieldSoldNotes holds the string denoting the sold_notes field in the database.
FieldSoldNotes = "sold_notes"
+ // EdgeGroup holds the string denoting the group edge name in mutations.
+ EdgeGroup = "group"
// EdgeParent holds the string denoting the parent edge name in mutations.
EdgeParent = "parent"
// EdgeChildren holds the string denoting the children edge name in mutations.
EdgeChildren = "children"
- // EdgeGroup holds the string denoting the group edge name in mutations.
- EdgeGroup = "group"
// EdgeLabel holds the string denoting the label edge name in mutations.
EdgeLabel = "label"
// EdgeLocation holds the string denoting the location edge name in mutations.
@@ -77,6 +79,13 @@ const (
EdgeAttachments = "attachments"
// Table holds the table name of the item in the database.
Table = "items"
+ // GroupTable is the table that holds the group relation/edge.
+ GroupTable = "items"
+ // GroupInverseTable is the table name for the Group entity.
+ // It exists in this package in order to avoid circular dependency with the "group" package.
+ GroupInverseTable = "groups"
+ // GroupColumn is the table column denoting the group relation/edge.
+ GroupColumn = "group_items"
// ParentTable is the table that holds the parent relation/edge.
ParentTable = "items"
// ParentColumn is the table column denoting the parent relation/edge.
@@ -85,13 +94,6 @@ const (
ChildrenTable = "items"
// ChildrenColumn is the table column denoting the children relation/edge.
ChildrenColumn = "item_children"
- // GroupTable is the table that holds the group relation/edge.
- GroupTable = "items"
- // GroupInverseTable is the table name for the Group entity.
- // It exists in this package in order to avoid circular dependency with the "group" package.
- GroupInverseTable = "groups"
- // GroupColumn is the table column denoting the group relation/edge.
- GroupColumn = "group_items"
// LabelTable is the table that holds the label relation/edge. The primary key declared below.
LabelTable = "label_items"
// LabelInverseTable is the table name for the Label entity.
@@ -226,3 +228,273 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the Item queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByImportRef orders the results by the import_ref field.
+func ByImportRef(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldImportRef, opts...).ToFunc()
+}
+
+// ByNotes orders the results by the notes field.
+func ByNotes(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldNotes, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByInsured orders the results by the insured field.
+func ByInsured(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldInsured, opts...).ToFunc()
+}
+
+// ByArchived orders the results by the archived field.
+func ByArchived(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldArchived, opts...).ToFunc()
+}
+
+// ByAssetID orders the results by the asset_id field.
+func ByAssetID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldAssetID, opts...).ToFunc()
+}
+
+// BySerialNumber orders the results by the serial_number field.
+func BySerialNumber(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSerialNumber, opts...).ToFunc()
+}
+
+// ByModelNumber orders the results by the model_number field.
+func ByModelNumber(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldModelNumber, opts...).ToFunc()
+}
+
+// ByManufacturer orders the results by the manufacturer field.
+func ByManufacturer(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldManufacturer, opts...).ToFunc()
+}
+
+// ByLifetimeWarranty orders the results by the lifetime_warranty field.
+func ByLifetimeWarranty(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldLifetimeWarranty, opts...).ToFunc()
+}
+
+// ByWarrantyExpires orders the results by the warranty_expires field.
+func ByWarrantyExpires(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldWarrantyExpires, opts...).ToFunc()
+}
+
+// ByWarrantyDetails orders the results by the warranty_details field.
+func ByWarrantyDetails(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldWarrantyDetails, opts...).ToFunc()
+}
+
+// ByPurchaseTime orders the results by the purchase_time field.
+func ByPurchaseTime(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPurchaseTime, opts...).ToFunc()
+}
+
+// ByPurchaseFrom orders the results by the purchase_from field.
+func ByPurchaseFrom(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPurchaseFrom, opts...).ToFunc()
+}
+
+// ByPurchasePrice orders the results by the purchase_price field.
+func ByPurchasePrice(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPurchasePrice, opts...).ToFunc()
+}
+
+// BySoldTime orders the results by the sold_time field.
+func BySoldTime(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSoldTime, opts...).ToFunc()
+}
+
+// BySoldTo orders the results by the sold_to field.
+func BySoldTo(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSoldTo, opts...).ToFunc()
+}
+
+// BySoldPrice orders the results by the sold_price field.
+func BySoldPrice(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSoldPrice, opts...).ToFunc()
+}
+
+// BySoldNotes orders the results by the sold_notes field.
+func BySoldNotes(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSoldNotes, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByParentField orders the results by parent field.
+func ByParentField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newParentStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByChildrenCount orders the results by children count.
+func ByChildrenCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newChildrenStep(), opts...)
+ }
+}
+
+// ByChildren orders the results by children terms.
+func ByChildren(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newChildrenStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByLabelCount orders the results by label count.
+func ByLabelCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newLabelStep(), opts...)
+ }
+}
+
+// ByLabel orders the results by label terms.
+func ByLabel(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newLabelStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByLocationField orders the results by location field.
+func ByLocationField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newLocationStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByFieldsCount orders the results by fields count.
+func ByFieldsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newFieldsStep(), opts...)
+ }
+}
+
+// ByFields orders the results by fields terms.
+func ByFields(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newFieldsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByMaintenanceEntriesCount orders the results by maintenance_entries count.
+func ByMaintenanceEntriesCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newMaintenanceEntriesStep(), opts...)
+ }
+}
+
+// ByMaintenanceEntries orders the results by maintenance_entries terms.
+func ByMaintenanceEntries(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newMaintenanceEntriesStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByAttachmentsCount orders the results by attachments count.
+func ByAttachmentsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newAttachmentsStep(), opts...)
+ }
+}
+
+// ByAttachments orders the results by attachments terms.
+func ByAttachments(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newAttachmentsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+}
+func newParentStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
+ )
+}
+func newChildrenStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
+ )
+}
+func newLabelStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(LabelInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, LabelTable, LabelPrimaryKey...),
+ )
+}
+func newLocationStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(LocationInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, LocationTable, LocationColumn),
+ )
+}
+func newFieldsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(FieldsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, FieldsTable, FieldsColumn),
+ )
+}
+func newMaintenanceEntriesStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(MaintenanceEntriesInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, MaintenanceEntriesTable, MaintenanceEntriesColumn),
+ )
+}
+func newAttachmentsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(AttachmentsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
+ )
+}
diff --git a/backend/internal/data/ent/item/where.go b/backend/internal/data/ent/item/where.go
index e57536e..7504e6a 100644
--- a/backend/internal/data/ent/item/where.go
+++ b/backend/internal/data/ent/item/where.go
@@ -1406,6 +1406,29 @@ func SoldNotesContainsFold(v string) predicate.Item {
return predicate.Item(sql.FieldContainsFold(FieldSoldNotes, v))
}
+// HasGroup applies the HasEdge predicate on the "group" edge.
+func HasGroup() predicate.Item {
+ return predicate.Item(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
+func HasGroupWith(preds ...predicate.Group) predicate.Item {
+ return predicate.Item(func(s *sql.Selector) {
+ step := newGroupStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
// HasParent applies the HasEdge predicate on the "parent" edge.
func HasParent() predicate.Item {
return predicate.Item(func(s *sql.Selector) {
@@ -1420,11 +1443,7 @@ func HasParent() predicate.Item {
// HasParentWith applies the HasEdge predicate on the "parent" edge with a given conditions (other predicates).
func HasParentWith(preds ...predicate.Item) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(Table, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
- )
+ step := newParentStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1447,38 +1466,7 @@ func HasChildren() predicate.Item {
// HasChildrenWith applies the HasEdge predicate on the "children" edge with a given conditions (other predicates).
func HasChildrenWith(preds ...predicate.Item) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(Table, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
- )
- sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
- for _, p := range preds {
- p(s)
- }
- })
- })
-}
-
-// HasGroup applies the HasEdge predicate on the "group" edge.
-func HasGroup() predicate.Item {
- return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
- sqlgraph.HasNeighbors(s, step)
- })
-}
-
-// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
-func HasGroupWith(preds ...predicate.Group) predicate.Item {
- return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(GroupInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
+ step := newChildrenStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1501,11 +1489,7 @@ func HasLabel() predicate.Item {
// HasLabelWith applies the HasEdge predicate on the "label" edge with a given conditions (other predicates).
func HasLabelWith(preds ...predicate.Label) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(LabelInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2M, true, LabelTable, LabelPrimaryKey...),
- )
+ step := newLabelStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1528,11 +1512,7 @@ func HasLocation() predicate.Item {
// HasLocationWith applies the HasEdge predicate on the "location" edge with a given conditions (other predicates).
func HasLocationWith(preds ...predicate.Location) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(LocationInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, LocationTable, LocationColumn),
- )
+ step := newLocationStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1555,11 +1535,7 @@ func HasFields() predicate.Item {
// HasFieldsWith applies the HasEdge predicate on the "fields" edge with a given conditions (other predicates).
func HasFieldsWith(preds ...predicate.ItemField) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(FieldsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, FieldsTable, FieldsColumn),
- )
+ step := newFieldsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1582,11 +1558,7 @@ func HasMaintenanceEntries() predicate.Item {
// HasMaintenanceEntriesWith applies the HasEdge predicate on the "maintenance_entries" edge with a given conditions (other predicates).
func HasMaintenanceEntriesWith(preds ...predicate.MaintenanceEntry) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(MaintenanceEntriesInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, MaintenanceEntriesTable, MaintenanceEntriesColumn),
- )
+ step := newMaintenanceEntriesStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1609,11 +1581,7 @@ func HasAttachments() predicate.Item {
// HasAttachmentsWith applies the HasEdge predicate on the "attachments" edge with a given conditions (other predicates).
func HasAttachmentsWith(preds ...predicate.Attachment) predicate.Item {
return predicate.Item(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(AttachmentsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, AttachmentsTable, AttachmentsColumn),
- )
+ step := newAttachmentsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -1624,32 +1592,15 @@ func HasAttachmentsWith(preds ...predicate.Attachment) predicate.Item {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Item) predicate.Item {
- return predicate.Item(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Item(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Item) predicate.Item {
- return predicate.Item(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Item(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Item) predicate.Item {
- return predicate.Item(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Item(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/item_create.go b/backend/internal/data/ent/item_create.go
index da36e66..9eb1cb6 100644
--- a/backend/internal/data/ent/item_create.go
+++ b/backend/internal/data/ent/item_create.go
@@ -355,6 +355,17 @@ func (ic *ItemCreate) SetNillableID(u *uuid.UUID) *ItemCreate {
return ic
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (ic *ItemCreate) SetGroupID(id uuid.UUID) *ItemCreate {
+ ic.mutation.SetGroupID(id)
+ return ic
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (ic *ItemCreate) SetGroup(g *Group) *ItemCreate {
+ return ic.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Item entity by ID.
func (ic *ItemCreate) SetParentID(id uuid.UUID) *ItemCreate {
ic.mutation.SetParentID(id)
@@ -389,17 +400,6 @@ func (ic *ItemCreate) AddChildren(i ...*Item) *ItemCreate {
return ic.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (ic *ItemCreate) SetGroupID(id uuid.UUID) *ItemCreate {
- ic.mutation.SetGroupID(id)
- return ic
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (ic *ItemCreate) SetGroup(g *Group) *ItemCreate {
- return ic.SetGroupID(g.ID)
-}
-
// AddLabelIDs adds the "label" edge to the Label entity by IDs.
func (ic *ItemCreate) AddLabelIDs(ids ...uuid.UUID) *ItemCreate {
ic.mutation.AddLabelIDs(ids...)
@@ -487,7 +487,7 @@ func (ic *ItemCreate) Mutation() *ItemMutation {
// Save creates the Item in the database.
func (ic *ItemCreate) Save(ctx context.Context) (*Item, error) {
ic.defaults()
- return withHooks[*Item, ItemMutation](ctx, ic.sqlSave, ic.mutation, ic.hooks)
+ return withHooks(ctx, ic.sqlSave, ic.mutation, ic.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -665,13 +665,7 @@ func (ic *ItemCreate) sqlSave(ctx context.Context) (*Item, error) {
func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
var (
_node = &Item{config: ic.config}
- _spec = &sqlgraph.CreateSpec{
- Table: item.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(item.Table, sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID))
)
if id, ok := ic.mutation.ID(); ok {
_node.ID = id
@@ -769,6 +763,23 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
_spec.SetField(item.FieldSoldNotes, field.TypeString, value)
_node.SoldNotes = value
}
+ if nodes := ic.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: item.GroupTable,
+ Columns: []string{item.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.group_items = &nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
if nodes := ic.mutation.ParentIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -777,10 +788,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -797,10 +805,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -808,26 +813,6 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
}
_spec.Edges = append(_spec.Edges, edge)
}
- if nodes := ic.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: item.GroupTable,
- Columns: []string{item.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _node.group_items = &nodes[0]
- _spec.Edges = append(_spec.Edges, edge)
- }
if nodes := ic.mutation.LabelIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
@@ -836,10 +821,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -855,10 +837,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.LocationColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -875,10 +854,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -894,10 +870,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -913,10 +886,7 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -930,11 +900,15 @@ func (ic *ItemCreate) createSpec() (*Item, *sqlgraph.CreateSpec) {
// ItemCreateBulk is the builder for creating many Item entities in bulk.
type ItemCreateBulk struct {
config
+ err error
builders []*ItemCreate
}
// Save creates the Item entities in the database.
func (icb *ItemCreateBulk) Save(ctx context.Context) ([]*Item, error) {
+ if icb.err != nil {
+ return nil, icb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(icb.builders))
nodes := make([]*Item, len(icb.builders))
mutators := make([]Mutator, len(icb.builders))
@@ -951,8 +925,8 @@ func (icb *ItemCreateBulk) Save(ctx context.Context) ([]*Item, error) {
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, icb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/item_delete.go b/backend/internal/data/ent/item_delete.go
index 4ebd167..d634d5d 100644
--- a/backend/internal/data/ent/item_delete.go
+++ b/backend/internal/data/ent/item_delete.go
@@ -27,7 +27,7 @@ func (id *ItemDelete) Where(ps ...predicate.Item) *ItemDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (id *ItemDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, ItemMutation](ctx, id.sqlExec, id.mutation, id.hooks)
+ return withHooks(ctx, id.sqlExec, id.mutation, id.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (id *ItemDelete) ExecX(ctx context.Context) int {
}
func (id *ItemDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: item.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(item.Table, sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID))
if ps := id.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type ItemDeleteOne struct {
id *ItemDelete
}
+// Where appends a list predicates to the ItemDelete builder.
+func (ido *ItemDeleteOne) Where(ps ...predicate.Item) *ItemDeleteOne {
+ ido.id.mutation.Where(ps...)
+ return ido
+}
+
// Exec executes the deletion query.
func (ido *ItemDeleteOne) Exec(ctx context.Context) error {
n, err := ido.id.Exec(ctx)
@@ -84,5 +82,7 @@ func (ido *ItemDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ido *ItemDeleteOne) ExecX(ctx context.Context) {
- ido.id.ExecX(ctx)
+ if err := ido.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/item_query.go b/backend/internal/data/ent/item_query.go
index cde5b44..12fc331 100644
--- a/backend/internal/data/ent/item_query.go
+++ b/backend/internal/data/ent/item_query.go
@@ -25,16 +25,13 @@ import (
// ItemQuery is the builder for querying Item entities.
type ItemQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []item.OrderOption
inters []Interceptor
predicates []predicate.Item
+ withGroup *GroupQuery
withParent *ItemQuery
withChildren *ItemQuery
- withGroup *GroupQuery
withLabel *LabelQuery
withLocation *LocationQuery
withFields *ItemFieldQuery
@@ -54,29 +51,51 @@ func (iq *ItemQuery) Where(ps ...predicate.Item) *ItemQuery {
// Limit the number of records to be returned by this query.
func (iq *ItemQuery) Limit(limit int) *ItemQuery {
- iq.limit = &limit
+ iq.ctx.Limit = &limit
return iq
}
// Offset to start from.
func (iq *ItemQuery) Offset(offset int) *ItemQuery {
- iq.offset = &offset
+ iq.ctx.Offset = &offset
return iq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (iq *ItemQuery) Unique(unique bool) *ItemQuery {
- iq.unique = &unique
+ iq.ctx.Unique = &unique
return iq
}
// Order specifies how the records should be ordered.
-func (iq *ItemQuery) Order(o ...OrderFunc) *ItemQuery {
+func (iq *ItemQuery) Order(o ...item.OrderOption) *ItemQuery {
iq.order = append(iq.order, o...)
return iq
}
+// QueryGroup chains the current query on the "group" edge.
+func (iq *ItemQuery) QueryGroup() *GroupQuery {
+ query := (&GroupClient{config: iq.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := iq.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := iq.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(item.Table, item.FieldID, selector),
+ sqlgraph.To(group.Table, group.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(iq.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
// QueryParent chains the current query on the "parent" edge.
func (iq *ItemQuery) QueryParent() *ItemQuery {
query := (&ItemClient{config: iq.config}).Query()
@@ -121,28 +140,6 @@ func (iq *ItemQuery) QueryChildren() *ItemQuery {
return query
}
-// QueryGroup chains the current query on the "group" edge.
-func (iq *ItemQuery) QueryGroup() *GroupQuery {
- query := (&GroupClient{config: iq.config}).Query()
- query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
- if err := iq.prepareQuery(ctx); err != nil {
- return nil, err
- }
- selector := iq.sqlQuery(ctx)
- if err := selector.Err(); err != nil {
- return nil, err
- }
- step := sqlgraph.NewStep(
- sqlgraph.From(item.Table, item.FieldID, selector),
- sqlgraph.To(group.Table, group.FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, item.GroupTable, item.GroupColumn),
- )
- fromU = sqlgraph.SetNeighbors(iq.driver.Dialect(), step)
- return fromU, nil
- }
- return query
-}
-
// QueryLabel chains the current query on the "label" edge.
func (iq *ItemQuery) QueryLabel() *LabelQuery {
query := (&LabelClient{config: iq.config}).Query()
@@ -256,7 +253,7 @@ func (iq *ItemQuery) QueryAttachments() *AttachmentQuery {
// First returns the first Item entity from the query.
// Returns a *NotFoundError when no Item was found.
func (iq *ItemQuery) First(ctx context.Context) (*Item, error) {
- nodes, err := iq.Limit(1).All(newQueryContext(ctx, TypeItem, "First"))
+ nodes, err := iq.Limit(1).All(setContextOp(ctx, iq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -279,7 +276,7 @@ func (iq *ItemQuery) FirstX(ctx context.Context) *Item {
// Returns a *NotFoundError when no Item ID was found.
func (iq *ItemQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = iq.Limit(1).IDs(newQueryContext(ctx, TypeItem, "FirstID")); err != nil {
+ if ids, err = iq.Limit(1).IDs(setContextOp(ctx, iq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -302,7 +299,7 @@ func (iq *ItemQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Item entity is found.
// Returns a *NotFoundError when no Item entities are found.
func (iq *ItemQuery) Only(ctx context.Context) (*Item, error) {
- nodes, err := iq.Limit(2).All(newQueryContext(ctx, TypeItem, "Only"))
+ nodes, err := iq.Limit(2).All(setContextOp(ctx, iq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -330,7 +327,7 @@ func (iq *ItemQuery) OnlyX(ctx context.Context) *Item {
// Returns a *NotFoundError when no entities are found.
func (iq *ItemQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = iq.Limit(2).IDs(newQueryContext(ctx, TypeItem, "OnlyID")); err != nil {
+ if ids, err = iq.Limit(2).IDs(setContextOp(ctx, iq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -355,7 +352,7 @@ func (iq *ItemQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Items.
func (iq *ItemQuery) All(ctx context.Context) ([]*Item, error) {
- ctx = newQueryContext(ctx, TypeItem, "All")
+ ctx = setContextOp(ctx, iq.ctx, "All")
if err := iq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -373,10 +370,12 @@ func (iq *ItemQuery) AllX(ctx context.Context) []*Item {
}
// IDs executes the query and returns a list of Item IDs.
-func (iq *ItemQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeItem, "IDs")
- if err := iq.Select(item.FieldID).Scan(ctx, &ids); err != nil {
+func (iq *ItemQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if iq.ctx.Unique == nil && iq.path != nil {
+ iq.Unique(true)
+ }
+ ctx = setContextOp(ctx, iq.ctx, "IDs")
+ if err = iq.Select(item.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -393,7 +392,7 @@ func (iq *ItemQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (iq *ItemQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeItem, "Count")
+ ctx = setContextOp(ctx, iq.ctx, "Count")
if err := iq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -411,7 +410,7 @@ func (iq *ItemQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (iq *ItemQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeItem, "Exist")
+ ctx = setContextOp(ctx, iq.ctx, "Exist")
switch _, err := iq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -439,26 +438,35 @@ func (iq *ItemQuery) Clone() *ItemQuery {
}
return &ItemQuery{
config: iq.config,
- limit: iq.limit,
- offset: iq.offset,
- order: append([]OrderFunc{}, iq.order...),
+ ctx: iq.ctx.Clone(),
+ order: append([]item.OrderOption{}, iq.order...),
inters: append([]Interceptor{}, iq.inters...),
predicates: append([]predicate.Item{}, iq.predicates...),
+ withGroup: iq.withGroup.Clone(),
withParent: iq.withParent.Clone(),
withChildren: iq.withChildren.Clone(),
- withGroup: iq.withGroup.Clone(),
withLabel: iq.withLabel.Clone(),
withLocation: iq.withLocation.Clone(),
withFields: iq.withFields.Clone(),
withMaintenanceEntries: iq.withMaintenanceEntries.Clone(),
withAttachments: iq.withAttachments.Clone(),
// clone intermediate query.
- sql: iq.sql.Clone(),
- path: iq.path,
- unique: iq.unique,
+ sql: iq.sql.Clone(),
+ path: iq.path,
}
}
+// WithGroup tells the query-builder to eager-load the nodes that are connected to
+// the "group" edge. The optional arguments are used to configure the query builder of the edge.
+func (iq *ItemQuery) WithGroup(opts ...func(*GroupQuery)) *ItemQuery {
+ query := (&GroupClient{config: iq.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ iq.withGroup = query
+ return iq
+}
+
// WithParent tells the query-builder to eager-load the nodes that are connected to
// the "parent" edge. The optional arguments are used to configure the query builder of the edge.
func (iq *ItemQuery) WithParent(opts ...func(*ItemQuery)) *ItemQuery {
@@ -481,17 +489,6 @@ func (iq *ItemQuery) WithChildren(opts ...func(*ItemQuery)) *ItemQuery {
return iq
}
-// WithGroup tells the query-builder to eager-load the nodes that are connected to
-// the "group" edge. The optional arguments are used to configure the query builder of the edge.
-func (iq *ItemQuery) WithGroup(opts ...func(*GroupQuery)) *ItemQuery {
- query := (&GroupClient{config: iq.config}).Query()
- for _, opt := range opts {
- opt(query)
- }
- iq.withGroup = query
- return iq
-}
-
// WithLabel tells the query-builder to eager-load the nodes that are connected to
// the "label" edge. The optional arguments are used to configure the query builder of the edge.
func (iq *ItemQuery) WithLabel(opts ...func(*LabelQuery)) *ItemQuery {
@@ -562,9 +559,9 @@ func (iq *ItemQuery) WithAttachments(opts ...func(*AttachmentQuery)) *ItemQuery
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (iq *ItemQuery) GroupBy(field string, fields ...string) *ItemGroupBy {
- iq.fields = append([]string{field}, fields...)
+ iq.ctx.Fields = append([]string{field}, fields...)
grbuild := &ItemGroupBy{build: iq}
- grbuild.flds = &iq.fields
+ grbuild.flds = &iq.ctx.Fields
grbuild.label = item.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -583,10 +580,10 @@ func (iq *ItemQuery) GroupBy(field string, fields ...string) *ItemGroupBy {
// Select(item.FieldCreatedAt).
// Scan(ctx, &v)
func (iq *ItemQuery) Select(fields ...string) *ItemSelect {
- iq.fields = append(iq.fields, fields...)
+ iq.ctx.Fields = append(iq.ctx.Fields, fields...)
sbuild := &ItemSelect{ItemQuery: iq}
sbuild.label = item.Label
- sbuild.flds, sbuild.scan = &iq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &iq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -606,7 +603,7 @@ func (iq *ItemQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range iq.fields {
+ for _, f := range iq.ctx.Fields {
if !item.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -627,9 +624,9 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
withFKs = iq.withFKs
_spec = iq.querySpec()
loadedTypes = [8]bool{
+ iq.withGroup != nil,
iq.withParent != nil,
iq.withChildren != nil,
- iq.withGroup != nil,
iq.withLabel != nil,
iq.withLocation != nil,
iq.withFields != nil,
@@ -637,7 +634,7 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
iq.withAttachments != nil,
}
)
- if iq.withParent != nil || iq.withGroup != nil || iq.withLocation != nil {
+ if iq.withGroup != nil || iq.withParent != nil || iq.withLocation != nil {
withFKs = true
}
if withFKs {
@@ -661,6 +658,12 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
if len(nodes) == 0 {
return nodes, nil
}
+ if query := iq.withGroup; query != nil {
+ if err := iq.loadGroup(ctx, query, nodes, nil,
+ func(n *Item, e *Group) { n.Edges.Group = e }); err != nil {
+ return nil, err
+ }
+ }
if query := iq.withParent; query != nil {
if err := iq.loadParent(ctx, query, nodes, nil,
func(n *Item, e *Item) { n.Edges.Parent = e }); err != nil {
@@ -674,12 +677,6 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
return nil, err
}
}
- if query := iq.withGroup; query != nil {
- if err := iq.loadGroup(ctx, query, nodes, nil,
- func(n *Item, e *Group) { n.Edges.Group = e }); err != nil {
- return nil, err
- }
- }
if query := iq.withLabel; query != nil {
if err := iq.loadLabel(ctx, query, nodes,
func(n *Item) { n.Edges.Label = []*Label{} },
@@ -717,6 +714,38 @@ func (iq *ItemQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Item, e
return nodes, nil
}
+func (iq *ItemQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Item, init func(*Item), assign func(*Item, *Group)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*Item)
+ for i := range nodes {
+ if nodes[i].group_items == nil {
+ continue
+ }
+ fk := *nodes[i].group_items
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(group.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "group_items" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
func (iq *ItemQuery) loadParent(ctx context.Context, query *ItemQuery, nodes []*Item, init func(*Item), assign func(*Item, *Item)) error {
ids := make([]uuid.UUID, 0, len(nodes))
nodeids := make(map[uuid.UUID][]*Item)
@@ -730,6 +759,9 @@ func (iq *ItemQuery) loadParent(ctx context.Context, query *ItemQuery, nodes []*
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(item.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -758,7 +790,7 @@ func (iq *ItemQuery) loadChildren(ctx context.Context, query *ItemQuery, nodes [
}
query.withFKs = true
query.Where(predicate.Item(func(s *sql.Selector) {
- s.Where(sql.InValues(item.ChildrenColumn, fks...))
+ s.Where(sql.InValues(s.C(item.ChildrenColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -771,41 +803,12 @@ func (iq *ItemQuery) loadChildren(ctx context.Context, query *ItemQuery, nodes [
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "item_children" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "item_children" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
-func (iq *ItemQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Item, init func(*Item), assign func(*Item, *Group)) error {
- ids := make([]uuid.UUID, 0, len(nodes))
- nodeids := make(map[uuid.UUID][]*Item)
- for i := range nodes {
- if nodes[i].group_items == nil {
- continue
- }
- fk := *nodes[i].group_items
- if _, ok := nodeids[fk]; !ok {
- ids = append(ids, fk)
- }
- nodeids[fk] = append(nodeids[fk], nodes[i])
- }
- query.Where(group.IDIn(ids...))
- neighbors, err := query.All(ctx)
- if err != nil {
- return err
- }
- for _, n := range neighbors {
- nodes, ok := nodeids[n.ID]
- if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_items" returned %v`, n.ID)
- }
- for i := range nodes {
- assign(nodes[i], n)
- }
- }
- return nil
-}
func (iq *ItemQuery) loadLabel(ctx context.Context, query *LabelQuery, nodes []*Item, init func(*Item), assign func(*Item, *Label)) error {
edgeIDs := make([]driver.Value, len(nodes))
byID := make(map[uuid.UUID]*Item)
@@ -829,27 +832,30 @@ func (iq *ItemQuery) loadLabel(ctx context.Context, query *LabelQuery, nodes []*
if err := query.prepareQuery(ctx); err != nil {
return err
}
- neighbors, err := query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
- assign := spec.Assign
- values := spec.ScanValues
- spec.ScanValues = func(columns []string) ([]any, error) {
- values, err := values(columns[1:])
- if err != nil {
- return nil, err
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
}
- return append([]any{new(uuid.UUID)}, values...), nil
- }
- spec.Assign = func(columns []string, values []any) error {
- outValue := *values[0].(*uuid.UUID)
- inValue := *values[1].(*uuid.UUID)
- if nids[inValue] == nil {
- nids[inValue] = map[*Item]struct{}{byID[outValue]: {}}
- return assign(columns[1:], values[1:])
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*Item]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
}
- nids[inValue][byID[outValue]] = struct{}{}
- return nil
- }
+ })
})
+ neighbors, err := withInterceptors[[]*Label](ctx, query, qr, query.inters)
if err != nil {
return err
}
@@ -877,6 +883,9 @@ func (iq *ItemQuery) loadLocation(ctx context.Context, query *LocationQuery, nod
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(location.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -905,7 +914,7 @@ func (iq *ItemQuery) loadFields(ctx context.Context, query *ItemFieldQuery, node
}
query.withFKs = true
query.Where(predicate.ItemField(func(s *sql.Selector) {
- s.Where(sql.InValues(item.FieldsColumn, fks...))
+ s.Where(sql.InValues(s.C(item.FieldsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -918,7 +927,7 @@ func (iq *ItemQuery) loadFields(ctx context.Context, query *ItemFieldQuery, node
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "item_fields" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "item_fields" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -934,8 +943,11 @@ func (iq *ItemQuery) loadMaintenanceEntries(ctx context.Context, query *Maintena
init(nodes[i])
}
}
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(maintenanceentry.FieldItemID)
+ }
query.Where(predicate.MaintenanceEntry(func(s *sql.Selector) {
- s.Where(sql.InValues(item.MaintenanceEntriesColumn, fks...))
+ s.Where(sql.InValues(s.C(item.MaintenanceEntriesColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -945,7 +957,7 @@ func (iq *ItemQuery) loadMaintenanceEntries(ctx context.Context, query *Maintena
fk := n.ItemID
node, ok := nodeids[fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "item_id" returned %v for node %v`, fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "item_id" returned %v for node %v`, fk, n.ID)
}
assign(node, n)
}
@@ -963,7 +975,7 @@ func (iq *ItemQuery) loadAttachments(ctx context.Context, query *AttachmentQuery
}
query.withFKs = true
query.Where(predicate.Attachment(func(s *sql.Selector) {
- s.Where(sql.InValues(item.AttachmentsColumn, fks...))
+ s.Where(sql.InValues(s.C(item.AttachmentsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -976,7 +988,7 @@ func (iq *ItemQuery) loadAttachments(ctx context.Context, query *AttachmentQuery
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "item_attachments" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "item_attachments" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -985,30 +997,22 @@ func (iq *ItemQuery) loadAttachments(ctx context.Context, query *AttachmentQuery
func (iq *ItemQuery) sqlCount(ctx context.Context) (int, error) {
_spec := iq.querySpec()
- _spec.Node.Columns = iq.fields
- if len(iq.fields) > 0 {
- _spec.Unique = iq.unique != nil && *iq.unique
+ _spec.Node.Columns = iq.ctx.Fields
+ if len(iq.ctx.Fields) > 0 {
+ _spec.Unique = iq.ctx.Unique != nil && *iq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, iq.driver, _spec)
}
func (iq *ItemQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: item.Table,
- Columns: item.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- From: iq.sql,
- Unique: true,
- }
- if unique := iq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(item.Table, item.Columns, sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID))
+ _spec.From = iq.sql
+ if unique := iq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if iq.path != nil {
+ _spec.Unique = true
}
- if fields := iq.fields; len(fields) > 0 {
+ if fields := iq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, item.FieldID)
for i := range fields {
@@ -1024,10 +1028,10 @@ func (iq *ItemQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := iq.limit; limit != nil {
+ if limit := iq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := iq.offset; offset != nil {
+ if offset := iq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := iq.order; len(ps) > 0 {
@@ -1043,7 +1047,7 @@ func (iq *ItemQuery) querySpec() *sqlgraph.QuerySpec {
func (iq *ItemQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(iq.driver.Dialect())
t1 := builder.Table(item.Table)
- columns := iq.fields
+ columns := iq.ctx.Fields
if len(columns) == 0 {
columns = item.Columns
}
@@ -1052,7 +1056,7 @@ func (iq *ItemQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = iq.sql
selector.Select(selector.Columns(columns...)...)
}
- if iq.unique != nil && *iq.unique {
+ if iq.ctx.Unique != nil && *iq.ctx.Unique {
selector.Distinct()
}
for _, p := range iq.predicates {
@@ -1061,12 +1065,12 @@ func (iq *ItemQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range iq.order {
p(selector)
}
- if offset := iq.offset; offset != nil {
+ if offset := iq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := iq.limit; limit != nil {
+ if limit := iq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -1086,7 +1090,7 @@ func (igb *ItemGroupBy) Aggregate(fns ...AggregateFunc) *ItemGroupBy {
// Scan applies the selector query and scans the result into the given value.
func (igb *ItemGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeItem, "GroupBy")
+ ctx = setContextOp(ctx, igb.build.ctx, "GroupBy")
if err := igb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -1134,7 +1138,7 @@ func (is *ItemSelect) Aggregate(fns ...AggregateFunc) *ItemSelect {
// Scan applies the selector query and scans the result into the given value.
func (is *ItemSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeItem, "Select")
+ ctx = setContextOp(ctx, is.ctx, "Select")
if err := is.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/item_update.go b/backend/internal/data/ent/item_update.go
index 1d5ec90..8cd4722 100644
--- a/backend/internal/data/ent/item_update.go
+++ b/backend/internal/data/ent/item_update.go
@@ -47,6 +47,14 @@ func (iu *ItemUpdate) SetName(s string) *ItemUpdate {
return iu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (iu *ItemUpdate) SetNillableName(s *string) *ItemUpdate {
+ if s != nil {
+ iu.SetName(*s)
+ }
+ return iu
+}
+
// SetDescription sets the "description" field.
func (iu *ItemUpdate) SetDescription(s string) *ItemUpdate {
iu.mutation.SetDescription(s)
@@ -67,6 +75,26 @@ func (iu *ItemUpdate) ClearDescription() *ItemUpdate {
return iu
}
+// SetImportRef sets the "import_ref" field.
+func (iu *ItemUpdate) SetImportRef(s string) *ItemUpdate {
+ iu.mutation.SetImportRef(s)
+ return iu
+}
+
+// SetNillableImportRef sets the "import_ref" field if the given value is not nil.
+func (iu *ItemUpdate) SetNillableImportRef(s *string) *ItemUpdate {
+ if s != nil {
+ iu.SetImportRef(*s)
+ }
+ return iu
+}
+
+// ClearImportRef clears the value of the "import_ref" field.
+func (iu *ItemUpdate) ClearImportRef() *ItemUpdate {
+ iu.mutation.ClearImportRef()
+ return iu
+}
+
// SetNotes sets the "notes" field.
func (iu *ItemUpdate) SetNotes(s string) *ItemUpdate {
iu.mutation.SetNotes(s)
@@ -413,6 +441,17 @@ func (iu *ItemUpdate) ClearSoldNotes() *ItemUpdate {
return iu
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (iu *ItemUpdate) SetGroupID(id uuid.UUID) *ItemUpdate {
+ iu.mutation.SetGroupID(id)
+ return iu
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (iu *ItemUpdate) SetGroup(g *Group) *ItemUpdate {
+ return iu.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Item entity by ID.
func (iu *ItemUpdate) SetParentID(id uuid.UUID) *ItemUpdate {
iu.mutation.SetParentID(id)
@@ -447,17 +486,6 @@ func (iu *ItemUpdate) AddChildren(i ...*Item) *ItemUpdate {
return iu.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (iu *ItemUpdate) SetGroupID(id uuid.UUID) *ItemUpdate {
- iu.mutation.SetGroupID(id)
- return iu
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (iu *ItemUpdate) SetGroup(g *Group) *ItemUpdate {
- return iu.SetGroupID(g.ID)
-}
-
// AddLabelIDs adds the "label" edge to the Label entity by IDs.
func (iu *ItemUpdate) AddLabelIDs(ids ...uuid.UUID) *ItemUpdate {
iu.mutation.AddLabelIDs(ids...)
@@ -542,6 +570,12 @@ func (iu *ItemUpdate) Mutation() *ItemMutation {
return iu.mutation
}
+// ClearGroup clears the "group" edge to the Group entity.
+func (iu *ItemUpdate) ClearGroup() *ItemUpdate {
+ iu.mutation.ClearGroup()
+ return iu
+}
+
// ClearParent clears the "parent" edge to the Item entity.
func (iu *ItemUpdate) ClearParent() *ItemUpdate {
iu.mutation.ClearParent()
@@ -569,12 +603,6 @@ func (iu *ItemUpdate) RemoveChildren(i ...*Item) *ItemUpdate {
return iu.RemoveChildIDs(ids...)
}
-// ClearGroup clears the "group" edge to the Group entity.
-func (iu *ItemUpdate) ClearGroup() *ItemUpdate {
- iu.mutation.ClearGroup()
- return iu
-}
-
// ClearLabel clears all "label" edges to the Label entity.
func (iu *ItemUpdate) ClearLabel() *ItemUpdate {
iu.mutation.ClearLabel()
@@ -668,7 +696,7 @@ func (iu *ItemUpdate) RemoveAttachments(a ...*Attachment) *ItemUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (iu *ItemUpdate) Save(ctx context.Context) (int, error) {
iu.defaults()
- return withHooks[int, ItemMutation](ctx, iu.sqlSave, iu.mutation, iu.hooks)
+ return withHooks(ctx, iu.sqlSave, iu.mutation, iu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -713,6 +741,11 @@ func (iu *ItemUpdate) check() error {
return &ValidationError{Name: "description", err: fmt.Errorf(`ent: validator failed for field "Item.description": %w`, err)}
}
}
+ if v, ok := iu.mutation.ImportRef(); ok {
+ if err := item.ImportRefValidator(v); err != nil {
+ return &ValidationError{Name: "import_ref", err: fmt.Errorf(`ent: validator failed for field "Item.import_ref": %w`, err)}
+ }
+ }
if v, ok := iu.mutation.Notes(); ok {
if err := item.NotesValidator(v); err != nil {
return &ValidationError{Name: "notes", err: fmt.Errorf(`ent: validator failed for field "Item.notes": %w`, err)}
@@ -753,16 +786,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := iu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: item.Table,
- Columns: item.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(item.Table, item.Columns, sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID))
if ps := iu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -782,6 +806,9 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
if iu.mutation.DescriptionCleared() {
_spec.ClearField(item.FieldDescription, field.TypeString)
}
+ if value, ok := iu.mutation.ImportRef(); ok {
+ _spec.SetField(item.FieldImportRef, field.TypeString, value)
+ }
if iu.mutation.ImportRefCleared() {
_spec.ClearField(item.FieldImportRef, field.TypeString)
}
@@ -884,6 +911,35 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
if iu.mutation.SoldNotesCleared() {
_spec.ClearField(item.FieldSoldNotes, field.TypeString)
}
+ if iu.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: item.GroupTable,
+ Columns: []string{item.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := iu.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: item.GroupTable,
+ Columns: []string{item.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
if iu.mutation.ParentCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -892,10 +948,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -908,10 +961,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -927,10 +977,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -943,10 +990,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -962,45 +1006,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _spec.Edges.Add = append(_spec.Edges.Add, edge)
- }
- if iu.mutation.GroupCleared() {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: item.GroupTable,
- Columns: []string{item.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
- }
- if nodes := iu.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: item.GroupTable,
- Columns: []string{item.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1016,10 +1022,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1032,10 +1035,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1051,10 +1051,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1070,10 +1067,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.LocationColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1086,10 +1080,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.LocationColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1105,10 +1096,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1121,10 +1109,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1140,10 +1125,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1159,10 +1141,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1175,10 +1154,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1194,10 +1170,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1213,10 +1186,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -1229,10 +1199,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1248,10 +1215,7 @@ func (iu *ItemUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -1291,6 +1255,14 @@ func (iuo *ItemUpdateOne) SetName(s string) *ItemUpdateOne {
return iuo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (iuo *ItemUpdateOne) SetNillableName(s *string) *ItemUpdateOne {
+ if s != nil {
+ iuo.SetName(*s)
+ }
+ return iuo
+}
+
// SetDescription sets the "description" field.
func (iuo *ItemUpdateOne) SetDescription(s string) *ItemUpdateOne {
iuo.mutation.SetDescription(s)
@@ -1311,6 +1283,26 @@ func (iuo *ItemUpdateOne) ClearDescription() *ItemUpdateOne {
return iuo
}
+// SetImportRef sets the "import_ref" field.
+func (iuo *ItemUpdateOne) SetImportRef(s string) *ItemUpdateOne {
+ iuo.mutation.SetImportRef(s)
+ return iuo
+}
+
+// SetNillableImportRef sets the "import_ref" field if the given value is not nil.
+func (iuo *ItemUpdateOne) SetNillableImportRef(s *string) *ItemUpdateOne {
+ if s != nil {
+ iuo.SetImportRef(*s)
+ }
+ return iuo
+}
+
+// ClearImportRef clears the value of the "import_ref" field.
+func (iuo *ItemUpdateOne) ClearImportRef() *ItemUpdateOne {
+ iuo.mutation.ClearImportRef()
+ return iuo
+}
+
// SetNotes sets the "notes" field.
func (iuo *ItemUpdateOne) SetNotes(s string) *ItemUpdateOne {
iuo.mutation.SetNotes(s)
@@ -1657,6 +1649,17 @@ func (iuo *ItemUpdateOne) ClearSoldNotes() *ItemUpdateOne {
return iuo
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (iuo *ItemUpdateOne) SetGroupID(id uuid.UUID) *ItemUpdateOne {
+ iuo.mutation.SetGroupID(id)
+ return iuo
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (iuo *ItemUpdateOne) SetGroup(g *Group) *ItemUpdateOne {
+ return iuo.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Item entity by ID.
func (iuo *ItemUpdateOne) SetParentID(id uuid.UUID) *ItemUpdateOne {
iuo.mutation.SetParentID(id)
@@ -1691,17 +1694,6 @@ func (iuo *ItemUpdateOne) AddChildren(i ...*Item) *ItemUpdateOne {
return iuo.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (iuo *ItemUpdateOne) SetGroupID(id uuid.UUID) *ItemUpdateOne {
- iuo.mutation.SetGroupID(id)
- return iuo
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (iuo *ItemUpdateOne) SetGroup(g *Group) *ItemUpdateOne {
- return iuo.SetGroupID(g.ID)
-}
-
// AddLabelIDs adds the "label" edge to the Label entity by IDs.
func (iuo *ItemUpdateOne) AddLabelIDs(ids ...uuid.UUID) *ItemUpdateOne {
iuo.mutation.AddLabelIDs(ids...)
@@ -1786,6 +1778,12 @@ func (iuo *ItemUpdateOne) Mutation() *ItemMutation {
return iuo.mutation
}
+// ClearGroup clears the "group" edge to the Group entity.
+func (iuo *ItemUpdateOne) ClearGroup() *ItemUpdateOne {
+ iuo.mutation.ClearGroup()
+ return iuo
+}
+
// ClearParent clears the "parent" edge to the Item entity.
func (iuo *ItemUpdateOne) ClearParent() *ItemUpdateOne {
iuo.mutation.ClearParent()
@@ -1813,12 +1811,6 @@ func (iuo *ItemUpdateOne) RemoveChildren(i ...*Item) *ItemUpdateOne {
return iuo.RemoveChildIDs(ids...)
}
-// ClearGroup clears the "group" edge to the Group entity.
-func (iuo *ItemUpdateOne) ClearGroup() *ItemUpdateOne {
- iuo.mutation.ClearGroup()
- return iuo
-}
-
// ClearLabel clears all "label" edges to the Label entity.
func (iuo *ItemUpdateOne) ClearLabel() *ItemUpdateOne {
iuo.mutation.ClearLabel()
@@ -1909,6 +1901,12 @@ func (iuo *ItemUpdateOne) RemoveAttachments(a ...*Attachment) *ItemUpdateOne {
return iuo.RemoveAttachmentIDs(ids...)
}
+// Where appends a list predicates to the ItemUpdate builder.
+func (iuo *ItemUpdateOne) Where(ps ...predicate.Item) *ItemUpdateOne {
+ iuo.mutation.Where(ps...)
+ return iuo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (iuo *ItemUpdateOne) Select(field string, fields ...string) *ItemUpdateOne {
@@ -1919,7 +1917,7 @@ func (iuo *ItemUpdateOne) Select(field string, fields ...string) *ItemUpdateOne
// Save executes the query and returns the updated Item entity.
func (iuo *ItemUpdateOne) Save(ctx context.Context) (*Item, error) {
iuo.defaults()
- return withHooks[*Item, ItemMutation](ctx, iuo.sqlSave, iuo.mutation, iuo.hooks)
+ return withHooks(ctx, iuo.sqlSave, iuo.mutation, iuo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -1964,6 +1962,11 @@ func (iuo *ItemUpdateOne) check() error {
return &ValidationError{Name: "description", err: fmt.Errorf(`ent: validator failed for field "Item.description": %w`, err)}
}
}
+ if v, ok := iuo.mutation.ImportRef(); ok {
+ if err := item.ImportRefValidator(v); err != nil {
+ return &ValidationError{Name: "import_ref", err: fmt.Errorf(`ent: validator failed for field "Item.import_ref": %w`, err)}
+ }
+ }
if v, ok := iuo.mutation.Notes(); ok {
if err := item.NotesValidator(v); err != nil {
return &ValidationError{Name: "notes", err: fmt.Errorf(`ent: validator failed for field "Item.notes": %w`, err)}
@@ -2004,16 +2007,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
if err := iuo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: item.Table,
- Columns: item.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(item.Table, item.Columns, sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID))
id, ok := iuo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Item.id" for update`)}
@@ -2050,6 +2044,9 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
if iuo.mutation.DescriptionCleared() {
_spec.ClearField(item.FieldDescription, field.TypeString)
}
+ if value, ok := iuo.mutation.ImportRef(); ok {
+ _spec.SetField(item.FieldImportRef, field.TypeString, value)
+ }
if iuo.mutation.ImportRefCleared() {
_spec.ClearField(item.FieldImportRef, field.TypeString)
}
@@ -2152,6 +2149,35 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
if iuo.mutation.SoldNotesCleared() {
_spec.ClearField(item.FieldSoldNotes, field.TypeString)
}
+ if iuo.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: item.GroupTable,
+ Columns: []string{item.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := iuo.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: item.GroupTable,
+ Columns: []string{item.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
if iuo.mutation.ParentCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -2160,10 +2186,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2176,10 +2199,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2195,10 +2215,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2211,10 +2228,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2230,45 +2244,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _spec.Edges.Add = append(_spec.Edges.Add, edge)
- }
- if iuo.mutation.GroupCleared() {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: item.GroupTable,
- Columns: []string{item.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
- }
- if nodes := iuo.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: item.GroupTable,
- Columns: []string{item.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2284,10 +2260,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2300,10 +2273,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2319,10 +2289,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: item.LabelPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2338,10 +2305,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.LocationColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2354,10 +2318,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.LocationColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2373,10 +2334,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2389,10 +2347,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2408,10 +2363,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.FieldsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2427,10 +2379,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2443,10 +2392,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2462,10 +2408,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.MaintenanceEntriesColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2481,10 +2424,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -2497,10 +2437,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -2516,10 +2453,7 @@ func (iuo *ItemUpdateOne) sqlSave(ctx context.Context) (_node *Item, err error)
Columns: []string{item.AttachmentsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: attachment.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(attachment.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/itemfield.go b/backend/internal/data/ent/itemfield.go
index be68023..b2b8b8d 100644
--- a/backend/internal/data/ent/itemfield.go
+++ b/backend/internal/data/ent/itemfield.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/item"
@@ -38,8 +39,9 @@ type ItemField struct {
TimeValue time.Time `json:"time_value,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the ItemFieldQuery when eager-loading is set.
- Edges ItemFieldEdges `json:"edges"`
- item_fields *uuid.UUID
+ Edges ItemFieldEdges `json:"edges"`
+ item_fields *uuid.UUID
+ selectValues sql.SelectValues
}
// ItemFieldEdges holds the relations/edges for other nodes in the graph.
@@ -82,7 +84,7 @@ func (*ItemField) scanValues(columns []string) ([]any, error) {
case itemfield.ForeignKeys[0]: // item_fields
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type ItemField", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -163,21 +165,29 @@ func (_if *ItemField) assignValues(columns []string, values []any) error {
_if.item_fields = new(uuid.UUID)
*_if.item_fields = *value.S.(*uuid.UUID)
}
+ default:
+ _if.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the ItemField.
+// This includes values selected through modifiers, order, etc.
+func (_if *ItemField) Value(name string) (ent.Value, error) {
+ return _if.selectValues.Get(name)
+}
+
// QueryItem queries the "item" edge of the ItemField entity.
func (_if *ItemField) QueryItem() *ItemQuery {
- return (&ItemFieldClient{config: _if.config}).QueryItem(_if)
+ return NewItemFieldClient(_if.config).QueryItem(_if)
}
// Update returns a builder for updating this ItemField.
// Note that you need to call ItemField.Unwrap() before calling this method if this ItemField
// was returned from a transaction, and the transaction was committed or rolled back.
func (_if *ItemField) Update() *ItemFieldUpdateOne {
- return (&ItemFieldClient{config: _if.config}).UpdateOne(_if)
+ return NewItemFieldClient(_if.config).UpdateOne(_if)
}
// Unwrap unwraps the ItemField entity that was returned from a transaction after it was closed,
@@ -228,9 +238,3 @@ func (_if *ItemField) String() string {
// ItemFields is a parsable slice of ItemField.
type ItemFields []*ItemField
-
-func (_if ItemFields) config(cfg config) {
- for _i := range _if {
- _if[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/itemfield/itemfield.go b/backend/internal/data/ent/itemfield/itemfield.go
index ccad0fe..dfbf378 100644
--- a/backend/internal/data/ent/itemfield/itemfield.go
+++ b/backend/internal/data/ent/itemfield/itemfield.go
@@ -6,6 +6,8 @@ import (
"fmt"
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -125,3 +127,70 @@ func TypeValidator(_type Type) error {
return fmt.Errorf("itemfield: invalid enum value for type field: %q", _type)
}
}
+
+// OrderOption defines the ordering options for the ItemField queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByTextValue orders the results by the text_value field.
+func ByTextValue(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldTextValue, opts...).ToFunc()
+}
+
+// ByNumberValue orders the results by the number_value field.
+func ByNumberValue(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldNumberValue, opts...).ToFunc()
+}
+
+// ByBooleanValue orders the results by the boolean_value field.
+func ByBooleanValue(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldBooleanValue, opts...).ToFunc()
+}
+
+// ByTimeValue orders the results by the time_value field.
+func ByTimeValue(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldTimeValue, opts...).ToFunc()
+}
+
+// ByItemField orders the results by item field.
+func ByItemField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newItemStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
+ )
+}
diff --git a/backend/internal/data/ent/itemfield/where.go b/backend/internal/data/ent/itemfield/where.go
index 94805ea..8a2d4aa 100644
--- a/backend/internal/data/ent/itemfield/where.go
+++ b/backend/internal/data/ent/itemfield/where.go
@@ -525,11 +525,7 @@ func HasItem() predicate.ItemField {
// HasItemWith applies the HasEdge predicate on the "item" edge with a given conditions (other predicates).
func HasItemWith(preds ...predicate.Item) predicate.ItemField {
return predicate.ItemField(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
- )
+ step := newItemStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -540,32 +536,15 @@ func HasItemWith(preds ...predicate.Item) predicate.ItemField {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.ItemField) predicate.ItemField {
- return predicate.ItemField(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.ItemField(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.ItemField) predicate.ItemField {
- return predicate.ItemField(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.ItemField(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.ItemField) predicate.ItemField {
- return predicate.ItemField(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.ItemField(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/itemfield_create.go b/backend/internal/data/ent/itemfield_create.go
index 32c5578..65a22fb 100644
--- a/backend/internal/data/ent/itemfield_create.go
+++ b/backend/internal/data/ent/itemfield_create.go
@@ -173,7 +173,7 @@ func (ifc *ItemFieldCreate) Mutation() *ItemFieldMutation {
// Save creates the ItemField in the database.
func (ifc *ItemFieldCreate) Save(ctx context.Context) (*ItemField, error) {
ifc.defaults()
- return withHooks[*ItemField, ItemFieldMutation](ctx, ifc.sqlSave, ifc.mutation, ifc.hooks)
+ return withHooks(ctx, ifc.sqlSave, ifc.mutation, ifc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -291,13 +291,7 @@ func (ifc *ItemFieldCreate) sqlSave(ctx context.Context) (*ItemField, error) {
func (ifc *ItemFieldCreate) createSpec() (*ItemField, *sqlgraph.CreateSpec) {
var (
_node = &ItemField{config: ifc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: itemfield.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(itemfield.Table, sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID))
)
if id, ok := ifc.mutation.ID(); ok {
_node.ID = id
@@ -347,10 +341,7 @@ func (ifc *ItemFieldCreate) createSpec() (*ItemField, *sqlgraph.CreateSpec) {
Columns: []string{itemfield.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -365,11 +356,15 @@ func (ifc *ItemFieldCreate) createSpec() (*ItemField, *sqlgraph.CreateSpec) {
// ItemFieldCreateBulk is the builder for creating many ItemField entities in bulk.
type ItemFieldCreateBulk struct {
config
+ err error
builders []*ItemFieldCreate
}
// Save creates the ItemField entities in the database.
func (ifcb *ItemFieldCreateBulk) Save(ctx context.Context) ([]*ItemField, error) {
+ if ifcb.err != nil {
+ return nil, ifcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(ifcb.builders))
nodes := make([]*ItemField, len(ifcb.builders))
mutators := make([]Mutator, len(ifcb.builders))
@@ -386,8 +381,8 @@ func (ifcb *ItemFieldCreateBulk) Save(ctx context.Context) ([]*ItemField, error)
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, ifcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/itemfield_delete.go b/backend/internal/data/ent/itemfield_delete.go
index aaca25a..ba85cbc 100644
--- a/backend/internal/data/ent/itemfield_delete.go
+++ b/backend/internal/data/ent/itemfield_delete.go
@@ -27,7 +27,7 @@ func (ifd *ItemFieldDelete) Where(ps ...predicate.ItemField) *ItemFieldDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (ifd *ItemFieldDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, ItemFieldMutation](ctx, ifd.sqlExec, ifd.mutation, ifd.hooks)
+ return withHooks(ctx, ifd.sqlExec, ifd.mutation, ifd.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (ifd *ItemFieldDelete) ExecX(ctx context.Context) int {
}
func (ifd *ItemFieldDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: itemfield.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(itemfield.Table, sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID))
if ps := ifd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type ItemFieldDeleteOne struct {
ifd *ItemFieldDelete
}
+// Where appends a list predicates to the ItemFieldDelete builder.
+func (ifdo *ItemFieldDeleteOne) Where(ps ...predicate.ItemField) *ItemFieldDeleteOne {
+ ifdo.ifd.mutation.Where(ps...)
+ return ifdo
+}
+
// Exec executes the deletion query.
func (ifdo *ItemFieldDeleteOne) Exec(ctx context.Context) error {
n, err := ifdo.ifd.Exec(ctx)
@@ -84,5 +82,7 @@ func (ifdo *ItemFieldDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ifdo *ItemFieldDeleteOne) ExecX(ctx context.Context) {
- ifdo.ifd.ExecX(ctx)
+ if err := ifdo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/itemfield_query.go b/backend/internal/data/ent/itemfield_query.go
index 4629dd2..21bffb8 100644
--- a/backend/internal/data/ent/itemfield_query.go
+++ b/backend/internal/data/ent/itemfield_query.go
@@ -19,11 +19,8 @@ import (
// ItemFieldQuery is the builder for querying ItemField entities.
type ItemFieldQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []itemfield.OrderOption
inters []Interceptor
predicates []predicate.ItemField
withItem *ItemQuery
@@ -41,25 +38,25 @@ func (ifq *ItemFieldQuery) Where(ps ...predicate.ItemField) *ItemFieldQuery {
// Limit the number of records to be returned by this query.
func (ifq *ItemFieldQuery) Limit(limit int) *ItemFieldQuery {
- ifq.limit = &limit
+ ifq.ctx.Limit = &limit
return ifq
}
// Offset to start from.
func (ifq *ItemFieldQuery) Offset(offset int) *ItemFieldQuery {
- ifq.offset = &offset
+ ifq.ctx.Offset = &offset
return ifq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (ifq *ItemFieldQuery) Unique(unique bool) *ItemFieldQuery {
- ifq.unique = &unique
+ ifq.ctx.Unique = &unique
return ifq
}
// Order specifies how the records should be ordered.
-func (ifq *ItemFieldQuery) Order(o ...OrderFunc) *ItemFieldQuery {
+func (ifq *ItemFieldQuery) Order(o ...itemfield.OrderOption) *ItemFieldQuery {
ifq.order = append(ifq.order, o...)
return ifq
}
@@ -89,7 +86,7 @@ func (ifq *ItemFieldQuery) QueryItem() *ItemQuery {
// First returns the first ItemField entity from the query.
// Returns a *NotFoundError when no ItemField was found.
func (ifq *ItemFieldQuery) First(ctx context.Context) (*ItemField, error) {
- nodes, err := ifq.Limit(1).All(newQueryContext(ctx, TypeItemField, "First"))
+ nodes, err := ifq.Limit(1).All(setContextOp(ctx, ifq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -112,7 +109,7 @@ func (ifq *ItemFieldQuery) FirstX(ctx context.Context) *ItemField {
// Returns a *NotFoundError when no ItemField ID was found.
func (ifq *ItemFieldQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = ifq.Limit(1).IDs(newQueryContext(ctx, TypeItemField, "FirstID")); err != nil {
+ if ids, err = ifq.Limit(1).IDs(setContextOp(ctx, ifq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -135,7 +132,7 @@ func (ifq *ItemFieldQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one ItemField entity is found.
// Returns a *NotFoundError when no ItemField entities are found.
func (ifq *ItemFieldQuery) Only(ctx context.Context) (*ItemField, error) {
- nodes, err := ifq.Limit(2).All(newQueryContext(ctx, TypeItemField, "Only"))
+ nodes, err := ifq.Limit(2).All(setContextOp(ctx, ifq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -163,7 +160,7 @@ func (ifq *ItemFieldQuery) OnlyX(ctx context.Context) *ItemField {
// Returns a *NotFoundError when no entities are found.
func (ifq *ItemFieldQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = ifq.Limit(2).IDs(newQueryContext(ctx, TypeItemField, "OnlyID")); err != nil {
+ if ids, err = ifq.Limit(2).IDs(setContextOp(ctx, ifq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -188,7 +185,7 @@ func (ifq *ItemFieldQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of ItemFields.
func (ifq *ItemFieldQuery) All(ctx context.Context) ([]*ItemField, error) {
- ctx = newQueryContext(ctx, TypeItemField, "All")
+ ctx = setContextOp(ctx, ifq.ctx, "All")
if err := ifq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -206,10 +203,12 @@ func (ifq *ItemFieldQuery) AllX(ctx context.Context) []*ItemField {
}
// IDs executes the query and returns a list of ItemField IDs.
-func (ifq *ItemFieldQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeItemField, "IDs")
- if err := ifq.Select(itemfield.FieldID).Scan(ctx, &ids); err != nil {
+func (ifq *ItemFieldQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if ifq.ctx.Unique == nil && ifq.path != nil {
+ ifq.Unique(true)
+ }
+ ctx = setContextOp(ctx, ifq.ctx, "IDs")
+ if err = ifq.Select(itemfield.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -226,7 +225,7 @@ func (ifq *ItemFieldQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (ifq *ItemFieldQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeItemField, "Count")
+ ctx = setContextOp(ctx, ifq.ctx, "Count")
if err := ifq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -244,7 +243,7 @@ func (ifq *ItemFieldQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (ifq *ItemFieldQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeItemField, "Exist")
+ ctx = setContextOp(ctx, ifq.ctx, "Exist")
switch _, err := ifq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -272,16 +271,14 @@ func (ifq *ItemFieldQuery) Clone() *ItemFieldQuery {
}
return &ItemFieldQuery{
config: ifq.config,
- limit: ifq.limit,
- offset: ifq.offset,
- order: append([]OrderFunc{}, ifq.order...),
+ ctx: ifq.ctx.Clone(),
+ order: append([]itemfield.OrderOption{}, ifq.order...),
inters: append([]Interceptor{}, ifq.inters...),
predicates: append([]predicate.ItemField{}, ifq.predicates...),
withItem: ifq.withItem.Clone(),
// clone intermediate query.
- sql: ifq.sql.Clone(),
- path: ifq.path,
- unique: ifq.unique,
+ sql: ifq.sql.Clone(),
+ path: ifq.path,
}
}
@@ -311,9 +308,9 @@ func (ifq *ItemFieldQuery) WithItem(opts ...func(*ItemQuery)) *ItemFieldQuery {
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (ifq *ItemFieldQuery) GroupBy(field string, fields ...string) *ItemFieldGroupBy {
- ifq.fields = append([]string{field}, fields...)
+ ifq.ctx.Fields = append([]string{field}, fields...)
grbuild := &ItemFieldGroupBy{build: ifq}
- grbuild.flds = &ifq.fields
+ grbuild.flds = &ifq.ctx.Fields
grbuild.label = itemfield.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -332,10 +329,10 @@ func (ifq *ItemFieldQuery) GroupBy(field string, fields ...string) *ItemFieldGro
// Select(itemfield.FieldCreatedAt).
// Scan(ctx, &v)
func (ifq *ItemFieldQuery) Select(fields ...string) *ItemFieldSelect {
- ifq.fields = append(ifq.fields, fields...)
+ ifq.ctx.Fields = append(ifq.ctx.Fields, fields...)
sbuild := &ItemFieldSelect{ItemFieldQuery: ifq}
sbuild.label = itemfield.Label
- sbuild.flds, sbuild.scan = &ifq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &ifq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -355,7 +352,7 @@ func (ifq *ItemFieldQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range ifq.fields {
+ for _, f := range ifq.ctx.Fields {
if !itemfield.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -425,6 +422,9 @@ func (ifq *ItemFieldQuery) loadItem(ctx context.Context, query *ItemQuery, nodes
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(item.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -444,30 +444,22 @@ func (ifq *ItemFieldQuery) loadItem(ctx context.Context, query *ItemQuery, nodes
func (ifq *ItemFieldQuery) sqlCount(ctx context.Context) (int, error) {
_spec := ifq.querySpec()
- _spec.Node.Columns = ifq.fields
- if len(ifq.fields) > 0 {
- _spec.Unique = ifq.unique != nil && *ifq.unique
+ _spec.Node.Columns = ifq.ctx.Fields
+ if len(ifq.ctx.Fields) > 0 {
+ _spec.Unique = ifq.ctx.Unique != nil && *ifq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, ifq.driver, _spec)
}
func (ifq *ItemFieldQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: itemfield.Table,
- Columns: itemfield.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
- },
- From: ifq.sql,
- Unique: true,
- }
- if unique := ifq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(itemfield.Table, itemfield.Columns, sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID))
+ _spec.From = ifq.sql
+ if unique := ifq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if ifq.path != nil {
+ _spec.Unique = true
}
- if fields := ifq.fields; len(fields) > 0 {
+ if fields := ifq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, itemfield.FieldID)
for i := range fields {
@@ -483,10 +475,10 @@ func (ifq *ItemFieldQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := ifq.limit; limit != nil {
+ if limit := ifq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := ifq.offset; offset != nil {
+ if offset := ifq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := ifq.order; len(ps) > 0 {
@@ -502,7 +494,7 @@ func (ifq *ItemFieldQuery) querySpec() *sqlgraph.QuerySpec {
func (ifq *ItemFieldQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(ifq.driver.Dialect())
t1 := builder.Table(itemfield.Table)
- columns := ifq.fields
+ columns := ifq.ctx.Fields
if len(columns) == 0 {
columns = itemfield.Columns
}
@@ -511,7 +503,7 @@ func (ifq *ItemFieldQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = ifq.sql
selector.Select(selector.Columns(columns...)...)
}
- if ifq.unique != nil && *ifq.unique {
+ if ifq.ctx.Unique != nil && *ifq.ctx.Unique {
selector.Distinct()
}
for _, p := range ifq.predicates {
@@ -520,12 +512,12 @@ func (ifq *ItemFieldQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range ifq.order {
p(selector)
}
- if offset := ifq.offset; offset != nil {
+ if offset := ifq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := ifq.limit; limit != nil {
+ if limit := ifq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -545,7 +537,7 @@ func (ifgb *ItemFieldGroupBy) Aggregate(fns ...AggregateFunc) *ItemFieldGroupBy
// Scan applies the selector query and scans the result into the given value.
func (ifgb *ItemFieldGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeItemField, "GroupBy")
+ ctx = setContextOp(ctx, ifgb.build.ctx, "GroupBy")
if err := ifgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -593,7 +585,7 @@ func (ifs *ItemFieldSelect) Aggregate(fns ...AggregateFunc) *ItemFieldSelect {
// Scan applies the selector query and scans the result into the given value.
func (ifs *ItemFieldSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeItemField, "Select")
+ ctx = setContextOp(ctx, ifs.ctx, "Select")
if err := ifs.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/itemfield_update.go b/backend/internal/data/ent/itemfield_update.go
index ec93a55..3f44dc1 100644
--- a/backend/internal/data/ent/itemfield_update.go
+++ b/backend/internal/data/ent/itemfield_update.go
@@ -42,6 +42,14 @@ func (ifu *ItemFieldUpdate) SetName(s string) *ItemFieldUpdate {
return ifu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (ifu *ItemFieldUpdate) SetNillableName(s *string) *ItemFieldUpdate {
+ if s != nil {
+ ifu.SetName(*s)
+ }
+ return ifu
+}
+
// SetDescription sets the "description" field.
func (ifu *ItemFieldUpdate) SetDescription(s string) *ItemFieldUpdate {
ifu.mutation.SetDescription(s)
@@ -68,6 +76,14 @@ func (ifu *ItemFieldUpdate) SetType(i itemfield.Type) *ItemFieldUpdate {
return ifu
}
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ifu *ItemFieldUpdate) SetNillableType(i *itemfield.Type) *ItemFieldUpdate {
+ if i != nil {
+ ifu.SetType(*i)
+ }
+ return ifu
+}
+
// SetTextValue sets the "text_value" field.
func (ifu *ItemFieldUpdate) SetTextValue(s string) *ItemFieldUpdate {
ifu.mutation.SetTextValue(s)
@@ -176,7 +192,7 @@ func (ifu *ItemFieldUpdate) ClearItem() *ItemFieldUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (ifu *ItemFieldUpdate) Save(ctx context.Context) (int, error) {
ifu.defaults()
- return withHooks[int, ItemFieldMutation](ctx, ifu.sqlSave, ifu.mutation, ifu.hooks)
+ return withHooks(ctx, ifu.sqlSave, ifu.mutation, ifu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -238,16 +254,7 @@ func (ifu *ItemFieldUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := ifu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: itemfield.Table,
- Columns: itemfield.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(itemfield.Table, itemfield.Columns, sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID))
if ps := ifu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -299,10 +306,7 @@ func (ifu *ItemFieldUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{itemfield.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -315,10 +319,7 @@ func (ifu *ItemFieldUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{itemfield.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -358,6 +359,14 @@ func (ifuo *ItemFieldUpdateOne) SetName(s string) *ItemFieldUpdateOne {
return ifuo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (ifuo *ItemFieldUpdateOne) SetNillableName(s *string) *ItemFieldUpdateOne {
+ if s != nil {
+ ifuo.SetName(*s)
+ }
+ return ifuo
+}
+
// SetDescription sets the "description" field.
func (ifuo *ItemFieldUpdateOne) SetDescription(s string) *ItemFieldUpdateOne {
ifuo.mutation.SetDescription(s)
@@ -384,6 +393,14 @@ func (ifuo *ItemFieldUpdateOne) SetType(i itemfield.Type) *ItemFieldUpdateOne {
return ifuo
}
+// SetNillableType sets the "type" field if the given value is not nil.
+func (ifuo *ItemFieldUpdateOne) SetNillableType(i *itemfield.Type) *ItemFieldUpdateOne {
+ if i != nil {
+ ifuo.SetType(*i)
+ }
+ return ifuo
+}
+
// SetTextValue sets the "text_value" field.
func (ifuo *ItemFieldUpdateOne) SetTextValue(s string) *ItemFieldUpdateOne {
ifuo.mutation.SetTextValue(s)
@@ -489,6 +506,12 @@ func (ifuo *ItemFieldUpdateOne) ClearItem() *ItemFieldUpdateOne {
return ifuo
}
+// Where appends a list predicates to the ItemFieldUpdate builder.
+func (ifuo *ItemFieldUpdateOne) Where(ps ...predicate.ItemField) *ItemFieldUpdateOne {
+ ifuo.mutation.Where(ps...)
+ return ifuo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (ifuo *ItemFieldUpdateOne) Select(field string, fields ...string) *ItemFieldUpdateOne {
@@ -499,7 +522,7 @@ func (ifuo *ItemFieldUpdateOne) Select(field string, fields ...string) *ItemFiel
// Save executes the query and returns the updated ItemField entity.
func (ifuo *ItemFieldUpdateOne) Save(ctx context.Context) (*ItemField, error) {
ifuo.defaults()
- return withHooks[*ItemField, ItemFieldMutation](ctx, ifuo.sqlSave, ifuo.mutation, ifuo.hooks)
+ return withHooks(ctx, ifuo.sqlSave, ifuo.mutation, ifuo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -561,16 +584,7 @@ func (ifuo *ItemFieldUpdateOne) sqlSave(ctx context.Context) (_node *ItemField,
if err := ifuo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: itemfield.Table,
- Columns: itemfield.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: itemfield.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(itemfield.Table, itemfield.Columns, sqlgraph.NewFieldSpec(itemfield.FieldID, field.TypeUUID))
id, ok := ifuo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "ItemField.id" for update`)}
@@ -639,10 +653,7 @@ func (ifuo *ItemFieldUpdateOne) sqlSave(ctx context.Context) (_node *ItemField,
Columns: []string{itemfield.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -655,10 +666,7 @@ func (ifuo *ItemFieldUpdateOne) sqlSave(ctx context.Context) (_node *ItemField,
Columns: []string{itemfield.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/label.go b/backend/internal/data/ent/label.go
index 9e65bfe..fdd6f8d 100644
--- a/backend/internal/data/ent/label.go
+++ b/backend/internal/data/ent/label.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/group"
@@ -32,6 +33,7 @@ type Label struct {
// The values are being populated by the LabelQuery when eager-loading is set.
Edges LabelEdges `json:"edges"`
group_labels *uuid.UUID
+ selectValues sql.SelectValues
}
// LabelEdges holds the relations/edges for other nodes in the graph.
@@ -81,7 +83,7 @@ func (*Label) scanValues(columns []string) ([]any, error) {
case label.ForeignKeys[0]: // group_labels
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type Label", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -138,26 +140,34 @@ func (l *Label) assignValues(columns []string, values []any) error {
l.group_labels = new(uuid.UUID)
*l.group_labels = *value.S.(*uuid.UUID)
}
+ default:
+ l.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the Label.
+// This includes values selected through modifiers, order, etc.
+func (l *Label) Value(name string) (ent.Value, error) {
+ return l.selectValues.Get(name)
+}
+
// QueryGroup queries the "group" edge of the Label entity.
func (l *Label) QueryGroup() *GroupQuery {
- return (&LabelClient{config: l.config}).QueryGroup(l)
+ return NewLabelClient(l.config).QueryGroup(l)
}
// QueryItems queries the "items" edge of the Label entity.
func (l *Label) QueryItems() *ItemQuery {
- return (&LabelClient{config: l.config}).QueryItems(l)
+ return NewLabelClient(l.config).QueryItems(l)
}
// Update returns a builder for updating this Label.
// Note that you need to call Label.Unwrap() before calling this method if this Label
// was returned from a transaction, and the transaction was committed or rolled back.
func (l *Label) Update() *LabelUpdateOne {
- return (&LabelClient{config: l.config}).UpdateOne(l)
+ return NewLabelClient(l.config).UpdateOne(l)
}
// Unwrap unwraps the Label entity that was returned from a transaction after it was closed,
@@ -196,9 +206,3 @@ func (l *Label) String() string {
// Labels is a parsable slice of Label.
type Labels []*Label
-
-func (l Labels) config(cfg config) {
- for _i := range l {
- l[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/label/label.go b/backend/internal/data/ent/label/label.go
index 82bcdbd..df34c87 100644
--- a/backend/internal/data/ent/label/label.go
+++ b/backend/internal/data/ent/label/label.go
@@ -5,6 +5,8 @@ package label
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -96,3 +98,71 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the Label queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByColor orders the results by the color field.
+func ByColor(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldColor, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByItemsCount orders the results by items count.
+func ByItemsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newItemsStep(), opts...)
+ }
+}
+
+// ByItems orders the results by items terms.
+func ByItems(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+}
+func newItemsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, ItemsTable, ItemsPrimaryKey...),
+ )
+}
diff --git a/backend/internal/data/ent/label/where.go b/backend/internal/data/ent/label/where.go
index fd321e1..3754ac7 100644
--- a/backend/internal/data/ent/label/where.go
+++ b/backend/internal/data/ent/label/where.go
@@ -390,11 +390,7 @@ func HasGroup() predicate.Label {
// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
func HasGroupWith(preds ...predicate.Group) predicate.Label {
return predicate.Label(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(GroupInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
+ step := newGroupStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -417,11 +413,7 @@ func HasItems() predicate.Label {
// HasItemsWith applies the HasEdge predicate on the "items" edge with a given conditions (other predicates).
func HasItemsWith(preds ...predicate.Item) predicate.Label {
return predicate.Label(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2M, false, ItemsTable, ItemsPrimaryKey...),
- )
+ step := newItemsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -432,32 +424,15 @@ func HasItemsWith(preds ...predicate.Item) predicate.Label {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Label) predicate.Label {
- return predicate.Label(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Label(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Label) predicate.Label {
- return predicate.Label(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Label(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Label) predicate.Label {
- return predicate.Label(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Label(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/label_create.go b/backend/internal/data/ent/label_create.go
index a9d8649..0ad6469 100644
--- a/backend/internal/data/ent/label_create.go
+++ b/backend/internal/data/ent/label_create.go
@@ -133,7 +133,7 @@ func (lc *LabelCreate) Mutation() *LabelMutation {
// Save creates the Label in the database.
func (lc *LabelCreate) Save(ctx context.Context) (*Label, error) {
lc.defaults()
- return withHooks[*Label, LabelMutation](ctx, lc.sqlSave, lc.mutation, lc.hooks)
+ return withHooks(ctx, lc.sqlSave, lc.mutation, lc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -232,13 +232,7 @@ func (lc *LabelCreate) sqlSave(ctx context.Context) (*Label, error) {
func (lc *LabelCreate) createSpec() (*Label, *sqlgraph.CreateSpec) {
var (
_node = &Label{config: lc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: label.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(label.Table, sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID))
)
if id, ok := lc.mutation.ID(); ok {
_node.ID = id
@@ -272,10 +266,7 @@ func (lc *LabelCreate) createSpec() (*Label, *sqlgraph.CreateSpec) {
Columns: []string{label.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -292,10 +283,7 @@ func (lc *LabelCreate) createSpec() (*Label, *sqlgraph.CreateSpec) {
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -309,11 +297,15 @@ func (lc *LabelCreate) createSpec() (*Label, *sqlgraph.CreateSpec) {
// LabelCreateBulk is the builder for creating many Label entities in bulk.
type LabelCreateBulk struct {
config
+ err error
builders []*LabelCreate
}
// Save creates the Label entities in the database.
func (lcb *LabelCreateBulk) Save(ctx context.Context) ([]*Label, error) {
+ if lcb.err != nil {
+ return nil, lcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(lcb.builders))
nodes := make([]*Label, len(lcb.builders))
mutators := make([]Mutator, len(lcb.builders))
@@ -330,8 +322,8 @@ func (lcb *LabelCreateBulk) Save(ctx context.Context) ([]*Label, error) {
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, lcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/label_delete.go b/backend/internal/data/ent/label_delete.go
index 1c520df..f3b514a 100644
--- a/backend/internal/data/ent/label_delete.go
+++ b/backend/internal/data/ent/label_delete.go
@@ -27,7 +27,7 @@ func (ld *LabelDelete) Where(ps ...predicate.Label) *LabelDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (ld *LabelDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, LabelMutation](ctx, ld.sqlExec, ld.mutation, ld.hooks)
+ return withHooks(ctx, ld.sqlExec, ld.mutation, ld.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (ld *LabelDelete) ExecX(ctx context.Context) int {
}
func (ld *LabelDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: label.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(label.Table, sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID))
if ps := ld.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type LabelDeleteOne struct {
ld *LabelDelete
}
+// Where appends a list predicates to the LabelDelete builder.
+func (ldo *LabelDeleteOne) Where(ps ...predicate.Label) *LabelDeleteOne {
+ ldo.ld.mutation.Where(ps...)
+ return ldo
+}
+
// Exec executes the deletion query.
func (ldo *LabelDeleteOne) Exec(ctx context.Context) error {
n, err := ldo.ld.Exec(ctx)
@@ -84,5 +82,7 @@ func (ldo *LabelDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ldo *LabelDeleteOne) ExecX(ctx context.Context) {
- ldo.ld.ExecX(ctx)
+ if err := ldo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/label_query.go b/backend/internal/data/ent/label_query.go
index 16de809..e3bb6d1 100644
--- a/backend/internal/data/ent/label_query.go
+++ b/backend/internal/data/ent/label_query.go
@@ -21,11 +21,8 @@ import (
// LabelQuery is the builder for querying Label entities.
type LabelQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []label.OrderOption
inters []Interceptor
predicates []predicate.Label
withGroup *GroupQuery
@@ -44,25 +41,25 @@ func (lq *LabelQuery) Where(ps ...predicate.Label) *LabelQuery {
// Limit the number of records to be returned by this query.
func (lq *LabelQuery) Limit(limit int) *LabelQuery {
- lq.limit = &limit
+ lq.ctx.Limit = &limit
return lq
}
// Offset to start from.
func (lq *LabelQuery) Offset(offset int) *LabelQuery {
- lq.offset = &offset
+ lq.ctx.Offset = &offset
return lq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (lq *LabelQuery) Unique(unique bool) *LabelQuery {
- lq.unique = &unique
+ lq.ctx.Unique = &unique
return lq
}
// Order specifies how the records should be ordered.
-func (lq *LabelQuery) Order(o ...OrderFunc) *LabelQuery {
+func (lq *LabelQuery) Order(o ...label.OrderOption) *LabelQuery {
lq.order = append(lq.order, o...)
return lq
}
@@ -114,7 +111,7 @@ func (lq *LabelQuery) QueryItems() *ItemQuery {
// First returns the first Label entity from the query.
// Returns a *NotFoundError when no Label was found.
func (lq *LabelQuery) First(ctx context.Context) (*Label, error) {
- nodes, err := lq.Limit(1).All(newQueryContext(ctx, TypeLabel, "First"))
+ nodes, err := lq.Limit(1).All(setContextOp(ctx, lq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -137,7 +134,7 @@ func (lq *LabelQuery) FirstX(ctx context.Context) *Label {
// Returns a *NotFoundError when no Label ID was found.
func (lq *LabelQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = lq.Limit(1).IDs(newQueryContext(ctx, TypeLabel, "FirstID")); err != nil {
+ if ids, err = lq.Limit(1).IDs(setContextOp(ctx, lq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -160,7 +157,7 @@ func (lq *LabelQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Label entity is found.
// Returns a *NotFoundError when no Label entities are found.
func (lq *LabelQuery) Only(ctx context.Context) (*Label, error) {
- nodes, err := lq.Limit(2).All(newQueryContext(ctx, TypeLabel, "Only"))
+ nodes, err := lq.Limit(2).All(setContextOp(ctx, lq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -188,7 +185,7 @@ func (lq *LabelQuery) OnlyX(ctx context.Context) *Label {
// Returns a *NotFoundError when no entities are found.
func (lq *LabelQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = lq.Limit(2).IDs(newQueryContext(ctx, TypeLabel, "OnlyID")); err != nil {
+ if ids, err = lq.Limit(2).IDs(setContextOp(ctx, lq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -213,7 +210,7 @@ func (lq *LabelQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Labels.
func (lq *LabelQuery) All(ctx context.Context) ([]*Label, error) {
- ctx = newQueryContext(ctx, TypeLabel, "All")
+ ctx = setContextOp(ctx, lq.ctx, "All")
if err := lq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -231,10 +228,12 @@ func (lq *LabelQuery) AllX(ctx context.Context) []*Label {
}
// IDs executes the query and returns a list of Label IDs.
-func (lq *LabelQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeLabel, "IDs")
- if err := lq.Select(label.FieldID).Scan(ctx, &ids); err != nil {
+func (lq *LabelQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if lq.ctx.Unique == nil && lq.path != nil {
+ lq.Unique(true)
+ }
+ ctx = setContextOp(ctx, lq.ctx, "IDs")
+ if err = lq.Select(label.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -251,7 +250,7 @@ func (lq *LabelQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (lq *LabelQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeLabel, "Count")
+ ctx = setContextOp(ctx, lq.ctx, "Count")
if err := lq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -269,7 +268,7 @@ func (lq *LabelQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (lq *LabelQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeLabel, "Exist")
+ ctx = setContextOp(ctx, lq.ctx, "Exist")
switch _, err := lq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -297,17 +296,15 @@ func (lq *LabelQuery) Clone() *LabelQuery {
}
return &LabelQuery{
config: lq.config,
- limit: lq.limit,
- offset: lq.offset,
- order: append([]OrderFunc{}, lq.order...),
+ ctx: lq.ctx.Clone(),
+ order: append([]label.OrderOption{}, lq.order...),
inters: append([]Interceptor{}, lq.inters...),
predicates: append([]predicate.Label{}, lq.predicates...),
withGroup: lq.withGroup.Clone(),
withItems: lq.withItems.Clone(),
// clone intermediate query.
- sql: lq.sql.Clone(),
- path: lq.path,
- unique: lq.unique,
+ sql: lq.sql.Clone(),
+ path: lq.path,
}
}
@@ -348,9 +345,9 @@ func (lq *LabelQuery) WithItems(opts ...func(*ItemQuery)) *LabelQuery {
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (lq *LabelQuery) GroupBy(field string, fields ...string) *LabelGroupBy {
- lq.fields = append([]string{field}, fields...)
+ lq.ctx.Fields = append([]string{field}, fields...)
grbuild := &LabelGroupBy{build: lq}
- grbuild.flds = &lq.fields
+ grbuild.flds = &lq.ctx.Fields
grbuild.label = label.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -369,10 +366,10 @@ func (lq *LabelQuery) GroupBy(field string, fields ...string) *LabelGroupBy {
// Select(label.FieldCreatedAt).
// Scan(ctx, &v)
func (lq *LabelQuery) Select(fields ...string) *LabelSelect {
- lq.fields = append(lq.fields, fields...)
+ lq.ctx.Fields = append(lq.ctx.Fields, fields...)
sbuild := &LabelSelect{LabelQuery: lq}
sbuild.label = label.Label
- sbuild.flds, sbuild.scan = &lq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &lq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -392,7 +389,7 @@ func (lq *LabelQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range lq.fields {
+ for _, f := range lq.ctx.Fields {
if !label.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -470,6 +467,9 @@ func (lq *LabelQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(group.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -509,27 +509,30 @@ func (lq *LabelQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*
if err := query.prepareQuery(ctx); err != nil {
return err
}
- neighbors, err := query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
- assign := spec.Assign
- values := spec.ScanValues
- spec.ScanValues = func(columns []string) ([]any, error) {
- values, err := values(columns[1:])
- if err != nil {
- return nil, err
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
}
- return append([]any{new(uuid.UUID)}, values...), nil
- }
- spec.Assign = func(columns []string, values []any) error {
- outValue := *values[0].(*uuid.UUID)
- inValue := *values[1].(*uuid.UUID)
- if nids[inValue] == nil {
- nids[inValue] = map[*Label]struct{}{byID[outValue]: {}}
- return assign(columns[1:], values[1:])
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*Label]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
}
- nids[inValue][byID[outValue]] = struct{}{}
- return nil
- }
+ })
})
+ neighbors, err := withInterceptors[[]*Item](ctx, query, qr, query.inters)
if err != nil {
return err
}
@@ -547,30 +550,22 @@ func (lq *LabelQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*
func (lq *LabelQuery) sqlCount(ctx context.Context) (int, error) {
_spec := lq.querySpec()
- _spec.Node.Columns = lq.fields
- if len(lq.fields) > 0 {
- _spec.Unique = lq.unique != nil && *lq.unique
+ _spec.Node.Columns = lq.ctx.Fields
+ if len(lq.ctx.Fields) > 0 {
+ _spec.Unique = lq.ctx.Unique != nil && *lq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, lq.driver, _spec)
}
func (lq *LabelQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: label.Table,
- Columns: label.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
- },
- From: lq.sql,
- Unique: true,
- }
- if unique := lq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(label.Table, label.Columns, sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID))
+ _spec.From = lq.sql
+ if unique := lq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if lq.path != nil {
+ _spec.Unique = true
}
- if fields := lq.fields; len(fields) > 0 {
+ if fields := lq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, label.FieldID)
for i := range fields {
@@ -586,10 +581,10 @@ func (lq *LabelQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := lq.limit; limit != nil {
+ if limit := lq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := lq.offset; offset != nil {
+ if offset := lq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := lq.order; len(ps) > 0 {
@@ -605,7 +600,7 @@ func (lq *LabelQuery) querySpec() *sqlgraph.QuerySpec {
func (lq *LabelQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(lq.driver.Dialect())
t1 := builder.Table(label.Table)
- columns := lq.fields
+ columns := lq.ctx.Fields
if len(columns) == 0 {
columns = label.Columns
}
@@ -614,7 +609,7 @@ func (lq *LabelQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = lq.sql
selector.Select(selector.Columns(columns...)...)
}
- if lq.unique != nil && *lq.unique {
+ if lq.ctx.Unique != nil && *lq.ctx.Unique {
selector.Distinct()
}
for _, p := range lq.predicates {
@@ -623,12 +618,12 @@ func (lq *LabelQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range lq.order {
p(selector)
}
- if offset := lq.offset; offset != nil {
+ if offset := lq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := lq.limit; limit != nil {
+ if limit := lq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -648,7 +643,7 @@ func (lgb *LabelGroupBy) Aggregate(fns ...AggregateFunc) *LabelGroupBy {
// Scan applies the selector query and scans the result into the given value.
func (lgb *LabelGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeLabel, "GroupBy")
+ ctx = setContextOp(ctx, lgb.build.ctx, "GroupBy")
if err := lgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -696,7 +691,7 @@ func (ls *LabelSelect) Aggregate(fns ...AggregateFunc) *LabelSelect {
// Scan applies the selector query and scans the result into the given value.
func (ls *LabelSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeLabel, "Select")
+ ctx = setContextOp(ctx, ls.ctx, "Select")
if err := ls.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/label_update.go b/backend/internal/data/ent/label_update.go
index 5b40eb2..0862d22 100644
--- a/backend/internal/data/ent/label_update.go
+++ b/backend/internal/data/ent/label_update.go
@@ -43,6 +43,14 @@ func (lu *LabelUpdate) SetName(s string) *LabelUpdate {
return lu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (lu *LabelUpdate) SetNillableName(s *string) *LabelUpdate {
+ if s != nil {
+ lu.SetName(*s)
+ }
+ return lu
+}
+
// SetDescription sets the "description" field.
func (lu *LabelUpdate) SetDescription(s string) *LabelUpdate {
lu.mutation.SetDescription(s)
@@ -144,7 +152,7 @@ func (lu *LabelUpdate) RemoveItems(i ...*Item) *LabelUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (lu *LabelUpdate) Save(ctx context.Context) (int, error) {
lu.defaults()
- return withHooks[int, LabelMutation](ctx, lu.sqlSave, lu.mutation, lu.hooks)
+ return withHooks(ctx, lu.sqlSave, lu.mutation, lu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -204,16 +212,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := lu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: label.Table,
- Columns: label.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(label.Table, label.Columns, sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID))
if ps := lu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -247,10 +246,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{label.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -263,10 +259,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{label.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -282,10 +275,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -298,10 +288,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -317,10 +304,7 @@ func (lu *LabelUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -360,6 +344,14 @@ func (luo *LabelUpdateOne) SetName(s string) *LabelUpdateOne {
return luo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (luo *LabelUpdateOne) SetNillableName(s *string) *LabelUpdateOne {
+ if s != nil {
+ luo.SetName(*s)
+ }
+ return luo
+}
+
// SetDescription sets the "description" field.
func (luo *LabelUpdateOne) SetDescription(s string) *LabelUpdateOne {
luo.mutation.SetDescription(s)
@@ -458,6 +450,12 @@ func (luo *LabelUpdateOne) RemoveItems(i ...*Item) *LabelUpdateOne {
return luo.RemoveItemIDs(ids...)
}
+// Where appends a list predicates to the LabelUpdate builder.
+func (luo *LabelUpdateOne) Where(ps ...predicate.Label) *LabelUpdateOne {
+ luo.mutation.Where(ps...)
+ return luo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (luo *LabelUpdateOne) Select(field string, fields ...string) *LabelUpdateOne {
@@ -468,7 +466,7 @@ func (luo *LabelUpdateOne) Select(field string, fields ...string) *LabelUpdateOn
// Save executes the query and returns the updated Label entity.
func (luo *LabelUpdateOne) Save(ctx context.Context) (*Label, error) {
luo.defaults()
- return withHooks[*Label, LabelMutation](ctx, luo.sqlSave, luo.mutation, luo.hooks)
+ return withHooks(ctx, luo.sqlSave, luo.mutation, luo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -528,16 +526,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
if err := luo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: label.Table,
- Columns: label.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: label.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(label.Table, label.Columns, sqlgraph.NewFieldSpec(label.FieldID, field.TypeUUID))
id, ok := luo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Label.id" for update`)}
@@ -588,10 +577,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
Columns: []string{label.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -604,10 +590,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
Columns: []string{label.GroupColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -623,10 +606,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -639,10 +619,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -658,10 +635,7 @@ func (luo *LabelUpdateOne) sqlSave(ctx context.Context) (_node *Label, err error
Columns: label.ItemsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/location.go b/backend/internal/data/ent/location.go
index 67abd30..640f05e 100644
--- a/backend/internal/data/ent/location.go
+++ b/backend/internal/data/ent/location.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/group"
@@ -31,16 +32,17 @@ type Location struct {
Edges LocationEdges `json:"edges"`
group_locations *uuid.UUID
location_children *uuid.UUID
+ selectValues sql.SelectValues
}
// LocationEdges holds the relations/edges for other nodes in the graph.
type LocationEdges struct {
+ // Group holds the value of the group edge.
+ Group *Group `json:"group,omitempty"`
// Parent holds the value of the parent edge.
Parent *Location `json:"parent,omitempty"`
// Children holds the value of the children edge.
Children []*Location `json:"children,omitempty"`
- // Group holds the value of the group edge.
- Group *Group `json:"group,omitempty"`
// Items holds the value of the items edge.
Items []*Item `json:"items,omitempty"`
// loadedTypes holds the information for reporting if a
@@ -48,10 +50,23 @@ type LocationEdges struct {
loadedTypes [4]bool
}
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e LocationEdges) GroupOrErr() (*Group, error) {
+ if e.loadedTypes[0] {
+ if e.Group == nil {
+ // Edge was loaded but was not found.
+ return nil, &NotFoundError{label: group.Label}
+ }
+ return e.Group, nil
+ }
+ return nil, &NotLoadedError{edge: "group"}
+}
+
// ParentOrErr returns the Parent value or an error if the edge
// was not loaded in eager-loading, or loaded but was not found.
func (e LocationEdges) ParentOrErr() (*Location, error) {
- if e.loadedTypes[0] {
+ if e.loadedTypes[1] {
if e.Parent == nil {
// Edge was loaded but was not found.
return nil, &NotFoundError{label: location.Label}
@@ -64,25 +79,12 @@ func (e LocationEdges) ParentOrErr() (*Location, error) {
// ChildrenOrErr returns the Children value or an error if the edge
// was not loaded in eager-loading.
func (e LocationEdges) ChildrenOrErr() ([]*Location, error) {
- if e.loadedTypes[1] {
+ if e.loadedTypes[2] {
return e.Children, nil
}
return nil, &NotLoadedError{edge: "children"}
}
-// GroupOrErr returns the Group value or an error if the edge
-// was not loaded in eager-loading, or loaded but was not found.
-func (e LocationEdges) GroupOrErr() (*Group, error) {
- if e.loadedTypes[2] {
- if e.Group == nil {
- // Edge was loaded but was not found.
- return nil, &NotFoundError{label: group.Label}
- }
- return e.Group, nil
- }
- return nil, &NotLoadedError{edge: "group"}
-}
-
// ItemsOrErr returns the Items value or an error if the edge
// was not loaded in eager-loading.
func (e LocationEdges) ItemsOrErr() ([]*Item, error) {
@@ -108,7 +110,7 @@ func (*Location) scanValues(columns []string) ([]any, error) {
case location.ForeignKeys[1]: // location_children
values[i] = &sql.NullScanner{S: new(uuid.UUID)}
default:
- return nil, fmt.Errorf("unexpected column %q for type Location", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -166,36 +168,44 @@ func (l *Location) assignValues(columns []string, values []any) error {
l.location_children = new(uuid.UUID)
*l.location_children = *value.S.(*uuid.UUID)
}
+ default:
+ l.selectValues.Set(columns[i], values[i])
}
}
return nil
}
-// QueryParent queries the "parent" edge of the Location entity.
-func (l *Location) QueryParent() *LocationQuery {
- return (&LocationClient{config: l.config}).QueryParent(l)
-}
-
-// QueryChildren queries the "children" edge of the Location entity.
-func (l *Location) QueryChildren() *LocationQuery {
- return (&LocationClient{config: l.config}).QueryChildren(l)
+// Value returns the ent.Value that was dynamically selected and assigned to the Location.
+// This includes values selected through modifiers, order, etc.
+func (l *Location) Value(name string) (ent.Value, error) {
+ return l.selectValues.Get(name)
}
// QueryGroup queries the "group" edge of the Location entity.
func (l *Location) QueryGroup() *GroupQuery {
- return (&LocationClient{config: l.config}).QueryGroup(l)
+ return NewLocationClient(l.config).QueryGroup(l)
+}
+
+// QueryParent queries the "parent" edge of the Location entity.
+func (l *Location) QueryParent() *LocationQuery {
+ return NewLocationClient(l.config).QueryParent(l)
+}
+
+// QueryChildren queries the "children" edge of the Location entity.
+func (l *Location) QueryChildren() *LocationQuery {
+ return NewLocationClient(l.config).QueryChildren(l)
}
// QueryItems queries the "items" edge of the Location entity.
func (l *Location) QueryItems() *ItemQuery {
- return (&LocationClient{config: l.config}).QueryItems(l)
+ return NewLocationClient(l.config).QueryItems(l)
}
// Update returns a builder for updating this Location.
// Note that you need to call Location.Unwrap() before calling this method if this Location
// was returned from a transaction, and the transaction was committed or rolled back.
func (l *Location) Update() *LocationUpdateOne {
- return (&LocationClient{config: l.config}).UpdateOne(l)
+ return NewLocationClient(l.config).UpdateOne(l)
}
// Unwrap unwraps the Location entity that was returned from a transaction after it was closed,
@@ -231,9 +241,3 @@ func (l *Location) String() string {
// Locations is a parsable slice of Location.
type Locations []*Location
-
-func (l Locations) config(cfg config) {
- for _i := range l {
- l[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/location/location.go b/backend/internal/data/ent/location/location.go
index 96cb75c..4a7fc16 100644
--- a/backend/internal/data/ent/location/location.go
+++ b/backend/internal/data/ent/location/location.go
@@ -5,6 +5,8 @@ package location
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -21,16 +23,23 @@ const (
FieldName = "name"
// FieldDescription holds the string denoting the description field in the database.
FieldDescription = "description"
+ // EdgeGroup holds the string denoting the group edge name in mutations.
+ EdgeGroup = "group"
// EdgeParent holds the string denoting the parent edge name in mutations.
EdgeParent = "parent"
// EdgeChildren holds the string denoting the children edge name in mutations.
EdgeChildren = "children"
- // EdgeGroup holds the string denoting the group edge name in mutations.
- EdgeGroup = "group"
// EdgeItems holds the string denoting the items edge name in mutations.
EdgeItems = "items"
// Table holds the table name of the location in the database.
Table = "locations"
+ // GroupTable is the table that holds the group relation/edge.
+ GroupTable = "locations"
+ // GroupInverseTable is the table name for the Group entity.
+ // It exists in this package in order to avoid circular dependency with the "group" package.
+ GroupInverseTable = "groups"
+ // GroupColumn is the table column denoting the group relation/edge.
+ GroupColumn = "group_locations"
// ParentTable is the table that holds the parent relation/edge.
ParentTable = "locations"
// ParentColumn is the table column denoting the parent relation/edge.
@@ -39,13 +48,6 @@ const (
ChildrenTable = "locations"
// ChildrenColumn is the table column denoting the children relation/edge.
ChildrenColumn = "location_children"
- // GroupTable is the table that holds the group relation/edge.
- GroupTable = "locations"
- // GroupInverseTable is the table name for the Group entity.
- // It exists in this package in order to avoid circular dependency with the "group" package.
- GroupInverseTable = "groups"
- // GroupColumn is the table column denoting the group relation/edge.
- GroupColumn = "group_locations"
// ItemsTable is the table that holds the items relation/edge.
ItemsTable = "items"
// ItemsInverseTable is the table name for the Item entity.
@@ -100,3 +102,101 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the Location queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByParentField orders the results by parent field.
+func ByParentField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newParentStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByChildrenCount orders the results by children count.
+func ByChildrenCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newChildrenStep(), opts...)
+ }
+}
+
+// ByChildren orders the results by children terms.
+func ByChildren(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newChildrenStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByItemsCount orders the results by items count.
+func ByItemsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newItemsStep(), opts...)
+ }
+}
+
+// ByItems orders the results by items terms.
+func ByItems(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+}
+func newParentStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
+ )
+}
+func newChildrenStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
+ )
+}
+func newItemsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, ItemsTable, ItemsColumn),
+ )
+}
diff --git a/backend/internal/data/ent/location/where.go b/backend/internal/data/ent/location/where.go
index cd9a20e..a89ef4d 100644
--- a/backend/internal/data/ent/location/where.go
+++ b/backend/internal/data/ent/location/where.go
@@ -296,6 +296,29 @@ func DescriptionContainsFold(v string) predicate.Location {
return predicate.Location(sql.FieldContainsFold(FieldDescription, v))
}
+// HasGroup applies the HasEdge predicate on the "group" edge.
+func HasGroup() predicate.Location {
+ return predicate.Location(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
+func HasGroupWith(preds ...predicate.Group) predicate.Location {
+ return predicate.Location(func(s *sql.Selector) {
+ step := newGroupStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
// HasParent applies the HasEdge predicate on the "parent" edge.
func HasParent() predicate.Location {
return predicate.Location(func(s *sql.Selector) {
@@ -310,11 +333,7 @@ func HasParent() predicate.Location {
// HasParentWith applies the HasEdge predicate on the "parent" edge with a given conditions (other predicates).
func HasParentWith(preds ...predicate.Location) predicate.Location {
return predicate.Location(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(Table, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, ParentTable, ParentColumn),
- )
+ step := newParentStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -337,38 +356,7 @@ func HasChildren() predicate.Location {
// HasChildrenWith applies the HasEdge predicate on the "children" edge with a given conditions (other predicates).
func HasChildrenWith(preds ...predicate.Location) predicate.Location {
return predicate.Location(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(Table, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, ChildrenTable, ChildrenColumn),
- )
- sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
- for _, p := range preds {
- p(s)
- }
- })
- })
-}
-
-// HasGroup applies the HasEdge predicate on the "group" edge.
-func HasGroup() predicate.Location {
- return predicate.Location(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
- sqlgraph.HasNeighbors(s, step)
- })
-}
-
-// HasGroupWith applies the HasEdge predicate on the "group" edge with a given conditions (other predicates).
-func HasGroupWith(preds ...predicate.Group) predicate.Location {
- return predicate.Location(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(GroupInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, GroupTable, GroupColumn),
- )
+ step := newChildrenStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -391,11 +379,7 @@ func HasItems() predicate.Location {
// HasItemsWith applies the HasEdge predicate on the "items" edge with a given conditions (other predicates).
func HasItemsWith(preds ...predicate.Item) predicate.Location {
return predicate.Location(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemsInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.O2M, false, ItemsTable, ItemsColumn),
- )
+ step := newItemsStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -406,32 +390,15 @@ func HasItemsWith(preds ...predicate.Item) predicate.Location {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Location) predicate.Location {
- return predicate.Location(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Location(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Location) predicate.Location {
- return predicate.Location(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.Location(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Location) predicate.Location {
- return predicate.Location(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.Location(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/location_create.go b/backend/internal/data/ent/location_create.go
index 72618cf..98f0f7a 100644
--- a/backend/internal/data/ent/location_create.go
+++ b/backend/internal/data/ent/location_create.go
@@ -85,6 +85,17 @@ func (lc *LocationCreate) SetNillableID(u *uuid.UUID) *LocationCreate {
return lc
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (lc *LocationCreate) SetGroupID(id uuid.UUID) *LocationCreate {
+ lc.mutation.SetGroupID(id)
+ return lc
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (lc *LocationCreate) SetGroup(g *Group) *LocationCreate {
+ return lc.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Location entity by ID.
func (lc *LocationCreate) SetParentID(id uuid.UUID) *LocationCreate {
lc.mutation.SetParentID(id)
@@ -119,17 +130,6 @@ func (lc *LocationCreate) AddChildren(l ...*Location) *LocationCreate {
return lc.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (lc *LocationCreate) SetGroupID(id uuid.UUID) *LocationCreate {
- lc.mutation.SetGroupID(id)
- return lc
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (lc *LocationCreate) SetGroup(g *Group) *LocationCreate {
- return lc.SetGroupID(g.ID)
-}
-
// AddItemIDs adds the "items" edge to the Item entity by IDs.
func (lc *LocationCreate) AddItemIDs(ids ...uuid.UUID) *LocationCreate {
lc.mutation.AddItemIDs(ids...)
@@ -153,7 +153,7 @@ func (lc *LocationCreate) Mutation() *LocationMutation {
// Save creates the Location in the database.
func (lc *LocationCreate) Save(ctx context.Context) (*Location, error) {
lc.defaults()
- return withHooks[*Location, LocationMutation](ctx, lc.sqlSave, lc.mutation, lc.hooks)
+ return withHooks(ctx, lc.sqlSave, lc.mutation, lc.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -247,13 +247,7 @@ func (lc *LocationCreate) sqlSave(ctx context.Context) (*Location, error) {
func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
var (
_node = &Location{config: lc.config}
- _spec = &sqlgraph.CreateSpec{
- Table: location.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(location.Table, sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID))
)
if id, ok := lc.mutation.ID(); ok {
_node.ID = id
@@ -275,6 +269,23 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
_spec.SetField(location.FieldDescription, field.TypeString, value)
_node.Description = value
}
+ if nodes := lc.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: location.GroupTable,
+ Columns: []string{location.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.group_locations = &nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
if nodes := lc.mutation.ParentIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -283,10 +294,7 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
Columns: []string{location.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -303,10 +311,7 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -314,26 +319,6 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
}
_spec.Edges = append(_spec.Edges, edge)
}
- if nodes := lc.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: location.GroupTable,
- Columns: []string{location.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _node.group_locations = &nodes[0]
- _spec.Edges = append(_spec.Edges, edge)
- }
if nodes := lc.mutation.ItemsIDs(); len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
@@ -342,10 +327,7 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -359,11 +341,15 @@ func (lc *LocationCreate) createSpec() (*Location, *sqlgraph.CreateSpec) {
// LocationCreateBulk is the builder for creating many Location entities in bulk.
type LocationCreateBulk struct {
config
+ err error
builders []*LocationCreate
}
// Save creates the Location entities in the database.
func (lcb *LocationCreateBulk) Save(ctx context.Context) ([]*Location, error) {
+ if lcb.err != nil {
+ return nil, lcb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(lcb.builders))
nodes := make([]*Location, len(lcb.builders))
mutators := make([]Mutator, len(lcb.builders))
@@ -380,8 +366,8 @@ func (lcb *LocationCreateBulk) Save(ctx context.Context) ([]*Location, error) {
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, lcb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/location_delete.go b/backend/internal/data/ent/location_delete.go
index 22403fe..451b7f1 100644
--- a/backend/internal/data/ent/location_delete.go
+++ b/backend/internal/data/ent/location_delete.go
@@ -27,7 +27,7 @@ func (ld *LocationDelete) Where(ps ...predicate.Location) *LocationDelete {
// Exec executes the deletion query and returns how many vertices were deleted.
func (ld *LocationDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, LocationMutation](ctx, ld.sqlExec, ld.mutation, ld.hooks)
+ return withHooks(ctx, ld.sqlExec, ld.mutation, ld.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (ld *LocationDelete) ExecX(ctx context.Context) int {
}
func (ld *LocationDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: location.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(location.Table, sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID))
if ps := ld.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type LocationDeleteOne struct {
ld *LocationDelete
}
+// Where appends a list predicates to the LocationDelete builder.
+func (ldo *LocationDeleteOne) Where(ps ...predicate.Location) *LocationDeleteOne {
+ ldo.ld.mutation.Where(ps...)
+ return ldo
+}
+
// Exec executes the deletion query.
func (ldo *LocationDeleteOne) Exec(ctx context.Context) error {
n, err := ldo.ld.Exec(ctx)
@@ -84,5 +82,7 @@ func (ldo *LocationDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (ldo *LocationDeleteOne) ExecX(ctx context.Context) {
- ldo.ld.ExecX(ctx)
+ if err := ldo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/location_query.go b/backend/internal/data/ent/location_query.go
index 992644d..4aae965 100644
--- a/backend/internal/data/ent/location_query.go
+++ b/backend/internal/data/ent/location_query.go
@@ -21,16 +21,13 @@ import (
// LocationQuery is the builder for querying Location entities.
type LocationQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []location.OrderOption
inters []Interceptor
predicates []predicate.Location
+ withGroup *GroupQuery
withParent *LocationQuery
withChildren *LocationQuery
- withGroup *GroupQuery
withItems *ItemQuery
withFKs bool
// intermediate query (i.e. traversal path).
@@ -46,29 +43,51 @@ func (lq *LocationQuery) Where(ps ...predicate.Location) *LocationQuery {
// Limit the number of records to be returned by this query.
func (lq *LocationQuery) Limit(limit int) *LocationQuery {
- lq.limit = &limit
+ lq.ctx.Limit = &limit
return lq
}
// Offset to start from.
func (lq *LocationQuery) Offset(offset int) *LocationQuery {
- lq.offset = &offset
+ lq.ctx.Offset = &offset
return lq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (lq *LocationQuery) Unique(unique bool) *LocationQuery {
- lq.unique = &unique
+ lq.ctx.Unique = &unique
return lq
}
// Order specifies how the records should be ordered.
-func (lq *LocationQuery) Order(o ...OrderFunc) *LocationQuery {
+func (lq *LocationQuery) Order(o ...location.OrderOption) *LocationQuery {
lq.order = append(lq.order, o...)
return lq
}
+// QueryGroup chains the current query on the "group" edge.
+func (lq *LocationQuery) QueryGroup() *GroupQuery {
+ query := (&GroupClient{config: lq.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := lq.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := lq.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(location.Table, location.FieldID, selector),
+ sqlgraph.To(group.Table, group.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(lq.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
// QueryParent chains the current query on the "parent" edge.
func (lq *LocationQuery) QueryParent() *LocationQuery {
query := (&LocationClient{config: lq.config}).Query()
@@ -113,28 +132,6 @@ func (lq *LocationQuery) QueryChildren() *LocationQuery {
return query
}
-// QueryGroup chains the current query on the "group" edge.
-func (lq *LocationQuery) QueryGroup() *GroupQuery {
- query := (&GroupClient{config: lq.config}).Query()
- query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
- if err := lq.prepareQuery(ctx); err != nil {
- return nil, err
- }
- selector := lq.sqlQuery(ctx)
- if err := selector.Err(); err != nil {
- return nil, err
- }
- step := sqlgraph.NewStep(
- sqlgraph.From(location.Table, location.FieldID, selector),
- sqlgraph.To(group.Table, group.FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, location.GroupTable, location.GroupColumn),
- )
- fromU = sqlgraph.SetNeighbors(lq.driver.Dialect(), step)
- return fromU, nil
- }
- return query
-}
-
// QueryItems chains the current query on the "items" edge.
func (lq *LocationQuery) QueryItems() *ItemQuery {
query := (&ItemClient{config: lq.config}).Query()
@@ -160,7 +157,7 @@ func (lq *LocationQuery) QueryItems() *ItemQuery {
// First returns the first Location entity from the query.
// Returns a *NotFoundError when no Location was found.
func (lq *LocationQuery) First(ctx context.Context) (*Location, error) {
- nodes, err := lq.Limit(1).All(newQueryContext(ctx, TypeLocation, "First"))
+ nodes, err := lq.Limit(1).All(setContextOp(ctx, lq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -183,7 +180,7 @@ func (lq *LocationQuery) FirstX(ctx context.Context) *Location {
// Returns a *NotFoundError when no Location ID was found.
func (lq *LocationQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = lq.Limit(1).IDs(newQueryContext(ctx, TypeLocation, "FirstID")); err != nil {
+ if ids, err = lq.Limit(1).IDs(setContextOp(ctx, lq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -206,7 +203,7 @@ func (lq *LocationQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one Location entity is found.
// Returns a *NotFoundError when no Location entities are found.
func (lq *LocationQuery) Only(ctx context.Context) (*Location, error) {
- nodes, err := lq.Limit(2).All(newQueryContext(ctx, TypeLocation, "Only"))
+ nodes, err := lq.Limit(2).All(setContextOp(ctx, lq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -234,7 +231,7 @@ func (lq *LocationQuery) OnlyX(ctx context.Context) *Location {
// Returns a *NotFoundError when no entities are found.
func (lq *LocationQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = lq.Limit(2).IDs(newQueryContext(ctx, TypeLocation, "OnlyID")); err != nil {
+ if ids, err = lq.Limit(2).IDs(setContextOp(ctx, lq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -259,7 +256,7 @@ func (lq *LocationQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of Locations.
func (lq *LocationQuery) All(ctx context.Context) ([]*Location, error) {
- ctx = newQueryContext(ctx, TypeLocation, "All")
+ ctx = setContextOp(ctx, lq.ctx, "All")
if err := lq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -277,10 +274,12 @@ func (lq *LocationQuery) AllX(ctx context.Context) []*Location {
}
// IDs executes the query and returns a list of Location IDs.
-func (lq *LocationQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeLocation, "IDs")
- if err := lq.Select(location.FieldID).Scan(ctx, &ids); err != nil {
+func (lq *LocationQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if lq.ctx.Unique == nil && lq.path != nil {
+ lq.Unique(true)
+ }
+ ctx = setContextOp(ctx, lq.ctx, "IDs")
+ if err = lq.Select(location.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -297,7 +296,7 @@ func (lq *LocationQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (lq *LocationQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeLocation, "Count")
+ ctx = setContextOp(ctx, lq.ctx, "Count")
if err := lq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -315,7 +314,7 @@ func (lq *LocationQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (lq *LocationQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeLocation, "Exist")
+ ctx = setContextOp(ctx, lq.ctx, "Exist")
switch _, err := lq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -343,22 +342,31 @@ func (lq *LocationQuery) Clone() *LocationQuery {
}
return &LocationQuery{
config: lq.config,
- limit: lq.limit,
- offset: lq.offset,
- order: append([]OrderFunc{}, lq.order...),
+ ctx: lq.ctx.Clone(),
+ order: append([]location.OrderOption{}, lq.order...),
inters: append([]Interceptor{}, lq.inters...),
predicates: append([]predicate.Location{}, lq.predicates...),
+ withGroup: lq.withGroup.Clone(),
withParent: lq.withParent.Clone(),
withChildren: lq.withChildren.Clone(),
- withGroup: lq.withGroup.Clone(),
withItems: lq.withItems.Clone(),
// clone intermediate query.
- sql: lq.sql.Clone(),
- path: lq.path,
- unique: lq.unique,
+ sql: lq.sql.Clone(),
+ path: lq.path,
}
}
+// WithGroup tells the query-builder to eager-load the nodes that are connected to
+// the "group" edge. The optional arguments are used to configure the query builder of the edge.
+func (lq *LocationQuery) WithGroup(opts ...func(*GroupQuery)) *LocationQuery {
+ query := (&GroupClient{config: lq.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ lq.withGroup = query
+ return lq
+}
+
// WithParent tells the query-builder to eager-load the nodes that are connected to
// the "parent" edge. The optional arguments are used to configure the query builder of the edge.
func (lq *LocationQuery) WithParent(opts ...func(*LocationQuery)) *LocationQuery {
@@ -381,17 +389,6 @@ func (lq *LocationQuery) WithChildren(opts ...func(*LocationQuery)) *LocationQue
return lq
}
-// WithGroup tells the query-builder to eager-load the nodes that are connected to
-// the "group" edge. The optional arguments are used to configure the query builder of the edge.
-func (lq *LocationQuery) WithGroup(opts ...func(*GroupQuery)) *LocationQuery {
- query := (&GroupClient{config: lq.config}).Query()
- for _, opt := range opts {
- opt(query)
- }
- lq.withGroup = query
- return lq
-}
-
// WithItems tells the query-builder to eager-load the nodes that are connected to
// the "items" edge. The optional arguments are used to configure the query builder of the edge.
func (lq *LocationQuery) WithItems(opts ...func(*ItemQuery)) *LocationQuery {
@@ -418,9 +415,9 @@ func (lq *LocationQuery) WithItems(opts ...func(*ItemQuery)) *LocationQuery {
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (lq *LocationQuery) GroupBy(field string, fields ...string) *LocationGroupBy {
- lq.fields = append([]string{field}, fields...)
+ lq.ctx.Fields = append([]string{field}, fields...)
grbuild := &LocationGroupBy{build: lq}
- grbuild.flds = &lq.fields
+ grbuild.flds = &lq.ctx.Fields
grbuild.label = location.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -439,10 +436,10 @@ func (lq *LocationQuery) GroupBy(field string, fields ...string) *LocationGroupB
// Select(location.FieldCreatedAt).
// Scan(ctx, &v)
func (lq *LocationQuery) Select(fields ...string) *LocationSelect {
- lq.fields = append(lq.fields, fields...)
+ lq.ctx.Fields = append(lq.ctx.Fields, fields...)
sbuild := &LocationSelect{LocationQuery: lq}
sbuild.label = location.Label
- sbuild.flds, sbuild.scan = &lq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &lq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -462,7 +459,7 @@ func (lq *LocationQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range lq.fields {
+ for _, f := range lq.ctx.Fields {
if !location.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -483,13 +480,13 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
withFKs = lq.withFKs
_spec = lq.querySpec()
loadedTypes = [4]bool{
+ lq.withGroup != nil,
lq.withParent != nil,
lq.withChildren != nil,
- lq.withGroup != nil,
lq.withItems != nil,
}
)
- if lq.withParent != nil || lq.withGroup != nil {
+ if lq.withGroup != nil || lq.withParent != nil {
withFKs = true
}
if withFKs {
@@ -513,6 +510,12 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
if len(nodes) == 0 {
return nodes, nil
}
+ if query := lq.withGroup; query != nil {
+ if err := lq.loadGroup(ctx, query, nodes, nil,
+ func(n *Location, e *Group) { n.Edges.Group = e }); err != nil {
+ return nil, err
+ }
+ }
if query := lq.withParent; query != nil {
if err := lq.loadParent(ctx, query, nodes, nil,
func(n *Location, e *Location) { n.Edges.Parent = e }); err != nil {
@@ -526,12 +529,6 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
return nil, err
}
}
- if query := lq.withGroup; query != nil {
- if err := lq.loadGroup(ctx, query, nodes, nil,
- func(n *Location, e *Group) { n.Edges.Group = e }); err != nil {
- return nil, err
- }
- }
if query := lq.withItems; query != nil {
if err := lq.loadItems(ctx, query, nodes,
func(n *Location) { n.Edges.Items = []*Item{} },
@@ -542,6 +539,38 @@ func (lq *LocationQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Loc
return nodes, nil
}
+func (lq *LocationQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Location, init func(*Location), assign func(*Location, *Group)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*Location)
+ for i := range nodes {
+ if nodes[i].group_locations == nil {
+ continue
+ }
+ fk := *nodes[i].group_locations
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(group.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "group_locations" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
func (lq *LocationQuery) loadParent(ctx context.Context, query *LocationQuery, nodes []*Location, init func(*Location), assign func(*Location, *Location)) error {
ids := make([]uuid.UUID, 0, len(nodes))
nodeids := make(map[uuid.UUID][]*Location)
@@ -555,6 +584,9 @@ func (lq *LocationQuery) loadParent(ctx context.Context, query *LocationQuery, n
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(location.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -583,7 +615,7 @@ func (lq *LocationQuery) loadChildren(ctx context.Context, query *LocationQuery,
}
query.withFKs = true
query.Where(predicate.Location(func(s *sql.Selector) {
- s.Where(sql.InValues(location.ChildrenColumn, fks...))
+ s.Where(sql.InValues(s.C(location.ChildrenColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -596,41 +628,12 @@ func (lq *LocationQuery) loadChildren(ctx context.Context, query *LocationQuery,
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "location_children" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "location_children" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
return nil
}
-func (lq *LocationQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*Location, init func(*Location), assign func(*Location, *Group)) error {
- ids := make([]uuid.UUID, 0, len(nodes))
- nodeids := make(map[uuid.UUID][]*Location)
- for i := range nodes {
- if nodes[i].group_locations == nil {
- continue
- }
- fk := *nodes[i].group_locations
- if _, ok := nodeids[fk]; !ok {
- ids = append(ids, fk)
- }
- nodeids[fk] = append(nodeids[fk], nodes[i])
- }
- query.Where(group.IDIn(ids...))
- neighbors, err := query.All(ctx)
- if err != nil {
- return err
- }
- for _, n := range neighbors {
- nodes, ok := nodeids[n.ID]
- if !ok {
- return fmt.Errorf(`unexpected foreign-key "group_locations" returned %v`, n.ID)
- }
- for i := range nodes {
- assign(nodes[i], n)
- }
- }
- return nil
-}
func (lq *LocationQuery) loadItems(ctx context.Context, query *ItemQuery, nodes []*Location, init func(*Location), assign func(*Location, *Item)) error {
fks := make([]driver.Value, 0, len(nodes))
nodeids := make(map[uuid.UUID]*Location)
@@ -643,7 +646,7 @@ func (lq *LocationQuery) loadItems(ctx context.Context, query *ItemQuery, nodes
}
query.withFKs = true
query.Where(predicate.Item(func(s *sql.Selector) {
- s.Where(sql.InValues(location.ItemsColumn, fks...))
+ s.Where(sql.InValues(s.C(location.ItemsColumn), fks...))
}))
neighbors, err := query.All(ctx)
if err != nil {
@@ -656,7 +659,7 @@ func (lq *LocationQuery) loadItems(ctx context.Context, query *ItemQuery, nodes
}
node, ok := nodeids[*fk]
if !ok {
- return fmt.Errorf(`unexpected foreign-key "location_items" returned %v for node %v`, *fk, n.ID)
+ return fmt.Errorf(`unexpected referenced foreign-key "location_items" returned %v for node %v`, *fk, n.ID)
}
assign(node, n)
}
@@ -665,30 +668,22 @@ func (lq *LocationQuery) loadItems(ctx context.Context, query *ItemQuery, nodes
func (lq *LocationQuery) sqlCount(ctx context.Context) (int, error) {
_spec := lq.querySpec()
- _spec.Node.Columns = lq.fields
- if len(lq.fields) > 0 {
- _spec.Unique = lq.unique != nil && *lq.unique
+ _spec.Node.Columns = lq.ctx.Fields
+ if len(lq.ctx.Fields) > 0 {
+ _spec.Unique = lq.ctx.Unique != nil && *lq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, lq.driver, _spec)
}
func (lq *LocationQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: location.Table,
- Columns: location.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- From: lq.sql,
- Unique: true,
- }
- if unique := lq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(location.Table, location.Columns, sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID))
+ _spec.From = lq.sql
+ if unique := lq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if lq.path != nil {
+ _spec.Unique = true
}
- if fields := lq.fields; len(fields) > 0 {
+ if fields := lq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, location.FieldID)
for i := range fields {
@@ -704,10 +699,10 @@ func (lq *LocationQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := lq.limit; limit != nil {
+ if limit := lq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := lq.offset; offset != nil {
+ if offset := lq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := lq.order; len(ps) > 0 {
@@ -723,7 +718,7 @@ func (lq *LocationQuery) querySpec() *sqlgraph.QuerySpec {
func (lq *LocationQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(lq.driver.Dialect())
t1 := builder.Table(location.Table)
- columns := lq.fields
+ columns := lq.ctx.Fields
if len(columns) == 0 {
columns = location.Columns
}
@@ -732,7 +727,7 @@ func (lq *LocationQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = lq.sql
selector.Select(selector.Columns(columns...)...)
}
- if lq.unique != nil && *lq.unique {
+ if lq.ctx.Unique != nil && *lq.ctx.Unique {
selector.Distinct()
}
for _, p := range lq.predicates {
@@ -741,12 +736,12 @@ func (lq *LocationQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range lq.order {
p(selector)
}
- if offset := lq.offset; offset != nil {
+ if offset := lq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := lq.limit; limit != nil {
+ if limit := lq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -766,7 +761,7 @@ func (lgb *LocationGroupBy) Aggregate(fns ...AggregateFunc) *LocationGroupBy {
// Scan applies the selector query and scans the result into the given value.
func (lgb *LocationGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeLocation, "GroupBy")
+ ctx = setContextOp(ctx, lgb.build.ctx, "GroupBy")
if err := lgb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -814,7 +809,7 @@ func (ls *LocationSelect) Aggregate(fns ...AggregateFunc) *LocationSelect {
// Scan applies the selector query and scans the result into the given value.
func (ls *LocationSelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeLocation, "Select")
+ ctx = setContextOp(ctx, ls.ctx, "Select")
if err := ls.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/location_update.go b/backend/internal/data/ent/location_update.go
index 6833208..d569b21 100644
--- a/backend/internal/data/ent/location_update.go
+++ b/backend/internal/data/ent/location_update.go
@@ -43,6 +43,14 @@ func (lu *LocationUpdate) SetName(s string) *LocationUpdate {
return lu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (lu *LocationUpdate) SetNillableName(s *string) *LocationUpdate {
+ if s != nil {
+ lu.SetName(*s)
+ }
+ return lu
+}
+
// SetDescription sets the "description" field.
func (lu *LocationUpdate) SetDescription(s string) *LocationUpdate {
lu.mutation.SetDescription(s)
@@ -63,6 +71,17 @@ func (lu *LocationUpdate) ClearDescription() *LocationUpdate {
return lu
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (lu *LocationUpdate) SetGroupID(id uuid.UUID) *LocationUpdate {
+ lu.mutation.SetGroupID(id)
+ return lu
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (lu *LocationUpdate) SetGroup(g *Group) *LocationUpdate {
+ return lu.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Location entity by ID.
func (lu *LocationUpdate) SetParentID(id uuid.UUID) *LocationUpdate {
lu.mutation.SetParentID(id)
@@ -97,17 +116,6 @@ func (lu *LocationUpdate) AddChildren(l ...*Location) *LocationUpdate {
return lu.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (lu *LocationUpdate) SetGroupID(id uuid.UUID) *LocationUpdate {
- lu.mutation.SetGroupID(id)
- return lu
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (lu *LocationUpdate) SetGroup(g *Group) *LocationUpdate {
- return lu.SetGroupID(g.ID)
-}
-
// AddItemIDs adds the "items" edge to the Item entity by IDs.
func (lu *LocationUpdate) AddItemIDs(ids ...uuid.UUID) *LocationUpdate {
lu.mutation.AddItemIDs(ids...)
@@ -128,6 +136,12 @@ func (lu *LocationUpdate) Mutation() *LocationMutation {
return lu.mutation
}
+// ClearGroup clears the "group" edge to the Group entity.
+func (lu *LocationUpdate) ClearGroup() *LocationUpdate {
+ lu.mutation.ClearGroup()
+ return lu
+}
+
// ClearParent clears the "parent" edge to the Location entity.
func (lu *LocationUpdate) ClearParent() *LocationUpdate {
lu.mutation.ClearParent()
@@ -155,12 +169,6 @@ func (lu *LocationUpdate) RemoveChildren(l ...*Location) *LocationUpdate {
return lu.RemoveChildIDs(ids...)
}
-// ClearGroup clears the "group" edge to the Group entity.
-func (lu *LocationUpdate) ClearGroup() *LocationUpdate {
- lu.mutation.ClearGroup()
- return lu
-}
-
// ClearItems clears all "items" edges to the Item entity.
func (lu *LocationUpdate) ClearItems() *LocationUpdate {
lu.mutation.ClearItems()
@@ -185,7 +193,7 @@ func (lu *LocationUpdate) RemoveItems(i ...*Item) *LocationUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (lu *LocationUpdate) Save(ctx context.Context) (int, error) {
lu.defaults()
- return withHooks[int, LocationMutation](ctx, lu.sqlSave, lu.mutation, lu.hooks)
+ return withHooks(ctx, lu.sqlSave, lu.mutation, lu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -240,16 +248,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
if err := lu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: location.Table,
- Columns: location.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(location.Table, location.Columns, sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID))
if ps := lu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -269,6 +268,35 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
if lu.mutation.DescriptionCleared() {
_spec.ClearField(location.FieldDescription, field.TypeString)
}
+ if lu.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: location.GroupTable,
+ Columns: []string{location.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := lu.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: location.GroupTable,
+ Columns: []string{location.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
if lu.mutation.ParentCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -277,10 +305,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -293,10 +318,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -312,10 +334,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -328,10 +347,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -347,45 +363,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _spec.Edges.Add = append(_spec.Edges.Add, edge)
- }
- if lu.mutation.GroupCleared() {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: location.GroupTable,
- Columns: []string{location.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
- }
- if nodes := lu.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: location.GroupTable,
- Columns: []string{location.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -401,10 +379,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -417,10 +392,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -436,10 +408,7 @@ func (lu *LocationUpdate) sqlSave(ctx context.Context) (n int, err error) {
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -479,6 +448,14 @@ func (luo *LocationUpdateOne) SetName(s string) *LocationUpdateOne {
return luo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (luo *LocationUpdateOne) SetNillableName(s *string) *LocationUpdateOne {
+ if s != nil {
+ luo.SetName(*s)
+ }
+ return luo
+}
+
// SetDescription sets the "description" field.
func (luo *LocationUpdateOne) SetDescription(s string) *LocationUpdateOne {
luo.mutation.SetDescription(s)
@@ -499,6 +476,17 @@ func (luo *LocationUpdateOne) ClearDescription() *LocationUpdateOne {
return luo
}
+// SetGroupID sets the "group" edge to the Group entity by ID.
+func (luo *LocationUpdateOne) SetGroupID(id uuid.UUID) *LocationUpdateOne {
+ luo.mutation.SetGroupID(id)
+ return luo
+}
+
+// SetGroup sets the "group" edge to the Group entity.
+func (luo *LocationUpdateOne) SetGroup(g *Group) *LocationUpdateOne {
+ return luo.SetGroupID(g.ID)
+}
+
// SetParentID sets the "parent" edge to the Location entity by ID.
func (luo *LocationUpdateOne) SetParentID(id uuid.UUID) *LocationUpdateOne {
luo.mutation.SetParentID(id)
@@ -533,17 +521,6 @@ func (luo *LocationUpdateOne) AddChildren(l ...*Location) *LocationUpdateOne {
return luo.AddChildIDs(ids...)
}
-// SetGroupID sets the "group" edge to the Group entity by ID.
-func (luo *LocationUpdateOne) SetGroupID(id uuid.UUID) *LocationUpdateOne {
- luo.mutation.SetGroupID(id)
- return luo
-}
-
-// SetGroup sets the "group" edge to the Group entity.
-func (luo *LocationUpdateOne) SetGroup(g *Group) *LocationUpdateOne {
- return luo.SetGroupID(g.ID)
-}
-
// AddItemIDs adds the "items" edge to the Item entity by IDs.
func (luo *LocationUpdateOne) AddItemIDs(ids ...uuid.UUID) *LocationUpdateOne {
luo.mutation.AddItemIDs(ids...)
@@ -564,6 +541,12 @@ func (luo *LocationUpdateOne) Mutation() *LocationMutation {
return luo.mutation
}
+// ClearGroup clears the "group" edge to the Group entity.
+func (luo *LocationUpdateOne) ClearGroup() *LocationUpdateOne {
+ luo.mutation.ClearGroup()
+ return luo
+}
+
// ClearParent clears the "parent" edge to the Location entity.
func (luo *LocationUpdateOne) ClearParent() *LocationUpdateOne {
luo.mutation.ClearParent()
@@ -591,12 +574,6 @@ func (luo *LocationUpdateOne) RemoveChildren(l ...*Location) *LocationUpdateOne
return luo.RemoveChildIDs(ids...)
}
-// ClearGroup clears the "group" edge to the Group entity.
-func (luo *LocationUpdateOne) ClearGroup() *LocationUpdateOne {
- luo.mutation.ClearGroup()
- return luo
-}
-
// ClearItems clears all "items" edges to the Item entity.
func (luo *LocationUpdateOne) ClearItems() *LocationUpdateOne {
luo.mutation.ClearItems()
@@ -618,6 +595,12 @@ func (luo *LocationUpdateOne) RemoveItems(i ...*Item) *LocationUpdateOne {
return luo.RemoveItemIDs(ids...)
}
+// Where appends a list predicates to the LocationUpdate builder.
+func (luo *LocationUpdateOne) Where(ps ...predicate.Location) *LocationUpdateOne {
+ luo.mutation.Where(ps...)
+ return luo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (luo *LocationUpdateOne) Select(field string, fields ...string) *LocationUpdateOne {
@@ -628,7 +611,7 @@ func (luo *LocationUpdateOne) Select(field string, fields ...string) *LocationUp
// Save executes the query and returns the updated Location entity.
func (luo *LocationUpdateOne) Save(ctx context.Context) (*Location, error) {
luo.defaults()
- return withHooks[*Location, LocationMutation](ctx, luo.sqlSave, luo.mutation, luo.hooks)
+ return withHooks(ctx, luo.sqlSave, luo.mutation, luo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -683,16 +666,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
if err := luo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: location.Table,
- Columns: location.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(location.Table, location.Columns, sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID))
id, ok := luo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Location.id" for update`)}
@@ -729,6 +703,35 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
if luo.mutation.DescriptionCleared() {
_spec.ClearField(location.FieldDescription, field.TypeString)
}
+ if luo.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: location.GroupTable,
+ Columns: []string{location.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := luo.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: location.GroupTable,
+ Columns: []string{location.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(group.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
if luo.mutation.ParentCleared() {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
@@ -737,10 +740,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -753,10 +753,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ParentColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -772,10 +769,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -788,10 +782,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -807,45 +798,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ChildrenColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: location.FieldID,
- },
- },
- }
- for _, k := range nodes {
- edge.Target.Nodes = append(edge.Target.Nodes, k)
- }
- _spec.Edges.Add = append(_spec.Edges.Add, edge)
- }
- if luo.mutation.GroupCleared() {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: location.GroupTable,
- Columns: []string{location.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
- },
- }
- _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
- }
- if nodes := luo.mutation.GroupIDs(); len(nodes) > 0 {
- edge := &sqlgraph.EdgeSpec{
- Rel: sqlgraph.M2O,
- Inverse: true,
- Table: location.GroupTable,
- Columns: []string{location.GroupColumn},
- Bidi: false,
- Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: group.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(location.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -861,10 +814,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -877,10 +827,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -896,10 +843,7 @@ func (luo *LocationUpdateOne) sqlSave(ctx context.Context) (_node *Location, err
Columns: []string{location.ItemsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/maintenanceentry.go b/backend/internal/data/ent/maintenanceentry.go
index 4d0b078..af35e0b 100644
--- a/backend/internal/data/ent/maintenanceentry.go
+++ b/backend/internal/data/ent/maintenanceentry.go
@@ -7,6 +7,7 @@ import (
"strings"
"time"
+ "entgo.io/ent"
"entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/item"
@@ -26,6 +27,8 @@ type MaintenanceEntry struct {
ItemID uuid.UUID `json:"item_id,omitempty"`
// Date holds the value of the "date" field.
Date time.Time `json:"date,omitempty"`
+ // ScheduledDate holds the value of the "scheduled_date" field.
+ ScheduledDate time.Time `json:"scheduled_date,omitempty"`
// Name holds the value of the "name" field.
Name string `json:"name,omitempty"`
// Description holds the value of the "description" field.
@@ -34,7 +37,8 @@ type MaintenanceEntry struct {
Cost float64 `json:"cost,omitempty"`
// Edges holds the relations/edges for other nodes in the graph.
// The values are being populated by the MaintenanceEntryQuery when eager-loading is set.
- Edges MaintenanceEntryEdges `json:"edges"`
+ Edges MaintenanceEntryEdges `json:"edges"`
+ selectValues sql.SelectValues
}
// MaintenanceEntryEdges holds the relations/edges for other nodes in the graph.
@@ -68,12 +72,12 @@ func (*MaintenanceEntry) scanValues(columns []string) ([]any, error) {
values[i] = new(sql.NullFloat64)
case maintenanceentry.FieldName, maintenanceentry.FieldDescription:
values[i] = new(sql.NullString)
- case maintenanceentry.FieldCreatedAt, maintenanceentry.FieldUpdatedAt, maintenanceentry.FieldDate:
+ case maintenanceentry.FieldCreatedAt, maintenanceentry.FieldUpdatedAt, maintenanceentry.FieldDate, maintenanceentry.FieldScheduledDate:
values[i] = new(sql.NullTime)
case maintenanceentry.FieldID, maintenanceentry.FieldItemID:
values[i] = new(uuid.UUID)
default:
- return nil, fmt.Errorf("unexpected column %q for type MaintenanceEntry", columns[i])
+ values[i] = new(sql.UnknownType)
}
}
return values, nil
@@ -117,6 +121,12 @@ func (me *MaintenanceEntry) assignValues(columns []string, values []any) error {
} else if value.Valid {
me.Date = value.Time
}
+ case maintenanceentry.FieldScheduledDate:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field scheduled_date", values[i])
+ } else if value.Valid {
+ me.ScheduledDate = value.Time
+ }
case maintenanceentry.FieldName:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field name", values[i])
@@ -135,21 +145,29 @@ func (me *MaintenanceEntry) assignValues(columns []string, values []any) error {
} else if value.Valid {
me.Cost = value.Float64
}
+ default:
+ me.selectValues.Set(columns[i], values[i])
}
}
return nil
}
+// Value returns the ent.Value that was dynamically selected and assigned to the MaintenanceEntry.
+// This includes values selected through modifiers, order, etc.
+func (me *MaintenanceEntry) Value(name string) (ent.Value, error) {
+ return me.selectValues.Get(name)
+}
+
// QueryItem queries the "item" edge of the MaintenanceEntry entity.
func (me *MaintenanceEntry) QueryItem() *ItemQuery {
- return (&MaintenanceEntryClient{config: me.config}).QueryItem(me)
+ return NewMaintenanceEntryClient(me.config).QueryItem(me)
}
// Update returns a builder for updating this MaintenanceEntry.
// Note that you need to call MaintenanceEntry.Unwrap() before calling this method if this MaintenanceEntry
// was returned from a transaction, and the transaction was committed or rolled back.
func (me *MaintenanceEntry) Update() *MaintenanceEntryUpdateOne {
- return (&MaintenanceEntryClient{config: me.config}).UpdateOne(me)
+ return NewMaintenanceEntryClient(me.config).UpdateOne(me)
}
// Unwrap unwraps the MaintenanceEntry entity that was returned from a transaction after it was closed,
@@ -180,6 +198,9 @@ func (me *MaintenanceEntry) String() string {
builder.WriteString("date=")
builder.WriteString(me.Date.Format(time.ANSIC))
builder.WriteString(", ")
+ builder.WriteString("scheduled_date=")
+ builder.WriteString(me.ScheduledDate.Format(time.ANSIC))
+ builder.WriteString(", ")
builder.WriteString("name=")
builder.WriteString(me.Name)
builder.WriteString(", ")
@@ -194,9 +215,3 @@ func (me *MaintenanceEntry) String() string {
// MaintenanceEntries is a parsable slice of MaintenanceEntry.
type MaintenanceEntries []*MaintenanceEntry
-
-func (me MaintenanceEntries) config(cfg config) {
- for _i := range me {
- me[_i].config = cfg
- }
-}
diff --git a/backend/internal/data/ent/maintenanceentry/maintenanceentry.go b/backend/internal/data/ent/maintenanceentry/maintenanceentry.go
index c1dcffc..b4b8142 100644
--- a/backend/internal/data/ent/maintenanceentry/maintenanceentry.go
+++ b/backend/internal/data/ent/maintenanceentry/maintenanceentry.go
@@ -5,6 +5,8 @@ package maintenanceentry
import (
"time"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
"github.com/google/uuid"
)
@@ -21,6 +23,8 @@ const (
FieldItemID = "item_id"
// FieldDate holds the string denoting the date field in the database.
FieldDate = "date"
+ // FieldScheduledDate holds the string denoting the scheduled_date field in the database.
+ FieldScheduledDate = "scheduled_date"
// FieldName holds the string denoting the name field in the database.
FieldName = "name"
// FieldDescription holds the string denoting the description field in the database.
@@ -47,6 +51,7 @@ var Columns = []string{
FieldUpdatedAt,
FieldItemID,
FieldDate,
+ FieldScheduledDate,
FieldName,
FieldDescription,
FieldCost,
@@ -69,8 +74,6 @@ var (
DefaultUpdatedAt func() time.Time
// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
UpdateDefaultUpdatedAt func() time.Time
- // DefaultDate holds the default value on creation for the "date" field.
- DefaultDate func() time.Time
// NameValidator is a validator for the "name" field. It is called by the builders before save.
NameValidator func(string) error
// DescriptionValidator is a validator for the "description" field. It is called by the builders before save.
@@ -80,3 +83,65 @@ var (
// DefaultID holds the default value on creation for the "id" field.
DefaultID func() uuid.UUID
)
+
+// OrderOption defines the ordering options for the MaintenanceEntry queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByItemID orders the results by the item_id field.
+func ByItemID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldItemID, opts...).ToFunc()
+}
+
+// ByDate orders the results by the date field.
+func ByDate(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDate, opts...).ToFunc()
+}
+
+// ByScheduledDate orders the results by the scheduled_date field.
+func ByScheduledDate(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldScheduledDate, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByCost orders the results by the cost field.
+func ByCost(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCost, opts...).ToFunc()
+}
+
+// ByItemField orders the results by item field.
+func ByItemField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newItemStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newItemStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(ItemInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
+ )
+}
diff --git a/backend/internal/data/ent/maintenanceentry/where.go b/backend/internal/data/ent/maintenanceentry/where.go
index 6a88550..85e736d 100644
--- a/backend/internal/data/ent/maintenanceentry/where.go
+++ b/backend/internal/data/ent/maintenanceentry/where.go
@@ -76,6 +76,11 @@ func Date(v time.Time) predicate.MaintenanceEntry {
return predicate.MaintenanceEntry(sql.FieldEQ(FieldDate, v))
}
+// ScheduledDate applies equality check predicate on the "scheduled_date" field. It's identical to ScheduledDateEQ.
+func ScheduledDate(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldEQ(FieldScheduledDate, v))
+}
+
// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
func Name(v string) predicate.MaintenanceEntry {
return predicate.MaintenanceEntry(sql.FieldEQ(FieldName, v))
@@ -231,6 +236,66 @@ func DateLTE(v time.Time) predicate.MaintenanceEntry {
return predicate.MaintenanceEntry(sql.FieldLTE(FieldDate, v))
}
+// DateIsNil applies the IsNil predicate on the "date" field.
+func DateIsNil() predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldIsNull(FieldDate))
+}
+
+// DateNotNil applies the NotNil predicate on the "date" field.
+func DateNotNil() predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldNotNull(FieldDate))
+}
+
+// ScheduledDateEQ applies the EQ predicate on the "scheduled_date" field.
+func ScheduledDateEQ(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldEQ(FieldScheduledDate, v))
+}
+
+// ScheduledDateNEQ applies the NEQ predicate on the "scheduled_date" field.
+func ScheduledDateNEQ(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldNEQ(FieldScheduledDate, v))
+}
+
+// ScheduledDateIn applies the In predicate on the "scheduled_date" field.
+func ScheduledDateIn(vs ...time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldIn(FieldScheduledDate, vs...))
+}
+
+// ScheduledDateNotIn applies the NotIn predicate on the "scheduled_date" field.
+func ScheduledDateNotIn(vs ...time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldNotIn(FieldScheduledDate, vs...))
+}
+
+// ScheduledDateGT applies the GT predicate on the "scheduled_date" field.
+func ScheduledDateGT(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldGT(FieldScheduledDate, v))
+}
+
+// ScheduledDateGTE applies the GTE predicate on the "scheduled_date" field.
+func ScheduledDateGTE(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldGTE(FieldScheduledDate, v))
+}
+
+// ScheduledDateLT applies the LT predicate on the "scheduled_date" field.
+func ScheduledDateLT(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldLT(FieldScheduledDate, v))
+}
+
+// ScheduledDateLTE applies the LTE predicate on the "scheduled_date" field.
+func ScheduledDateLTE(v time.Time) predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldLTE(FieldScheduledDate, v))
+}
+
+// ScheduledDateIsNil applies the IsNil predicate on the "scheduled_date" field.
+func ScheduledDateIsNil() predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldIsNull(FieldScheduledDate))
+}
+
+// ScheduledDateNotNil applies the NotNil predicate on the "scheduled_date" field.
+func ScheduledDateNotNil() predicate.MaintenanceEntry {
+ return predicate.MaintenanceEntry(sql.FieldNotNull(FieldScheduledDate))
+}
+
// NameEQ applies the EQ predicate on the "name" field.
func NameEQ(v string) predicate.MaintenanceEntry {
return predicate.MaintenanceEntry(sql.FieldEQ(FieldName, v))
@@ -425,11 +490,7 @@ func HasItem() predicate.MaintenanceEntry {
// HasItemWith applies the HasEdge predicate on the "item" edge with a given conditions (other predicates).
func HasItemWith(preds ...predicate.Item) predicate.MaintenanceEntry {
return predicate.MaintenanceEntry(func(s *sql.Selector) {
- step := sqlgraph.NewStep(
- sqlgraph.From(Table, FieldID),
- sqlgraph.To(ItemInverseTable, FieldID),
- sqlgraph.Edge(sqlgraph.M2O, true, ItemTable, ItemColumn),
- )
+ step := newItemStep()
sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
for _, p := range preds {
p(s)
@@ -440,32 +501,15 @@ func HasItemWith(preds ...predicate.Item) predicate.MaintenanceEntry {
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.MaintenanceEntry) predicate.MaintenanceEntry {
- return predicate.MaintenanceEntry(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for _, p := range predicates {
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.MaintenanceEntry(sql.AndPredicates(predicates...))
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.MaintenanceEntry) predicate.MaintenanceEntry {
- return predicate.MaintenanceEntry(func(s *sql.Selector) {
- s1 := s.Clone().SetP(nil)
- for i, p := range predicates {
- if i > 0 {
- s1.Or()
- }
- p(s1)
- }
- s.Where(s1.P())
- })
+ return predicate.MaintenanceEntry(sql.OrPredicates(predicates...))
}
// Not applies the not operator on the given predicate.
func Not(p predicate.MaintenanceEntry) predicate.MaintenanceEntry {
- return predicate.MaintenanceEntry(func(s *sql.Selector) {
- p(s.Not())
- })
+ return predicate.MaintenanceEntry(sql.NotPredicates(p))
}
diff --git a/backend/internal/data/ent/maintenanceentry_create.go b/backend/internal/data/ent/maintenanceentry_create.go
index a7a6a94..ea71a4d 100644
--- a/backend/internal/data/ent/maintenanceentry_create.go
+++ b/backend/internal/data/ent/maintenanceentry_create.go
@@ -70,6 +70,20 @@ func (mec *MaintenanceEntryCreate) SetNillableDate(t *time.Time) *MaintenanceEnt
return mec
}
+// SetScheduledDate sets the "scheduled_date" field.
+func (mec *MaintenanceEntryCreate) SetScheduledDate(t time.Time) *MaintenanceEntryCreate {
+ mec.mutation.SetScheduledDate(t)
+ return mec
+}
+
+// SetNillableScheduledDate sets the "scheduled_date" field if the given value is not nil.
+func (mec *MaintenanceEntryCreate) SetNillableScheduledDate(t *time.Time) *MaintenanceEntryCreate {
+ if t != nil {
+ mec.SetScheduledDate(*t)
+ }
+ return mec
+}
+
// SetName sets the "name" field.
func (mec *MaintenanceEntryCreate) SetName(s string) *MaintenanceEntryCreate {
mec.mutation.SetName(s)
@@ -131,7 +145,7 @@ func (mec *MaintenanceEntryCreate) Mutation() *MaintenanceEntryMutation {
// Save creates the MaintenanceEntry in the database.
func (mec *MaintenanceEntryCreate) Save(ctx context.Context) (*MaintenanceEntry, error) {
mec.defaults()
- return withHooks[*MaintenanceEntry, MaintenanceEntryMutation](ctx, mec.sqlSave, mec.mutation, mec.hooks)
+ return withHooks(ctx, mec.sqlSave, mec.mutation, mec.hooks)
}
// SaveX calls Save and panics if Save returns an error.
@@ -166,10 +180,6 @@ func (mec *MaintenanceEntryCreate) defaults() {
v := maintenanceentry.DefaultUpdatedAt()
mec.mutation.SetUpdatedAt(v)
}
- if _, ok := mec.mutation.Date(); !ok {
- v := maintenanceentry.DefaultDate()
- mec.mutation.SetDate(v)
- }
if _, ok := mec.mutation.Cost(); !ok {
v := maintenanceentry.DefaultCost
mec.mutation.SetCost(v)
@@ -191,9 +201,6 @@ func (mec *MaintenanceEntryCreate) check() error {
if _, ok := mec.mutation.ItemID(); !ok {
return &ValidationError{Name: "item_id", err: errors.New(`ent: missing required field "MaintenanceEntry.item_id"`)}
}
- if _, ok := mec.mutation.Date(); !ok {
- return &ValidationError{Name: "date", err: errors.New(`ent: missing required field "MaintenanceEntry.date"`)}
- }
if _, ok := mec.mutation.Name(); !ok {
return &ValidationError{Name: "name", err: errors.New(`ent: missing required field "MaintenanceEntry.name"`)}
}
@@ -242,13 +249,7 @@ func (mec *MaintenanceEntryCreate) sqlSave(ctx context.Context) (*MaintenanceEnt
func (mec *MaintenanceEntryCreate) createSpec() (*MaintenanceEntry, *sqlgraph.CreateSpec) {
var (
_node = &MaintenanceEntry{config: mec.config}
- _spec = &sqlgraph.CreateSpec{
- Table: maintenanceentry.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
- }
+ _spec = sqlgraph.NewCreateSpec(maintenanceentry.Table, sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID))
)
if id, ok := mec.mutation.ID(); ok {
_node.ID = id
@@ -266,6 +267,10 @@ func (mec *MaintenanceEntryCreate) createSpec() (*MaintenanceEntry, *sqlgraph.Cr
_spec.SetField(maintenanceentry.FieldDate, field.TypeTime, value)
_node.Date = value
}
+ if value, ok := mec.mutation.ScheduledDate(); ok {
+ _spec.SetField(maintenanceentry.FieldScheduledDate, field.TypeTime, value)
+ _node.ScheduledDate = value
+ }
if value, ok := mec.mutation.Name(); ok {
_spec.SetField(maintenanceentry.FieldName, field.TypeString, value)
_node.Name = value
@@ -286,10 +291,7 @@ func (mec *MaintenanceEntryCreate) createSpec() (*MaintenanceEntry, *sqlgraph.Cr
Columns: []string{maintenanceentry.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -304,11 +306,15 @@ func (mec *MaintenanceEntryCreate) createSpec() (*MaintenanceEntry, *sqlgraph.Cr
// MaintenanceEntryCreateBulk is the builder for creating many MaintenanceEntry entities in bulk.
type MaintenanceEntryCreateBulk struct {
config
+ err error
builders []*MaintenanceEntryCreate
}
// Save creates the MaintenanceEntry entities in the database.
func (mecb *MaintenanceEntryCreateBulk) Save(ctx context.Context) ([]*MaintenanceEntry, error) {
+ if mecb.err != nil {
+ return nil, mecb.err
+ }
specs := make([]*sqlgraph.CreateSpec, len(mecb.builders))
nodes := make([]*MaintenanceEntry, len(mecb.builders))
mutators := make([]Mutator, len(mecb.builders))
@@ -325,8 +331,8 @@ func (mecb *MaintenanceEntryCreateBulk) Save(ctx context.Context) ([]*Maintenanc
return nil, err
}
builder.mutation = mutation
- nodes[i], specs[i] = builder.createSpec()
var err error
+ nodes[i], specs[i] = builder.createSpec()
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, mecb.builders[i+1].mutation)
} else {
diff --git a/backend/internal/data/ent/maintenanceentry_delete.go b/backend/internal/data/ent/maintenanceentry_delete.go
index 7ee2c67..0323ae9 100644
--- a/backend/internal/data/ent/maintenanceentry_delete.go
+++ b/backend/internal/data/ent/maintenanceentry_delete.go
@@ -27,7 +27,7 @@ func (med *MaintenanceEntryDelete) Where(ps ...predicate.MaintenanceEntry) *Main
// Exec executes the deletion query and returns how many vertices were deleted.
func (med *MaintenanceEntryDelete) Exec(ctx context.Context) (int, error) {
- return withHooks[int, MaintenanceEntryMutation](ctx, med.sqlExec, med.mutation, med.hooks)
+ return withHooks(ctx, med.sqlExec, med.mutation, med.hooks)
}
// ExecX is like Exec, but panics if an error occurs.
@@ -40,15 +40,7 @@ func (med *MaintenanceEntryDelete) ExecX(ctx context.Context) int {
}
func (med *MaintenanceEntryDelete) sqlExec(ctx context.Context) (int, error) {
- _spec := &sqlgraph.DeleteSpec{
- Node: &sqlgraph.NodeSpec{
- Table: maintenanceentry.Table,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewDeleteSpec(maintenanceentry.Table, sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID))
if ps := med.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -69,6 +61,12 @@ type MaintenanceEntryDeleteOne struct {
med *MaintenanceEntryDelete
}
+// Where appends a list predicates to the MaintenanceEntryDelete builder.
+func (medo *MaintenanceEntryDeleteOne) Where(ps ...predicate.MaintenanceEntry) *MaintenanceEntryDeleteOne {
+ medo.med.mutation.Where(ps...)
+ return medo
+}
+
// Exec executes the deletion query.
func (medo *MaintenanceEntryDeleteOne) Exec(ctx context.Context) error {
n, err := medo.med.Exec(ctx)
@@ -84,5 +82,7 @@ func (medo *MaintenanceEntryDeleteOne) Exec(ctx context.Context) error {
// ExecX is like Exec, but panics if an error occurs.
func (medo *MaintenanceEntryDeleteOne) ExecX(ctx context.Context) {
- medo.med.ExecX(ctx)
+ if err := medo.Exec(ctx); err != nil {
+ panic(err)
+ }
}
diff --git a/backend/internal/data/ent/maintenanceentry_query.go b/backend/internal/data/ent/maintenanceentry_query.go
index b394869..8d41f75 100644
--- a/backend/internal/data/ent/maintenanceentry_query.go
+++ b/backend/internal/data/ent/maintenanceentry_query.go
@@ -19,11 +19,8 @@ import (
// MaintenanceEntryQuery is the builder for querying MaintenanceEntry entities.
type MaintenanceEntryQuery struct {
config
- limit *int
- offset *int
- unique *bool
- order []OrderFunc
- fields []string
+ ctx *QueryContext
+ order []maintenanceentry.OrderOption
inters []Interceptor
predicates []predicate.MaintenanceEntry
withItem *ItemQuery
@@ -40,25 +37,25 @@ func (meq *MaintenanceEntryQuery) Where(ps ...predicate.MaintenanceEntry) *Maint
// Limit the number of records to be returned by this query.
func (meq *MaintenanceEntryQuery) Limit(limit int) *MaintenanceEntryQuery {
- meq.limit = &limit
+ meq.ctx.Limit = &limit
return meq
}
// Offset to start from.
func (meq *MaintenanceEntryQuery) Offset(offset int) *MaintenanceEntryQuery {
- meq.offset = &offset
+ meq.ctx.Offset = &offset
return meq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (meq *MaintenanceEntryQuery) Unique(unique bool) *MaintenanceEntryQuery {
- meq.unique = &unique
+ meq.ctx.Unique = &unique
return meq
}
// Order specifies how the records should be ordered.
-func (meq *MaintenanceEntryQuery) Order(o ...OrderFunc) *MaintenanceEntryQuery {
+func (meq *MaintenanceEntryQuery) Order(o ...maintenanceentry.OrderOption) *MaintenanceEntryQuery {
meq.order = append(meq.order, o...)
return meq
}
@@ -88,7 +85,7 @@ func (meq *MaintenanceEntryQuery) QueryItem() *ItemQuery {
// First returns the first MaintenanceEntry entity from the query.
// Returns a *NotFoundError when no MaintenanceEntry was found.
func (meq *MaintenanceEntryQuery) First(ctx context.Context) (*MaintenanceEntry, error) {
- nodes, err := meq.Limit(1).All(newQueryContext(ctx, TypeMaintenanceEntry, "First"))
+ nodes, err := meq.Limit(1).All(setContextOp(ctx, meq.ctx, "First"))
if err != nil {
return nil, err
}
@@ -111,7 +108,7 @@ func (meq *MaintenanceEntryQuery) FirstX(ctx context.Context) *MaintenanceEntry
// Returns a *NotFoundError when no MaintenanceEntry ID was found.
func (meq *MaintenanceEntryQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = meq.Limit(1).IDs(newQueryContext(ctx, TypeMaintenanceEntry, "FirstID")); err != nil {
+ if ids, err = meq.Limit(1).IDs(setContextOp(ctx, meq.ctx, "FirstID")); err != nil {
return
}
if len(ids) == 0 {
@@ -134,7 +131,7 @@ func (meq *MaintenanceEntryQuery) FirstIDX(ctx context.Context) uuid.UUID {
// Returns a *NotSingularError when more than one MaintenanceEntry entity is found.
// Returns a *NotFoundError when no MaintenanceEntry entities are found.
func (meq *MaintenanceEntryQuery) Only(ctx context.Context) (*MaintenanceEntry, error) {
- nodes, err := meq.Limit(2).All(newQueryContext(ctx, TypeMaintenanceEntry, "Only"))
+ nodes, err := meq.Limit(2).All(setContextOp(ctx, meq.ctx, "Only"))
if err != nil {
return nil, err
}
@@ -162,7 +159,7 @@ func (meq *MaintenanceEntryQuery) OnlyX(ctx context.Context) *MaintenanceEntry {
// Returns a *NotFoundError when no entities are found.
func (meq *MaintenanceEntryQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
var ids []uuid.UUID
- if ids, err = meq.Limit(2).IDs(newQueryContext(ctx, TypeMaintenanceEntry, "OnlyID")); err != nil {
+ if ids, err = meq.Limit(2).IDs(setContextOp(ctx, meq.ctx, "OnlyID")); err != nil {
return
}
switch len(ids) {
@@ -187,7 +184,7 @@ func (meq *MaintenanceEntryQuery) OnlyIDX(ctx context.Context) uuid.UUID {
// All executes the query and returns a list of MaintenanceEntries.
func (meq *MaintenanceEntryQuery) All(ctx context.Context) ([]*MaintenanceEntry, error) {
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "All")
+ ctx = setContextOp(ctx, meq.ctx, "All")
if err := meq.prepareQuery(ctx); err != nil {
return nil, err
}
@@ -205,10 +202,12 @@ func (meq *MaintenanceEntryQuery) AllX(ctx context.Context) []*MaintenanceEntry
}
// IDs executes the query and returns a list of MaintenanceEntry IDs.
-func (meq *MaintenanceEntryQuery) IDs(ctx context.Context) ([]uuid.UUID, error) {
- var ids []uuid.UUID
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "IDs")
- if err := meq.Select(maintenanceentry.FieldID).Scan(ctx, &ids); err != nil {
+func (meq *MaintenanceEntryQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if meq.ctx.Unique == nil && meq.path != nil {
+ meq.Unique(true)
+ }
+ ctx = setContextOp(ctx, meq.ctx, "IDs")
+ if err = meq.Select(maintenanceentry.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
@@ -225,7 +224,7 @@ func (meq *MaintenanceEntryQuery) IDsX(ctx context.Context) []uuid.UUID {
// Count returns the count of the given query.
func (meq *MaintenanceEntryQuery) Count(ctx context.Context) (int, error) {
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "Count")
+ ctx = setContextOp(ctx, meq.ctx, "Count")
if err := meq.prepareQuery(ctx); err != nil {
return 0, err
}
@@ -243,7 +242,7 @@ func (meq *MaintenanceEntryQuery) CountX(ctx context.Context) int {
// Exist returns true if the query has elements in the graph.
func (meq *MaintenanceEntryQuery) Exist(ctx context.Context) (bool, error) {
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "Exist")
+ ctx = setContextOp(ctx, meq.ctx, "Exist")
switch _, err := meq.FirstID(ctx); {
case IsNotFound(err):
return false, nil
@@ -271,16 +270,14 @@ func (meq *MaintenanceEntryQuery) Clone() *MaintenanceEntryQuery {
}
return &MaintenanceEntryQuery{
config: meq.config,
- limit: meq.limit,
- offset: meq.offset,
- order: append([]OrderFunc{}, meq.order...),
+ ctx: meq.ctx.Clone(),
+ order: append([]maintenanceentry.OrderOption{}, meq.order...),
inters: append([]Interceptor{}, meq.inters...),
predicates: append([]predicate.MaintenanceEntry{}, meq.predicates...),
withItem: meq.withItem.Clone(),
// clone intermediate query.
- sql: meq.sql.Clone(),
- path: meq.path,
- unique: meq.unique,
+ sql: meq.sql.Clone(),
+ path: meq.path,
}
}
@@ -310,9 +307,9 @@ func (meq *MaintenanceEntryQuery) WithItem(opts ...func(*ItemQuery)) *Maintenanc
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (meq *MaintenanceEntryQuery) GroupBy(field string, fields ...string) *MaintenanceEntryGroupBy {
- meq.fields = append([]string{field}, fields...)
+ meq.ctx.Fields = append([]string{field}, fields...)
grbuild := &MaintenanceEntryGroupBy{build: meq}
- grbuild.flds = &meq.fields
+ grbuild.flds = &meq.ctx.Fields
grbuild.label = maintenanceentry.Label
grbuild.scan = grbuild.Scan
return grbuild
@@ -331,10 +328,10 @@ func (meq *MaintenanceEntryQuery) GroupBy(field string, fields ...string) *Maint
// Select(maintenanceentry.FieldCreatedAt).
// Scan(ctx, &v)
func (meq *MaintenanceEntryQuery) Select(fields ...string) *MaintenanceEntrySelect {
- meq.fields = append(meq.fields, fields...)
+ meq.ctx.Fields = append(meq.ctx.Fields, fields...)
sbuild := &MaintenanceEntrySelect{MaintenanceEntryQuery: meq}
sbuild.label = maintenanceentry.Label
- sbuild.flds, sbuild.scan = &meq.fields, sbuild.Scan
+ sbuild.flds, sbuild.scan = &meq.ctx.Fields, sbuild.Scan
return sbuild
}
@@ -354,7 +351,7 @@ func (meq *MaintenanceEntryQuery) prepareQuery(ctx context.Context) error {
}
}
}
- for _, f := range meq.fields {
+ for _, f := range meq.ctx.Fields {
if !maintenanceentry.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
@@ -414,6 +411,9 @@ func (meq *MaintenanceEntryQuery) loadItem(ctx context.Context, query *ItemQuery
}
nodeids[fk] = append(nodeids[fk], nodes[i])
}
+ if len(ids) == 0 {
+ return nil
+ }
query.Where(item.IDIn(ids...))
neighbors, err := query.All(ctx)
if err != nil {
@@ -433,30 +433,22 @@ func (meq *MaintenanceEntryQuery) loadItem(ctx context.Context, query *ItemQuery
func (meq *MaintenanceEntryQuery) sqlCount(ctx context.Context) (int, error) {
_spec := meq.querySpec()
- _spec.Node.Columns = meq.fields
- if len(meq.fields) > 0 {
- _spec.Unique = meq.unique != nil && *meq.unique
+ _spec.Node.Columns = meq.ctx.Fields
+ if len(meq.ctx.Fields) > 0 {
+ _spec.Unique = meq.ctx.Unique != nil && *meq.ctx.Unique
}
return sqlgraph.CountNodes(ctx, meq.driver, _spec)
}
func (meq *MaintenanceEntryQuery) querySpec() *sqlgraph.QuerySpec {
- _spec := &sqlgraph.QuerySpec{
- Node: &sqlgraph.NodeSpec{
- Table: maintenanceentry.Table,
- Columns: maintenanceentry.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
- },
- From: meq.sql,
- Unique: true,
- }
- if unique := meq.unique; unique != nil {
+ _spec := sqlgraph.NewQuerySpec(maintenanceentry.Table, maintenanceentry.Columns, sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID))
+ _spec.From = meq.sql
+ if unique := meq.ctx.Unique; unique != nil {
_spec.Unique = *unique
+ } else if meq.path != nil {
+ _spec.Unique = true
}
- if fields := meq.fields; len(fields) > 0 {
+ if fields := meq.ctx.Fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, maintenanceentry.FieldID)
for i := range fields {
@@ -464,6 +456,9 @@ func (meq *MaintenanceEntryQuery) querySpec() *sqlgraph.QuerySpec {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
}
}
+ if meq.withItem != nil {
+ _spec.Node.AddColumnOnce(maintenanceentry.FieldItemID)
+ }
}
if ps := meq.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
@@ -472,10 +467,10 @@ func (meq *MaintenanceEntryQuery) querySpec() *sqlgraph.QuerySpec {
}
}
}
- if limit := meq.limit; limit != nil {
+ if limit := meq.ctx.Limit; limit != nil {
_spec.Limit = *limit
}
- if offset := meq.offset; offset != nil {
+ if offset := meq.ctx.Offset; offset != nil {
_spec.Offset = *offset
}
if ps := meq.order; len(ps) > 0 {
@@ -491,7 +486,7 @@ func (meq *MaintenanceEntryQuery) querySpec() *sqlgraph.QuerySpec {
func (meq *MaintenanceEntryQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(meq.driver.Dialect())
t1 := builder.Table(maintenanceentry.Table)
- columns := meq.fields
+ columns := meq.ctx.Fields
if len(columns) == 0 {
columns = maintenanceentry.Columns
}
@@ -500,7 +495,7 @@ func (meq *MaintenanceEntryQuery) sqlQuery(ctx context.Context) *sql.Selector {
selector = meq.sql
selector.Select(selector.Columns(columns...)...)
}
- if meq.unique != nil && *meq.unique {
+ if meq.ctx.Unique != nil && *meq.ctx.Unique {
selector.Distinct()
}
for _, p := range meq.predicates {
@@ -509,12 +504,12 @@ func (meq *MaintenanceEntryQuery) sqlQuery(ctx context.Context) *sql.Selector {
for _, p := range meq.order {
p(selector)
}
- if offset := meq.offset; offset != nil {
+ if offset := meq.ctx.Offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
- if limit := meq.limit; limit != nil {
+ if limit := meq.ctx.Limit; limit != nil {
selector.Limit(*limit)
}
return selector
@@ -534,7 +529,7 @@ func (megb *MaintenanceEntryGroupBy) Aggregate(fns ...AggregateFunc) *Maintenanc
// Scan applies the selector query and scans the result into the given value.
func (megb *MaintenanceEntryGroupBy) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "GroupBy")
+ ctx = setContextOp(ctx, megb.build.ctx, "GroupBy")
if err := megb.build.prepareQuery(ctx); err != nil {
return err
}
@@ -582,7 +577,7 @@ func (mes *MaintenanceEntrySelect) Aggregate(fns ...AggregateFunc) *MaintenanceE
// Scan applies the selector query and scans the result into the given value.
func (mes *MaintenanceEntrySelect) Scan(ctx context.Context, v any) error {
- ctx = newQueryContext(ctx, TypeMaintenanceEntry, "Select")
+ ctx = setContextOp(ctx, mes.ctx, "Select")
if err := mes.prepareQuery(ctx); err != nil {
return err
}
diff --git a/backend/internal/data/ent/maintenanceentry_update.go b/backend/internal/data/ent/maintenanceentry_update.go
index d4c3ee3..3616d32 100644
--- a/backend/internal/data/ent/maintenanceentry_update.go
+++ b/backend/internal/data/ent/maintenanceentry_update.go
@@ -42,6 +42,14 @@ func (meu *MaintenanceEntryUpdate) SetItemID(u uuid.UUID) *MaintenanceEntryUpdat
return meu
}
+// SetNillableItemID sets the "item_id" field if the given value is not nil.
+func (meu *MaintenanceEntryUpdate) SetNillableItemID(u *uuid.UUID) *MaintenanceEntryUpdate {
+ if u != nil {
+ meu.SetItemID(*u)
+ }
+ return meu
+}
+
// SetDate sets the "date" field.
func (meu *MaintenanceEntryUpdate) SetDate(t time.Time) *MaintenanceEntryUpdate {
meu.mutation.SetDate(t)
@@ -56,12 +64,46 @@ func (meu *MaintenanceEntryUpdate) SetNillableDate(t *time.Time) *MaintenanceEnt
return meu
}
+// ClearDate clears the value of the "date" field.
+func (meu *MaintenanceEntryUpdate) ClearDate() *MaintenanceEntryUpdate {
+ meu.mutation.ClearDate()
+ return meu
+}
+
+// SetScheduledDate sets the "scheduled_date" field.
+func (meu *MaintenanceEntryUpdate) SetScheduledDate(t time.Time) *MaintenanceEntryUpdate {
+ meu.mutation.SetScheduledDate(t)
+ return meu
+}
+
+// SetNillableScheduledDate sets the "scheduled_date" field if the given value is not nil.
+func (meu *MaintenanceEntryUpdate) SetNillableScheduledDate(t *time.Time) *MaintenanceEntryUpdate {
+ if t != nil {
+ meu.SetScheduledDate(*t)
+ }
+ return meu
+}
+
+// ClearScheduledDate clears the value of the "scheduled_date" field.
+func (meu *MaintenanceEntryUpdate) ClearScheduledDate() *MaintenanceEntryUpdate {
+ meu.mutation.ClearScheduledDate()
+ return meu
+}
+
// SetName sets the "name" field.
func (meu *MaintenanceEntryUpdate) SetName(s string) *MaintenanceEntryUpdate {
meu.mutation.SetName(s)
return meu
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (meu *MaintenanceEntryUpdate) SetNillableName(s *string) *MaintenanceEntryUpdate {
+ if s != nil {
+ meu.SetName(*s)
+ }
+ return meu
+}
+
// SetDescription sets the "description" field.
func (meu *MaintenanceEntryUpdate) SetDescription(s string) *MaintenanceEntryUpdate {
meu.mutation.SetDescription(s)
@@ -122,7 +164,7 @@ func (meu *MaintenanceEntryUpdate) ClearItem() *MaintenanceEntryUpdate {
// Save executes the query and returns the number of nodes affected by the update operation.
func (meu *MaintenanceEntryUpdate) Save(ctx context.Context) (int, error) {
meu.defaults()
- return withHooks[int, MaintenanceEntryMutation](ctx, meu.sqlSave, meu.mutation, meu.hooks)
+ return withHooks(ctx, meu.sqlSave, meu.mutation, meu.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -177,16 +219,7 @@ func (meu *MaintenanceEntryUpdate) sqlSave(ctx context.Context) (n int, err erro
if err := meu.check(); err != nil {
return n, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: maintenanceentry.Table,
- Columns: maintenanceentry.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(maintenanceentry.Table, maintenanceentry.Columns, sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID))
if ps := meu.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
@@ -200,6 +233,15 @@ func (meu *MaintenanceEntryUpdate) sqlSave(ctx context.Context) (n int, err erro
if value, ok := meu.mutation.Date(); ok {
_spec.SetField(maintenanceentry.FieldDate, field.TypeTime, value)
}
+ if meu.mutation.DateCleared() {
+ _spec.ClearField(maintenanceentry.FieldDate, field.TypeTime)
+ }
+ if value, ok := meu.mutation.ScheduledDate(); ok {
+ _spec.SetField(maintenanceentry.FieldScheduledDate, field.TypeTime, value)
+ }
+ if meu.mutation.ScheduledDateCleared() {
+ _spec.ClearField(maintenanceentry.FieldScheduledDate, field.TypeTime)
+ }
if value, ok := meu.mutation.Name(); ok {
_spec.SetField(maintenanceentry.FieldName, field.TypeString, value)
}
@@ -223,10 +265,7 @@ func (meu *MaintenanceEntryUpdate) sqlSave(ctx context.Context) (n int, err erro
Columns: []string{maintenanceentry.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -239,10 +278,7 @@ func (meu *MaintenanceEntryUpdate) sqlSave(ctx context.Context) (n int, err erro
Columns: []string{maintenanceentry.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
@@ -282,6 +318,14 @@ func (meuo *MaintenanceEntryUpdateOne) SetItemID(u uuid.UUID) *MaintenanceEntryU
return meuo
}
+// SetNillableItemID sets the "item_id" field if the given value is not nil.
+func (meuo *MaintenanceEntryUpdateOne) SetNillableItemID(u *uuid.UUID) *MaintenanceEntryUpdateOne {
+ if u != nil {
+ meuo.SetItemID(*u)
+ }
+ return meuo
+}
+
// SetDate sets the "date" field.
func (meuo *MaintenanceEntryUpdateOne) SetDate(t time.Time) *MaintenanceEntryUpdateOne {
meuo.mutation.SetDate(t)
@@ -296,12 +340,46 @@ func (meuo *MaintenanceEntryUpdateOne) SetNillableDate(t *time.Time) *Maintenanc
return meuo
}
+// ClearDate clears the value of the "date" field.
+func (meuo *MaintenanceEntryUpdateOne) ClearDate() *MaintenanceEntryUpdateOne {
+ meuo.mutation.ClearDate()
+ return meuo
+}
+
+// SetScheduledDate sets the "scheduled_date" field.
+func (meuo *MaintenanceEntryUpdateOne) SetScheduledDate(t time.Time) *MaintenanceEntryUpdateOne {
+ meuo.mutation.SetScheduledDate(t)
+ return meuo
+}
+
+// SetNillableScheduledDate sets the "scheduled_date" field if the given value is not nil.
+func (meuo *MaintenanceEntryUpdateOne) SetNillableScheduledDate(t *time.Time) *MaintenanceEntryUpdateOne {
+ if t != nil {
+ meuo.SetScheduledDate(*t)
+ }
+ return meuo
+}
+
+// ClearScheduledDate clears the value of the "scheduled_date" field.
+func (meuo *MaintenanceEntryUpdateOne) ClearScheduledDate() *MaintenanceEntryUpdateOne {
+ meuo.mutation.ClearScheduledDate()
+ return meuo
+}
+
// SetName sets the "name" field.
func (meuo *MaintenanceEntryUpdateOne) SetName(s string) *MaintenanceEntryUpdateOne {
meuo.mutation.SetName(s)
return meuo
}
+// SetNillableName sets the "name" field if the given value is not nil.
+func (meuo *MaintenanceEntryUpdateOne) SetNillableName(s *string) *MaintenanceEntryUpdateOne {
+ if s != nil {
+ meuo.SetName(*s)
+ }
+ return meuo
+}
+
// SetDescription sets the "description" field.
func (meuo *MaintenanceEntryUpdateOne) SetDescription(s string) *MaintenanceEntryUpdateOne {
meuo.mutation.SetDescription(s)
@@ -359,6 +437,12 @@ func (meuo *MaintenanceEntryUpdateOne) ClearItem() *MaintenanceEntryUpdateOne {
return meuo
}
+// Where appends a list predicates to the MaintenanceEntryUpdate builder.
+func (meuo *MaintenanceEntryUpdateOne) Where(ps ...predicate.MaintenanceEntry) *MaintenanceEntryUpdateOne {
+ meuo.mutation.Where(ps...)
+ return meuo
+}
+
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (meuo *MaintenanceEntryUpdateOne) Select(field string, fields ...string) *MaintenanceEntryUpdateOne {
@@ -369,7 +453,7 @@ func (meuo *MaintenanceEntryUpdateOne) Select(field string, fields ...string) *M
// Save executes the query and returns the updated MaintenanceEntry entity.
func (meuo *MaintenanceEntryUpdateOne) Save(ctx context.Context) (*MaintenanceEntry, error) {
meuo.defaults()
- return withHooks[*MaintenanceEntry, MaintenanceEntryMutation](ctx, meuo.sqlSave, meuo.mutation, meuo.hooks)
+ return withHooks(ctx, meuo.sqlSave, meuo.mutation, meuo.hooks)
}
// SaveX is like Save, but panics if an error occurs.
@@ -424,16 +508,7 @@ func (meuo *MaintenanceEntryUpdateOne) sqlSave(ctx context.Context) (_node *Main
if err := meuo.check(); err != nil {
return _node, err
}
- _spec := &sqlgraph.UpdateSpec{
- Node: &sqlgraph.NodeSpec{
- Table: maintenanceentry.Table,
- Columns: maintenanceentry.Columns,
- ID: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: maintenanceentry.FieldID,
- },
- },
- }
+ _spec := sqlgraph.NewUpdateSpec(maintenanceentry.Table, maintenanceentry.Columns, sqlgraph.NewFieldSpec(maintenanceentry.FieldID, field.TypeUUID))
id, ok := meuo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "MaintenanceEntry.id" for update`)}
@@ -464,6 +539,15 @@ func (meuo *MaintenanceEntryUpdateOne) sqlSave(ctx context.Context) (_node *Main
if value, ok := meuo.mutation.Date(); ok {
_spec.SetField(maintenanceentry.FieldDate, field.TypeTime, value)
}
+ if meuo.mutation.DateCleared() {
+ _spec.ClearField(maintenanceentry.FieldDate, field.TypeTime)
+ }
+ if value, ok := meuo.mutation.ScheduledDate(); ok {
+ _spec.SetField(maintenanceentry.FieldScheduledDate, field.TypeTime, value)
+ }
+ if meuo.mutation.ScheduledDateCleared() {
+ _spec.ClearField(maintenanceentry.FieldScheduledDate, field.TypeTime)
+ }
if value, ok := meuo.mutation.Name(); ok {
_spec.SetField(maintenanceentry.FieldName, field.TypeString, value)
}
@@ -487,10 +571,7 @@ func (meuo *MaintenanceEntryUpdateOne) sqlSave(ctx context.Context) (_node *Main
Columns: []string{maintenanceentry.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
@@ -503,10 +584,7 @@ func (meuo *MaintenanceEntryUpdateOne) sqlSave(ctx context.Context) (_node *Main
Columns: []string{maintenanceentry.ItemColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
- IDSpec: &sqlgraph.FieldSpec{
- Type: field.TypeUUID,
- Column: item.FieldID,
- },
+ IDSpec: sqlgraph.NewFieldSpec(item.FieldID, field.TypeUUID),
},
}
for _, k := range nodes {
diff --git a/backend/internal/data/ent/migrate/schema.go b/backend/internal/data/ent/migrate/schema.go
index c700d34..2b58838 100644
--- a/backend/internal/data/ent/migrate/schema.go
+++ b/backend/internal/data/ent/migrate/schema.go
@@ -14,6 +14,7 @@ var (
{Name: "created_at", Type: field.TypeTime},
{Name: "updated_at", Type: field.TypeTime},
{Name: "type", Type: field.TypeEnum, Enums: []string{"photo", "manual", "warranty", "attachment", "receipt"}, Default: "attachment"},
+ {Name: "primary", Type: field.TypeBool, Default: false},
{Name: "document_attachments", Type: field.TypeUUID},
{Name: "item_attachments", Type: field.TypeUUID},
}
@@ -25,13 +26,13 @@ var (
ForeignKeys: []*schema.ForeignKey{
{
Symbol: "attachments_documents_attachments",
- Columns: []*schema.Column{AttachmentsColumns[4]},
+ Columns: []*schema.Column{AttachmentsColumns[5]},
RefColumns: []*schema.Column{DocumentsColumns[0]},
OnDelete: schema.Cascade,
},
{
Symbol: "attachments_items_attachments",
- Columns: []*schema.Column{AttachmentsColumns[5]},
+ Columns: []*schema.Column{AttachmentsColumns[6]},
RefColumns: []*schema.Column{ItemsColumns[0]},
OnDelete: schema.Cascade,
},
@@ -116,7 +117,7 @@ var (
{Name: "created_at", Type: field.TypeTime},
{Name: "updated_at", Type: field.TypeTime},
{Name: "name", Type: field.TypeString, Size: 255},
- {Name: "currency", Type: field.TypeEnum, Enums: []string{"usd", "eur", "gbp", "jpy", "zar", "aud", "nok", "sek", "dkk", "inr", "rmb"}, Default: "usd"},
+ {Name: "currency", Type: field.TypeString, Default: "usd"},
}
// GroupsTable holds the schema information for the "groups" table.
GroupsTable = &schema.Table{
@@ -323,7 +324,8 @@ var (
{Name: "id", Type: field.TypeUUID},
{Name: "created_at", Type: field.TypeTime},
{Name: "updated_at", Type: field.TypeTime},
- {Name: "date", Type: field.TypeTime},
+ {Name: "date", Type: field.TypeTime, Nullable: true},
+ {Name: "scheduled_date", Type: field.TypeTime, Nullable: true},
{Name: "name", Type: field.TypeString, Size: 255},
{Name: "description", Type: field.TypeString, Nullable: true, Size: 2500},
{Name: "cost", Type: field.TypeFloat64, Default: 0},
@@ -337,12 +339,65 @@ var (
ForeignKeys: []*schema.ForeignKey{
{
Symbol: "maintenance_entries_items_maintenance_entries",
- Columns: []*schema.Column{MaintenanceEntriesColumns[7]},
+ Columns: []*schema.Column{MaintenanceEntriesColumns[8]},
RefColumns: []*schema.Column{ItemsColumns[0]},
OnDelete: schema.Cascade,
},
},
}
+ // NotifiersColumns holds the columns for the "notifiers" table.
+ NotifiersColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "updated_at", Type: field.TypeTime},
+ {Name: "name", Type: field.TypeString, Size: 255},
+ {Name: "url", Type: field.TypeString, Size: 2083},
+ {Name: "is_active", Type: field.TypeBool, Default: true},
+ {Name: "group_id", Type: field.TypeUUID},
+ {Name: "user_id", Type: field.TypeUUID},
+ }
+ // NotifiersTable holds the schema information for the "notifiers" table.
+ NotifiersTable = &schema.Table{
+ Name: "notifiers",
+ Columns: NotifiersColumns,
+ PrimaryKey: []*schema.Column{NotifiersColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "notifiers_groups_notifiers",
+ Columns: []*schema.Column{NotifiersColumns[6]},
+ RefColumns: []*schema.Column{GroupsColumns[0]},
+ OnDelete: schema.Cascade,
+ },
+ {
+ Symbol: "notifiers_users_notifiers",
+ Columns: []*schema.Column{NotifiersColumns[7]},
+ RefColumns: []*schema.Column{UsersColumns[0]},
+ OnDelete: schema.Cascade,
+ },
+ },
+ Indexes: []*schema.Index{
+ {
+ Name: "notifier_user_id",
+ Unique: false,
+ Columns: []*schema.Column{NotifiersColumns[7]},
+ },
+ {
+ Name: "notifier_user_id_is_active",
+ Unique: false,
+ Columns: []*schema.Column{NotifiersColumns[7], NotifiersColumns[5]},
+ },
+ {
+ Name: "notifier_group_id",
+ Unique: false,
+ Columns: []*schema.Column{NotifiersColumns[6]},
+ },
+ {
+ Name: "notifier_group_id_is_active",
+ Unique: false,
+ Columns: []*schema.Column{NotifiersColumns[6], NotifiersColumns[5]},
+ },
+ },
+ }
// UsersColumns holds the columns for the "users" table.
UsersColumns = []*schema.Column{
{Name: "id", Type: field.TypeUUID},
@@ -352,8 +407,8 @@ var (
{Name: "email", Type: field.TypeString, Unique: true, Size: 255},
{Name: "password", Type: field.TypeString, Size: 255},
{Name: "is_superuser", Type: field.TypeBool, Default: false},
- {Name: "role", Type: field.TypeEnum, Enums: []string{"user", "owner"}, Default: "user"},
{Name: "superuser", Type: field.TypeBool, Default: false},
+ {Name: "role", Type: field.TypeEnum, Enums: []string{"user", "owner"}, Default: "user"},
{Name: "activated_on", Type: field.TypeTime, Nullable: true},
{Name: "group_users", Type: field.TypeUUID},
}
@@ -409,6 +464,7 @@ var (
LabelsTable,
LocationsTable,
MaintenanceEntriesTable,
+ NotifiersTable,
UsersTable,
LabelItemsTable,
}
@@ -429,6 +485,8 @@ func init() {
LocationsTable.ForeignKeys[0].RefTable = GroupsTable
LocationsTable.ForeignKeys[1].RefTable = LocationsTable
MaintenanceEntriesTable.ForeignKeys[0].RefTable = ItemsTable
+ NotifiersTable.ForeignKeys[0].RefTable = GroupsTable
+ NotifiersTable.ForeignKeys[1].RefTable = UsersTable
UsersTable.ForeignKeys[0].RefTable = GroupsTable
LabelItemsTable.ForeignKeys[0].RefTable = LabelsTable
LabelItemsTable.ForeignKeys[1].RefTable = ItemsTable
diff --git a/backend/internal/data/ent/mutation.go b/backend/internal/data/ent/mutation.go
index 164071e..6fa15d3 100644
--- a/backend/internal/data/ent/mutation.go
+++ b/backend/internal/data/ent/mutation.go
@@ -9,6 +9,8 @@ import (
"sync"
"time"
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
"github.com/google/uuid"
"github.com/hay-kot/homebox/backend/internal/data/ent/attachment"
"github.com/hay-kot/homebox/backend/internal/data/ent/authroles"
@@ -21,11 +23,9 @@ import (
"github.com/hay-kot/homebox/backend/internal/data/ent/label"
"github.com/hay-kot/homebox/backend/internal/data/ent/location"
"github.com/hay-kot/homebox/backend/internal/data/ent/maintenanceentry"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
"github.com/hay-kot/homebox/backend/internal/data/ent/predicate"
"github.com/hay-kot/homebox/backend/internal/data/ent/user"
-
- "entgo.io/ent"
- "entgo.io/ent/dialect/sql"
)
const (
@@ -48,6 +48,7 @@ const (
TypeLabel = "Label"
TypeLocation = "Location"
TypeMaintenanceEntry = "MaintenanceEntry"
+ TypeNotifier = "Notifier"
TypeUser = "User"
)
@@ -60,6 +61,7 @@ type AttachmentMutation struct {
created_at *time.Time
updated_at *time.Time
_type *attachment.Type
+ primary *bool
clearedFields map[string]struct{}
item *uuid.UUID
cleareditem bool
@@ -282,6 +284,42 @@ func (m *AttachmentMutation) ResetType() {
m._type = nil
}
+// SetPrimary sets the "primary" field.
+func (m *AttachmentMutation) SetPrimary(b bool) {
+ m.primary = &b
+}
+
+// Primary returns the value of the "primary" field in the mutation.
+func (m *AttachmentMutation) Primary() (r bool, exists bool) {
+ v := m.primary
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldPrimary returns the old "primary" field's value of the Attachment entity.
+// If the Attachment object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *AttachmentMutation) OldPrimary(ctx context.Context) (v bool, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldPrimary is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldPrimary requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldPrimary: %w", err)
+ }
+ return oldValue.Primary, nil
+}
+
+// ResetPrimary resets all changes to the "primary" field.
+func (m *AttachmentMutation) ResetPrimary() {
+ m.primary = nil
+}
+
// SetItemID sets the "item" edge to the Item entity by id.
func (m *AttachmentMutation) SetItemID(id uuid.UUID) {
m.item = &id
@@ -394,7 +432,7 @@ func (m *AttachmentMutation) Type() string {
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *AttachmentMutation) Fields() []string {
- fields := make([]string, 0, 3)
+ fields := make([]string, 0, 4)
if m.created_at != nil {
fields = append(fields, attachment.FieldCreatedAt)
}
@@ -404,6 +442,9 @@ func (m *AttachmentMutation) Fields() []string {
if m._type != nil {
fields = append(fields, attachment.FieldType)
}
+ if m.primary != nil {
+ fields = append(fields, attachment.FieldPrimary)
+ }
return fields
}
@@ -418,6 +459,8 @@ func (m *AttachmentMutation) Field(name string) (ent.Value, bool) {
return m.UpdatedAt()
case attachment.FieldType:
return m.GetType()
+ case attachment.FieldPrimary:
+ return m.Primary()
}
return nil, false
}
@@ -433,6 +476,8 @@ func (m *AttachmentMutation) OldField(ctx context.Context, name string) (ent.Val
return m.OldUpdatedAt(ctx)
case attachment.FieldType:
return m.OldType(ctx)
+ case attachment.FieldPrimary:
+ return m.OldPrimary(ctx)
}
return nil, fmt.Errorf("unknown Attachment field %s", name)
}
@@ -463,6 +508,13 @@ func (m *AttachmentMutation) SetField(name string, value ent.Value) error {
}
m.SetType(v)
return nil
+ case attachment.FieldPrimary:
+ v, ok := value.(bool)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetPrimary(v)
+ return nil
}
return fmt.Errorf("unknown Attachment field %s", name)
}
@@ -521,6 +573,9 @@ func (m *AttachmentMutation) ResetField(name string) error {
case attachment.FieldType:
m.ResetType()
return nil
+ case attachment.FieldPrimary:
+ m.ResetPrimary()
+ return nil
}
return fmt.Errorf("unknown Attachment field %s", name)
}
@@ -2285,7 +2340,7 @@ type GroupMutation struct {
created_at *time.Time
updated_at *time.Time
name *string
- currency *group.Currency
+ currency *string
clearedFields map[string]struct{}
users map[uuid.UUID]struct{}
removedusers map[uuid.UUID]struct{}
@@ -2305,6 +2360,9 @@ type GroupMutation struct {
invitation_tokens map[uuid.UUID]struct{}
removedinvitation_tokens map[uuid.UUID]struct{}
clearedinvitation_tokens bool
+ notifiers map[uuid.UUID]struct{}
+ removednotifiers map[uuid.UUID]struct{}
+ clearednotifiers bool
done bool
oldValue func(context.Context) (*Group, error)
predicates []predicate.Group
@@ -2523,12 +2581,12 @@ func (m *GroupMutation) ResetName() {
}
// SetCurrency sets the "currency" field.
-func (m *GroupMutation) SetCurrency(gr group.Currency) {
- m.currency = &gr
+func (m *GroupMutation) SetCurrency(s string) {
+ m.currency = &s
}
// Currency returns the value of the "currency" field in the mutation.
-func (m *GroupMutation) Currency() (r group.Currency, exists bool) {
+func (m *GroupMutation) Currency() (r string, exists bool) {
v := m.currency
if v == nil {
return
@@ -2539,7 +2597,7 @@ func (m *GroupMutation) Currency() (r group.Currency, exists bool) {
// OldCurrency returns the old "currency" field's value of the Group entity.
// If the Group object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *GroupMutation) OldCurrency(ctx context.Context) (v group.Currency, err error) {
+func (m *GroupMutation) OldCurrency(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldCurrency is only allowed on UpdateOne operations")
}
@@ -2882,6 +2940,60 @@ func (m *GroupMutation) ResetInvitationTokens() {
m.removedinvitation_tokens = nil
}
+// AddNotifierIDs adds the "notifiers" edge to the Notifier entity by ids.
+func (m *GroupMutation) AddNotifierIDs(ids ...uuid.UUID) {
+ if m.notifiers == nil {
+ m.notifiers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.notifiers[ids[i]] = struct{}{}
+ }
+}
+
+// ClearNotifiers clears the "notifiers" edge to the Notifier entity.
+func (m *GroupMutation) ClearNotifiers() {
+ m.clearednotifiers = true
+}
+
+// NotifiersCleared reports if the "notifiers" edge to the Notifier entity was cleared.
+func (m *GroupMutation) NotifiersCleared() bool {
+ return m.clearednotifiers
+}
+
+// RemoveNotifierIDs removes the "notifiers" edge to the Notifier entity by IDs.
+func (m *GroupMutation) RemoveNotifierIDs(ids ...uuid.UUID) {
+ if m.removednotifiers == nil {
+ m.removednotifiers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.notifiers, ids[i])
+ m.removednotifiers[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedNotifiers returns the removed IDs of the "notifiers" edge to the Notifier entity.
+func (m *GroupMutation) RemovedNotifiersIDs() (ids []uuid.UUID) {
+ for id := range m.removednotifiers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// NotifiersIDs returns the "notifiers" edge IDs in the mutation.
+func (m *GroupMutation) NotifiersIDs() (ids []uuid.UUID) {
+ for id := range m.notifiers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetNotifiers resets all changes to the "notifiers" edge.
+func (m *GroupMutation) ResetNotifiers() {
+ m.notifiers = nil
+ m.clearednotifiers = false
+ m.removednotifiers = nil
+}
+
// Where appends a list predicates to the GroupMutation builder.
func (m *GroupMutation) Where(ps ...predicate.Group) {
m.predicates = append(m.predicates, ps...)
@@ -2993,7 +3105,7 @@ func (m *GroupMutation) SetField(name string, value ent.Value) error {
m.SetName(v)
return nil
case group.FieldCurrency:
- v, ok := value.(group.Currency)
+ v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
@@ -3066,7 +3178,7 @@ func (m *GroupMutation) ResetField(name string) error {
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *GroupMutation) AddedEdges() []string {
- edges := make([]string, 0, 6)
+ edges := make([]string, 0, 7)
if m.users != nil {
edges = append(edges, group.EdgeUsers)
}
@@ -3085,6 +3197,9 @@ func (m *GroupMutation) AddedEdges() []string {
if m.invitation_tokens != nil {
edges = append(edges, group.EdgeInvitationTokens)
}
+ if m.notifiers != nil {
+ edges = append(edges, group.EdgeNotifiers)
+ }
return edges
}
@@ -3128,13 +3243,19 @@ func (m *GroupMutation) AddedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
+ case group.EdgeNotifiers:
+ ids := make([]ent.Value, 0, len(m.notifiers))
+ for id := range m.notifiers {
+ ids = append(ids, id)
+ }
+ return ids
}
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *GroupMutation) RemovedEdges() []string {
- edges := make([]string, 0, 6)
+ edges := make([]string, 0, 7)
if m.removedusers != nil {
edges = append(edges, group.EdgeUsers)
}
@@ -3153,6 +3274,9 @@ func (m *GroupMutation) RemovedEdges() []string {
if m.removedinvitation_tokens != nil {
edges = append(edges, group.EdgeInvitationTokens)
}
+ if m.removednotifiers != nil {
+ edges = append(edges, group.EdgeNotifiers)
+ }
return edges
}
@@ -3196,13 +3320,19 @@ func (m *GroupMutation) RemovedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
+ case group.EdgeNotifiers:
+ ids := make([]ent.Value, 0, len(m.removednotifiers))
+ for id := range m.removednotifiers {
+ ids = append(ids, id)
+ }
+ return ids
}
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *GroupMutation) ClearedEdges() []string {
- edges := make([]string, 0, 6)
+ edges := make([]string, 0, 7)
if m.clearedusers {
edges = append(edges, group.EdgeUsers)
}
@@ -3221,6 +3351,9 @@ func (m *GroupMutation) ClearedEdges() []string {
if m.clearedinvitation_tokens {
edges = append(edges, group.EdgeInvitationTokens)
}
+ if m.clearednotifiers {
+ edges = append(edges, group.EdgeNotifiers)
+ }
return edges
}
@@ -3240,6 +3373,8 @@ func (m *GroupMutation) EdgeCleared(name string) bool {
return m.cleareddocuments
case group.EdgeInvitationTokens:
return m.clearedinvitation_tokens
+ case group.EdgeNotifiers:
+ return m.clearednotifiers
}
return false
}
@@ -3274,6 +3409,9 @@ func (m *GroupMutation) ResetEdge(name string) error {
case group.EdgeInvitationTokens:
m.ResetInvitationTokens()
return nil
+ case group.EdgeNotifiers:
+ m.ResetNotifiers()
+ return nil
}
return fmt.Errorf("unknown Group edge %s", name)
}
@@ -3963,13 +4101,13 @@ type ItemMutation struct {
addsold_price *float64
sold_notes *string
clearedFields map[string]struct{}
+ group *uuid.UUID
+ clearedgroup bool
parent *uuid.UUID
clearedparent bool
children map[uuid.UUID]struct{}
removedchildren map[uuid.UUID]struct{}
clearedchildren bool
- group *uuid.UUID
- clearedgroup bool
label map[uuid.UUID]struct{}
removedlabel map[uuid.UUID]struct{}
clearedlabel bool
@@ -5170,6 +5308,45 @@ func (m *ItemMutation) ResetSoldNotes() {
delete(m.clearedFields, item.FieldSoldNotes)
}
+// SetGroupID sets the "group" edge to the Group entity by id.
+func (m *ItemMutation) SetGroupID(id uuid.UUID) {
+ m.group = &id
+}
+
+// ClearGroup clears the "group" edge to the Group entity.
+func (m *ItemMutation) ClearGroup() {
+ m.clearedgroup = true
+}
+
+// GroupCleared reports if the "group" edge to the Group entity was cleared.
+func (m *ItemMutation) GroupCleared() bool {
+ return m.clearedgroup
+}
+
+// GroupID returns the "group" edge ID in the mutation.
+func (m *ItemMutation) GroupID() (id uuid.UUID, exists bool) {
+ if m.group != nil {
+ return *m.group, true
+ }
+ return
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *ItemMutation) GroupIDs() (ids []uuid.UUID) {
+ if id := m.group; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetGroup resets all changes to the "group" edge.
+func (m *ItemMutation) ResetGroup() {
+ m.group = nil
+ m.clearedgroup = false
+}
+
// SetParentID sets the "parent" edge to the Item entity by id.
func (m *ItemMutation) SetParentID(id uuid.UUID) {
m.parent = &id
@@ -5263,45 +5440,6 @@ func (m *ItemMutation) ResetChildren() {
m.removedchildren = nil
}
-// SetGroupID sets the "group" edge to the Group entity by id.
-func (m *ItemMutation) SetGroupID(id uuid.UUID) {
- m.group = &id
-}
-
-// ClearGroup clears the "group" edge to the Group entity.
-func (m *ItemMutation) ClearGroup() {
- m.clearedgroup = true
-}
-
-// GroupCleared reports if the "group" edge to the Group entity was cleared.
-func (m *ItemMutation) GroupCleared() bool {
- return m.clearedgroup
-}
-
-// GroupID returns the "group" edge ID in the mutation.
-func (m *ItemMutation) GroupID() (id uuid.UUID, exists bool) {
- if m.group != nil {
- return *m.group, true
- }
- return
-}
-
-// GroupIDs returns the "group" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// GroupID instead. It exists only for internal usage by the builders.
-func (m *ItemMutation) GroupIDs() (ids []uuid.UUID) {
- if id := m.group; id != nil {
- ids = append(ids, *id)
- }
- return
-}
-
-// ResetGroup resets all changes to the "group" edge.
-func (m *ItemMutation) ResetGroup() {
- m.group = nil
- m.clearedgroup = false
-}
-
// AddLabelIDs adds the "label" edge to the Label entity by ids.
func (m *ItemMutation) AddLabelIDs(ids ...uuid.UUID) {
if m.label == nil {
@@ -6197,15 +6335,15 @@ func (m *ItemMutation) ResetField(name string) error {
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *ItemMutation) AddedEdges() []string {
edges := make([]string, 0, 8)
+ if m.group != nil {
+ edges = append(edges, item.EdgeGroup)
+ }
if m.parent != nil {
edges = append(edges, item.EdgeParent)
}
if m.children != nil {
edges = append(edges, item.EdgeChildren)
}
- if m.group != nil {
- edges = append(edges, item.EdgeGroup)
- }
if m.label != nil {
edges = append(edges, item.EdgeLabel)
}
@@ -6228,6 +6366,10 @@ func (m *ItemMutation) AddedEdges() []string {
// name in this mutation.
func (m *ItemMutation) AddedIDs(name string) []ent.Value {
switch name {
+ case item.EdgeGroup:
+ if id := m.group; id != nil {
+ return []ent.Value{*id}
+ }
case item.EdgeParent:
if id := m.parent; id != nil {
return []ent.Value{*id}
@@ -6238,10 +6380,6 @@ func (m *ItemMutation) AddedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
- case item.EdgeGroup:
- if id := m.group; id != nil {
- return []ent.Value{*id}
- }
case item.EdgeLabel:
ids := make([]ent.Value, 0, len(m.label))
for id := range m.label {
@@ -6336,15 +6474,15 @@ func (m *ItemMutation) RemovedIDs(name string) []ent.Value {
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *ItemMutation) ClearedEdges() []string {
edges := make([]string, 0, 8)
+ if m.clearedgroup {
+ edges = append(edges, item.EdgeGroup)
+ }
if m.clearedparent {
edges = append(edges, item.EdgeParent)
}
if m.clearedchildren {
edges = append(edges, item.EdgeChildren)
}
- if m.clearedgroup {
- edges = append(edges, item.EdgeGroup)
- }
if m.clearedlabel {
edges = append(edges, item.EdgeLabel)
}
@@ -6367,12 +6505,12 @@ func (m *ItemMutation) ClearedEdges() []string {
// was cleared in this mutation.
func (m *ItemMutation) EdgeCleared(name string) bool {
switch name {
+ case item.EdgeGroup:
+ return m.clearedgroup
case item.EdgeParent:
return m.clearedparent
case item.EdgeChildren:
return m.clearedchildren
- case item.EdgeGroup:
- return m.clearedgroup
case item.EdgeLabel:
return m.clearedlabel
case item.EdgeLocation:
@@ -6391,12 +6529,12 @@ func (m *ItemMutation) EdgeCleared(name string) bool {
// if that edge is not defined in the schema.
func (m *ItemMutation) ClearEdge(name string) error {
switch name {
- case item.EdgeParent:
- m.ClearParent()
- return nil
case item.EdgeGroup:
m.ClearGroup()
return nil
+ case item.EdgeParent:
+ m.ClearParent()
+ return nil
case item.EdgeLocation:
m.ClearLocation()
return nil
@@ -6408,15 +6546,15 @@ func (m *ItemMutation) ClearEdge(name string) error {
// It returns an error if the edge is not defined in the schema.
func (m *ItemMutation) ResetEdge(name string) error {
switch name {
+ case item.EdgeGroup:
+ m.ResetGroup()
+ return nil
case item.EdgeParent:
m.ResetParent()
return nil
case item.EdgeChildren:
m.ResetChildren()
return nil
- case item.EdgeGroup:
- m.ResetGroup()
- return nil
case item.EdgeLabel:
m.ResetLabel()
return nil
@@ -8116,13 +8254,13 @@ type LocationMutation struct {
name *string
description *string
clearedFields map[string]struct{}
+ group *uuid.UUID
+ clearedgroup bool
parent *uuid.UUID
clearedparent bool
children map[uuid.UUID]struct{}
removedchildren map[uuid.UUID]struct{}
clearedchildren bool
- group *uuid.UUID
- clearedgroup bool
items map[uuid.UUID]struct{}
removeditems map[uuid.UUID]struct{}
cleareditems bool
@@ -8392,6 +8530,45 @@ func (m *LocationMutation) ResetDescription() {
delete(m.clearedFields, location.FieldDescription)
}
+// SetGroupID sets the "group" edge to the Group entity by id.
+func (m *LocationMutation) SetGroupID(id uuid.UUID) {
+ m.group = &id
+}
+
+// ClearGroup clears the "group" edge to the Group entity.
+func (m *LocationMutation) ClearGroup() {
+ m.clearedgroup = true
+}
+
+// GroupCleared reports if the "group" edge to the Group entity was cleared.
+func (m *LocationMutation) GroupCleared() bool {
+ return m.clearedgroup
+}
+
+// GroupID returns the "group" edge ID in the mutation.
+func (m *LocationMutation) GroupID() (id uuid.UUID, exists bool) {
+ if m.group != nil {
+ return *m.group, true
+ }
+ return
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *LocationMutation) GroupIDs() (ids []uuid.UUID) {
+ if id := m.group; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetGroup resets all changes to the "group" edge.
+func (m *LocationMutation) ResetGroup() {
+ m.group = nil
+ m.clearedgroup = false
+}
+
// SetParentID sets the "parent" edge to the Location entity by id.
func (m *LocationMutation) SetParentID(id uuid.UUID) {
m.parent = &id
@@ -8485,45 +8662,6 @@ func (m *LocationMutation) ResetChildren() {
m.removedchildren = nil
}
-// SetGroupID sets the "group" edge to the Group entity by id.
-func (m *LocationMutation) SetGroupID(id uuid.UUID) {
- m.group = &id
-}
-
-// ClearGroup clears the "group" edge to the Group entity.
-func (m *LocationMutation) ClearGroup() {
- m.clearedgroup = true
-}
-
-// GroupCleared reports if the "group" edge to the Group entity was cleared.
-func (m *LocationMutation) GroupCleared() bool {
- return m.clearedgroup
-}
-
-// GroupID returns the "group" edge ID in the mutation.
-func (m *LocationMutation) GroupID() (id uuid.UUID, exists bool) {
- if m.group != nil {
- return *m.group, true
- }
- return
-}
-
-// GroupIDs returns the "group" edge IDs in the mutation.
-// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
-// GroupID instead. It exists only for internal usage by the builders.
-func (m *LocationMutation) GroupIDs() (ids []uuid.UUID) {
- if id := m.group; id != nil {
- ids = append(ids, *id)
- }
- return
-}
-
-// ResetGroup resets all changes to the "group" edge.
-func (m *LocationMutation) ResetGroup() {
- m.group = nil
- m.clearedgroup = false
-}
-
// AddItemIDs adds the "items" edge to the Item entity by ids.
func (m *LocationMutation) AddItemIDs(ids ...uuid.UUID) {
if m.items == nil {
@@ -8772,15 +8910,15 @@ func (m *LocationMutation) ResetField(name string) error {
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *LocationMutation) AddedEdges() []string {
edges := make([]string, 0, 4)
+ if m.group != nil {
+ edges = append(edges, location.EdgeGroup)
+ }
if m.parent != nil {
edges = append(edges, location.EdgeParent)
}
if m.children != nil {
edges = append(edges, location.EdgeChildren)
}
- if m.group != nil {
- edges = append(edges, location.EdgeGroup)
- }
if m.items != nil {
edges = append(edges, location.EdgeItems)
}
@@ -8791,6 +8929,10 @@ func (m *LocationMutation) AddedEdges() []string {
// name in this mutation.
func (m *LocationMutation) AddedIDs(name string) []ent.Value {
switch name {
+ case location.EdgeGroup:
+ if id := m.group; id != nil {
+ return []ent.Value{*id}
+ }
case location.EdgeParent:
if id := m.parent; id != nil {
return []ent.Value{*id}
@@ -8801,10 +8943,6 @@ func (m *LocationMutation) AddedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
- case location.EdgeGroup:
- if id := m.group; id != nil {
- return []ent.Value{*id}
- }
case location.EdgeItems:
ids := make([]ent.Value, 0, len(m.items))
for id := range m.items {
@@ -8850,15 +8988,15 @@ func (m *LocationMutation) RemovedIDs(name string) []ent.Value {
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *LocationMutation) ClearedEdges() []string {
edges := make([]string, 0, 4)
+ if m.clearedgroup {
+ edges = append(edges, location.EdgeGroup)
+ }
if m.clearedparent {
edges = append(edges, location.EdgeParent)
}
if m.clearedchildren {
edges = append(edges, location.EdgeChildren)
}
- if m.clearedgroup {
- edges = append(edges, location.EdgeGroup)
- }
if m.cleareditems {
edges = append(edges, location.EdgeItems)
}
@@ -8869,12 +9007,12 @@ func (m *LocationMutation) ClearedEdges() []string {
// was cleared in this mutation.
func (m *LocationMutation) EdgeCleared(name string) bool {
switch name {
+ case location.EdgeGroup:
+ return m.clearedgroup
case location.EdgeParent:
return m.clearedparent
case location.EdgeChildren:
return m.clearedchildren
- case location.EdgeGroup:
- return m.clearedgroup
case location.EdgeItems:
return m.cleareditems
}
@@ -8885,12 +9023,12 @@ func (m *LocationMutation) EdgeCleared(name string) bool {
// if that edge is not defined in the schema.
func (m *LocationMutation) ClearEdge(name string) error {
switch name {
- case location.EdgeParent:
- m.ClearParent()
- return nil
case location.EdgeGroup:
m.ClearGroup()
return nil
+ case location.EdgeParent:
+ m.ClearParent()
+ return nil
}
return fmt.Errorf("unknown Location unique edge %s", name)
}
@@ -8899,15 +9037,15 @@ func (m *LocationMutation) ClearEdge(name string) error {
// It returns an error if the edge is not defined in the schema.
func (m *LocationMutation) ResetEdge(name string) error {
switch name {
+ case location.EdgeGroup:
+ m.ResetGroup()
+ return nil
case location.EdgeParent:
m.ResetParent()
return nil
case location.EdgeChildren:
m.ResetChildren()
return nil
- case location.EdgeGroup:
- m.ResetGroup()
- return nil
case location.EdgeItems:
m.ResetItems()
return nil
@@ -8918,22 +9056,23 @@ func (m *LocationMutation) ResetEdge(name string) error {
// MaintenanceEntryMutation represents an operation that mutates the MaintenanceEntry nodes in the graph.
type MaintenanceEntryMutation struct {
config
- op Op
- typ string
- id *uuid.UUID
- created_at *time.Time
- updated_at *time.Time
- date *time.Time
- name *string
- description *string
- cost *float64
- addcost *float64
- clearedFields map[string]struct{}
- item *uuid.UUID
- cleareditem bool
- done bool
- oldValue func(context.Context) (*MaintenanceEntry, error)
- predicates []predicate.MaintenanceEntry
+ op Op
+ typ string
+ id *uuid.UUID
+ created_at *time.Time
+ updated_at *time.Time
+ date *time.Time
+ scheduled_date *time.Time
+ name *string
+ description *string
+ cost *float64
+ addcost *float64
+ clearedFields map[string]struct{}
+ item *uuid.UUID
+ cleareditem bool
+ done bool
+ oldValue func(context.Context) (*MaintenanceEntry, error)
+ predicates []predicate.MaintenanceEntry
}
var _ ent.Mutation = (*MaintenanceEntryMutation)(nil)
@@ -9179,9 +9318,71 @@ func (m *MaintenanceEntryMutation) OldDate(ctx context.Context) (v time.Time, er
return oldValue.Date, nil
}
+// ClearDate clears the value of the "date" field.
+func (m *MaintenanceEntryMutation) ClearDate() {
+ m.date = nil
+ m.clearedFields[maintenanceentry.FieldDate] = struct{}{}
+}
+
+// DateCleared returns if the "date" field was cleared in this mutation.
+func (m *MaintenanceEntryMutation) DateCleared() bool {
+ _, ok := m.clearedFields[maintenanceentry.FieldDate]
+ return ok
+}
+
// ResetDate resets all changes to the "date" field.
func (m *MaintenanceEntryMutation) ResetDate() {
m.date = nil
+ delete(m.clearedFields, maintenanceentry.FieldDate)
+}
+
+// SetScheduledDate sets the "scheduled_date" field.
+func (m *MaintenanceEntryMutation) SetScheduledDate(t time.Time) {
+ m.scheduled_date = &t
+}
+
+// ScheduledDate returns the value of the "scheduled_date" field in the mutation.
+func (m *MaintenanceEntryMutation) ScheduledDate() (r time.Time, exists bool) {
+ v := m.scheduled_date
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldScheduledDate returns the old "scheduled_date" field's value of the MaintenanceEntry entity.
+// If the MaintenanceEntry object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *MaintenanceEntryMutation) OldScheduledDate(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldScheduledDate is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldScheduledDate requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldScheduledDate: %w", err)
+ }
+ return oldValue.ScheduledDate, nil
+}
+
+// ClearScheduledDate clears the value of the "scheduled_date" field.
+func (m *MaintenanceEntryMutation) ClearScheduledDate() {
+ m.scheduled_date = nil
+ m.clearedFields[maintenanceentry.FieldScheduledDate] = struct{}{}
+}
+
+// ScheduledDateCleared returns if the "scheduled_date" field was cleared in this mutation.
+func (m *MaintenanceEntryMutation) ScheduledDateCleared() bool {
+ _, ok := m.clearedFields[maintenanceentry.FieldScheduledDate]
+ return ok
+}
+
+// ResetScheduledDate resets all changes to the "scheduled_date" field.
+func (m *MaintenanceEntryMutation) ResetScheduledDate() {
+ m.scheduled_date = nil
+ delete(m.clearedFields, maintenanceentry.FieldScheduledDate)
}
// SetName sets the "name" field.
@@ -9328,6 +9529,7 @@ func (m *MaintenanceEntryMutation) ResetCost() {
// ClearItem clears the "item" edge to the Item entity.
func (m *MaintenanceEntryMutation) ClearItem() {
m.cleareditem = true
+ m.clearedFields[maintenanceentry.FieldItemID] = struct{}{}
}
// ItemCleared reports if the "item" edge to the Item entity was cleared.
@@ -9385,7 +9587,7 @@ func (m *MaintenanceEntryMutation) Type() string {
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *MaintenanceEntryMutation) Fields() []string {
- fields := make([]string, 0, 7)
+ fields := make([]string, 0, 8)
if m.created_at != nil {
fields = append(fields, maintenanceentry.FieldCreatedAt)
}
@@ -9398,6 +9600,9 @@ func (m *MaintenanceEntryMutation) Fields() []string {
if m.date != nil {
fields = append(fields, maintenanceentry.FieldDate)
}
+ if m.scheduled_date != nil {
+ fields = append(fields, maintenanceentry.FieldScheduledDate)
+ }
if m.name != nil {
fields = append(fields, maintenanceentry.FieldName)
}
@@ -9423,6 +9628,8 @@ func (m *MaintenanceEntryMutation) Field(name string) (ent.Value, bool) {
return m.ItemID()
case maintenanceentry.FieldDate:
return m.Date()
+ case maintenanceentry.FieldScheduledDate:
+ return m.ScheduledDate()
case maintenanceentry.FieldName:
return m.Name()
case maintenanceentry.FieldDescription:
@@ -9446,6 +9653,8 @@ func (m *MaintenanceEntryMutation) OldField(ctx context.Context, name string) (e
return m.OldItemID(ctx)
case maintenanceentry.FieldDate:
return m.OldDate(ctx)
+ case maintenanceentry.FieldScheduledDate:
+ return m.OldScheduledDate(ctx)
case maintenanceentry.FieldName:
return m.OldName(ctx)
case maintenanceentry.FieldDescription:
@@ -9489,6 +9698,13 @@ func (m *MaintenanceEntryMutation) SetField(name string, value ent.Value) error
}
m.SetDate(v)
return nil
+ case maintenanceentry.FieldScheduledDate:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetScheduledDate(v)
+ return nil
case maintenanceentry.FieldName:
v, ok := value.(string)
if !ok {
@@ -9555,6 +9771,12 @@ func (m *MaintenanceEntryMutation) AddField(name string, value ent.Value) error
// mutation.
func (m *MaintenanceEntryMutation) ClearedFields() []string {
var fields []string
+ if m.FieldCleared(maintenanceentry.FieldDate) {
+ fields = append(fields, maintenanceentry.FieldDate)
+ }
+ if m.FieldCleared(maintenanceentry.FieldScheduledDate) {
+ fields = append(fields, maintenanceentry.FieldScheduledDate)
+ }
if m.FieldCleared(maintenanceentry.FieldDescription) {
fields = append(fields, maintenanceentry.FieldDescription)
}
@@ -9572,6 +9794,12 @@ func (m *MaintenanceEntryMutation) FieldCleared(name string) bool {
// error if the field is not defined in the schema.
func (m *MaintenanceEntryMutation) ClearField(name string) error {
switch name {
+ case maintenanceentry.FieldDate:
+ m.ClearDate()
+ return nil
+ case maintenanceentry.FieldScheduledDate:
+ m.ClearScheduledDate()
+ return nil
case maintenanceentry.FieldDescription:
m.ClearDescription()
return nil
@@ -9595,6 +9823,9 @@ func (m *MaintenanceEntryMutation) ResetField(name string) error {
case maintenanceentry.FieldDate:
m.ResetDate()
return nil
+ case maintenanceentry.FieldScheduledDate:
+ m.ResetScheduledDate()
+ return nil
case maintenanceentry.FieldName:
m.ResetName()
return nil
@@ -9682,6 +9913,762 @@ func (m *MaintenanceEntryMutation) ResetEdge(name string) error {
return fmt.Errorf("unknown MaintenanceEntry edge %s", name)
}
+// NotifierMutation represents an operation that mutates the Notifier nodes in the graph.
+type NotifierMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ created_at *time.Time
+ updated_at *time.Time
+ name *string
+ url *string
+ is_active *bool
+ clearedFields map[string]struct{}
+ group *uuid.UUID
+ clearedgroup bool
+ user *uuid.UUID
+ cleareduser bool
+ done bool
+ oldValue func(context.Context) (*Notifier, error)
+ predicates []predicate.Notifier
+}
+
+var _ ent.Mutation = (*NotifierMutation)(nil)
+
+// notifierOption allows management of the mutation configuration using functional options.
+type notifierOption func(*NotifierMutation)
+
+// newNotifierMutation creates new mutation for the Notifier entity.
+func newNotifierMutation(c config, op Op, opts ...notifierOption) *NotifierMutation {
+ m := &NotifierMutation{
+ config: c,
+ op: op,
+ typ: TypeNotifier,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withNotifierID sets the ID field of the mutation.
+func withNotifierID(id uuid.UUID) notifierOption {
+ return func(m *NotifierMutation) {
+ var (
+ err error
+ once sync.Once
+ value *Notifier
+ )
+ m.oldValue = func(ctx context.Context) (*Notifier, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().Notifier.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withNotifier sets the old Notifier of the mutation.
+func withNotifier(node *Notifier) notifierOption {
+ return func(m *NotifierMutation) {
+ m.oldValue = func(context.Context) (*Notifier, error) {
+ return node, nil
+ }
+ m.id = &node.ID
+ }
+}
+
+// Client returns a new `ent.Client` from the mutation. If the mutation was
+// executed in a transaction (ent.Tx), a transactional client is returned.
+func (m NotifierMutation) Client() *Client {
+ client := &Client{config: m.config}
+ client.init()
+ return client
+}
+
+// Tx returns an `ent.Tx` for mutations that were executed in transactions;
+// it returns an error otherwise.
+func (m NotifierMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("ent: mutation is not running in a transaction")
+ }
+ tx := &Tx{config: m.config}
+ tx.init()
+ return tx, nil
+}
+
+// SetID sets the value of the id field. Note that this
+// operation is only accepted on creation of Notifier entities.
+func (m *NotifierMutation) SetID(id uuid.UUID) {
+ m.id = &id
+}
+
+// ID returns the ID value in the mutation. Note that the ID is only available
+// if it was provided to the builder or after it was returned from the database.
+func (m *NotifierMutation) ID() (id uuid.UUID, exists bool) {
+ if m.id == nil {
+ return
+ }
+ return *m.id, true
+}
+
+// IDs queries the database and returns the entity ids that match the mutation's predicate.
+// That means, if the mutation is applied within a transaction with an isolation level such
+// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
+// or updated by the mutation.
+func (m *NotifierMutation) IDs(ctx context.Context) ([]uuid.UUID, error) {
+ switch {
+ case m.op.Is(OpUpdateOne | OpDeleteOne):
+ id, exists := m.ID()
+ if exists {
+ return []uuid.UUID{id}, nil
+ }
+ fallthrough
+ case m.op.Is(OpUpdate | OpDelete):
+ return m.Client().Notifier.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *NotifierMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *NotifierMutation) CreatedAt() (r time.Time, exists bool) {
+ v := m.created_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldCreatedAt returns the old "created_at" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldCreatedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldCreatedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldCreatedAt: %w", err)
+ }
+ return oldValue.CreatedAt, nil
+}
+
+// ResetCreatedAt resets all changes to the "created_at" field.
+func (m *NotifierMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *NotifierMutation) SetUpdatedAt(t time.Time) {
+ m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *NotifierMutation) UpdatedAt() (r time.Time, exists bool) {
+ v := m.updated_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUpdatedAt returns the old "updated_at" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUpdatedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUpdatedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUpdatedAt: %w", err)
+ }
+ return oldValue.UpdatedAt, nil
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *NotifierMutation) ResetUpdatedAt() {
+ m.updated_at = nil
+}
+
+// SetGroupID sets the "group_id" field.
+func (m *NotifierMutation) SetGroupID(u uuid.UUID) {
+ m.group = &u
+}
+
+// GroupID returns the value of the "group_id" field in the mutation.
+func (m *NotifierMutation) GroupID() (r uuid.UUID, exists bool) {
+ v := m.group
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldGroupID returns the old "group_id" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldGroupID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldGroupID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldGroupID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldGroupID: %w", err)
+ }
+ return oldValue.GroupID, nil
+}
+
+// ResetGroupID resets all changes to the "group_id" field.
+func (m *NotifierMutation) ResetGroupID() {
+ m.group = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *NotifierMutation) SetUserID(u uuid.UUID) {
+ m.user = &u
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *NotifierMutation) UserID() (r uuid.UUID, exists bool) {
+ v := m.user
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+ }
+ return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *NotifierMutation) ResetUserID() {
+ m.user = nil
+}
+
+// SetName sets the "name" field.
+func (m *NotifierMutation) SetName(s string) {
+ m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *NotifierMutation) Name() (r string, exists bool) {
+ v := m.name
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldName returns the old "name" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldName(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldName is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldName requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldName: %w", err)
+ }
+ return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *NotifierMutation) ResetName() {
+ m.name = nil
+}
+
+// SetURL sets the "url" field.
+func (m *NotifierMutation) SetURL(s string) {
+ m.url = &s
+}
+
+// URL returns the value of the "url" field in the mutation.
+func (m *NotifierMutation) URL() (r string, exists bool) {
+ v := m.url
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldURL returns the old "url" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldURL(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldURL is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldURL requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldURL: %w", err)
+ }
+ return oldValue.URL, nil
+}
+
+// ResetURL resets all changes to the "url" field.
+func (m *NotifierMutation) ResetURL() {
+ m.url = nil
+}
+
+// SetIsActive sets the "is_active" field.
+func (m *NotifierMutation) SetIsActive(b bool) {
+ m.is_active = &b
+}
+
+// IsActive returns the value of the "is_active" field in the mutation.
+func (m *NotifierMutation) IsActive() (r bool, exists bool) {
+ v := m.is_active
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldIsActive returns the old "is_active" field's value of the Notifier entity.
+// If the Notifier object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *NotifierMutation) OldIsActive(ctx context.Context) (v bool, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldIsActive is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldIsActive requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldIsActive: %w", err)
+ }
+ return oldValue.IsActive, nil
+}
+
+// ResetIsActive resets all changes to the "is_active" field.
+func (m *NotifierMutation) ResetIsActive() {
+ m.is_active = nil
+}
+
+// ClearGroup clears the "group" edge to the Group entity.
+func (m *NotifierMutation) ClearGroup() {
+ m.clearedgroup = true
+ m.clearedFields[notifier.FieldGroupID] = struct{}{}
+}
+
+// GroupCleared reports if the "group" edge to the Group entity was cleared.
+func (m *NotifierMutation) GroupCleared() bool {
+ return m.clearedgroup
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *NotifierMutation) GroupIDs() (ids []uuid.UUID) {
+ if id := m.group; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetGroup resets all changes to the "group" edge.
+func (m *NotifierMutation) ResetGroup() {
+ m.group = nil
+ m.clearedgroup = false
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *NotifierMutation) ClearUser() {
+ m.cleareduser = true
+ m.clearedFields[notifier.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *NotifierMutation) UserCleared() bool {
+ return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *NotifierMutation) UserIDs() (ids []uuid.UUID) {
+ if id := m.user; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *NotifierMutation) ResetUser() {
+ m.user = nil
+ m.cleareduser = false
+}
+
+// Where appends a list predicates to the NotifierMutation builder.
+func (m *NotifierMutation) Where(ps ...predicate.Notifier) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the NotifierMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *NotifierMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.Notifier, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *NotifierMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *NotifierMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (Notifier).
+func (m *NotifierMutation) Type() string {
+ return m.typ
+}
+
+// Fields returns all fields that were changed during this mutation. Note that in
+// order to get all numeric fields that were incremented/decremented, call
+// AddedFields().
+func (m *NotifierMutation) Fields() []string {
+ fields := make([]string, 0, 7)
+ if m.created_at != nil {
+ fields = append(fields, notifier.FieldCreatedAt)
+ }
+ if m.updated_at != nil {
+ fields = append(fields, notifier.FieldUpdatedAt)
+ }
+ if m.group != nil {
+ fields = append(fields, notifier.FieldGroupID)
+ }
+ if m.user != nil {
+ fields = append(fields, notifier.FieldUserID)
+ }
+ if m.name != nil {
+ fields = append(fields, notifier.FieldName)
+ }
+ if m.url != nil {
+ fields = append(fields, notifier.FieldURL)
+ }
+ if m.is_active != nil {
+ fields = append(fields, notifier.FieldIsActive)
+ }
+ return fields
+}
+
+// Field returns the value of a field with the given name. The second boolean
+// return value indicates that this field was not set, or was not defined in the
+// schema.
+func (m *NotifierMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case notifier.FieldCreatedAt:
+ return m.CreatedAt()
+ case notifier.FieldUpdatedAt:
+ return m.UpdatedAt()
+ case notifier.FieldGroupID:
+ return m.GroupID()
+ case notifier.FieldUserID:
+ return m.UserID()
+ case notifier.FieldName:
+ return m.Name()
+ case notifier.FieldURL:
+ return m.URL()
+ case notifier.FieldIsActive:
+ return m.IsActive()
+ }
+ return nil, false
+}
+
+// OldField returns the old value of the field from the database. An error is
+// returned if the mutation operation is not UpdateOne, or the query to the
+// database failed.
+func (m *NotifierMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case notifier.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ case notifier.FieldUpdatedAt:
+ return m.OldUpdatedAt(ctx)
+ case notifier.FieldGroupID:
+ return m.OldGroupID(ctx)
+ case notifier.FieldUserID:
+ return m.OldUserID(ctx)
+ case notifier.FieldName:
+ return m.OldName(ctx)
+ case notifier.FieldURL:
+ return m.OldURL(ctx)
+ case notifier.FieldIsActive:
+ return m.OldIsActive(ctx)
+ }
+ return nil, fmt.Errorf("unknown Notifier field %s", name)
+}
+
+// SetField sets the value of a field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *NotifierMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case notifier.FieldCreatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetCreatedAt(v)
+ return nil
+ case notifier.FieldUpdatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUpdatedAt(v)
+ return nil
+ case notifier.FieldGroupID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetGroupID(v)
+ return nil
+ case notifier.FieldUserID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserID(v)
+ return nil
+ case notifier.FieldName:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetName(v)
+ return nil
+ case notifier.FieldURL:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetURL(v)
+ return nil
+ case notifier.FieldIsActive:
+ v, ok := value.(bool)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetIsActive(v)
+ return nil
+ }
+ return fmt.Errorf("unknown Notifier field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *NotifierMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *NotifierMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *NotifierMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown Notifier numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *NotifierMutation) ClearedFields() []string {
+ return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *NotifierMutation) FieldCleared(name string) bool {
+ _, ok := m.clearedFields[name]
+ return ok
+}
+
+// ClearField clears the value of the field with the given name. It returns an
+// error if the field is not defined in the schema.
+func (m *NotifierMutation) ClearField(name string) error {
+ return fmt.Errorf("unknown Notifier nullable field %s", name)
+}
+
+// ResetField resets all changes in the mutation for the field with the given name.
+// It returns an error if the field is not defined in the schema.
+func (m *NotifierMutation) ResetField(name string) error {
+ switch name {
+ case notifier.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ case notifier.FieldUpdatedAt:
+ m.ResetUpdatedAt()
+ return nil
+ case notifier.FieldGroupID:
+ m.ResetGroupID()
+ return nil
+ case notifier.FieldUserID:
+ m.ResetUserID()
+ return nil
+ case notifier.FieldName:
+ m.ResetName()
+ return nil
+ case notifier.FieldURL:
+ m.ResetURL()
+ return nil
+ case notifier.FieldIsActive:
+ m.ResetIsActive()
+ return nil
+ }
+ return fmt.Errorf("unknown Notifier field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *NotifierMutation) AddedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.group != nil {
+ edges = append(edges, notifier.EdgeGroup)
+ }
+ if m.user != nil {
+ edges = append(edges, notifier.EdgeUser)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *NotifierMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case notifier.EdgeGroup:
+ if id := m.group; id != nil {
+ return []ent.Value{*id}
+ }
+ case notifier.EdgeUser:
+ if id := m.user; id != nil {
+ return []ent.Value{*id}
+ }
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *NotifierMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 2)
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *NotifierMutation) RemovedIDs(name string) []ent.Value {
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *NotifierMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.clearedgroup {
+ edges = append(edges, notifier.EdgeGroup)
+ }
+ if m.cleareduser {
+ edges = append(edges, notifier.EdgeUser)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *NotifierMutation) EdgeCleared(name string) bool {
+ switch name {
+ case notifier.EdgeGroup:
+ return m.clearedgroup
+ case notifier.EdgeUser:
+ return m.cleareduser
+ }
+ return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *NotifierMutation) ClearEdge(name string) error {
+ switch name {
+ case notifier.EdgeGroup:
+ m.ClearGroup()
+ return nil
+ case notifier.EdgeUser:
+ m.ClearUser()
+ return nil
+ }
+ return fmt.Errorf("unknown Notifier unique edge %s", name)
+}
+
+// ResetEdge resets all changes to the edge with the given name in this mutation.
+// It returns an error if the edge is not defined in the schema.
+func (m *NotifierMutation) ResetEdge(name string) error {
+ switch name {
+ case notifier.EdgeGroup:
+ m.ResetGroup()
+ return nil
+ case notifier.EdgeUser:
+ m.ResetUser()
+ return nil
+ }
+ return fmt.Errorf("unknown Notifier edge %s", name)
+}
+
// UserMutation represents an operation that mutates the User nodes in the graph.
type UserMutation struct {
config
@@ -9694,8 +10681,8 @@ type UserMutation struct {
email *string
password *string
is_superuser *bool
- role *user.Role
superuser *bool
+ role *user.Role
activated_on *time.Time
clearedFields map[string]struct{}
group *uuid.UUID
@@ -9703,6 +10690,9 @@ type UserMutation struct {
auth_tokens map[uuid.UUID]struct{}
removedauth_tokens map[uuid.UUID]struct{}
clearedauth_tokens bool
+ notifiers map[uuid.UUID]struct{}
+ removednotifiers map[uuid.UUID]struct{}
+ clearednotifiers bool
done bool
oldValue func(context.Context) (*User, error)
predicates []predicate.User
@@ -10028,42 +11018,6 @@ func (m *UserMutation) ResetIsSuperuser() {
m.is_superuser = nil
}
-// SetRole sets the "role" field.
-func (m *UserMutation) SetRole(u user.Role) {
- m.role = &u
-}
-
-// Role returns the value of the "role" field in the mutation.
-func (m *UserMutation) Role() (r user.Role, exists bool) {
- v := m.role
- if v == nil {
- return
- }
- return *v, true
-}
-
-// OldRole returns the old "role" field's value of the User entity.
-// If the User object wasn't provided to the builder, the object is fetched from the database.
-// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *UserMutation) OldRole(ctx context.Context) (v user.Role, err error) {
- if !m.op.Is(OpUpdateOne) {
- return v, errors.New("OldRole is only allowed on UpdateOne operations")
- }
- if m.id == nil || m.oldValue == nil {
- return v, errors.New("OldRole requires an ID field in the mutation")
- }
- oldValue, err := m.oldValue(ctx)
- if err != nil {
- return v, fmt.Errorf("querying old value for OldRole: %w", err)
- }
- return oldValue.Role, nil
-}
-
-// ResetRole resets all changes to the "role" field.
-func (m *UserMutation) ResetRole() {
- m.role = nil
-}
-
// SetSuperuser sets the "superuser" field.
func (m *UserMutation) SetSuperuser(b bool) {
m.superuser = &b
@@ -10100,6 +11054,42 @@ func (m *UserMutation) ResetSuperuser() {
m.superuser = nil
}
+// SetRole sets the "role" field.
+func (m *UserMutation) SetRole(u user.Role) {
+ m.role = &u
+}
+
+// Role returns the value of the "role" field in the mutation.
+func (m *UserMutation) Role() (r user.Role, exists bool) {
+ v := m.role
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldRole returns the old "role" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldRole(ctx context.Context) (v user.Role, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldRole is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldRole requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldRole: %w", err)
+ }
+ return oldValue.Role, nil
+}
+
+// ResetRole resets all changes to the "role" field.
+func (m *UserMutation) ResetRole() {
+ m.role = nil
+}
+
// SetActivatedOn sets the "activated_on" field.
func (m *UserMutation) SetActivatedOn(t time.Time) {
m.activated_on = &t
@@ -10242,6 +11232,60 @@ func (m *UserMutation) ResetAuthTokens() {
m.removedauth_tokens = nil
}
+// AddNotifierIDs adds the "notifiers" edge to the Notifier entity by ids.
+func (m *UserMutation) AddNotifierIDs(ids ...uuid.UUID) {
+ if m.notifiers == nil {
+ m.notifiers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.notifiers[ids[i]] = struct{}{}
+ }
+}
+
+// ClearNotifiers clears the "notifiers" edge to the Notifier entity.
+func (m *UserMutation) ClearNotifiers() {
+ m.clearednotifiers = true
+}
+
+// NotifiersCleared reports if the "notifiers" edge to the Notifier entity was cleared.
+func (m *UserMutation) NotifiersCleared() bool {
+ return m.clearednotifiers
+}
+
+// RemoveNotifierIDs removes the "notifiers" edge to the Notifier entity by IDs.
+func (m *UserMutation) RemoveNotifierIDs(ids ...uuid.UUID) {
+ if m.removednotifiers == nil {
+ m.removednotifiers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.notifiers, ids[i])
+ m.removednotifiers[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedNotifiers returns the removed IDs of the "notifiers" edge to the Notifier entity.
+func (m *UserMutation) RemovedNotifiersIDs() (ids []uuid.UUID) {
+ for id := range m.removednotifiers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// NotifiersIDs returns the "notifiers" edge IDs in the mutation.
+func (m *UserMutation) NotifiersIDs() (ids []uuid.UUID) {
+ for id := range m.notifiers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetNotifiers resets all changes to the "notifiers" edge.
+func (m *UserMutation) ResetNotifiers() {
+ m.notifiers = nil
+ m.clearednotifiers = false
+ m.removednotifiers = nil
+}
+
// Where appends a list predicates to the UserMutation builder.
func (m *UserMutation) Where(ps ...predicate.User) {
m.predicates = append(m.predicates, ps...)
@@ -10295,12 +11339,12 @@ func (m *UserMutation) Fields() []string {
if m.is_superuser != nil {
fields = append(fields, user.FieldIsSuperuser)
}
- if m.role != nil {
- fields = append(fields, user.FieldRole)
- }
if m.superuser != nil {
fields = append(fields, user.FieldSuperuser)
}
+ if m.role != nil {
+ fields = append(fields, user.FieldRole)
+ }
if m.activated_on != nil {
fields = append(fields, user.FieldActivatedOn)
}
@@ -10324,10 +11368,10 @@ func (m *UserMutation) Field(name string) (ent.Value, bool) {
return m.Password()
case user.FieldIsSuperuser:
return m.IsSuperuser()
- case user.FieldRole:
- return m.Role()
case user.FieldSuperuser:
return m.Superuser()
+ case user.FieldRole:
+ return m.Role()
case user.FieldActivatedOn:
return m.ActivatedOn()
}
@@ -10351,10 +11395,10 @@ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, er
return m.OldPassword(ctx)
case user.FieldIsSuperuser:
return m.OldIsSuperuser(ctx)
- case user.FieldRole:
- return m.OldRole(ctx)
case user.FieldSuperuser:
return m.OldSuperuser(ctx)
+ case user.FieldRole:
+ return m.OldRole(ctx)
case user.FieldActivatedOn:
return m.OldActivatedOn(ctx)
}
@@ -10408,13 +11452,6 @@ func (m *UserMutation) SetField(name string, value ent.Value) error {
}
m.SetIsSuperuser(v)
return nil
- case user.FieldRole:
- v, ok := value.(user.Role)
- if !ok {
- return fmt.Errorf("unexpected type %T for field %s", value, name)
- }
- m.SetRole(v)
- return nil
case user.FieldSuperuser:
v, ok := value.(bool)
if !ok {
@@ -10422,6 +11459,13 @@ func (m *UserMutation) SetField(name string, value ent.Value) error {
}
m.SetSuperuser(v)
return nil
+ case user.FieldRole:
+ v, ok := value.(user.Role)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetRole(v)
+ return nil
case user.FieldActivatedOn:
v, ok := value.(time.Time)
if !ok {
@@ -10505,12 +11549,12 @@ func (m *UserMutation) ResetField(name string) error {
case user.FieldIsSuperuser:
m.ResetIsSuperuser()
return nil
- case user.FieldRole:
- m.ResetRole()
- return nil
case user.FieldSuperuser:
m.ResetSuperuser()
return nil
+ case user.FieldRole:
+ m.ResetRole()
+ return nil
case user.FieldActivatedOn:
m.ResetActivatedOn()
return nil
@@ -10520,13 +11564,16 @@ func (m *UserMutation) ResetField(name string) error {
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *UserMutation) AddedEdges() []string {
- edges := make([]string, 0, 2)
+ edges := make([]string, 0, 3)
if m.group != nil {
edges = append(edges, user.EdgeGroup)
}
if m.auth_tokens != nil {
edges = append(edges, user.EdgeAuthTokens)
}
+ if m.notifiers != nil {
+ edges = append(edges, user.EdgeNotifiers)
+ }
return edges
}
@@ -10544,16 +11591,25 @@ func (m *UserMutation) AddedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
+ case user.EdgeNotifiers:
+ ids := make([]ent.Value, 0, len(m.notifiers))
+ for id := range m.notifiers {
+ ids = append(ids, id)
+ }
+ return ids
}
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *UserMutation) RemovedEdges() []string {
- edges := make([]string, 0, 2)
+ edges := make([]string, 0, 3)
if m.removedauth_tokens != nil {
edges = append(edges, user.EdgeAuthTokens)
}
+ if m.removednotifiers != nil {
+ edges = append(edges, user.EdgeNotifiers)
+ }
return edges
}
@@ -10567,19 +11623,28 @@ func (m *UserMutation) RemovedIDs(name string) []ent.Value {
ids = append(ids, id)
}
return ids
+ case user.EdgeNotifiers:
+ ids := make([]ent.Value, 0, len(m.removednotifiers))
+ for id := range m.removednotifiers {
+ ids = append(ids, id)
+ }
+ return ids
}
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *UserMutation) ClearedEdges() []string {
- edges := make([]string, 0, 2)
+ edges := make([]string, 0, 3)
if m.clearedgroup {
edges = append(edges, user.EdgeGroup)
}
if m.clearedauth_tokens {
edges = append(edges, user.EdgeAuthTokens)
}
+ if m.clearednotifiers {
+ edges = append(edges, user.EdgeNotifiers)
+ }
return edges
}
@@ -10591,6 +11656,8 @@ func (m *UserMutation) EdgeCleared(name string) bool {
return m.clearedgroup
case user.EdgeAuthTokens:
return m.clearedauth_tokens
+ case user.EdgeNotifiers:
+ return m.clearednotifiers
}
return false
}
@@ -10616,6 +11683,9 @@ func (m *UserMutation) ResetEdge(name string) error {
case user.EdgeAuthTokens:
m.ResetAuthTokens()
return nil
+ case user.EdgeNotifiers:
+ m.ResetNotifiers()
+ return nil
}
return fmt.Errorf("unknown User edge %s", name)
}
diff --git a/backend/internal/data/ent/notifier.go b/backend/internal/data/ent/notifier.go
new file mode 100644
index 0000000..05a267b
--- /dev/null
+++ b/backend/internal/data/ent/notifier.go
@@ -0,0 +1,226 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/google/uuid"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/group"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/notifier"
+ "github.com/hay-kot/homebox/backend/internal/data/ent/user"
+)
+
+// Notifier is the model entity for the Notifier schema.
+type Notifier struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // CreatedAt holds the value of the "created_at" field.
+ CreatedAt time.Time `json:"created_at,omitempty"`
+ // UpdatedAt holds the value of the "updated_at" field.
+ UpdatedAt time.Time `json:"updated_at,omitempty"`
+ // GroupID holds the value of the "group_id" field.
+ GroupID uuid.UUID `json:"group_id,omitempty"`
+ // UserID holds the value of the "user_id" field.
+ UserID uuid.UUID `json:"user_id,omitempty"`
+ // Name holds the value of the "name" field.
+ Name string `json:"name,omitempty"`
+ // URL holds the value of the "url" field.
+ URL string `json:"-"`
+ // IsActive holds the value of the "is_active" field.
+ IsActive bool `json:"is_active,omitempty"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the NotifierQuery when eager-loading is set.
+ Edges NotifierEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// NotifierEdges holds the relations/edges for other nodes in the graph.
+type NotifierEdges struct {
+ // Group holds the value of the group edge.
+ Group *Group `json:"group,omitempty"`
+ // User holds the value of the user edge.
+ User *User `json:"user,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [2]bool
+}
+
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e NotifierEdges) GroupOrErr() (*Group, error) {
+ if e.loadedTypes[0] {
+ if e.Group == nil {
+ // Edge was loaded but was not found.
+ return nil, &NotFoundError{label: group.Label}
+ }
+ return e.Group, nil
+ }
+ return nil, &NotLoadedError{edge: "group"}
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e NotifierEdges) UserOrErr() (*User, error) {
+ if e.loadedTypes[1] {
+ if e.User == nil {
+ // Edge was loaded but was not found.
+ return nil, &NotFoundError{label: user.Label}
+ }
+ return e.User, nil
+ }
+ return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Notifier) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case notifier.FieldIsActive:
+ values[i] = new(sql.NullBool)
+ case notifier.FieldName, notifier.FieldURL:
+ values[i] = new(sql.NullString)
+ case notifier.FieldCreatedAt, notifier.FieldUpdatedAt:
+ values[i] = new(sql.NullTime)
+ case notifier.FieldID, notifier.FieldGroupID, notifier.FieldUserID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Notifier fields.
+func (n *Notifier) assignValues(columns []string, values []any) error {
+ if m, n := len(values), len(columns); m < n {
+ return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+ }
+ for i := range columns {
+ switch columns[i] {
+ case notifier.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ n.ID = *value
+ }
+ case notifier.FieldCreatedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field created_at", values[i])
+ } else if value.Valid {
+ n.CreatedAt = value.Time
+ }
+ case notifier.FieldUpdatedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+ } else if value.Valid {
+ n.UpdatedAt = value.Time
+ }
+ case notifier.FieldGroupID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field group_id", values[i])
+ } else if value != nil {
+ n.GroupID = *value
+ }
+ case notifier.FieldUserID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field user_id", values[i])
+ } else if value != nil {
+ n.UserID = *value
+ }
+ case notifier.FieldName:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field name", values[i])
+ } else if value.Valid {
+ n.Name = value.String
+ }
+ case notifier.FieldURL:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field url", values[i])
+ } else if value.Valid {
+ n.URL = value.String
+ }
+ case notifier.FieldIsActive:
+ if value, ok := values[i].(*sql.NullBool); !ok {
+ return fmt.Errorf("unexpected type %T for field is_active", values[i])
+ } else if value.Valid {
+ n.IsActive = value.Bool
+ }
+ default:
+ n.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Notifier.
+// This includes values selected through modifiers, order, etc.
+func (n *Notifier) Value(name string) (ent.Value, error) {
+ return n.selectValues.Get(name)
+}
+
+// QueryGroup queries the "group" edge of the Notifier entity.
+func (n *Notifier) QueryGroup() *GroupQuery {
+ return NewNotifierClient(n.config).QueryGroup(n)
+}
+
+// QueryUser queries the "user" edge of the Notifier entity.
+func (n *Notifier) QueryUser() *UserQuery {
+ return NewNotifierClient(n.config).QueryUser(n)
+}
+
+// Update returns a builder for updating this Notifier.
+// Note that you need to call Notifier.Unwrap() before calling this method if this Notifier
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (n *Notifier) Update() *NotifierUpdateOne {
+ return NewNotifierClient(n.config).UpdateOne(n)
+}
+
+// Unwrap unwraps the Notifier entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (n *Notifier) Unwrap() *Notifier {
+ _tx, ok := n.config.driver.(*txDriver)
+ if !ok {
+ panic("ent: Notifier is not a transactional entity")
+ }
+ n.config.driver = _tx.drv
+ return n
+}
+
+// String implements the fmt.Stringer.
+func (n *Notifier) String() string {
+ var builder strings.Builder
+ builder.WriteString("Notifier(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", n.ID))
+ builder.WriteString("created_at=")
+ builder.WriteString(n.CreatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("updated_at=")
+ builder.WriteString(n.UpdatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("group_id=")
+ builder.WriteString(fmt.Sprintf("%v", n.GroupID))
+ builder.WriteString(", ")
+ builder.WriteString("user_id=")
+ builder.WriteString(fmt.Sprintf("%v", n.UserID))
+ builder.WriteString(", ")
+ builder.WriteString("name=")
+ builder.WriteString(n.Name)
+ builder.WriteString(", ")
+ builder.WriteString("url=
+