From 245591cb23a81bceac9c444327377c8c0914f7f6 Mon Sep 17 00:00:00 2001 From: Hayden <64056131+hay-kot@users.noreply.github.com> Date: Sat, 1 Oct 2022 14:02:14 -0800 Subject: [PATCH] (wip) init token APIs --- backend/app/api/docs/docs.go | 63 ++ backend/app/api/docs/swagger.json | 63 ++ backend/app/api/docs/swagger.yaml | 39 + backend/app/api/routes.go | 2 + backend/app/api/v1/v1_ctrl_group.go | 62 ++ backend/ent/client.go | 177 +++- backend/ent/config.go | 21 +- backend/ent/ent.go | 22 +- backend/ent/group.go | 18 +- backend/ent/group/group.go | 9 + backend/ent/group/where.go | 28 + backend/ent/group_create.go | 35 + backend/ent/group_query.go | 121 ++- backend/ent/group_update.go | 181 ++++ backend/ent/groupinvitationtoken.go | 190 +++++ .../groupinvitationtoken.go | 83 ++ backend/ent/groupinvitationtoken/where.go | 498 +++++++++++ backend/ent/groupinvitationtoken_create.go | 413 +++++++++ backend/ent/groupinvitationtoken_delete.go | 115 +++ backend/ent/groupinvitationtoken_query.go | 614 ++++++++++++++ backend/ent/groupinvitationtoken_update.go | 550 ++++++++++++ backend/ent/hook/hook.go | 13 + backend/ent/migrate/schema.go | 26 + backend/ent/mutation.go | 799 +++++++++++++++++- backend/ent/predicate/predicate.go | 3 + backend/ent/runtime.go | 28 + backend/ent/schema/group.go | 4 + backend/ent/schema/group_invitation_token.go | 42 + backend/ent/tx.go | 3 + .../20221001210956_group_invitations.sql | 4 + .../internal/migrations/migrations/atlas.sum | 3 +- backend/internal/repo/main_test.go | 4 +- backend/internal/repo/repo_group.go | 103 ++- backend/internal/repo/repo_group_test.go | 4 +- backend/internal/services/main_test.go | 4 +- backend/internal/services/service_user.go | 61 +- frontend/lib/api/types/data-contracts.ts | 12 + 37 files changed, 4286 insertions(+), 131 deletions(-) create mode 100644 backend/app/api/v1/v1_ctrl_group.go create mode 100644 backend/ent/groupinvitationtoken.go create mode 100644 backend/ent/groupinvitationtoken/groupinvitationtoken.go create mode 100644 backend/ent/groupinvitationtoken/where.go create mode 100644 backend/ent/groupinvitationtoken_create.go create mode 100644 backend/ent/groupinvitationtoken_delete.go create mode 100644 backend/ent/groupinvitationtoken_query.go create mode 100644 backend/ent/groupinvitationtoken_update.go create mode 100644 backend/ent/schema/group_invitation_token.go create mode 100644 backend/internal/migrations/migrations/20221001210956_group_invitations.sql diff --git a/backend/app/api/docs/docs.go b/backend/app/api/docs/docs.go index c420603..7cd9965 100644 --- a/backend/app/api/docs/docs.go +++ b/backend/app/api/docs/docs.go @@ -21,6 +21,41 @@ const docTemplate = `{ "host": "{{.Host}}", "basePath": "{{.BasePath}}", "paths": { + "/v1/groups/invitations": { + "post": { + "security": [ + { + "Bearer": [] + } + ], + "produces": [ + "application/json" + ], + "tags": [ + "User" + ], + "summary": "Get the current user", + "parameters": [ + { + "description": "User Data", + "name": "payload", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1.GroupTokenPayload" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/v1.GroupTokenResponse" + } + } + } + } + }, "/v1/items": { "get": { "security": [ @@ -1504,6 +1539,9 @@ const docTemplate = `{ }, "password": { "type": "string" + }, + "token": { + "type": "string" } } }, @@ -1544,6 +1582,31 @@ const docTemplate = `{ } } }, + "v1.GroupTokenPayload": { + "type": "object", + "properties": { + "expiresAt": { + "type": "string" + }, + "uses": { + "type": "integer" + } + } + }, + "v1.GroupTokenResponse": { + "type": "object", + "properties": { + "expiresAt": { + "type": "string" + }, + "token": { + "type": "string" + }, + "uses": { + "type": "integer" + } + } + }, "v1.ItemAttachmentToken": { "type": "object", "properties": { diff --git a/backend/app/api/docs/swagger.json b/backend/app/api/docs/swagger.json index bae7858..a6287ea 100644 --- a/backend/app/api/docs/swagger.json +++ b/backend/app/api/docs/swagger.json @@ -13,6 +13,41 @@ }, "basePath": "/api", "paths": { + "/v1/groups/invitations": { + "post": { + "security": [ + { + "Bearer": [] + } + ], + "produces": [ + "application/json" + ], + "tags": [ + "User" + ], + "summary": "Get the current user", + "parameters": [ + { + "description": "User Data", + "name": "payload", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1.GroupTokenPayload" + } + } + ], + "responses": { + "200": { + "description": "OK", + "schema": { + "$ref": "#/definitions/v1.GroupTokenResponse" + } + } + } + } + }, "/v1/items": { "get": { "security": [ @@ -1496,6 +1531,9 @@ }, "password": { "type": "string" + }, + "token": { + "type": "string" } } }, @@ -1536,6 +1574,31 @@ } } }, + "v1.GroupTokenPayload": { + "type": "object", + "properties": { + "expiresAt": { + "type": "string" + }, + "uses": { + "type": "integer" + } + } + }, + "v1.GroupTokenResponse": { + "type": "object", + "properties": { + "expiresAt": { + "type": "string" + }, + "token": { + "type": "string" + }, + "uses": { + "type": "integer" + } + } + }, "v1.ItemAttachmentToken": { "type": "object", "properties": { diff --git a/backend/app/api/docs/swagger.yaml b/backend/app/api/docs/swagger.yaml index 404d682..a624a43 100644 --- a/backend/app/api/docs/swagger.yaml +++ b/backend/app/api/docs/swagger.yaml @@ -328,6 +328,8 @@ definitions: type: string password: type: string + token: + type: string type: object v1.ApiSummary: properties: @@ -353,6 +355,22 @@ definitions: version: type: string type: object + v1.GroupTokenPayload: + properties: + expiresAt: + type: string + uses: + type: integer + type: object + v1.GroupTokenResponse: + properties: + expiresAt: + type: string + token: + type: string + uses: + type: integer + type: object v1.ItemAttachmentToken: properties: token: @@ -376,6 +394,27 @@ info: title: Go API Templates version: "1.0" paths: + /v1/groups/invitations: + post: + parameters: + - description: User Data + in: body + name: payload + required: true + schema: + $ref: '#/definitions/v1.GroupTokenPayload' + produces: + - application/json + responses: + "200": + description: OK + schema: + $ref: '#/definitions/v1.GroupTokenResponse' + security: + - Bearer: [] + summary: Get the current user + tags: + - User /v1/items: get: produces: diff --git a/backend/app/api/routes.go b/backend/app/api/routes.go index 4b20fe8..b9e93be 100644 --- a/backend/app/api/routes.go +++ b/backend/app/api/routes.go @@ -66,6 +66,8 @@ func (a *app) newRouter(repos *repo.AllRepos) *chi.Mux { r.Post(v1Base("/users/logout"), v1Ctrl.HandleAuthLogout()) r.Get(v1Base("/users/refresh"), v1Ctrl.HandleAuthRefresh()) + r.Post(v1Base("/groups/invitations"), v1Ctrl.HandleGroupInvitationsCreate()) + r.Get(v1Base("/locations"), v1Ctrl.HandleLocationGetAll()) r.Post(v1Base("/locations"), v1Ctrl.HandleLocationCreate()) r.Get(v1Base("/locations/{id}"), v1Ctrl.HandleLocationGet()) diff --git a/backend/app/api/v1/v1_ctrl_group.go b/backend/app/api/v1/v1_ctrl_group.go new file mode 100644 index 0000000..8e1cb6f --- /dev/null +++ b/backend/app/api/v1/v1_ctrl_group.go @@ -0,0 +1,62 @@ +package v1 + +import ( + "net/http" + "time" + + "github.com/hay-kot/homebox/backend/internal/services" + "github.com/hay-kot/homebox/backend/pkgs/server" + "github.com/rs/zerolog/log" +) + +type ( + GroupTokenPayload struct { + Uses int `json:"uses"` + ExpiresAt time.Time `json:"expiresAt"` + } + + GroupTokenResponse struct { + Token string `json:"token"` + ExpiresAt time.Time `json:"expiresAt"` + Uses int `json:"uses"` + } +) + +// HandleUserSelf godoc +// @Summary Get the current user +// @Tags User +// @Produce json +// @Param payload body GroupTokenPayload true "User Data" +// @Success 200 {object} GroupTokenResponse +// @Router /v1/groups/invitations [Post] +// @Security Bearer +func (ctrl *V1Controller) HandleGroupInvitationsCreate() http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + data := GroupTokenPayload{} + + if err := server.Decode(r, &data); err != nil { + log.Err(err).Msg("failed to decode user registration data") + server.RespondError(w, http.StatusInternalServerError, err) + return + } + + if data.ExpiresAt.IsZero() { + data.ExpiresAt = time.Now().Add(time.Hour * 24) + } + + ctx := services.NewContext(r.Context()) + + token, err := ctrl.svc.User.NewInvitation(ctx, data.Uses, data.ExpiresAt) + if err != nil { + log.Err(err).Msg("failed to create new token") + server.RespondError(w, http.StatusInternalServerError, err) + return + } + + server.Respond(w, http.StatusCreated, server.Wrap(GroupTokenResponse{ + Token: token, + ExpiresAt: data.ExpiresAt, + Uses: data.Uses, + })) + } +} diff --git a/backend/ent/client.go b/backend/ent/client.go index 0172b66..54a0d47 100644 --- a/backend/ent/client.go +++ b/backend/ent/client.go @@ -16,6 +16,7 @@ import ( "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/documenttoken" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/itemfield" "github.com/hay-kot/homebox/backend/ent/label" @@ -42,6 +43,8 @@ type Client struct { DocumentToken *DocumentTokenClient // Group is the client for interacting with the Group builders. Group *GroupClient + // GroupInvitationToken is the client for interacting with the GroupInvitationToken builders. + GroupInvitationToken *GroupInvitationTokenClient // Item is the client for interacting with the Item builders. Item *ItemClient // ItemField is the client for interacting with the ItemField builders. @@ -70,6 +73,7 @@ func (c *Client) init() { c.Document = NewDocumentClient(c.config) c.DocumentToken = NewDocumentTokenClient(c.config) c.Group = NewGroupClient(c.config) + c.GroupInvitationToken = NewGroupInvitationTokenClient(c.config) c.Item = NewItemClient(c.config) c.ItemField = NewItemFieldClient(c.config) c.Label = NewLabelClient(c.config) @@ -106,18 +110,19 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) { cfg := c.config cfg.driver = tx return &Tx{ - ctx: ctx, - config: cfg, - Attachment: NewAttachmentClient(cfg), - AuthTokens: NewAuthTokensClient(cfg), - Document: NewDocumentClient(cfg), - DocumentToken: NewDocumentTokenClient(cfg), - Group: NewGroupClient(cfg), - Item: NewItemClient(cfg), - ItemField: NewItemFieldClient(cfg), - Label: NewLabelClient(cfg), - Location: NewLocationClient(cfg), - User: NewUserClient(cfg), + ctx: ctx, + config: cfg, + Attachment: NewAttachmentClient(cfg), + AuthTokens: NewAuthTokensClient(cfg), + Document: NewDocumentClient(cfg), + DocumentToken: NewDocumentTokenClient(cfg), + Group: NewGroupClient(cfg), + GroupInvitationToken: NewGroupInvitationTokenClient(cfg), + Item: NewItemClient(cfg), + ItemField: NewItemFieldClient(cfg), + Label: NewLabelClient(cfg), + Location: NewLocationClient(cfg), + User: NewUserClient(cfg), }, nil } @@ -135,18 +140,19 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) cfg := c.config cfg.driver = &txDriver{tx: tx, drv: c.driver} return &Tx{ - ctx: ctx, - config: cfg, - Attachment: NewAttachmentClient(cfg), - AuthTokens: NewAuthTokensClient(cfg), - Document: NewDocumentClient(cfg), - DocumentToken: NewDocumentTokenClient(cfg), - Group: NewGroupClient(cfg), - Item: NewItemClient(cfg), - ItemField: NewItemFieldClient(cfg), - Label: NewLabelClient(cfg), - Location: NewLocationClient(cfg), - User: NewUserClient(cfg), + ctx: ctx, + config: cfg, + Attachment: NewAttachmentClient(cfg), + AuthTokens: NewAuthTokensClient(cfg), + Document: NewDocumentClient(cfg), + DocumentToken: NewDocumentTokenClient(cfg), + Group: NewGroupClient(cfg), + GroupInvitationToken: NewGroupInvitationTokenClient(cfg), + Item: NewItemClient(cfg), + ItemField: NewItemFieldClient(cfg), + Label: NewLabelClient(cfg), + Location: NewLocationClient(cfg), + User: NewUserClient(cfg), }, nil } @@ -180,6 +186,7 @@ func (c *Client) Use(hooks ...Hook) { c.Document.Use(hooks...) c.DocumentToken.Use(hooks...) c.Group.Use(hooks...) + c.GroupInvitationToken.Use(hooks...) c.Item.Use(hooks...) c.ItemField.Use(hooks...) c.Label.Use(hooks...) @@ -824,11 +831,133 @@ func (c *GroupClient) QueryDocuments(gr *Group) *DocumentQuery { return query } +// QueryInvitationTokens queries the invitation_tokens edge of a Group. +func (c *GroupClient) QueryInvitationTokens(gr *Group) *GroupInvitationTokenQuery { + query := &GroupInvitationTokenQuery{config: c.config} + query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) { + id := gr.ID + step := sqlgraph.NewStep( + sqlgraph.From(group.Table, group.FieldID, id), + sqlgraph.To(groupinvitationtoken.Table, groupinvitationtoken.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, group.InvitationTokensTable, group.InvitationTokensColumn), + ) + 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 } +// GroupInvitationTokenClient is a client for the GroupInvitationToken schema. +type GroupInvitationTokenClient struct { + config +} + +// NewGroupInvitationTokenClient returns a client for the GroupInvitationToken from the given config. +func NewGroupInvitationTokenClient(c config) *GroupInvitationTokenClient { + return &GroupInvitationTokenClient{config: c} +} + +// Use adds a list of mutation hooks to the hooks stack. +// A call to `Use(f, g, h)` equals to `groupinvitationtoken.Hooks(f(g(h())))`. +func (c *GroupInvitationTokenClient) Use(hooks ...Hook) { + c.hooks.GroupInvitationToken = append(c.hooks.GroupInvitationToken, hooks...) +} + +// Create returns a builder for creating a GroupInvitationToken entity. +func (c *GroupInvitationTokenClient) Create() *GroupInvitationTokenCreate { + mutation := newGroupInvitationTokenMutation(c.config, OpCreate) + return &GroupInvitationTokenCreate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// CreateBulk returns a builder for creating a bulk of GroupInvitationToken entities. +func (c *GroupInvitationTokenClient) CreateBulk(builders ...*GroupInvitationTokenCreate) *GroupInvitationTokenCreateBulk { + return &GroupInvitationTokenCreateBulk{config: c.config, builders: builders} +} + +// Update returns an update builder for GroupInvitationToken. +func (c *GroupInvitationTokenClient) Update() *GroupInvitationTokenUpdate { + mutation := newGroupInvitationTokenMutation(c.config, OpUpdate) + return &GroupInvitationTokenUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOne returns an update builder for the given entity. +func (c *GroupInvitationTokenClient) UpdateOne(git *GroupInvitationToken) *GroupInvitationTokenUpdateOne { + mutation := newGroupInvitationTokenMutation(c.config, OpUpdateOne, withGroupInvitationToken(git)) + return &GroupInvitationTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// UpdateOneID returns an update builder for the given id. +func (c *GroupInvitationTokenClient) UpdateOneID(id uuid.UUID) *GroupInvitationTokenUpdateOne { + mutation := newGroupInvitationTokenMutation(c.config, OpUpdateOne, withGroupInvitationTokenID(id)) + return &GroupInvitationTokenUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// Delete returns a delete builder for GroupInvitationToken. +func (c *GroupInvitationTokenClient) Delete() *GroupInvitationTokenDelete { + mutation := newGroupInvitationTokenMutation(c.config, OpDelete) + return &GroupInvitationTokenDelete{config: c.config, hooks: c.Hooks(), mutation: mutation} +} + +// DeleteOne returns a builder for deleting the given entity. +func (c *GroupInvitationTokenClient) DeleteOne(git *GroupInvitationToken) *GroupInvitationTokenDeleteOne { + return c.DeleteOneID(git.ID) +} + +// DeleteOne returns a builder for deleting the given entity by its id. +func (c *GroupInvitationTokenClient) DeleteOneID(id uuid.UUID) *GroupInvitationTokenDeleteOne { + builder := c.Delete().Where(groupinvitationtoken.ID(id)) + builder.mutation.id = &id + builder.mutation.op = OpDeleteOne + return &GroupInvitationTokenDeleteOne{builder} +} + +// Query returns a query builder for GroupInvitationToken. +func (c *GroupInvitationTokenClient) Query() *GroupInvitationTokenQuery { + return &GroupInvitationTokenQuery{ + config: c.config, + } +} + +// Get returns a GroupInvitationToken entity by its id. +func (c *GroupInvitationTokenClient) Get(ctx context.Context, id uuid.UUID) (*GroupInvitationToken, error) { + return c.Query().Where(groupinvitationtoken.ID(id)).Only(ctx) +} + +// GetX is like Get, but panics if an error occurs. +func (c *GroupInvitationTokenClient) GetX(ctx context.Context, id uuid.UUID) *GroupInvitationToken { + obj, err := c.Get(ctx, id) + if err != nil { + panic(err) + } + return obj +} + +// QueryGroup queries the group edge of a GroupInvitationToken. +func (c *GroupInvitationTokenClient) QueryGroup(git *GroupInvitationToken) *GroupQuery { + query := &GroupQuery{config: c.config} + query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) { + id := git.ID + step := sqlgraph.NewStep( + sqlgraph.From(groupinvitationtoken.Table, groupinvitationtoken.FieldID, id), + sqlgraph.To(group.Table, group.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, groupinvitationtoken.GroupTable, groupinvitationtoken.GroupColumn), + ) + fromV = sqlgraph.Neighbors(git.driver.Dialect(), step) + return fromV, nil + } + return query +} + +// Hooks returns the client hooks. +func (c *GroupInvitationTokenClient) Hooks() []Hook { + return c.hooks.GroupInvitationToken +} + // ItemClient is a client for the Item schema. type ItemClient struct { config diff --git a/backend/ent/config.go b/backend/ent/config.go index 11cf05c..da76f30 100644 --- a/backend/ent/config.go +++ b/backend/ent/config.go @@ -24,16 +24,17 @@ type config struct { // hooks per client, for fast access. type hooks struct { - Attachment []ent.Hook - AuthTokens []ent.Hook - Document []ent.Hook - DocumentToken []ent.Hook - Group []ent.Hook - Item []ent.Hook - ItemField []ent.Hook - Label []ent.Hook - Location []ent.Hook - User []ent.Hook + Attachment []ent.Hook + AuthTokens []ent.Hook + Document []ent.Hook + DocumentToken []ent.Hook + Group []ent.Hook + GroupInvitationToken []ent.Hook + Item []ent.Hook + ItemField []ent.Hook + Label []ent.Hook + Location []ent.Hook + User []ent.Hook } // Options applies the options on the config object. diff --git a/backend/ent/ent.go b/backend/ent/ent.go index f8f3348..66676f3 100644 --- a/backend/ent/ent.go +++ b/backend/ent/ent.go @@ -15,6 +15,7 @@ import ( "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/documenttoken" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/itemfield" "github.com/hay-kot/homebox/backend/ent/label" @@ -40,16 +41,17 @@ 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, - authtokens.Table: authtokens.ValidColumn, - document.Table: document.ValidColumn, - documenttoken.Table: documenttoken.ValidColumn, - group.Table: group.ValidColumn, - item.Table: item.ValidColumn, - itemfield.Table: itemfield.ValidColumn, - label.Table: label.ValidColumn, - location.Table: location.ValidColumn, - user.Table: user.ValidColumn, + attachment.Table: attachment.ValidColumn, + authtokens.Table: authtokens.ValidColumn, + document.Table: document.ValidColumn, + documenttoken.Table: documenttoken.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, + user.Table: user.ValidColumn, } check, ok := checks[table] if !ok { diff --git a/backend/ent/group.go b/backend/ent/group.go index 788382b..814560c 100644 --- a/backend/ent/group.go +++ b/backend/ent/group.go @@ -42,9 +42,11 @@ type GroupEdges struct { Labels []*Label `json:"labels,omitempty"` // Documents holds the value of the documents edge. Documents []*Document `json:"documents,omitempty"` + // InvitationTokens holds the value of the invitation_tokens edge. + InvitationTokens []*GroupInvitationToken `json:"invitation_tokens,omitempty"` // loadedTypes holds the information for reporting if a // type was loaded (or requested) in eager-loading or not. - loadedTypes [5]bool + loadedTypes [6]bool } // UsersOrErr returns the Users value or an error if the edge @@ -92,6 +94,15 @@ func (e GroupEdges) DocumentsOrErr() ([]*Document, error) { return nil, &NotLoadedError{edge: "documents"} } +// InvitationTokensOrErr returns the InvitationTokens value or an error if the edge +// was not loaded in eager-loading. +func (e GroupEdges) InvitationTokensOrErr() ([]*GroupInvitationToken, error) { + if e.loadedTypes[5] { + return e.InvitationTokens, nil + } + return nil, &NotLoadedError{edge: "invitation_tokens"} +} + // scanValues returns the types for scanning values from sql.Rows. func (*Group) scanValues(columns []string) ([]any, error) { values := make([]any, len(columns)) @@ -178,6 +189,11 @@ func (gr *Group) QueryDocuments() *DocumentQuery { return (&GroupClient{config: 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) +} + // 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. diff --git a/backend/ent/group/group.go b/backend/ent/group/group.go index d30b781..7485a7e 100644 --- a/backend/ent/group/group.go +++ b/backend/ent/group/group.go @@ -32,6 +32,8 @@ const ( EdgeLabels = "labels" // EdgeDocuments holds the string denoting the documents edge name in mutations. EdgeDocuments = "documents" + // EdgeInvitationTokens holds the string denoting the invitation_tokens edge name in mutations. + EdgeInvitationTokens = "invitation_tokens" // Table holds the table name of the group in the database. Table = "groups" // UsersTable is the table that holds the users relation/edge. @@ -69,6 +71,13 @@ const ( DocumentsInverseTable = "documents" // DocumentsColumn is the table column denoting the documents relation/edge. DocumentsColumn = "group_documents" + // InvitationTokensTable is the table that holds the invitation_tokens relation/edge. + InvitationTokensTable = "group_invitation_tokens" + // InvitationTokensInverseTable is the table name for the GroupInvitationToken entity. + // It exists in this package in order to avoid circular dependency with the "groupinvitationtoken" package. + InvitationTokensInverseTable = "group_invitation_tokens" + // InvitationTokensColumn is the table column denoting the invitation_tokens relation/edge. + InvitationTokensColumn = "group_invitation_tokens" ) // Columns holds all SQL columns for group fields. diff --git a/backend/ent/group/where.go b/backend/ent/group/where.go index 7c55e78..b95fef7 100644 --- a/backend/ent/group/where.go +++ b/backend/ent/group/where.go @@ -506,6 +506,34 @@ func HasDocumentsWith(preds ...predicate.Document) predicate.Group { }) } +// HasInvitationTokens applies the HasEdge predicate on the "invitation_tokens" edge. +func HasInvitationTokens() predicate.Group { + return predicate.Group(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(InvitationTokensTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, InvitationTokensTable, InvitationTokensColumn), + ) + sqlgraph.HasNeighbors(s, step) + }) +} + +// 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 := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(InvitationTokensInverseTable, FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, InvitationTokensTable, InvitationTokensColumn), + ) + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + // And groups predicates with the AND operator between them. func And(predicates ...predicate.Group) predicate.Group { return predicate.Group(func(s *sql.Selector) { diff --git a/backend/ent/group_create.go b/backend/ent/group_create.go index 86080f2..cdb4619 100644 --- a/backend/ent/group_create.go +++ b/backend/ent/group_create.go @@ -13,6 +13,7 @@ import ( "github.com/google/uuid" "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/label" "github.com/hay-kot/homebox/backend/ent/location" @@ -163,6 +164,21 @@ func (gc *GroupCreate) AddDocuments(d ...*Document) *GroupCreate { return gc.AddDocumentIDs(ids...) } +// AddInvitationTokenIDs adds the "invitation_tokens" edge to the GroupInvitationToken entity by IDs. +func (gc *GroupCreate) AddInvitationTokenIDs(ids ...uuid.UUID) *GroupCreate { + gc.mutation.AddInvitationTokenIDs(ids...) + return gc +} + +// AddInvitationTokens adds the "invitation_tokens" edges to the GroupInvitationToken entity. +func (gc *GroupCreate) AddInvitationTokens(g ...*GroupInvitationToken) *GroupCreate { + ids := make([]uuid.UUID, len(g)) + for i := range g { + ids[i] = g[i].ID + } + return gc.AddInvitationTokenIDs(ids...) +} + // Mutation returns the GroupMutation object of the builder. func (gc *GroupCreate) Mutation() *GroupMutation { return gc.mutation @@ -445,6 +461,25 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { } _spec.Edges = append(_spec.Edges, edge) } + if nodes := gc.mutation.InvitationTokensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges = append(_spec.Edges, edge) + } return _node, _spec } diff --git a/backend/ent/group_query.go b/backend/ent/group_query.go index 1fc452d..13bfd9b 100644 --- a/backend/ent/group_query.go +++ b/backend/ent/group_query.go @@ -14,6 +14,7 @@ import ( "github.com/google/uuid" "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/label" "github.com/hay-kot/homebox/backend/ent/location" @@ -24,17 +25,18 @@ import ( // GroupQuery is the builder for querying Group entities. type GroupQuery struct { config - limit *int - offset *int - unique *bool - order []OrderFunc - fields []string - predicates []predicate.Group - withUsers *UserQuery - withLocations *LocationQuery - withItems *ItemQuery - withLabels *LabelQuery - withDocuments *DocumentQuery + limit *int + offset *int + unique *bool + order []OrderFunc + fields []string + predicates []predicate.Group + withUsers *UserQuery + withLocations *LocationQuery + withItems *ItemQuery + withLabels *LabelQuery + withDocuments *DocumentQuery + withInvitationTokens *GroupInvitationTokenQuery // intermediate query (i.e. traversal path). sql *sql.Selector path func(context.Context) (*sql.Selector, error) @@ -181,6 +183,28 @@ func (gq *GroupQuery) QueryDocuments() *DocumentQuery { return query } +// QueryInvitationTokens chains the current query on the "invitation_tokens" edge. +func (gq *GroupQuery) QueryInvitationTokens() *GroupInvitationTokenQuery { + query := &GroupInvitationTokenQuery{config: gq.config} + 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(groupinvitationtoken.Table, groupinvitationtoken.FieldID), + sqlgraph.Edge(sqlgraph.O2M, false, group.InvitationTokensTable, group.InvitationTokensColumn), + ) + 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) { @@ -357,16 +381,17 @@ func (gq *GroupQuery) Clone() *GroupQuery { return nil } return &GroupQuery{ - config: gq.config, - limit: gq.limit, - offset: gq.offset, - order: append([]OrderFunc{}, gq.order...), - predicates: append([]predicate.Group{}, gq.predicates...), - withUsers: gq.withUsers.Clone(), - withLocations: gq.withLocations.Clone(), - withItems: gq.withItems.Clone(), - withLabels: gq.withLabels.Clone(), - withDocuments: gq.withDocuments.Clone(), + config: gq.config, + limit: gq.limit, + offset: gq.offset, + order: append([]OrderFunc{}, gq.order...), + predicates: append([]predicate.Group{}, gq.predicates...), + withUsers: gq.withUsers.Clone(), + withLocations: gq.withLocations.Clone(), + withItems: gq.withItems.Clone(), + withLabels: gq.withLabels.Clone(), + withDocuments: gq.withDocuments.Clone(), + withInvitationTokens: gq.withInvitationTokens.Clone(), // clone intermediate query. sql: gq.sql.Clone(), path: gq.path, @@ -429,6 +454,17 @@ func (gq *GroupQuery) WithDocuments(opts ...func(*DocumentQuery)) *GroupQuery { return gq } +// WithInvitationTokens tells the query-builder to eager-load the nodes that are connected to +// the "invitation_tokens" edge. The optional arguments are used to configure the query builder of the edge. +func (gq *GroupQuery) WithInvitationTokens(opts ...func(*GroupInvitationTokenQuery)) *GroupQuery { + query := &GroupInvitationTokenQuery{config: gq.config} + for _, opt := range opts { + opt(query) + } + gq.withInvitationTokens = 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. // @@ -497,12 +533,13 @@ func (gq *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group, var ( nodes = []*Group{} _spec = gq.querySpec() - loadedTypes = [5]bool{ + loadedTypes = [6]bool{ gq.withUsers != nil, gq.withLocations != nil, gq.withItems != nil, gq.withLabels != nil, gq.withDocuments != nil, + gq.withInvitationTokens != nil, } ) _spec.ScanValues = func(columns []string) ([]any, error) { @@ -558,6 +595,15 @@ func (gq *GroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Group, return nil, err } } + if query := gq.withInvitationTokens; query != nil { + if err := gq.loadInvitationTokens(ctx, query, nodes, + func(n *Group) { n.Edges.InvitationTokens = []*GroupInvitationToken{} }, + func(n *Group, e *GroupInvitationToken) { + n.Edges.InvitationTokens = append(n.Edges.InvitationTokens, e) + }); err != nil { + return nil, err + } + } return nodes, nil } @@ -716,6 +762,37 @@ func (gq *GroupQuery) loadDocuments(ctx context.Context, query *DocumentQuery, n } return nil } +func (gq *GroupQuery) loadInvitationTokens(ctx context.Context, query *GroupInvitationTokenQuery, nodes []*Group, init func(*Group), assign func(*Group, *GroupInvitationToken)) 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]) + } + } + query.withFKs = true + query.Where(predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.InValues(group.InvitationTokensColumn, fks...)) + })) + neighbors, err := query.All(ctx) + if err != nil { + return err + } + for _, n := range neighbors { + fk := n.group_invitation_tokens + if fk == nil { + return fmt.Errorf(`foreign-key "group_invitation_tokens" is nil for node %v`, n.ID) + } + node, ok := nodeids[*fk] + if !ok { + return fmt.Errorf(`unexpected foreign-key "group_invitation_tokens" returned %v for node %v`, *fk, n.ID) + } + assign(node, n) + } + return nil +} func (gq *GroupQuery) sqlCount(ctx context.Context) (int, error) { _spec := gq.querySpec() diff --git a/backend/ent/group_update.go b/backend/ent/group_update.go index 0c60708..6400c1b 100644 --- a/backend/ent/group_update.go +++ b/backend/ent/group_update.go @@ -14,6 +14,7 @@ import ( "github.com/google/uuid" "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/label" "github.com/hay-kot/homebox/backend/ent/location" @@ -135,6 +136,21 @@ func (gu *GroupUpdate) AddDocuments(d ...*Document) *GroupUpdate { return gu.AddDocumentIDs(ids...) } +// AddInvitationTokenIDs adds the "invitation_tokens" edge to the GroupInvitationToken entity by IDs. +func (gu *GroupUpdate) AddInvitationTokenIDs(ids ...uuid.UUID) *GroupUpdate { + gu.mutation.AddInvitationTokenIDs(ids...) + return gu +} + +// AddInvitationTokens adds the "invitation_tokens" edges to the GroupInvitationToken entity. +func (gu *GroupUpdate) AddInvitationTokens(g ...*GroupInvitationToken) *GroupUpdate { + ids := make([]uuid.UUID, len(g)) + for i := range g { + ids[i] = g[i].ID + } + return gu.AddInvitationTokenIDs(ids...) +} + // Mutation returns the GroupMutation object of the builder. func (gu *GroupUpdate) Mutation() *GroupMutation { return gu.mutation @@ -245,6 +261,27 @@ func (gu *GroupUpdate) RemoveDocuments(d ...*Document) *GroupUpdate { return gu.RemoveDocumentIDs(ids...) } +// ClearInvitationTokens clears all "invitation_tokens" edges to the GroupInvitationToken entity. +func (gu *GroupUpdate) ClearInvitationTokens() *GroupUpdate { + gu.mutation.ClearInvitationTokens() + return gu +} + +// RemoveInvitationTokenIDs removes the "invitation_tokens" edge to GroupInvitationToken entities by IDs. +func (gu *GroupUpdate) RemoveInvitationTokenIDs(ids ...uuid.UUID) *GroupUpdate { + gu.mutation.RemoveInvitationTokenIDs(ids...) + return gu +} + +// RemoveInvitationTokens removes "invitation_tokens" edges to GroupInvitationToken entities. +func (gu *GroupUpdate) RemoveInvitationTokens(g ...*GroupInvitationToken) *GroupUpdate { + ids := make([]uuid.UUID, len(g)) + for i := range g { + ids[i] = g[i].ID + } + return gu.RemoveInvitationTokenIDs(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) { var ( @@ -638,6 +675,60 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) { } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if gu.mutation.InvitationTokensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := gu.mutation.RemovedInvitationTokensIDs(); len(nodes) > 0 && !gu.mutation.InvitationTokensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := gu.mutation.InvitationTokensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } if n, err = sqlgraph.UpdateNodes(ctx, gu.driver, _spec); err != nil { if _, ok := err.(*sqlgraph.NotFoundError); ok { err = &NotFoundError{group.Label} @@ -758,6 +849,21 @@ func (guo *GroupUpdateOne) AddDocuments(d ...*Document) *GroupUpdateOne { return guo.AddDocumentIDs(ids...) } +// AddInvitationTokenIDs adds the "invitation_tokens" edge to the GroupInvitationToken entity by IDs. +func (guo *GroupUpdateOne) AddInvitationTokenIDs(ids ...uuid.UUID) *GroupUpdateOne { + guo.mutation.AddInvitationTokenIDs(ids...) + return guo +} + +// AddInvitationTokens adds the "invitation_tokens" edges to the GroupInvitationToken entity. +func (guo *GroupUpdateOne) AddInvitationTokens(g ...*GroupInvitationToken) *GroupUpdateOne { + ids := make([]uuid.UUID, len(g)) + for i := range g { + ids[i] = g[i].ID + } + return guo.AddInvitationTokenIDs(ids...) +} + // Mutation returns the GroupMutation object of the builder. func (guo *GroupUpdateOne) Mutation() *GroupMutation { return guo.mutation @@ -868,6 +974,27 @@ func (guo *GroupUpdateOne) RemoveDocuments(d ...*Document) *GroupUpdateOne { return guo.RemoveDocumentIDs(ids...) } +// ClearInvitationTokens clears all "invitation_tokens" edges to the GroupInvitationToken entity. +func (guo *GroupUpdateOne) ClearInvitationTokens() *GroupUpdateOne { + guo.mutation.ClearInvitationTokens() + return guo +} + +// RemoveInvitationTokenIDs removes the "invitation_tokens" edge to GroupInvitationToken entities by IDs. +func (guo *GroupUpdateOne) RemoveInvitationTokenIDs(ids ...uuid.UUID) *GroupUpdateOne { + guo.mutation.RemoveInvitationTokenIDs(ids...) + return guo +} + +// RemoveInvitationTokens removes "invitation_tokens" edges to GroupInvitationToken entities. +func (guo *GroupUpdateOne) RemoveInvitationTokens(g ...*GroupInvitationToken) *GroupUpdateOne { + ids := make([]uuid.UUID, len(g)) + for i := range g { + ids[i] = g[i].ID + } + return guo.RemoveInvitationTokenIDs(ids...) +} + // 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 { @@ -1291,6 +1418,60 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error } _spec.Edges.Add = append(_spec.Edges.Add, edge) } + if guo.mutation.InvitationTokensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := guo.mutation.RemovedInvitationTokensIDs(); len(nodes) > 0 && !guo.mutation.InvitationTokensCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Clear = append(_spec.Edges.Clear, edge) + } + if nodes := guo.mutation.InvitationTokensIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.O2M, + Inverse: false, + Table: group.InvitationTokensTable, + Columns: []string{group.InvitationTokensColumn}, + Bidi: false, + Target: &sqlgraph.EdgeTarget{ + IDSpec: &sqlgraph.FieldSpec{ + Type: field.TypeUUID, + Column: groupinvitationtoken.FieldID, + }, + }, + } + for _, k := range nodes { + edge.Target.Nodes = append(edge.Target.Nodes, k) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } _node = &Group{config: guo.config} _spec.Assign = _node.assignValues _spec.ScanValues = _node.scanValues diff --git a/backend/ent/groupinvitationtoken.go b/backend/ent/groupinvitationtoken.go new file mode 100644 index 0000000..50346d8 --- /dev/null +++ b/backend/ent/groupinvitationtoken.go @@ -0,0 +1,190 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "fmt" + "strings" + "time" + + "entgo.io/ent/dialect/sql" + "github.com/google/uuid" + "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" +) + +// GroupInvitationToken is the model entity for the GroupInvitationToken schema. +type GroupInvitationToken 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"` + // Token holds the value of the "token" field. + Token []byte `json:"token,omitempty"` + // ExpiresAt holds the value of the "expires_at" field. + ExpiresAt time.Time `json:"expires_at,omitempty"` + // Uses holds the value of the "uses" field. + Uses int `json:"uses,omitempty"` + // Edges holds the relations/edges for other nodes in the graph. + // The values are being populated by the GroupInvitationTokenQuery when eager-loading is set. + Edges GroupInvitationTokenEdges `json:"edges"` + group_invitation_tokens *uuid.UUID +} + +// GroupInvitationTokenEdges holds the relations/edges for other nodes in the graph. +type GroupInvitationTokenEdges struct { + // Group holds the value of the group edge. + Group *Group `json:"group,omitempty"` + // loadedTypes holds the information for reporting if a + // type was loaded (or requested) in eager-loading or not. + loadedTypes [1]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 GroupInvitationTokenEdges) 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"} +} + +// scanValues returns the types for scanning values from sql.Rows. +func (*GroupInvitationToken) scanValues(columns []string) ([]any, error) { + values := make([]any, len(columns)) + for i := range columns { + switch columns[i] { + case groupinvitationtoken.FieldToken: + values[i] = new([]byte) + case groupinvitationtoken.FieldUses: + values[i] = new(sql.NullInt64) + case groupinvitationtoken.FieldCreatedAt, groupinvitationtoken.FieldUpdatedAt, groupinvitationtoken.FieldExpiresAt: + values[i] = new(sql.NullTime) + case groupinvitationtoken.FieldID: + values[i] = new(uuid.UUID) + 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]) + } + } + return values, nil +} + +// assignValues assigns the values that were returned from sql.Rows (after scanning) +// to the GroupInvitationToken fields. +func (git *GroupInvitationToken) 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 groupinvitationtoken.FieldID: + if value, ok := values[i].(*uuid.UUID); !ok { + return fmt.Errorf("unexpected type %T for field id", values[i]) + } else if value != nil { + git.ID = *value + } + case groupinvitationtoken.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 { + git.CreatedAt = value.Time + } + case groupinvitationtoken.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 { + git.UpdatedAt = value.Time + } + case groupinvitationtoken.FieldToken: + if value, ok := values[i].(*[]byte); !ok { + return fmt.Errorf("unexpected type %T for field token", values[i]) + } else if value != nil { + git.Token = *value + } + case groupinvitationtoken.FieldExpiresAt: + if value, ok := values[i].(*sql.NullTime); !ok { + return fmt.Errorf("unexpected type %T for field expires_at", values[i]) + } else if value.Valid { + git.ExpiresAt = value.Time + } + case groupinvitationtoken.FieldUses: + if value, ok := values[i].(*sql.NullInt64); !ok { + return fmt.Errorf("unexpected type %T for field uses", values[i]) + } else if value.Valid { + git.Uses = int(value.Int64) + } + case groupinvitationtoken.ForeignKeys[0]: + if value, ok := values[i].(*sql.NullScanner); !ok { + return fmt.Errorf("unexpected type %T for field group_invitation_tokens", values[i]) + } else if value.Valid { + git.group_invitation_tokens = new(uuid.UUID) + *git.group_invitation_tokens = *value.S.(*uuid.UUID) + } + } + } + return nil +} + +// QueryGroup queries the "group" edge of the GroupInvitationToken entity. +func (git *GroupInvitationToken) QueryGroup() *GroupQuery { + return (&GroupInvitationTokenClient{config: 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) +} + +// Unwrap unwraps the GroupInvitationToken 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 (git *GroupInvitationToken) Unwrap() *GroupInvitationToken { + _tx, ok := git.config.driver.(*txDriver) + if !ok { + panic("ent: GroupInvitationToken is not a transactional entity") + } + git.config.driver = _tx.drv + return git +} + +// String implements the fmt.Stringer. +func (git *GroupInvitationToken) String() string { + var builder strings.Builder + builder.WriteString("GroupInvitationToken(") + builder.WriteString(fmt.Sprintf("id=%v, ", git.ID)) + builder.WriteString("created_at=") + builder.WriteString(git.CreatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("updated_at=") + builder.WriteString(git.UpdatedAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("token=") + builder.WriteString(fmt.Sprintf("%v", git.Token)) + builder.WriteString(", ") + builder.WriteString("expires_at=") + builder.WriteString(git.ExpiresAt.Format(time.ANSIC)) + builder.WriteString(", ") + builder.WriteString("uses=") + builder.WriteString(fmt.Sprintf("%v", git.Uses)) + builder.WriteByte(')') + return builder.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/ent/groupinvitationtoken/groupinvitationtoken.go b/backend/ent/groupinvitationtoken/groupinvitationtoken.go new file mode 100644 index 0000000..1daea17 --- /dev/null +++ b/backend/ent/groupinvitationtoken/groupinvitationtoken.go @@ -0,0 +1,83 @@ +// Code generated by ent, DO NOT EDIT. + +package groupinvitationtoken + +import ( + "time" + + "github.com/google/uuid" +) + +const ( + // Label holds the string label denoting the groupinvitationtoken type in the database. + Label = "group_invitation_token" + // FieldID holds the string denoting the id field in the database. + FieldID = "id" + // FieldCreatedAt holds the string denoting the created_at field in the database. + FieldCreatedAt = "created_at" + // FieldUpdatedAt holds the string denoting the updated_at field in the database. + FieldUpdatedAt = "updated_at" + // FieldToken holds the string denoting the token field in the database. + FieldToken = "token" + // FieldExpiresAt holds the string denoting the expires_at field in the database. + FieldExpiresAt = "expires_at" + // FieldUses holds the string denoting the uses field in the database. + FieldUses = "uses" + // EdgeGroup holds the string denoting the group edge name in mutations. + EdgeGroup = "group" + // Table holds the table name of the groupinvitationtoken in the database. + Table = "group_invitation_tokens" + // GroupTable is the table that holds the group relation/edge. + GroupTable = "group_invitation_tokens" + // 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_invitation_tokens" +) + +// Columns holds all SQL columns for groupinvitationtoken fields. +var Columns = []string{ + FieldID, + FieldCreatedAt, + FieldUpdatedAt, + FieldToken, + FieldExpiresAt, + FieldUses, +} + +// ForeignKeys holds the SQL foreign-keys that are owned by the "group_invitation_tokens" +// table and are not defined as standalone fields in the schema. +var ForeignKeys = []string{ + "group_invitation_tokens", +} + +// ValidColumn reports if the column name is valid (part of the table columns). +func ValidColumn(column string) bool { + for i := range Columns { + if column == Columns[i] { + return true + } + } + for i := range ForeignKeys { + if column == ForeignKeys[i] { + return true + } + } + return false +} + +var ( + // DefaultCreatedAt holds the default value on creation for the "created_at" field. + DefaultCreatedAt func() time.Time + // DefaultUpdatedAt holds the default value on creation for the "updated_at" field. + DefaultUpdatedAt func() time.Time + // UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field. + UpdateDefaultUpdatedAt func() time.Time + // DefaultExpiresAt holds the default value on creation for the "expires_at" field. + DefaultExpiresAt func() time.Time + // DefaultUses holds the default value on creation for the "uses" field. + DefaultUses int + // DefaultID holds the default value on creation for the "id" field. + DefaultID func() uuid.UUID +) diff --git a/backend/ent/groupinvitationtoken/where.go b/backend/ent/groupinvitationtoken/where.go new file mode 100644 index 0000000..a613e6a --- /dev/null +++ b/backend/ent/groupinvitationtoken/where.go @@ -0,0 +1,498 @@ +// Code generated by ent, DO NOT EDIT. + +package groupinvitationtoken + +import ( + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "github.com/google/uuid" + "github.com/hay-kot/homebox/backend/ent/predicate" +) + +// ID filters vertices based on their ID field. +func ID(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldID), id)) + }) +} + +// IDEQ applies the EQ predicate on the ID field. +func IDEQ(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldID), id)) + }) +} + +// IDNEQ applies the NEQ predicate on the ID field. +func IDNEQ(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldID), id)) + }) +} + +// IDIn applies the In predicate on the ID field. +func IDIn(ids ...uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + v := make([]any, len(ids)) + for i := range v { + v[i] = ids[i] + } + s.Where(sql.In(s.C(FieldID), v...)) + }) +} + +// IDNotIn applies the NotIn predicate on the ID field. +func IDNotIn(ids ...uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + v := make([]any, len(ids)) + for i := range v { + v[i] = ids[i] + } + s.Where(sql.NotIn(s.C(FieldID), v...)) + }) +} + +// IDGT applies the GT predicate on the ID field. +func IDGT(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldID), id)) + }) +} + +// IDGTE applies the GTE predicate on the ID field. +func IDGTE(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldID), id)) + }) +} + +// IDLT applies the LT predicate on the ID field. +func IDLT(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldID), id)) + }) +} + +// IDLTE applies the LTE predicate on the ID field. +func IDLTE(id uuid.UUID) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldID), id)) + }) +} + +// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ. +func CreatedAt(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldCreatedAt), v)) + }) +} + +// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ. +func UpdatedAt(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldUpdatedAt), v)) + }) +} + +// Token applies equality check predicate on the "token" field. It's identical to TokenEQ. +func Token(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldToken), v)) + }) +} + +// ExpiresAt applies equality check predicate on the "expires_at" field. It's identical to ExpiresAtEQ. +func ExpiresAt(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldExpiresAt), v)) + }) +} + +// Uses applies equality check predicate on the "uses" field. It's identical to UsesEQ. +func Uses(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldUses), v)) + }) +} + +// CreatedAtEQ applies the EQ predicate on the "created_at" field. +func CreatedAtEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldCreatedAt), v)) + }) +} + +// CreatedAtNEQ applies the NEQ predicate on the "created_at" field. +func CreatedAtNEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldCreatedAt), v)) + }) +} + +// CreatedAtIn applies the In predicate on the "created_at" field. +func CreatedAtIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.In(s.C(FieldCreatedAt), v...)) + }) +} + +// CreatedAtNotIn applies the NotIn predicate on the "created_at" field. +func CreatedAtNotIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NotIn(s.C(FieldCreatedAt), v...)) + }) +} + +// CreatedAtGT applies the GT predicate on the "created_at" field. +func CreatedAtGT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldCreatedAt), v)) + }) +} + +// CreatedAtGTE applies the GTE predicate on the "created_at" field. +func CreatedAtGTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldCreatedAt), v)) + }) +} + +// CreatedAtLT applies the LT predicate on the "created_at" field. +func CreatedAtLT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldCreatedAt), v)) + }) +} + +// CreatedAtLTE applies the LTE predicate on the "created_at" field. +func CreatedAtLTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldCreatedAt), v)) + }) +} + +// UpdatedAtEQ applies the EQ predicate on the "updated_at" field. +func UpdatedAtEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldUpdatedAt), v)) + }) +} + +// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field. +func UpdatedAtNEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldUpdatedAt), v)) + }) +} + +// UpdatedAtIn applies the In predicate on the "updated_at" field. +func UpdatedAtIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.In(s.C(FieldUpdatedAt), v...)) + }) +} + +// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field. +func UpdatedAtNotIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NotIn(s.C(FieldUpdatedAt), v...)) + }) +} + +// UpdatedAtGT applies the GT predicate on the "updated_at" field. +func UpdatedAtGT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldUpdatedAt), v)) + }) +} + +// UpdatedAtGTE applies the GTE predicate on the "updated_at" field. +func UpdatedAtGTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldUpdatedAt), v)) + }) +} + +// UpdatedAtLT applies the LT predicate on the "updated_at" field. +func UpdatedAtLT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldUpdatedAt), v)) + }) +} + +// UpdatedAtLTE applies the LTE predicate on the "updated_at" field. +func UpdatedAtLTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldUpdatedAt), v)) + }) +} + +// TokenEQ applies the EQ predicate on the "token" field. +func TokenEQ(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldToken), v)) + }) +} + +// TokenNEQ applies the NEQ predicate on the "token" field. +func TokenNEQ(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldToken), v)) + }) +} + +// TokenIn applies the In predicate on the "token" field. +func TokenIn(vs ...[]byte) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.In(s.C(FieldToken), v...)) + }) +} + +// TokenNotIn applies the NotIn predicate on the "token" field. +func TokenNotIn(vs ...[]byte) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NotIn(s.C(FieldToken), v...)) + }) +} + +// TokenGT applies the GT predicate on the "token" field. +func TokenGT(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldToken), v)) + }) +} + +// TokenGTE applies the GTE predicate on the "token" field. +func TokenGTE(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldToken), v)) + }) +} + +// TokenLT applies the LT predicate on the "token" field. +func TokenLT(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldToken), v)) + }) +} + +// TokenLTE applies the LTE predicate on the "token" field. +func TokenLTE(v []byte) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldToken), v)) + }) +} + +// ExpiresAtEQ applies the EQ predicate on the "expires_at" field. +func ExpiresAtEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldExpiresAt), v)) + }) +} + +// ExpiresAtNEQ applies the NEQ predicate on the "expires_at" field. +func ExpiresAtNEQ(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldExpiresAt), v)) + }) +} + +// ExpiresAtIn applies the In predicate on the "expires_at" field. +func ExpiresAtIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.In(s.C(FieldExpiresAt), v...)) + }) +} + +// ExpiresAtNotIn applies the NotIn predicate on the "expires_at" field. +func ExpiresAtNotIn(vs ...time.Time) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NotIn(s.C(FieldExpiresAt), v...)) + }) +} + +// ExpiresAtGT applies the GT predicate on the "expires_at" field. +func ExpiresAtGT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldExpiresAt), v)) + }) +} + +// ExpiresAtGTE applies the GTE predicate on the "expires_at" field. +func ExpiresAtGTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldExpiresAt), v)) + }) +} + +// ExpiresAtLT applies the LT predicate on the "expires_at" field. +func ExpiresAtLT(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldExpiresAt), v)) + }) +} + +// ExpiresAtLTE applies the LTE predicate on the "expires_at" field. +func ExpiresAtLTE(v time.Time) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldExpiresAt), v)) + }) +} + +// UsesEQ applies the EQ predicate on the "uses" field. +func UsesEQ(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.EQ(s.C(FieldUses), v)) + }) +} + +// UsesNEQ applies the NEQ predicate on the "uses" field. +func UsesNEQ(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NEQ(s.C(FieldUses), v)) + }) +} + +// UsesIn applies the In predicate on the "uses" field. +func UsesIn(vs ...int) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.In(s.C(FieldUses), v...)) + }) +} + +// UsesNotIn applies the NotIn predicate on the "uses" field. +func UsesNotIn(vs ...int) predicate.GroupInvitationToken { + v := make([]any, len(vs)) + for i := range v { + v[i] = vs[i] + } + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.NotIn(s.C(FieldUses), v...)) + }) +} + +// UsesGT applies the GT predicate on the "uses" field. +func UsesGT(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GT(s.C(FieldUses), v)) + }) +} + +// UsesGTE applies the GTE predicate on the "uses" field. +func UsesGTE(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.GTE(s.C(FieldUses), v)) + }) +} + +// UsesLT applies the LT predicate on the "uses" field. +func UsesLT(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LT(s.C(FieldUses), v)) + }) +} + +// UsesLTE applies the LTE predicate on the "uses" field. +func UsesLTE(v int) predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + s.Where(sql.LTE(s.C(FieldUses), v)) + }) +} + +// HasGroup applies the HasEdge predicate on the "group" edge. +func HasGroup() predicate.GroupInvitationToken { + return predicate.GroupInvitationToken(func(s *sql.Selector) { + step := sqlgraph.NewStep( + sqlgraph.From(Table, FieldID), + sqlgraph.To(GroupTable, 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.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), + ) + sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) + }) +} + +// 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()) + }) +} + +// 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()) + }) +} + +// 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()) + }) +} diff --git a/backend/ent/groupinvitationtoken_create.go b/backend/ent/groupinvitationtoken_create.go new file mode 100644 index 0000000..b36d623 --- /dev/null +++ b/backend/ent/groupinvitationtoken_create.go @@ -0,0 +1,413 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/google/uuid" + "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" +) + +// GroupInvitationTokenCreate is the builder for creating a GroupInvitationToken entity. +type GroupInvitationTokenCreate struct { + config + mutation *GroupInvitationTokenMutation + hooks []Hook +} + +// SetCreatedAt sets the "created_at" field. +func (gitc *GroupInvitationTokenCreate) SetCreatedAt(t time.Time) *GroupInvitationTokenCreate { + gitc.mutation.SetCreatedAt(t) + return gitc +} + +// SetNillableCreatedAt sets the "created_at" field if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableCreatedAt(t *time.Time) *GroupInvitationTokenCreate { + if t != nil { + gitc.SetCreatedAt(*t) + } + return gitc +} + +// SetUpdatedAt sets the "updated_at" field. +func (gitc *GroupInvitationTokenCreate) SetUpdatedAt(t time.Time) *GroupInvitationTokenCreate { + gitc.mutation.SetUpdatedAt(t) + return gitc +} + +// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableUpdatedAt(t *time.Time) *GroupInvitationTokenCreate { + if t != nil { + gitc.SetUpdatedAt(*t) + } + return gitc +} + +// SetToken sets the "token" field. +func (gitc *GroupInvitationTokenCreate) SetToken(b []byte) *GroupInvitationTokenCreate { + gitc.mutation.SetToken(b) + return gitc +} + +// SetExpiresAt sets the "expires_at" field. +func (gitc *GroupInvitationTokenCreate) SetExpiresAt(t time.Time) *GroupInvitationTokenCreate { + gitc.mutation.SetExpiresAt(t) + return gitc +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableExpiresAt(t *time.Time) *GroupInvitationTokenCreate { + if t != nil { + gitc.SetExpiresAt(*t) + } + return gitc +} + +// SetUses sets the "uses" field. +func (gitc *GroupInvitationTokenCreate) SetUses(i int) *GroupInvitationTokenCreate { + gitc.mutation.SetUses(i) + return gitc +} + +// SetNillableUses sets the "uses" field if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableUses(i *int) *GroupInvitationTokenCreate { + if i != nil { + gitc.SetUses(*i) + } + return gitc +} + +// SetID sets the "id" field. +func (gitc *GroupInvitationTokenCreate) SetID(u uuid.UUID) *GroupInvitationTokenCreate { + gitc.mutation.SetID(u) + return gitc +} + +// SetNillableID sets the "id" field if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableID(u *uuid.UUID) *GroupInvitationTokenCreate { + if u != nil { + gitc.SetID(*u) + } + return gitc +} + +// SetGroupID sets the "group" edge to the Group entity by ID. +func (gitc *GroupInvitationTokenCreate) SetGroupID(id uuid.UUID) *GroupInvitationTokenCreate { + gitc.mutation.SetGroupID(id) + return gitc +} + +// SetNillableGroupID sets the "group" edge to the Group entity by ID if the given value is not nil. +func (gitc *GroupInvitationTokenCreate) SetNillableGroupID(id *uuid.UUID) *GroupInvitationTokenCreate { + if id != nil { + gitc = gitc.SetGroupID(*id) + } + return gitc +} + +// SetGroup sets the "group" edge to the Group entity. +func (gitc *GroupInvitationTokenCreate) SetGroup(g *Group) *GroupInvitationTokenCreate { + return gitc.SetGroupID(g.ID) +} + +// Mutation returns the GroupInvitationTokenMutation object of the builder. +func (gitc *GroupInvitationTokenCreate) Mutation() *GroupInvitationTokenMutation { + return gitc.mutation +} + +// Save creates the GroupInvitationToken in the database. +func (gitc *GroupInvitationTokenCreate) Save(ctx context.Context) (*GroupInvitationToken, error) { + var ( + err error + node *GroupInvitationToken + ) + gitc.defaults() + if len(gitc.hooks) == 0 { + if err = gitc.check(); err != nil { + return nil, err + } + node, err = gitc.sqlSave(ctx) + } else { + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err = gitc.check(); err != nil { + return nil, err + } + gitc.mutation = mutation + if node, err = gitc.sqlSave(ctx); err != nil { + return nil, err + } + mutation.id = &node.ID + mutation.done = true + return node, err + }) + for i := len(gitc.hooks) - 1; i >= 0; i-- { + if gitc.hooks[i] == nil { + return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") + } + mut = gitc.hooks[i](mut) + } + v, err := mut.Mutate(ctx, gitc.mutation) + if err != nil { + return nil, err + } + nv, ok := v.(*GroupInvitationToken) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInvitationTokenMutation", v) + } + node = nv + } + return node, err +} + +// SaveX calls Save and panics if Save returns an error. +func (gitc *GroupInvitationTokenCreate) SaveX(ctx context.Context) *GroupInvitationToken { + v, err := gitc.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (gitc *GroupInvitationTokenCreate) Exec(ctx context.Context) error { + _, err := gitc.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gitc *GroupInvitationTokenCreate) ExecX(ctx context.Context) { + if err := gitc.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (gitc *GroupInvitationTokenCreate) defaults() { + if _, ok := gitc.mutation.CreatedAt(); !ok { + v := groupinvitationtoken.DefaultCreatedAt() + gitc.mutation.SetCreatedAt(v) + } + if _, ok := gitc.mutation.UpdatedAt(); !ok { + v := groupinvitationtoken.DefaultUpdatedAt() + gitc.mutation.SetUpdatedAt(v) + } + if _, ok := gitc.mutation.ExpiresAt(); !ok { + v := groupinvitationtoken.DefaultExpiresAt() + gitc.mutation.SetExpiresAt(v) + } + if _, ok := gitc.mutation.Uses(); !ok { + v := groupinvitationtoken.DefaultUses + gitc.mutation.SetUses(v) + } + if _, ok := gitc.mutation.ID(); !ok { + v := groupinvitationtoken.DefaultID() + gitc.mutation.SetID(v) + } +} + +// check runs all checks and user-defined validators on the builder. +func (gitc *GroupInvitationTokenCreate) check() error { + if _, ok := gitc.mutation.CreatedAt(); !ok { + return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "GroupInvitationToken.created_at"`)} + } + if _, ok := gitc.mutation.UpdatedAt(); !ok { + return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "GroupInvitationToken.updated_at"`)} + } + if _, ok := gitc.mutation.Token(); !ok { + return &ValidationError{Name: "token", err: errors.New(`ent: missing required field "GroupInvitationToken.token"`)} + } + if _, ok := gitc.mutation.ExpiresAt(); !ok { + return &ValidationError{Name: "expires_at", err: errors.New(`ent: missing required field "GroupInvitationToken.expires_at"`)} + } + if _, ok := gitc.mutation.Uses(); !ok { + return &ValidationError{Name: "uses", err: errors.New(`ent: missing required field "GroupInvitationToken.uses"`)} + } + return nil +} + +func (gitc *GroupInvitationTokenCreate) sqlSave(ctx context.Context) (*GroupInvitationToken, error) { + _node, _spec := gitc.createSpec() + if err := sqlgraph.CreateNode(ctx, gitc.driver, _spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + if _spec.ID.Value != nil { + if id, ok := _spec.ID.Value.(*uuid.UUID); ok { + _node.ID = *id + } else if err := _node.ID.Scan(_spec.ID.Value); err != nil { + return nil, err + } + } + return _node, nil +} + +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, + }, + } + ) + if id, ok := gitc.mutation.ID(); ok { + _node.ID = id + _spec.ID.Value = &id + } + if value, ok := gitc.mutation.CreatedAt(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldCreatedAt, + }) + _node.CreatedAt = value + } + if value, ok := gitc.mutation.UpdatedAt(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldUpdatedAt, + }) + _node.UpdatedAt = value + } + if value, ok := gitc.mutation.Token(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeBytes, + Value: value, + Column: groupinvitationtoken.FieldToken, + }) + _node.Token = value + } + if value, ok := gitc.mutation.ExpiresAt(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldExpiresAt, + }) + _node.ExpiresAt = value + } + if value, ok := gitc.mutation.Uses(); ok { + _spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Value: value, + Column: groupinvitationtoken.FieldUses, + }) + _node.Uses = value + } + if nodes := gitc.mutation.GroupIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: groupinvitationtoken.GroupTable, + Columns: []string{groupinvitationtoken.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_invitation_tokens = &nodes[0] + _spec.Edges = append(_spec.Edges, edge) + } + return _node, _spec +} + +// GroupInvitationTokenCreateBulk is the builder for creating many GroupInvitationToken entities in bulk. +type GroupInvitationTokenCreateBulk struct { + config + builders []*GroupInvitationTokenCreate +} + +// Save creates the GroupInvitationToken entities in the database. +func (gitcb *GroupInvitationTokenCreateBulk) Save(ctx context.Context) ([]*GroupInvitationToken, error) { + specs := make([]*sqlgraph.CreateSpec, len(gitcb.builders)) + nodes := make([]*GroupInvitationToken, len(gitcb.builders)) + mutators := make([]Mutator, len(gitcb.builders)) + for i := range gitcb.builders { + func(i int, root context.Context) { + builder := gitcb.builders[i] + builder.defaults() + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + if err := builder.check(); err != nil { + return nil, err + } + builder.mutation = mutation + nodes[i], specs[i] = builder.createSpec() + var err error + if i < len(mutators)-1 { + _, err = mutators[i+1].Mutate(root, gitcb.builders[i+1].mutation) + } else { + spec := &sqlgraph.BatchCreateSpec{Nodes: specs} + // Invoke the actual operation on the latest mutation in the chain. + if err = sqlgraph.BatchCreate(ctx, gitcb.driver, spec); err != nil { + if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + } + } + if err != nil { + return nil, err + } + mutation.id = &nodes[i].ID + mutation.done = true + return nodes[i], nil + }) + for i := len(builder.hooks) - 1; i >= 0; i-- { + mut = builder.hooks[i](mut) + } + mutators[i] = mut + }(i, ctx) + } + if len(mutators) > 0 { + if _, err := mutators[0].Mutate(ctx, gitcb.builders[0].mutation); err != nil { + return nil, err + } + } + return nodes, nil +} + +// SaveX is like Save, but panics if an error occurs. +func (gitcb *GroupInvitationTokenCreateBulk) SaveX(ctx context.Context) []*GroupInvitationToken { + v, err := gitcb.Save(ctx) + if err != nil { + panic(err) + } + return v +} + +// Exec executes the query. +func (gitcb *GroupInvitationTokenCreateBulk) Exec(ctx context.Context) error { + _, err := gitcb.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gitcb *GroupInvitationTokenCreateBulk) ExecX(ctx context.Context) { + if err := gitcb.Exec(ctx); err != nil { + panic(err) + } +} diff --git a/backend/ent/groupinvitationtoken_delete.go b/backend/ent/groupinvitationtoken_delete.go new file mode 100644 index 0000000..42fad8b --- /dev/null +++ b/backend/ent/groupinvitationtoken_delete.go @@ -0,0 +1,115 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "fmt" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" + "github.com/hay-kot/homebox/backend/ent/predicate" +) + +// GroupInvitationTokenDelete is the builder for deleting a GroupInvitationToken entity. +type GroupInvitationTokenDelete struct { + config + hooks []Hook + mutation *GroupInvitationTokenMutation +} + +// Where appends a list predicates to the GroupInvitationTokenDelete builder. +func (gitd *GroupInvitationTokenDelete) Where(ps ...predicate.GroupInvitationToken) *GroupInvitationTokenDelete { + gitd.mutation.Where(ps...) + return gitd +} + +// Exec executes the deletion query and returns how many vertices were deleted. +func (gitd *GroupInvitationTokenDelete) Exec(ctx context.Context) (int, error) { + var ( + err error + affected int + ) + if len(gitd.hooks) == 0 { + affected, err = gitd.sqlExec(ctx) + } else { + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + gitd.mutation = mutation + affected, err = gitd.sqlExec(ctx) + mutation.done = true + return affected, err + }) + for i := len(gitd.hooks) - 1; i >= 0; i-- { + if gitd.hooks[i] == nil { + return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") + } + mut = gitd.hooks[i](mut) + } + if _, err := mut.Mutate(ctx, gitd.mutation); err != nil { + return 0, err + } + } + return affected, err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gitd *GroupInvitationTokenDelete) ExecX(ctx context.Context) int { + n, err := gitd.Exec(ctx) + if err != nil { + panic(err) + } + return n +} + +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, + }, + }, + } + if ps := gitd.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + affected, err := sqlgraph.DeleteNodes(ctx, gitd.driver, _spec) + if err != nil && sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return affected, err +} + +// GroupInvitationTokenDeleteOne is the builder for deleting a single GroupInvitationToken entity. +type GroupInvitationTokenDeleteOne struct { + gitd *GroupInvitationTokenDelete +} + +// Exec executes the deletion query. +func (gitdo *GroupInvitationTokenDeleteOne) Exec(ctx context.Context) error { + n, err := gitdo.gitd.Exec(ctx) + switch { + case err != nil: + return err + case n == 0: + return &NotFoundError{groupinvitationtoken.Label} + default: + return nil + } +} + +// ExecX is like Exec, but panics if an error occurs. +func (gitdo *GroupInvitationTokenDeleteOne) ExecX(ctx context.Context) { + gitdo.gitd.ExecX(ctx) +} diff --git a/backend/ent/groupinvitationtoken_query.go b/backend/ent/groupinvitationtoken_query.go new file mode 100644 index 0000000..ea380b0 --- /dev/null +++ b/backend/ent/groupinvitationtoken_query.go @@ -0,0 +1,614 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "fmt" + "math" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/google/uuid" + "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" + "github.com/hay-kot/homebox/backend/ent/predicate" +) + +// GroupInvitationTokenQuery is the builder for querying GroupInvitationToken entities. +type GroupInvitationTokenQuery struct { + config + limit *int + offset *int + unique *bool + order []OrderFunc + fields []string + predicates []predicate.GroupInvitationToken + withGroup *GroupQuery + withFKs bool + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Where adds a new predicate for the GroupInvitationTokenQuery builder. +func (gitq *GroupInvitationTokenQuery) Where(ps ...predicate.GroupInvitationToken) *GroupInvitationTokenQuery { + gitq.predicates = append(gitq.predicates, ps...) + return gitq +} + +// Limit adds a limit step to the query. +func (gitq *GroupInvitationTokenQuery) Limit(limit int) *GroupInvitationTokenQuery { + gitq.limit = &limit + return gitq +} + +// Offset adds an offset step to the query. +func (gitq *GroupInvitationTokenQuery) Offset(offset int) *GroupInvitationTokenQuery { + gitq.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 + return gitq +} + +// Order adds an order step to the query. +func (gitq *GroupInvitationTokenQuery) Order(o ...OrderFunc) *GroupInvitationTokenQuery { + gitq.order = append(gitq.order, o...) + return gitq +} + +// QueryGroup chains the current query on the "group" edge. +func (gitq *GroupInvitationTokenQuery) QueryGroup() *GroupQuery { + query := &GroupQuery{config: gitq.config} + query.path = func(ctx context.Context) (fromU *sql.Selector, err error) { + if err := gitq.prepareQuery(ctx); err != nil { + return nil, err + } + selector := gitq.sqlQuery(ctx) + if err := selector.Err(); err != nil { + return nil, err + } + step := sqlgraph.NewStep( + sqlgraph.From(groupinvitationtoken.Table, groupinvitationtoken.FieldID, selector), + sqlgraph.To(group.Table, group.FieldID), + sqlgraph.Edge(sqlgraph.M2O, true, groupinvitationtoken.GroupTable, groupinvitationtoken.GroupColumn), + ) + fromU = sqlgraph.SetNeighbors(gitq.driver.Dialect(), step) + return fromU, nil + } + return query +} + +// 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(ctx) + if err != nil { + return nil, err + } + if len(nodes) == 0 { + return nil, &NotFoundError{groupinvitationtoken.Label} + } + return nodes[0], nil +} + +// FirstX is like First, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) FirstX(ctx context.Context) *GroupInvitationToken { + node, err := gitq.First(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return node +} + +// FirstID returns the first GroupInvitationToken ID from the query. +// 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(ctx); err != nil { + return + } + if len(ids) == 0 { + err = &NotFoundError{groupinvitationtoken.Label} + return + } + return ids[0], nil +} + +// FirstIDX is like FirstID, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) FirstIDX(ctx context.Context) uuid.UUID { + id, err := gitq.FirstID(ctx) + if err != nil && !IsNotFound(err) { + panic(err) + } + return id +} + +// Only returns a single GroupInvitationToken entity found by the query, ensuring it only returns one. +// 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(ctx) + if err != nil { + return nil, err + } + switch len(nodes) { + case 1: + return nodes[0], nil + case 0: + return nil, &NotFoundError{groupinvitationtoken.Label} + default: + return nil, &NotSingularError{groupinvitationtoken.Label} + } +} + +// OnlyX is like Only, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) OnlyX(ctx context.Context) *GroupInvitationToken { + node, err := gitq.Only(ctx) + if err != nil { + panic(err) + } + return node +} + +// OnlyID is like Only, but returns the only GroupInvitationToken ID in the query. +// Returns a *NotSingularError when more than one GroupInvitationToken ID is found. +// 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(ctx); err != nil { + return + } + switch len(ids) { + case 1: + id = ids[0] + case 0: + err = &NotFoundError{groupinvitationtoken.Label} + default: + err = &NotSingularError{groupinvitationtoken.Label} + } + return +} + +// OnlyIDX is like OnlyID, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) OnlyIDX(ctx context.Context) uuid.UUID { + id, err := gitq.OnlyID(ctx) + if err != nil { + panic(err) + } + return id +} + +// All executes the query and returns a list of GroupInvitationTokens. +func (gitq *GroupInvitationTokenQuery) All(ctx context.Context) ([]*GroupInvitationToken, error) { + if err := gitq.prepareQuery(ctx); err != nil { + return nil, err + } + return gitq.sqlAll(ctx) +} + +// AllX is like All, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) AllX(ctx context.Context) []*GroupInvitationToken { + nodes, err := gitq.All(ctx) + if err != nil { + panic(err) + } + return nodes +} + +// 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 + if err := gitq.Select(groupinvitationtoken.FieldID).Scan(ctx, &ids); err != nil { + return nil, err + } + return ids, nil +} + +// IDsX is like IDs, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) IDsX(ctx context.Context) []uuid.UUID { + ids, err := gitq.IDs(ctx) + if err != nil { + panic(err) + } + return ids +} + +// Count returns the count of the given query. +func (gitq *GroupInvitationTokenQuery) Count(ctx context.Context) (int, error) { + if err := gitq.prepareQuery(ctx); err != nil { + return 0, err + } + return gitq.sqlCount(ctx) +} + +// CountX is like Count, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) CountX(ctx context.Context) int { + count, err := gitq.Count(ctx) + if err != nil { + panic(err) + } + return count +} + +// Exist returns true if the query has elements in the graph. +func (gitq *GroupInvitationTokenQuery) Exist(ctx context.Context) (bool, error) { + if err := gitq.prepareQuery(ctx); err != nil { + return false, err + } + return gitq.sqlExist(ctx) +} + +// ExistX is like Exist, but panics if an error occurs. +func (gitq *GroupInvitationTokenQuery) ExistX(ctx context.Context) bool { + exist, err := gitq.Exist(ctx) + if err != nil { + panic(err) + } + return exist +} + +// Clone returns a duplicate of the GroupInvitationTokenQuery builder, including all associated steps. It can be +// used to prepare common query builders and use them differently after the clone is made. +func (gitq *GroupInvitationTokenQuery) Clone() *GroupInvitationTokenQuery { + if gitq == nil { + return nil + } + return &GroupInvitationTokenQuery{ + config: gitq.config, + limit: gitq.limit, + offset: gitq.offset, + order: append([]OrderFunc{}, gitq.order...), + predicates: append([]predicate.GroupInvitationToken{}, gitq.predicates...), + withGroup: gitq.withGroup.Clone(), + // clone intermediate query. + sql: gitq.sql.Clone(), + path: gitq.path, + unique: gitq.unique, + } +} + +// 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 (gitq *GroupInvitationTokenQuery) WithGroup(opts ...func(*GroupQuery)) *GroupInvitationTokenQuery { + query := &GroupQuery{config: gitq.config} + for _, opt := range opts { + opt(query) + } + gitq.withGroup = query + return gitq +} + +// 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. +// +// Example: +// +// var v []struct { +// CreatedAt time.Time `json:"created_at,omitempty"` +// Count int `json:"count,omitempty"` +// } +// +// client.GroupInvitationToken.Query(). +// GroupBy(groupinvitationtoken.FieldCreatedAt). +// Aggregate(ent.Count()). +// Scan(ctx, &v) +func (gitq *GroupInvitationTokenQuery) GroupBy(field string, fields ...string) *GroupInvitationTokenGroupBy { + grbuild := &GroupInvitationTokenGroupBy{config: gitq.config} + grbuild.fields = append([]string{field}, fields...) + grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) { + if err := gitq.prepareQuery(ctx); err != nil { + return nil, err + } + return gitq.sqlQuery(ctx), nil + } + grbuild.label = groupinvitationtoken.Label + grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan + return grbuild +} + +// Select allows the selection one or more fields/columns for the given query, +// instead of selecting all fields in the entity. +// +// Example: +// +// var v []struct { +// CreatedAt time.Time `json:"created_at,omitempty"` +// } +// +// client.GroupInvitationToken.Query(). +// Select(groupinvitationtoken.FieldCreatedAt). +// Scan(ctx, &v) +func (gitq *GroupInvitationTokenQuery) Select(fields ...string) *GroupInvitationTokenSelect { + gitq.fields = append(gitq.fields, fields...) + selbuild := &GroupInvitationTokenSelect{GroupInvitationTokenQuery: gitq} + selbuild.label = groupinvitationtoken.Label + selbuild.flds, selbuild.scan = &gitq.fields, selbuild.Scan + return selbuild +} + +func (gitq *GroupInvitationTokenQuery) prepareQuery(ctx context.Context) error { + for _, f := range gitq.fields { + if !groupinvitationtoken.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + } + if gitq.path != nil { + prev, err := gitq.path(ctx) + if err != nil { + return err + } + gitq.sql = prev + } + return nil +} + +func (gitq *GroupInvitationTokenQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*GroupInvitationToken, error) { + var ( + nodes = []*GroupInvitationToken{} + withFKs = gitq.withFKs + _spec = gitq.querySpec() + loadedTypes = [1]bool{ + gitq.withGroup != nil, + } + ) + if gitq.withGroup != nil { + withFKs = true + } + if withFKs { + _spec.Node.Columns = append(_spec.Node.Columns, groupinvitationtoken.ForeignKeys...) + } + _spec.ScanValues = func(columns []string) ([]any, error) { + return (*GroupInvitationToken).scanValues(nil, columns) + } + _spec.Assign = func(columns []string, values []any) error { + node := &GroupInvitationToken{config: gitq.config} + nodes = append(nodes, node) + node.Edges.loadedTypes = loadedTypes + return node.assignValues(columns, values) + } + for i := range hooks { + hooks[i](ctx, _spec) + } + if err := sqlgraph.QueryNodes(ctx, gitq.driver, _spec); err != nil { + return nil, err + } + if len(nodes) == 0 { + return nodes, nil + } + if query := gitq.withGroup; query != nil { + if err := gitq.loadGroup(ctx, query, nodes, nil, + func(n *GroupInvitationToken, e *Group) { n.Edges.Group = e }); err != nil { + return nil, err + } + } + return nodes, nil +} + +func (gitq *GroupInvitationTokenQuery) loadGroup(ctx context.Context, query *GroupQuery, nodes []*GroupInvitationToken, init func(*GroupInvitationToken), assign func(*GroupInvitationToken, *Group)) error { + ids := make([]uuid.UUID, 0, len(nodes)) + nodeids := make(map[uuid.UUID][]*GroupInvitationToken) + for i := range nodes { + if nodes[i].group_invitation_tokens == nil { + continue + } + fk := *nodes[i].group_invitation_tokens + 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_invitation_tokens" returned %v`, n.ID) + } + for i := range nodes { + assign(nodes[i], n) + } + } + return nil +} + +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 + } + return sqlgraph.CountNodes(ctx, gitq.driver, _spec) +} + +func (gitq *GroupInvitationTokenQuery) sqlExist(ctx context.Context) (bool, error) { + switch _, err := gitq.FirstID(ctx); { + case IsNotFound(err): + return false, nil + case err != nil: + return false, fmt.Errorf("ent: check existence: %w", err) + default: + return true, nil + } +} + +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.Unique = *unique + } + if fields := gitq.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 { + if fields[i] != groupinvitationtoken.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, fields[i]) + } + } + } + if ps := gitq.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if limit := gitq.limit; limit != nil { + _spec.Limit = *limit + } + if offset := gitq.offset; offset != nil { + _spec.Offset = *offset + } + if ps := gitq.order; len(ps) > 0 { + _spec.Order = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + return _spec +} + +func (gitq *GroupInvitationTokenQuery) sqlQuery(ctx context.Context) *sql.Selector { + builder := sql.Dialect(gitq.driver.Dialect()) + t1 := builder.Table(groupinvitationtoken.Table) + columns := gitq.fields + if len(columns) == 0 { + columns = groupinvitationtoken.Columns + } + selector := builder.Select(t1.Columns(columns...)...).From(t1) + if gitq.sql != nil { + selector = gitq.sql + selector.Select(selector.Columns(columns...)...) + } + if gitq.unique != nil && *gitq.unique { + selector.Distinct() + } + for _, p := range gitq.predicates { + p(selector) + } + for _, p := range gitq.order { + p(selector) + } + if offset := gitq.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 { + selector.Limit(*limit) + } + return selector +} + +// GroupInvitationTokenGroupBy is the group-by builder for GroupInvitationToken entities. +type GroupInvitationTokenGroupBy struct { + config + selector + fields []string + fns []AggregateFunc + // intermediate query (i.e. traversal path). + sql *sql.Selector + path func(context.Context) (*sql.Selector, error) +} + +// Aggregate adds the given aggregation functions to the group-by query. +func (gitgb *GroupInvitationTokenGroupBy) Aggregate(fns ...AggregateFunc) *GroupInvitationTokenGroupBy { + gitgb.fns = append(gitgb.fns, fns...) + return gitgb +} + +// Scan applies the group-by query and scans the result into the given value. +func (gitgb *GroupInvitationTokenGroupBy) Scan(ctx context.Context, v any) error { + query, err := gitgb.path(ctx) + if err != nil { + return err + } + gitgb.sql = query + return gitgb.sqlScan(ctx, v) +} + +func (gitgb *GroupInvitationTokenGroupBy) sqlScan(ctx context.Context, v any) error { + for _, f := range gitgb.fields { + if !groupinvitationtoken.ValidColumn(f) { + return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)} + } + } + selector := gitgb.sqlQuery() + if err := selector.Err(); err != nil { + return err + } + rows := &sql.Rows{} + query, args := selector.Query() + if err := gitgb.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} + +func (gitgb *GroupInvitationTokenGroupBy) sqlQuery() *sql.Selector { + selector := gitgb.sql.Select() + aggregation := make([]string, 0, len(gitgb.fns)) + for _, fn := range gitgb.fns { + aggregation = append(aggregation, fn(selector)) + } + // If no columns were selected in a custom aggregation function, the default + // selection is the fields used for "group-by", and the aggregation functions. + if len(selector.SelectedColumns()) == 0 { + columns := make([]string, 0, len(gitgb.fields)+len(gitgb.fns)) + for _, f := range gitgb.fields { + columns = append(columns, selector.C(f)) + } + columns = append(columns, aggregation...) + selector.Select(columns...) + } + return selector.GroupBy(selector.Columns(gitgb.fields...)...) +} + +// GroupInvitationTokenSelect is the builder for selecting fields of GroupInvitationToken entities. +type GroupInvitationTokenSelect struct { + *GroupInvitationTokenQuery + selector + // intermediate query (i.e. traversal path). + sql *sql.Selector +} + +// Scan applies the selector query and scans the result into the given value. +func (gits *GroupInvitationTokenSelect) Scan(ctx context.Context, v any) error { + if err := gits.prepareQuery(ctx); err != nil { + return err + } + gits.sql = gits.GroupInvitationTokenQuery.sqlQuery(ctx) + return gits.sqlScan(ctx, v) +} + +func (gits *GroupInvitationTokenSelect) sqlScan(ctx context.Context, v any) error { + rows := &sql.Rows{} + query, args := gits.sql.Query() + if err := gits.driver.Query(ctx, query, args, rows); err != nil { + return err + } + defer rows.Close() + return sql.ScanSlice(rows, v) +} diff --git a/backend/ent/groupinvitationtoken_update.go b/backend/ent/groupinvitationtoken_update.go new file mode 100644 index 0000000..3459c4e --- /dev/null +++ b/backend/ent/groupinvitationtoken_update.go @@ -0,0 +1,550 @@ +// Code generated by ent, DO NOT EDIT. + +package ent + +import ( + "context" + "errors" + "fmt" + "time" + + "entgo.io/ent/dialect/sql" + "entgo.io/ent/dialect/sql/sqlgraph" + "entgo.io/ent/schema/field" + "github.com/google/uuid" + "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" + "github.com/hay-kot/homebox/backend/ent/predicate" +) + +// GroupInvitationTokenUpdate is the builder for updating GroupInvitationToken entities. +type GroupInvitationTokenUpdate struct { + config + hooks []Hook + mutation *GroupInvitationTokenMutation +} + +// Where appends a list predicates to the GroupInvitationTokenUpdate builder. +func (gitu *GroupInvitationTokenUpdate) Where(ps ...predicate.GroupInvitationToken) *GroupInvitationTokenUpdate { + gitu.mutation.Where(ps...) + return gitu +} + +// SetUpdatedAt sets the "updated_at" field. +func (gitu *GroupInvitationTokenUpdate) SetUpdatedAt(t time.Time) *GroupInvitationTokenUpdate { + gitu.mutation.SetUpdatedAt(t) + return gitu +} + +// SetToken sets the "token" field. +func (gitu *GroupInvitationTokenUpdate) SetToken(b []byte) *GroupInvitationTokenUpdate { + gitu.mutation.SetToken(b) + return gitu +} + +// SetExpiresAt sets the "expires_at" field. +func (gitu *GroupInvitationTokenUpdate) SetExpiresAt(t time.Time) *GroupInvitationTokenUpdate { + gitu.mutation.SetExpiresAt(t) + return gitu +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (gitu *GroupInvitationTokenUpdate) SetNillableExpiresAt(t *time.Time) *GroupInvitationTokenUpdate { + if t != nil { + gitu.SetExpiresAt(*t) + } + return gitu +} + +// SetUses sets the "uses" field. +func (gitu *GroupInvitationTokenUpdate) SetUses(i int) *GroupInvitationTokenUpdate { + gitu.mutation.ResetUses() + gitu.mutation.SetUses(i) + return gitu +} + +// SetNillableUses sets the "uses" field if the given value is not nil. +func (gitu *GroupInvitationTokenUpdate) SetNillableUses(i *int) *GroupInvitationTokenUpdate { + if i != nil { + gitu.SetUses(*i) + } + return gitu +} + +// AddUses adds i to the "uses" field. +func (gitu *GroupInvitationTokenUpdate) AddUses(i int) *GroupInvitationTokenUpdate { + gitu.mutation.AddUses(i) + return gitu +} + +// SetGroupID sets the "group" edge to the Group entity by ID. +func (gitu *GroupInvitationTokenUpdate) SetGroupID(id uuid.UUID) *GroupInvitationTokenUpdate { + gitu.mutation.SetGroupID(id) + return gitu +} + +// SetNillableGroupID sets the "group" edge to the Group entity by ID if the given value is not nil. +func (gitu *GroupInvitationTokenUpdate) SetNillableGroupID(id *uuid.UUID) *GroupInvitationTokenUpdate { + if id != nil { + gitu = gitu.SetGroupID(*id) + } + return gitu +} + +// SetGroup sets the "group" edge to the Group entity. +func (gitu *GroupInvitationTokenUpdate) SetGroup(g *Group) *GroupInvitationTokenUpdate { + return gitu.SetGroupID(g.ID) +} + +// Mutation returns the GroupInvitationTokenMutation object of the builder. +func (gitu *GroupInvitationTokenUpdate) Mutation() *GroupInvitationTokenMutation { + return gitu.mutation +} + +// ClearGroup clears the "group" edge to the Group entity. +func (gitu *GroupInvitationTokenUpdate) ClearGroup() *GroupInvitationTokenUpdate { + gitu.mutation.ClearGroup() + return gitu +} + +// Save executes the query and returns the number of nodes affected by the update operation. +func (gitu *GroupInvitationTokenUpdate) Save(ctx context.Context) (int, error) { + var ( + err error + affected int + ) + gitu.defaults() + if len(gitu.hooks) == 0 { + affected, err = gitu.sqlSave(ctx) + } else { + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + gitu.mutation = mutation + affected, err = gitu.sqlSave(ctx) + mutation.done = true + return affected, err + }) + for i := len(gitu.hooks) - 1; i >= 0; i-- { + if gitu.hooks[i] == nil { + return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") + } + mut = gitu.hooks[i](mut) + } + if _, err := mut.Mutate(ctx, gitu.mutation); err != nil { + return 0, err + } + } + return affected, err +} + +// SaveX is like Save, but panics if an error occurs. +func (gitu *GroupInvitationTokenUpdate) SaveX(ctx context.Context) int { + affected, err := gitu.Save(ctx) + if err != nil { + panic(err) + } + return affected +} + +// Exec executes the query. +func (gitu *GroupInvitationTokenUpdate) Exec(ctx context.Context) error { + _, err := gitu.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gitu *GroupInvitationTokenUpdate) ExecX(ctx context.Context) { + if err := gitu.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (gitu *GroupInvitationTokenUpdate) defaults() { + if _, ok := gitu.mutation.UpdatedAt(); !ok { + v := groupinvitationtoken.UpdateDefaultUpdatedAt() + gitu.mutation.SetUpdatedAt(v) + } +} + +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, + }, + }, + } + if ps := gitu.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := gitu.mutation.UpdatedAt(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldUpdatedAt, + }) + } + if value, ok := gitu.mutation.Token(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeBytes, + Value: value, + Column: groupinvitationtoken.FieldToken, + }) + } + if value, ok := gitu.mutation.ExpiresAt(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldExpiresAt, + }) + } + if value, ok := gitu.mutation.Uses(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Value: value, + Column: groupinvitationtoken.FieldUses, + }) + } + if value, ok := gitu.mutation.AddedUses(); ok { + _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Value: value, + Column: groupinvitationtoken.FieldUses, + }) + } + if gitu.mutation.GroupCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: groupinvitationtoken.GroupTable, + Columns: []string{groupinvitationtoken.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 := gitu.mutation.GroupIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: groupinvitationtoken.GroupTable, + Columns: []string{groupinvitationtoken.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) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + if n, err = sqlgraph.UpdateNodes(ctx, gitu.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{groupinvitationtoken.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return 0, err + } + return n, nil +} + +// GroupInvitationTokenUpdateOne is the builder for updating a single GroupInvitationToken entity. +type GroupInvitationTokenUpdateOne struct { + config + fields []string + hooks []Hook + mutation *GroupInvitationTokenMutation +} + +// SetUpdatedAt sets the "updated_at" field. +func (gituo *GroupInvitationTokenUpdateOne) SetUpdatedAt(t time.Time) *GroupInvitationTokenUpdateOne { + gituo.mutation.SetUpdatedAt(t) + return gituo +} + +// SetToken sets the "token" field. +func (gituo *GroupInvitationTokenUpdateOne) SetToken(b []byte) *GroupInvitationTokenUpdateOne { + gituo.mutation.SetToken(b) + return gituo +} + +// SetExpiresAt sets the "expires_at" field. +func (gituo *GroupInvitationTokenUpdateOne) SetExpiresAt(t time.Time) *GroupInvitationTokenUpdateOne { + gituo.mutation.SetExpiresAt(t) + return gituo +} + +// SetNillableExpiresAt sets the "expires_at" field if the given value is not nil. +func (gituo *GroupInvitationTokenUpdateOne) SetNillableExpiresAt(t *time.Time) *GroupInvitationTokenUpdateOne { + if t != nil { + gituo.SetExpiresAt(*t) + } + return gituo +} + +// SetUses sets the "uses" field. +func (gituo *GroupInvitationTokenUpdateOne) SetUses(i int) *GroupInvitationTokenUpdateOne { + gituo.mutation.ResetUses() + gituo.mutation.SetUses(i) + return gituo +} + +// SetNillableUses sets the "uses" field if the given value is not nil. +func (gituo *GroupInvitationTokenUpdateOne) SetNillableUses(i *int) *GroupInvitationTokenUpdateOne { + if i != nil { + gituo.SetUses(*i) + } + return gituo +} + +// AddUses adds i to the "uses" field. +func (gituo *GroupInvitationTokenUpdateOne) AddUses(i int) *GroupInvitationTokenUpdateOne { + gituo.mutation.AddUses(i) + return gituo +} + +// SetGroupID sets the "group" edge to the Group entity by ID. +func (gituo *GroupInvitationTokenUpdateOne) SetGroupID(id uuid.UUID) *GroupInvitationTokenUpdateOne { + gituo.mutation.SetGroupID(id) + return gituo +} + +// SetNillableGroupID sets the "group" edge to the Group entity by ID if the given value is not nil. +func (gituo *GroupInvitationTokenUpdateOne) SetNillableGroupID(id *uuid.UUID) *GroupInvitationTokenUpdateOne { + if id != nil { + gituo = gituo.SetGroupID(*id) + } + return gituo +} + +// SetGroup sets the "group" edge to the Group entity. +func (gituo *GroupInvitationTokenUpdateOne) SetGroup(g *Group) *GroupInvitationTokenUpdateOne { + return gituo.SetGroupID(g.ID) +} + +// Mutation returns the GroupInvitationTokenMutation object of the builder. +func (gituo *GroupInvitationTokenUpdateOne) Mutation() *GroupInvitationTokenMutation { + return gituo.mutation +} + +// ClearGroup clears the "group" edge to the Group entity. +func (gituo *GroupInvitationTokenUpdateOne) ClearGroup() *GroupInvitationTokenUpdateOne { + gituo.mutation.ClearGroup() + 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 { + gituo.fields = append([]string{field}, fields...) + return gituo +} + +// Save executes the query and returns the updated GroupInvitationToken entity. +func (gituo *GroupInvitationTokenUpdateOne) Save(ctx context.Context) (*GroupInvitationToken, error) { + var ( + err error + node *GroupInvitationToken + ) + gituo.defaults() + if len(gituo.hooks) == 0 { + node, err = gituo.sqlSave(ctx) + } else { + var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) { + mutation, ok := m.(*GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T", m) + } + gituo.mutation = mutation + node, err = gituo.sqlSave(ctx) + mutation.done = true + return node, err + }) + for i := len(gituo.hooks) - 1; i >= 0; i-- { + if gituo.hooks[i] == nil { + return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)") + } + mut = gituo.hooks[i](mut) + } + v, err := mut.Mutate(ctx, gituo.mutation) + if err != nil { + return nil, err + } + nv, ok := v.(*GroupInvitationToken) + if !ok { + return nil, fmt.Errorf("unexpected node type %T returned from GroupInvitationTokenMutation", v) + } + node = nv + } + return node, err +} + +// SaveX is like Save, but panics if an error occurs. +func (gituo *GroupInvitationTokenUpdateOne) SaveX(ctx context.Context) *GroupInvitationToken { + node, err := gituo.Save(ctx) + if err != nil { + panic(err) + } + return node +} + +// Exec executes the query on the entity. +func (gituo *GroupInvitationTokenUpdateOne) Exec(ctx context.Context) error { + _, err := gituo.Save(ctx) + return err +} + +// ExecX is like Exec, but panics if an error occurs. +func (gituo *GroupInvitationTokenUpdateOne) ExecX(ctx context.Context) { + if err := gituo.Exec(ctx); err != nil { + panic(err) + } +} + +// defaults sets the default values of the builder before save. +func (gituo *GroupInvitationTokenUpdateOne) defaults() { + if _, ok := gituo.mutation.UpdatedAt(); !ok { + v := groupinvitationtoken.UpdateDefaultUpdatedAt() + gituo.mutation.SetUpdatedAt(v) + } +} + +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, + }, + }, + } + id, ok := gituo.mutation.ID() + if !ok { + return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "GroupInvitationToken.id" for update`)} + } + _spec.Node.ID.Value = id + if fields := gituo.fields; len(fields) > 0 { + _spec.Node.Columns = make([]string, 0, len(fields)) + _spec.Node.Columns = append(_spec.Node.Columns, groupinvitationtoken.FieldID) + for _, f := range fields { + if !groupinvitationtoken.ValidColumn(f) { + return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)} + } + if f != groupinvitationtoken.FieldID { + _spec.Node.Columns = append(_spec.Node.Columns, f) + } + } + } + if ps := gituo.mutation.predicates; len(ps) > 0 { + _spec.Predicate = func(selector *sql.Selector) { + for i := range ps { + ps[i](selector) + } + } + } + if value, ok := gituo.mutation.UpdatedAt(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldUpdatedAt, + }) + } + if value, ok := gituo.mutation.Token(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeBytes, + Value: value, + Column: groupinvitationtoken.FieldToken, + }) + } + if value, ok := gituo.mutation.ExpiresAt(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeTime, + Value: value, + Column: groupinvitationtoken.FieldExpiresAt, + }) + } + if value, ok := gituo.mutation.Uses(); ok { + _spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Value: value, + Column: groupinvitationtoken.FieldUses, + }) + } + if value, ok := gituo.mutation.AddedUses(); ok { + _spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{ + Type: field.TypeInt, + Value: value, + Column: groupinvitationtoken.FieldUses, + }) + } + if gituo.mutation.GroupCleared() { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: groupinvitationtoken.GroupTable, + Columns: []string{groupinvitationtoken.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 := gituo.mutation.GroupIDs(); len(nodes) > 0 { + edge := &sqlgraph.EdgeSpec{ + Rel: sqlgraph.M2O, + Inverse: true, + Table: groupinvitationtoken.GroupTable, + Columns: []string{groupinvitationtoken.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) + } + _spec.Edges.Add = append(_spec.Edges.Add, edge) + } + _node = &GroupInvitationToken{config: gituo.config} + _spec.Assign = _node.assignValues + _spec.ScanValues = _node.scanValues + if err = sqlgraph.UpdateNode(ctx, gituo.driver, _spec); err != nil { + if _, ok := err.(*sqlgraph.NotFoundError); ok { + err = &NotFoundError{groupinvitationtoken.Label} + } else if sqlgraph.IsConstraintError(err) { + err = &ConstraintError{msg: err.Error(), wrap: err} + } + return nil, err + } + return _node, nil +} diff --git a/backend/ent/hook/hook.go b/backend/ent/hook/hook.go index fe2ec6d..0fbd6d1 100644 --- a/backend/ent/hook/hook.go +++ b/backend/ent/hook/hook.go @@ -74,6 +74,19 @@ func (f GroupFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error return f(ctx, mv) } +// The GroupInvitationTokenFunc type is an adapter to allow the use of ordinary +// function as GroupInvitationToken mutator. +type GroupInvitationTokenFunc func(context.Context, *ent.GroupInvitationTokenMutation) (ent.Value, error) + +// Mutate calls f(ctx, m). +func (f GroupInvitationTokenFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) { + mv, ok := m.(*ent.GroupInvitationTokenMutation) + if !ok { + return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.GroupInvitationTokenMutation", m) + } + return f(ctx, mv) +} + // The ItemFunc type is an adapter to allow the use of ordinary // function as Item mutator. type ItemFunc func(context.Context, *ent.ItemMutation) (ent.Value, error) diff --git a/backend/ent/migrate/schema.go b/backend/ent/migrate/schema.go index 7b00b01..f71e4e0 100644 --- a/backend/ent/migrate/schema.go +++ b/backend/ent/migrate/schema.go @@ -135,6 +135,30 @@ var ( Columns: GroupsColumns, PrimaryKey: []*schema.Column{GroupsColumns[0]}, } + // GroupInvitationTokensColumns holds the columns for the "group_invitation_tokens" table. + GroupInvitationTokensColumns = []*schema.Column{ + {Name: "id", Type: field.TypeUUID}, + {Name: "created_at", Type: field.TypeTime}, + {Name: "updated_at", Type: field.TypeTime}, + {Name: "token", Type: field.TypeBytes, Unique: true}, + {Name: "expires_at", Type: field.TypeTime}, + {Name: "uses", Type: field.TypeInt, Default: 0}, + {Name: "group_invitation_tokens", Type: field.TypeUUID, Nullable: true}, + } + // GroupInvitationTokensTable holds the schema information for the "group_invitation_tokens" table. + GroupInvitationTokensTable = &schema.Table{ + Name: "group_invitation_tokens", + Columns: GroupInvitationTokensColumns, + PrimaryKey: []*schema.Column{GroupInvitationTokensColumns[0]}, + ForeignKeys: []*schema.ForeignKey{ + { + Symbol: "group_invitation_tokens_groups_invitation_tokens", + Columns: []*schema.Column{GroupInvitationTokensColumns[6]}, + RefColumns: []*schema.Column{GroupsColumns[0]}, + OnDelete: schema.Cascade, + }, + }, + } // ItemsColumns holds the columns for the "items" table. ItemsColumns = []*schema.Column{ {Name: "id", Type: field.TypeUUID}, @@ -336,6 +360,7 @@ var ( DocumentsTable, DocumentTokensTable, GroupsTable, + GroupInvitationTokensTable, ItemsTable, ItemFieldsTable, LabelsTable, @@ -351,6 +376,7 @@ func init() { AuthTokensTable.ForeignKeys[0].RefTable = UsersTable DocumentsTable.ForeignKeys[0].RefTable = GroupsTable DocumentTokensTable.ForeignKeys[0].RefTable = DocumentsTable + GroupInvitationTokensTable.ForeignKeys[0].RefTable = GroupsTable ItemsTable.ForeignKeys[0].RefTable = GroupsTable ItemsTable.ForeignKeys[1].RefTable = LocationsTable ItemFieldsTable.ForeignKeys[0].RefTable = ItemsTable diff --git a/backend/ent/mutation.go b/backend/ent/mutation.go index 11b64af..fff3519 100644 --- a/backend/ent/mutation.go +++ b/backend/ent/mutation.go @@ -15,6 +15,7 @@ import ( "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/documenttoken" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/itemfield" "github.com/hay-kot/homebox/backend/ent/label" @@ -34,16 +35,17 @@ const ( OpUpdateOne = ent.OpUpdateOne // Node types. - TypeAttachment = "Attachment" - TypeAuthTokens = "AuthTokens" - TypeDocument = "Document" - TypeDocumentToken = "DocumentToken" - TypeGroup = "Group" - TypeItem = "Item" - TypeItemField = "ItemField" - TypeLabel = "Label" - TypeLocation = "Location" - TypeUser = "User" + TypeAttachment = "Attachment" + TypeAuthTokens = "AuthTokens" + TypeDocument = "Document" + TypeDocumentToken = "DocumentToken" + TypeGroup = "Group" + TypeGroupInvitationToken = "GroupInvitationToken" + TypeItem = "Item" + TypeItemField = "ItemField" + TypeLabel = "Label" + TypeLocation = "Location" + TypeUser = "User" ) // AttachmentMutation represents an operation that mutates the Attachment nodes in the graph. @@ -2496,32 +2498,35 @@ func (m *DocumentTokenMutation) ResetEdge(name string) error { // GroupMutation represents an operation that mutates the Group nodes in the graph. type GroupMutation struct { config - op Op - typ string - id *uuid.UUID - created_at *time.Time - updated_at *time.Time - name *string - currency *group.Currency - clearedFields map[string]struct{} - users map[uuid.UUID]struct{} - removedusers map[uuid.UUID]struct{} - clearedusers bool - locations map[uuid.UUID]struct{} - removedlocations map[uuid.UUID]struct{} - clearedlocations bool - items map[uuid.UUID]struct{} - removeditems map[uuid.UUID]struct{} - cleareditems bool - labels map[uuid.UUID]struct{} - removedlabels map[uuid.UUID]struct{} - clearedlabels bool - documents map[uuid.UUID]struct{} - removeddocuments map[uuid.UUID]struct{} - cleareddocuments bool - done bool - oldValue func(context.Context) (*Group, error) - predicates []predicate.Group + op Op + typ string + id *uuid.UUID + created_at *time.Time + updated_at *time.Time + name *string + currency *group.Currency + clearedFields map[string]struct{} + users map[uuid.UUID]struct{} + removedusers map[uuid.UUID]struct{} + clearedusers bool + locations map[uuid.UUID]struct{} + removedlocations map[uuid.UUID]struct{} + clearedlocations bool + items map[uuid.UUID]struct{} + removeditems map[uuid.UUID]struct{} + cleareditems bool + labels map[uuid.UUID]struct{} + removedlabels map[uuid.UUID]struct{} + clearedlabels bool + documents map[uuid.UUID]struct{} + removeddocuments map[uuid.UUID]struct{} + cleareddocuments bool + invitation_tokens map[uuid.UUID]struct{} + removedinvitation_tokens map[uuid.UUID]struct{} + clearedinvitation_tokens bool + done bool + oldValue func(context.Context) (*Group, error) + predicates []predicate.Group } var _ ent.Mutation = (*GroupMutation)(nil) @@ -3042,6 +3047,60 @@ func (m *GroupMutation) ResetDocuments() { m.removeddocuments = nil } +// AddInvitationTokenIDs adds the "invitation_tokens" edge to the GroupInvitationToken entity by ids. +func (m *GroupMutation) AddInvitationTokenIDs(ids ...uuid.UUID) { + if m.invitation_tokens == nil { + m.invitation_tokens = make(map[uuid.UUID]struct{}) + } + for i := range ids { + m.invitation_tokens[ids[i]] = struct{}{} + } +} + +// ClearInvitationTokens clears the "invitation_tokens" edge to the GroupInvitationToken entity. +func (m *GroupMutation) ClearInvitationTokens() { + m.clearedinvitation_tokens = true +} + +// InvitationTokensCleared reports if the "invitation_tokens" edge to the GroupInvitationToken entity was cleared. +func (m *GroupMutation) InvitationTokensCleared() bool { + return m.clearedinvitation_tokens +} + +// RemoveInvitationTokenIDs removes the "invitation_tokens" edge to the GroupInvitationToken entity by IDs. +func (m *GroupMutation) RemoveInvitationTokenIDs(ids ...uuid.UUID) { + if m.removedinvitation_tokens == nil { + m.removedinvitation_tokens = make(map[uuid.UUID]struct{}) + } + for i := range ids { + delete(m.invitation_tokens, ids[i]) + m.removedinvitation_tokens[ids[i]] = struct{}{} + } +} + +// RemovedInvitationTokens returns the removed IDs of the "invitation_tokens" edge to the GroupInvitationToken entity. +func (m *GroupMutation) RemovedInvitationTokensIDs() (ids []uuid.UUID) { + for id := range m.removedinvitation_tokens { + ids = append(ids, id) + } + return +} + +// InvitationTokensIDs returns the "invitation_tokens" edge IDs in the mutation. +func (m *GroupMutation) InvitationTokensIDs() (ids []uuid.UUID) { + for id := range m.invitation_tokens { + ids = append(ids, id) + } + return +} + +// ResetInvitationTokens resets all changes to the "invitation_tokens" edge. +func (m *GroupMutation) ResetInvitationTokens() { + m.invitation_tokens = nil + m.clearedinvitation_tokens = false + m.removedinvitation_tokens = nil +} + // Where appends a list predicates to the GroupMutation builder. func (m *GroupMutation) Where(ps ...predicate.Group) { m.predicates = append(m.predicates, ps...) @@ -3211,7 +3270,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, 5) + edges := make([]string, 0, 6) if m.users != nil { edges = append(edges, group.EdgeUsers) } @@ -3227,6 +3286,9 @@ func (m *GroupMutation) AddedEdges() []string { if m.documents != nil { edges = append(edges, group.EdgeDocuments) } + if m.invitation_tokens != nil { + edges = append(edges, group.EdgeInvitationTokens) + } return edges } @@ -3264,13 +3326,19 @@ func (m *GroupMutation) AddedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case group.EdgeInvitationTokens: + ids := make([]ent.Value, 0, len(m.invitation_tokens)) + for id := range m.invitation_tokens { + 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, 5) + edges := make([]string, 0, 6) if m.removedusers != nil { edges = append(edges, group.EdgeUsers) } @@ -3286,6 +3354,9 @@ func (m *GroupMutation) RemovedEdges() []string { if m.removeddocuments != nil { edges = append(edges, group.EdgeDocuments) } + if m.removedinvitation_tokens != nil { + edges = append(edges, group.EdgeInvitationTokens) + } return edges } @@ -3323,13 +3394,19 @@ func (m *GroupMutation) RemovedIDs(name string) []ent.Value { ids = append(ids, id) } return ids + case group.EdgeInvitationTokens: + ids := make([]ent.Value, 0, len(m.removedinvitation_tokens)) + for id := range m.removedinvitation_tokens { + 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, 5) + edges := make([]string, 0, 6) if m.clearedusers { edges = append(edges, group.EdgeUsers) } @@ -3345,6 +3422,9 @@ func (m *GroupMutation) ClearedEdges() []string { if m.cleareddocuments { edges = append(edges, group.EdgeDocuments) } + if m.clearedinvitation_tokens { + edges = append(edges, group.EdgeInvitationTokens) + } return edges } @@ -3362,6 +3442,8 @@ func (m *GroupMutation) EdgeCleared(name string) bool { return m.clearedlabels case group.EdgeDocuments: return m.cleareddocuments + case group.EdgeInvitationTokens: + return m.clearedinvitation_tokens } return false } @@ -3393,10 +3475,649 @@ func (m *GroupMutation) ResetEdge(name string) error { case group.EdgeDocuments: m.ResetDocuments() return nil + case group.EdgeInvitationTokens: + m.ResetInvitationTokens() + return nil } return fmt.Errorf("unknown Group edge %s", name) } +// GroupInvitationTokenMutation represents an operation that mutates the GroupInvitationToken nodes in the graph. +type GroupInvitationTokenMutation struct { + config + op Op + typ string + id *uuid.UUID + created_at *time.Time + updated_at *time.Time + token *[]byte + expires_at *time.Time + uses *int + adduses *int + clearedFields map[string]struct{} + group *uuid.UUID + clearedgroup bool + done bool + oldValue func(context.Context) (*GroupInvitationToken, error) + predicates []predicate.GroupInvitationToken +} + +var _ ent.Mutation = (*GroupInvitationTokenMutation)(nil) + +// groupinvitationtokenOption allows management of the mutation configuration using functional options. +type groupinvitationtokenOption func(*GroupInvitationTokenMutation) + +// newGroupInvitationTokenMutation creates new mutation for the GroupInvitationToken entity. +func newGroupInvitationTokenMutation(c config, op Op, opts ...groupinvitationtokenOption) *GroupInvitationTokenMutation { + m := &GroupInvitationTokenMutation{ + config: c, + op: op, + typ: TypeGroupInvitationToken, + clearedFields: make(map[string]struct{}), + } + for _, opt := range opts { + opt(m) + } + return m +} + +// withGroupInvitationTokenID sets the ID field of the mutation. +func withGroupInvitationTokenID(id uuid.UUID) groupinvitationtokenOption { + return func(m *GroupInvitationTokenMutation) { + var ( + err error + once sync.Once + value *GroupInvitationToken + ) + m.oldValue = func(ctx context.Context) (*GroupInvitationToken, error) { + once.Do(func() { + if m.done { + err = errors.New("querying old values post mutation is not allowed") + } else { + value, err = m.Client().GroupInvitationToken.Get(ctx, id) + } + }) + return value, err + } + m.id = &id + } +} + +// withGroupInvitationToken sets the old GroupInvitationToken of the mutation. +func withGroupInvitationToken(node *GroupInvitationToken) groupinvitationtokenOption { + return func(m *GroupInvitationTokenMutation) { + m.oldValue = func(context.Context) (*GroupInvitationToken, 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 GroupInvitationTokenMutation) 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 GroupInvitationTokenMutation) 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 GroupInvitationToken entities. +func (m *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) 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().GroupInvitationToken.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 *GroupInvitationTokenMutation) SetCreatedAt(t time.Time) { + m.created_at = &t +} + +// CreatedAt returns the value of the "created_at" field in the mutation. +func (m *GroupInvitationTokenMutation) 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 GroupInvitationToken entity. +// If the GroupInvitationToken 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 *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) ResetCreatedAt() { + m.created_at = nil +} + +// SetUpdatedAt sets the "updated_at" field. +func (m *GroupInvitationTokenMutation) SetUpdatedAt(t time.Time) { + m.updated_at = &t +} + +// UpdatedAt returns the value of the "updated_at" field in the mutation. +func (m *GroupInvitationTokenMutation) 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 GroupInvitationToken entity. +// If the GroupInvitationToken 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 *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) ResetUpdatedAt() { + m.updated_at = nil +} + +// SetToken sets the "token" field. +func (m *GroupInvitationTokenMutation) SetToken(b []byte) { + m.token = &b +} + +// Token returns the value of the "token" field in the mutation. +func (m *GroupInvitationTokenMutation) Token() (r []byte, exists bool) { + v := m.token + if v == nil { + return + } + return *v, true +} + +// OldToken returns the old "token" field's value of the GroupInvitationToken entity. +// If the GroupInvitationToken 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 *GroupInvitationTokenMutation) OldToken(ctx context.Context) (v []byte, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldToken is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldToken requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldToken: %w", err) + } + return oldValue.Token, nil +} + +// ResetToken resets all changes to the "token" field. +func (m *GroupInvitationTokenMutation) ResetToken() { + m.token = nil +} + +// SetExpiresAt sets the "expires_at" field. +func (m *GroupInvitationTokenMutation) SetExpiresAt(t time.Time) { + m.expires_at = &t +} + +// ExpiresAt returns the value of the "expires_at" field in the mutation. +func (m *GroupInvitationTokenMutation) ExpiresAt() (r time.Time, exists bool) { + v := m.expires_at + if v == nil { + return + } + return *v, true +} + +// OldExpiresAt returns the old "expires_at" field's value of the GroupInvitationToken entity. +// If the GroupInvitationToken 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 *GroupInvitationTokenMutation) OldExpiresAt(ctx context.Context) (v time.Time, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldExpiresAt is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldExpiresAt requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldExpiresAt: %w", err) + } + return oldValue.ExpiresAt, nil +} + +// ResetExpiresAt resets all changes to the "expires_at" field. +func (m *GroupInvitationTokenMutation) ResetExpiresAt() { + m.expires_at = nil +} + +// SetUses sets the "uses" field. +func (m *GroupInvitationTokenMutation) SetUses(i int) { + m.uses = &i + m.adduses = nil +} + +// Uses returns the value of the "uses" field in the mutation. +func (m *GroupInvitationTokenMutation) Uses() (r int, exists bool) { + v := m.uses + if v == nil { + return + } + return *v, true +} + +// OldUses returns the old "uses" field's value of the GroupInvitationToken entity. +// If the GroupInvitationToken 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 *GroupInvitationTokenMutation) OldUses(ctx context.Context) (v int, err error) { + if !m.op.Is(OpUpdateOne) { + return v, errors.New("OldUses is only allowed on UpdateOne operations") + } + if m.id == nil || m.oldValue == nil { + return v, errors.New("OldUses requires an ID field in the mutation") + } + oldValue, err := m.oldValue(ctx) + if err != nil { + return v, fmt.Errorf("querying old value for OldUses: %w", err) + } + return oldValue.Uses, nil +} + +// AddUses adds i to the "uses" field. +func (m *GroupInvitationTokenMutation) AddUses(i int) { + if m.adduses != nil { + *m.adduses += i + } else { + m.adduses = &i + } +} + +// AddedUses returns the value that was added to the "uses" field in this mutation. +func (m *GroupInvitationTokenMutation) AddedUses() (r int, exists bool) { + v := m.adduses + if v == nil { + return + } + return *v, true +} + +// ResetUses resets all changes to the "uses" field. +func (m *GroupInvitationTokenMutation) ResetUses() { + m.uses = nil + m.adduses = nil +} + +// SetGroupID sets the "group" edge to the Group entity by id. +func (m *GroupInvitationTokenMutation) SetGroupID(id uuid.UUID) { + m.group = &id +} + +// ClearGroup clears the "group" edge to the Group entity. +func (m *GroupInvitationTokenMutation) ClearGroup() { + m.clearedgroup = true +} + +// GroupCleared reports if the "group" edge to the Group entity was cleared. +func (m *GroupInvitationTokenMutation) GroupCleared() bool { + return m.clearedgroup +} + +// GroupID returns the "group" edge ID in the mutation. +func (m *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) ResetGroup() { + m.group = nil + m.clearedgroup = false +} + +// Where appends a list predicates to the GroupInvitationTokenMutation builder. +func (m *GroupInvitationTokenMutation) Where(ps ...predicate.GroupInvitationToken) { + m.predicates = append(m.predicates, ps...) +} + +// Op returns the operation name. +func (m *GroupInvitationTokenMutation) Op() Op { + return m.op +} + +// Type returns the node type of this mutation (GroupInvitationToken). +func (m *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) Fields() []string { + fields := make([]string, 0, 5) + if m.created_at != nil { + fields = append(fields, groupinvitationtoken.FieldCreatedAt) + } + if m.updated_at != nil { + fields = append(fields, groupinvitationtoken.FieldUpdatedAt) + } + if m.token != nil { + fields = append(fields, groupinvitationtoken.FieldToken) + } + if m.expires_at != nil { + fields = append(fields, groupinvitationtoken.FieldExpiresAt) + } + if m.uses != nil { + fields = append(fields, groupinvitationtoken.FieldUses) + } + 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 *GroupInvitationTokenMutation) Field(name string) (ent.Value, bool) { + switch name { + case groupinvitationtoken.FieldCreatedAt: + return m.CreatedAt() + case groupinvitationtoken.FieldUpdatedAt: + return m.UpdatedAt() + case groupinvitationtoken.FieldToken: + return m.Token() + case groupinvitationtoken.FieldExpiresAt: + return m.ExpiresAt() + case groupinvitationtoken.FieldUses: + return m.Uses() + } + 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 *GroupInvitationTokenMutation) OldField(ctx context.Context, name string) (ent.Value, error) { + switch name { + case groupinvitationtoken.FieldCreatedAt: + return m.OldCreatedAt(ctx) + case groupinvitationtoken.FieldUpdatedAt: + return m.OldUpdatedAt(ctx) + case groupinvitationtoken.FieldToken: + return m.OldToken(ctx) + case groupinvitationtoken.FieldExpiresAt: + return m.OldExpiresAt(ctx) + case groupinvitationtoken.FieldUses: + return m.OldUses(ctx) + } + return nil, fmt.Errorf("unknown GroupInvitationToken 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 *GroupInvitationTokenMutation) SetField(name string, value ent.Value) error { + switch name { + case groupinvitationtoken.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 groupinvitationtoken.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 groupinvitationtoken.FieldToken: + v, ok := value.([]byte) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetToken(v) + return nil + case groupinvitationtoken.FieldExpiresAt: + v, ok := value.(time.Time) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetExpiresAt(v) + return nil + case groupinvitationtoken.FieldUses: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.SetUses(v) + return nil + } + return fmt.Errorf("unknown GroupInvitationToken field %s", name) +} + +// AddedFields returns all numeric fields that were incremented/decremented during +// this mutation. +func (m *GroupInvitationTokenMutation) AddedFields() []string { + var fields []string + if m.adduses != nil { + fields = append(fields, groupinvitationtoken.FieldUses) + } + return fields +} + +// 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 *GroupInvitationTokenMutation) AddedField(name string) (ent.Value, bool) { + switch name { + case groupinvitationtoken.FieldUses: + return m.AddedUses() + } + 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 *GroupInvitationTokenMutation) AddField(name string, value ent.Value) error { + switch name { + case groupinvitationtoken.FieldUses: + v, ok := value.(int) + if !ok { + return fmt.Errorf("unexpected type %T for field %s", value, name) + } + m.AddUses(v) + return nil + } + return fmt.Errorf("unknown GroupInvitationToken numeric field %s", name) +} + +// ClearedFields returns all nullable fields that were cleared during this +// mutation. +func (m *GroupInvitationTokenMutation) ClearedFields() []string { + return nil +} + +// FieldCleared returns a boolean indicating if a field with the given name was +// cleared in this mutation. +func (m *GroupInvitationTokenMutation) 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 *GroupInvitationTokenMutation) ClearField(name string) error { + return fmt.Errorf("unknown GroupInvitationToken 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 *GroupInvitationTokenMutation) ResetField(name string) error { + switch name { + case groupinvitationtoken.FieldCreatedAt: + m.ResetCreatedAt() + return nil + case groupinvitationtoken.FieldUpdatedAt: + m.ResetUpdatedAt() + return nil + case groupinvitationtoken.FieldToken: + m.ResetToken() + return nil + case groupinvitationtoken.FieldExpiresAt: + m.ResetExpiresAt() + return nil + case groupinvitationtoken.FieldUses: + m.ResetUses() + return nil + } + return fmt.Errorf("unknown GroupInvitationToken field %s", name) +} + +// AddedEdges returns all edge names that were set/added in this mutation. +func (m *GroupInvitationTokenMutation) AddedEdges() []string { + edges := make([]string, 0, 1) + if m.group != nil { + edges = append(edges, groupinvitationtoken.EdgeGroup) + } + return edges +} + +// AddedIDs returns all IDs (to other nodes) that were added for the given edge +// name in this mutation. +func (m *GroupInvitationTokenMutation) AddedIDs(name string) []ent.Value { + switch name { + case groupinvitationtoken.EdgeGroup: + if id := m.group; id != nil { + return []ent.Value{*id} + } + } + return nil +} + +// RemovedEdges returns all edge names that were removed in this mutation. +func (m *GroupInvitationTokenMutation) RemovedEdges() []string { + edges := make([]string, 0, 1) + return edges +} + +// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with +// the given name in this mutation. +func (m *GroupInvitationTokenMutation) RemovedIDs(name string) []ent.Value { + return nil +} + +// ClearedEdges returns all edge names that were cleared in this mutation. +func (m *GroupInvitationTokenMutation) ClearedEdges() []string { + edges := make([]string, 0, 1) + if m.clearedgroup { + edges = append(edges, groupinvitationtoken.EdgeGroup) + } + return edges +} + +// EdgeCleared returns a boolean which indicates if the edge with the given name +// was cleared in this mutation. +func (m *GroupInvitationTokenMutation) EdgeCleared(name string) bool { + switch name { + case groupinvitationtoken.EdgeGroup: + return m.clearedgroup + } + 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 *GroupInvitationTokenMutation) ClearEdge(name string) error { + switch name { + case groupinvitationtoken.EdgeGroup: + m.ClearGroup() + return nil + } + return fmt.Errorf("unknown GroupInvitationToken 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 *GroupInvitationTokenMutation) ResetEdge(name string) error { + switch name { + case groupinvitationtoken.EdgeGroup: + m.ResetGroup() + return nil + } + return fmt.Errorf("unknown GroupInvitationToken edge %s", name) +} + // ItemMutation represents an operation that mutates the Item nodes in the graph. type ItemMutation struct { config diff --git a/backend/ent/predicate/predicate.go b/backend/ent/predicate/predicate.go index 4287b9d..12b1f44 100644 --- a/backend/ent/predicate/predicate.go +++ b/backend/ent/predicate/predicate.go @@ -21,6 +21,9 @@ type DocumentToken func(*sql.Selector) // Group is the predicate function for group builders. type Group func(*sql.Selector) +// GroupInvitationToken is the predicate function for groupinvitationtoken builders. +type GroupInvitationToken func(*sql.Selector) + // Item is the predicate function for item builders. type Item func(*sql.Selector) diff --git a/backend/ent/runtime.go b/backend/ent/runtime.go index 6414b69..043b1fc 100644 --- a/backend/ent/runtime.go +++ b/backend/ent/runtime.go @@ -11,6 +11,7 @@ import ( "github.com/hay-kot/homebox/backend/ent/document" "github.com/hay-kot/homebox/backend/ent/documenttoken" "github.com/hay-kot/homebox/backend/ent/group" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" "github.com/hay-kot/homebox/backend/ent/item" "github.com/hay-kot/homebox/backend/ent/itemfield" "github.com/hay-kot/homebox/backend/ent/label" @@ -188,6 +189,33 @@ func init() { groupDescID := groupMixinFields0[0].Descriptor() // group.DefaultID holds the default value on creation for the id field. group.DefaultID = groupDescID.Default.(func() uuid.UUID) + groupinvitationtokenMixin := schema.GroupInvitationToken{}.Mixin() + groupinvitationtokenMixinFields0 := groupinvitationtokenMixin[0].Fields() + _ = groupinvitationtokenMixinFields0 + groupinvitationtokenFields := schema.GroupInvitationToken{}.Fields() + _ = groupinvitationtokenFields + // groupinvitationtokenDescCreatedAt is the schema descriptor for created_at field. + groupinvitationtokenDescCreatedAt := groupinvitationtokenMixinFields0[1].Descriptor() + // groupinvitationtoken.DefaultCreatedAt holds the default value on creation for the created_at field. + groupinvitationtoken.DefaultCreatedAt = groupinvitationtokenDescCreatedAt.Default.(func() time.Time) + // groupinvitationtokenDescUpdatedAt is the schema descriptor for updated_at field. + groupinvitationtokenDescUpdatedAt := groupinvitationtokenMixinFields0[2].Descriptor() + // groupinvitationtoken.DefaultUpdatedAt holds the default value on creation for the updated_at field. + groupinvitationtoken.DefaultUpdatedAt = groupinvitationtokenDescUpdatedAt.Default.(func() time.Time) + // groupinvitationtoken.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field. + groupinvitationtoken.UpdateDefaultUpdatedAt = groupinvitationtokenDescUpdatedAt.UpdateDefault.(func() time.Time) + // groupinvitationtokenDescExpiresAt is the schema descriptor for expires_at field. + groupinvitationtokenDescExpiresAt := groupinvitationtokenFields[1].Descriptor() + // groupinvitationtoken.DefaultExpiresAt holds the default value on creation for the expires_at field. + groupinvitationtoken.DefaultExpiresAt = groupinvitationtokenDescExpiresAt.Default.(func() time.Time) + // groupinvitationtokenDescUses is the schema descriptor for uses field. + groupinvitationtokenDescUses := groupinvitationtokenFields[2].Descriptor() + // groupinvitationtoken.DefaultUses holds the default value on creation for the uses field. + groupinvitationtoken.DefaultUses = groupinvitationtokenDescUses.Default.(int) + // groupinvitationtokenDescID is the schema descriptor for id field. + groupinvitationtokenDescID := groupinvitationtokenMixinFields0[0].Descriptor() + // groupinvitationtoken.DefaultID holds the default value on creation for the id field. + groupinvitationtoken.DefaultID = groupinvitationtokenDescID.Default.(func() uuid.UUID) itemMixin := schema.Item{}.Mixin() itemMixinFields0 := itemMixin[0].Fields() _ = itemMixinFields0 diff --git a/backend/ent/schema/group.go b/backend/ent/schema/group.go index 97237ca..01f0c1f 100644 --- a/backend/ent/schema/group.go +++ b/backend/ent/schema/group.go @@ -54,5 +54,9 @@ func (Group) Edges() []ent.Edge { Annotations(entsql.Annotation{ OnDelete: entsql.Cascade, }), + edge.To("invitation_tokens", GroupInvitationToken.Type). + Annotations(entsql.Annotation{ + OnDelete: entsql.Cascade, + }), } } diff --git a/backend/ent/schema/group_invitation_token.go b/backend/ent/schema/group_invitation_token.go new file mode 100644 index 0000000..6ba41cd --- /dev/null +++ b/backend/ent/schema/group_invitation_token.go @@ -0,0 +1,42 @@ +package schema + +import ( + "time" + + "entgo.io/ent" + "entgo.io/ent/schema/edge" + "entgo.io/ent/schema/field" + "github.com/hay-kot/homebox/backend/ent/schema/mixins" +) + +// GroupInvitationToken holds the schema definition for the GroupInvitationToken entity. +type GroupInvitationToken struct { + ent.Schema +} + +func (GroupInvitationToken) Mixin() []ent.Mixin { + return []ent.Mixin{ + mixins.BaseMixin{}, + } +} + +// Fields of the GroupInvitationToken. +func (GroupInvitationToken) Fields() []ent.Field { + return []ent.Field{ + field.Bytes("token"). + Unique(), + field.Time("expires_at"). + Default(func() time.Time { return time.Now().Add(time.Hour * 24 * 7) }), + field.Int("uses"). + Default(0), + } +} + +// Edges of the GroupInvitationToken. +func (GroupInvitationToken) Edges() []ent.Edge { + return []ent.Edge{ + edge.From("group", Group.Type). + Ref("invitation_tokens"). + Unique(), + } +} diff --git a/backend/ent/tx.go b/backend/ent/tx.go index 3dc6db8..12e5e9f 100644 --- a/backend/ent/tx.go +++ b/backend/ent/tx.go @@ -22,6 +22,8 @@ type Tx struct { DocumentToken *DocumentTokenClient // Group is the client for interacting with the Group builders. Group *GroupClient + // GroupInvitationToken is the client for interacting with the GroupInvitationToken builders. + GroupInvitationToken *GroupInvitationTokenClient // Item is the client for interacting with the Item builders. Item *ItemClient // ItemField is the client for interacting with the ItemField builders. @@ -172,6 +174,7 @@ func (tx *Tx) init() { tx.Document = NewDocumentClient(tx.config) tx.DocumentToken = NewDocumentTokenClient(tx.config) tx.Group = NewGroupClient(tx.config) + tx.GroupInvitationToken = NewGroupInvitationTokenClient(tx.config) tx.Item = NewItemClient(tx.config) tx.ItemField = NewItemFieldClient(tx.config) tx.Label = NewLabelClient(tx.config) diff --git a/backend/internal/migrations/migrations/20221001210956_group_invitations.sql b/backend/internal/migrations/migrations/20221001210956_group_invitations.sql new file mode 100644 index 0000000..30ecec0 --- /dev/null +++ b/backend/internal/migrations/migrations/20221001210956_group_invitations.sql @@ -0,0 +1,4 @@ +-- create "group_invitation_tokens" table +CREATE TABLE `group_invitation_tokens` (`id` uuid NOT NULL, `created_at` datetime NOT NULL, `updated_at` datetime NOT NULL, `token` blob NOT NULL, `expires_at` datetime NOT NULL, `uses` integer NOT NULL DEFAULT 0, `group_invitation_tokens` uuid NULL, PRIMARY KEY (`id`), CONSTRAINT `group_invitation_tokens_groups_invitation_tokens` FOREIGN KEY (`group_invitation_tokens`) REFERENCES `groups` (`id`) ON DELETE CASCADE); +-- create index "group_invitation_tokens_token_key" to table: "group_invitation_tokens" +CREATE UNIQUE INDEX `group_invitation_tokens_token_key` ON `group_invitation_tokens` (`token`); diff --git a/backend/internal/migrations/migrations/atlas.sum b/backend/internal/migrations/migrations/atlas.sum index 0064f8a..a5c2573 100644 --- a/backend/internal/migrations/migrations/atlas.sum +++ b/backend/internal/migrations/migrations/atlas.sum @@ -1,2 +1,3 @@ -h1:ihsTwGsfNb8b/1qt+jw0OPKM8I/Bcw1J3Ise0ZFu5co= +h1:JE1IHs4N6SqydqXavjqcO40KuPMZ4uA9q9eQmqeYI/o= 20220929052825_init.sql h1:ZlCqm1wzjDmofeAcSX3jE4h4VcdTNGpRg2eabztDy9Q= +20221001210956_group_invitations.sql h1:YQKJFtE39wFOcRNbZQ/d+ZlHwrcfcsZlcv/pLEYdpjw= diff --git a/backend/internal/repo/main_test.go b/backend/internal/repo/main_test.go index aa864e5..8729bab 100644 --- a/backend/internal/repo/main_test.go +++ b/backend/internal/repo/main_test.go @@ -19,7 +19,7 @@ var ( tClient *ent.Client tRepos *AllRepos tUser UserOut - tGroup *ent.Group + tGroup Group ) func bootstrap() { @@ -28,7 +28,7 @@ func bootstrap() { ctx = context.Background() ) - tGroup, err = tRepos.Groups.Create(ctx, "test-group") + tGroup, err = tRepos.Groups.GroupCreate(ctx, "test-group") if err != nil { log.Fatal(err) } diff --git a/backend/internal/repo/repo_group.go b/backend/internal/repo/repo_group.go index dfc7e07..ef7b502 100644 --- a/backend/internal/repo/repo_group.go +++ b/backend/internal/repo/repo_group.go @@ -2,21 +2,112 @@ package repo import ( "context" + "time" "github.com/google/uuid" "github.com/hay-kot/homebox/backend/ent" + "github.com/hay-kot/homebox/backend/ent/groupinvitationtoken" ) type GroupRepository struct { db *ent.Client } -func (r *GroupRepository) Create(ctx context.Context, name string) (*ent.Group, error) { - return r.db.Group.Create(). - SetName(name). - Save(ctx) +type ( + Group struct { + ID uuid.UUID + Name string + CreatedAt time.Time + UpdatedAt time.Time + Currency string + } + + GroupInvitationCreate struct { + Token []byte `json:"-"` + ExpiresAt time.Time `json:"expiresAt"` + Uses int `json:"uses"` + } + + GroupInvitation struct { + ID uuid.UUID `json:"id"` + ExpiresAt time.Time `json:"expiresAt"` + Uses int `json:"uses"` + Group Group `json:"group"` + } +) + +var ( + mapToGroupErr = mapTErrFunc(mapToGroup) +) + +func mapToGroup(g *ent.Group) Group { + return Group{ + ID: g.ID, + Name: g.Name, + CreatedAt: g.CreatedAt, + UpdatedAt: g.UpdatedAt, + Currency: g.Currency.String(), + } } -func (r *GroupRepository) GetOneId(ctx context.Context, id uuid.UUID) (*ent.Group, error) { - return r.db.Group.Get(ctx, id) +var ( + mapToGroupInvitationErr = mapTErrFunc(mapToGroupInvitation) +) + +func mapToGroupInvitation(g *ent.GroupInvitationToken) GroupInvitation { + return GroupInvitation{ + ID: g.ID, + ExpiresAt: g.ExpiresAt, + Uses: g.Uses, + Group: mapToGroup(g.Edges.Group), + } +} + +func (r *GroupRepository) GroupCreate(ctx context.Context, name string) (Group, error) { + return mapToGroupErr(r.db.Group.Create(). + SetName(name). + Save(ctx)) +} + +func (r *GroupRepository) GroupByID(ctx context.Context, id uuid.UUID) (Group, error) { + return mapToGroupErr(r.db.Group.Get(ctx, id)) +} + +func (r *GroupRepository) InvitationGet(ctx context.Context, token []byte) (GroupInvitation, error) { + return mapToGroupInvitationErr(r.db.GroupInvitationToken.Query(). + Where(groupinvitationtoken.Token(token)). + WithGroup(). + Only(ctx)) +} + +func (r *GroupRepository) InvitationCreate(ctx context.Context, groupID uuid.UUID, invite GroupInvitationCreate) (GroupInvitation, error) { + entity, err := r.db.GroupInvitationToken.Create(). + SetGroupID(groupID). + SetToken(invite.Token). + SetExpiresAt(invite.ExpiresAt). + SetUses(invite.Uses). + Save(ctx) + + if err != nil { + return GroupInvitation{}, err + } + + return r.InvitationGet(ctx, entity.Token) +} + +func (r *GroupRepository) InvitationUpdate(ctx context.Context, id uuid.UUID, uses int) error { + _, err := r.db.GroupInvitationToken.UpdateOneID(id).SetUses(uses).Save(ctx) + return err +} + +// InvitationPurge removes all expired invitations or those that have been used up. +// It returns the number of deleted invitations. +func (r *GroupRepository) InvitationPurge(ctx context.Context) (amount int, err error) { + q := r.db.GroupInvitationToken.Delete() + q.Where(groupinvitationtoken.Or( + groupinvitationtoken.ExpiresAtLT(time.Now()), + groupinvitationtoken.UsesLTE(0), + )) + + return q.Exec(ctx) } diff --git a/backend/internal/repo/repo_group_test.go b/backend/internal/repo/repo_group_test.go index 41bf686..198393d 100644 --- a/backend/internal/repo/repo_group_test.go +++ b/backend/internal/repo/repo_group_test.go @@ -8,13 +8,13 @@ import ( ) func Test_Group_Create(t *testing.T) { - g, err := tRepos.Groups.Create(context.Background(), "test") + g, err := tRepos.Groups.GroupCreate(context.Background(), "test") assert.NoError(t, err) assert.Equal(t, "test", g.Name) // Get by ID - foundGroup, err := tRepos.Groups.GetOneId(context.Background(), g.ID) + foundGroup, err := tRepos.Groups.GroupByID(context.Background(), g.ID) assert.NoError(t, err) assert.Equal(t, g.ID, foundGroup.ID) } diff --git a/backend/internal/services/main_test.go b/backend/internal/services/main_test.go index 03d25e4..fa88314 100644 --- a/backend/internal/services/main_test.go +++ b/backend/internal/services/main_test.go @@ -21,7 +21,7 @@ var ( tClient *ent.Client tRepos *repo.AllRepos tUser repo.UserOut - tGroup *ent.Group + tGroup repo.Group tSvc *AllServices ) @@ -31,7 +31,7 @@ func bootstrap() { ctx = context.Background() ) - tGroup, err = tRepos.Groups.Create(ctx, "test-group") + tGroup, err = tRepos.Groups.GroupCreate(ctx, "test-group") if err != nil { log.Fatal(err) } diff --git a/backend/internal/services/service_user.go b/backend/internal/services/service_user.go index 3e55ba8..93008c8 100644 --- a/backend/internal/services/service_user.go +++ b/backend/internal/services/service_user.go @@ -24,20 +24,16 @@ type UserService struct { type ( UserRegistration struct { - Name string `json:"name"` - Email string `json:"email"` - Password string `json:"password"` - GroupName string `json:"groupName"` + GroupToken string `json:"token"` + Name string `json:"name"` + Email string `json:"email"` + Password string `json:"password"` + GroupName string `json:"groupName"` } UserAuthTokenDetail struct { Raw string `json:"raw"` ExpiresAt time.Time `json:"expiresAt"` } - UserAuthTokenCreate struct { - TokenHash []byte `json:"token"` - UserID uuid.UUID `json:"userId"` - ExpiresAt time.Time `json:"expiresAt"` - } LoginForm struct { Username string `json:"username"` Password string `json:"password"` @@ -51,11 +47,28 @@ func (svc *UserService) RegisterUser(ctx context.Context, data UserRegistration) Str("name", data.Name). Str("email", data.Email). Str("groupName", data.GroupName). + Str("groupToken", data.GroupToken). Msg("Registering new user") - group, err := svc.repos.Groups.Create(ctx, data.GroupName) - if err != nil { - return repo.UserOut{}, err + var ( + err error + group repo.Group + token repo.GroupInvitation + ) + + if data.GroupToken == "" { + group, err = svc.repos.Groups.GroupCreate(ctx, data.GroupName) + if err != nil { + log.Err(err).Msg("Failed to create group") + return repo.UserOut{}, err + } + } else { + token, err = svc.repos.Groups.InvitationGet(ctx, hasher.HashToken(data.GroupToken)) + if err != nil { + log.Err(err).Msg("Failed to get invitation token") + return repo.UserOut{}, err + } + group = token.Group } hashed, _ := hasher.HashPassword(data.Password) @@ -86,6 +99,15 @@ func (svc *UserService) RegisterUser(ctx context.Context, data UserRegistration) } } + // Decrement the invitation token if it was used + if token.ID != uuid.Nil { + err = svc.repos.Groups.InvitationUpdate(ctx, token.ID, token.Uses-1) + if err != nil { + log.Err(err).Msg("Failed to update invitation token") + return repo.UserOut{}, err + } + } + return usr, nil } @@ -155,3 +177,18 @@ func (svc *UserService) RenewToken(ctx context.Context, token string) (UserAuthT func (svc *UserService) DeleteSelf(ctx context.Context, ID uuid.UUID) error { return svc.repos.Users.Delete(ctx, ID) } + +func (svc *UserService) NewInvitation(ctx Context, uses int, expiresAt time.Time) (string, error) { + token := hasher.GenerateToken() + + _, err := svc.repos.Groups.InvitationCreate(ctx, ctx.GID, repo.GroupInvitationCreate{ + Token: token.Hash, + Uses: uses, + ExpiresAt: expiresAt, + }) + if err != nil { + return "", err + } + + return token.Raw, nil +} diff --git a/frontend/lib/api/types/data-contracts.ts b/frontend/lib/api/types/data-contracts.ts index 001d775..c2b09b9 100644 --- a/frontend/lib/api/types/data-contracts.ts +++ b/frontend/lib/api/types/data-contracts.ts @@ -222,6 +222,7 @@ export interface UserRegistration { groupName: string; name: string; password: string; + token: string; } export interface ApiSummary { @@ -238,6 +239,17 @@ export interface Build { version: string; } +export interface GroupTokenPayload { + expiresAt: string; + uses: number; +} + +export interface GroupTokenResponse { + expiresAt: string; + token: string; + uses: number; +} + export interface ItemAttachmentToken { token: string; }