diff --git a/backend/.gitignore b/backend/.gitignore
new file mode 100644
index 00000000..9b970f5e
--- /dev/null
+++ b/backend/.gitignore
@@ -0,0 +1,15 @@
+.env
+*.exe
+*.dll
+*.so
+*.dylib
+*.test
+*.out
+vendor/
+dbv2/
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+config/server/config.yaml
diff --git a/backend/Makefile b/backend/Makefile
new file mode 100644
index 00000000..cd330b8c
--- /dev/null
+++ b/backend/Makefile
@@ -0,0 +1,32 @@
+PLATFORM=linux/amd64
+TAG=$(shell git rev-parse --short HEAD)
+OUTPUT=type=docker,dest=$(HOME)/tmp/mcai_server.tar
+GOCACHE=/root/.cache/go-build
+GOMODCACHE?=/go/pkg/mod
+REGISTRY=chaitin-registry.cn-hangzhou.cr.aliyuncs.com/monkeycode
+
+# make server PLATFORM= TAG= OUTPUT_SERVER= GOCACHE=
+image:
+ docker buildx build \
+ -f build/Dockerfile \
+ --build-arg GOCACHE=${GOCACHE} \
+ --build-arg GOMODCACHE=${GOMODCACHE} \
+ --build-arg REPO_COMMIT=$(shell git rev-parse HEAD) \
+ --build-arg BUILD_TARGET=server \
+ --platform ${PLATFORM} \
+ --tag ${REGISTRY}/monkeycode-ai-server:${TAG} \
+ --secret id=netrc,src=${HOME}/.netrc \
+ --output ${OUTPUT} \
+ .
+
+generate:
+ go generate ./ent
+
+check-generate:
+ @echo "Checking if generated code is up to date..."
+ @go generate ./ent
+ @git diff --quiet dbv2/ || (echo "Error: Generated code out of sync with schema. Run 'make generate' and commit the changes." && exit 1)
+ @echo "Generated code is up to date."
+
+migrate_sql:
+ migrate create -ext sql -dir migration -seq ${SEQ}
\ No newline at end of file
diff --git a/backend/biz/public/register.go b/backend/biz/public/register.go
new file mode 100644
index 00000000..509ac0fd
--- /dev/null
+++ b/backend/biz/public/register.go
@@ -0,0 +1,23 @@
+package public
+
+import (
+ "github.com/GoYoko/web"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/pkg/captcha"
+)
+
+// RegisterPublic 注册 public 模块
+func RegisterPublic(i *do.Injector) error {
+ w := do.MustInvoke[*web.Web](i)
+ captchaSvc := do.MustInvoke[*captcha.Captcha](i)
+
+ // 验证码路由
+ v1 := w.Group("/api/v1/public")
+ v1.GET("/captcha", web.BaseHandler(func(c *web.Context) error {
+ return c.String(200, "captcha endpoint")
+ }))
+ _ = captchaSvc
+
+ return nil
+}
diff --git a/backend/biz/register.go b/backend/biz/register.go
new file mode 100644
index 00000000..446346df
--- /dev/null
+++ b/backend/biz/register.go
@@ -0,0 +1,29 @@
+package biz
+
+import (
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/biz/public"
+ "github.com/chaitin/MonkeyCode/backend/biz/team"
+ "github.com/chaitin/MonkeyCode/backend/biz/user"
+)
+
+// RegisterAll 注册所有 biz 模块
+func RegisterAll(i *do.Injector) error {
+ // 注册 public 模块
+ if err := public.RegisterPublic(i); err != nil {
+ return err
+ }
+
+ // 注册 user 模块
+ if err := user.RegisterUser(i); err != nil {
+ return err
+ }
+
+ // 注册 team 模块
+ if err := team.RegisterTeam(i); err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/backend/biz/team/handler/http/v1/user.go b/backend/biz/team/handler/http/v1/user.go
new file mode 100644
index 00000000..d92b5c55
--- /dev/null
+++ b/backend/biz/team/handler/http/v1/user.go
@@ -0,0 +1,394 @@
+package v1
+
+import (
+ "context"
+ "log/slog"
+ "net/http"
+
+ "github.com/GoYoko/web"
+ "github.com/google/uuid"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/middleware"
+ "github.com/chaitin/MonkeyCode/backend/pkg/captcha"
+)
+
+// TeamGroupUserHandler 团队分组用户处理器
+type TeamGroupUserHandler struct {
+ usecase domain.TeamGroupUserUsecase
+ repo domain.TeamGroupUserRepo
+ config *config.Config
+ authMiddleware *middleware.AuthMiddleware
+ auditMiddleware *middleware.AuditMiddleware
+ logger *slog.Logger
+ captcha *captcha.Captcha
+}
+
+// NewTeamGroupUserHandler 创建团队分组用户处理器 (samber/do 风格)
+func NewTeamGroupUserHandler(i *do.Injector) (*TeamGroupUserHandler, error) {
+ w := do.MustInvoke[*web.Web](i)
+ usecase := do.MustInvoke[domain.TeamGroupUserUsecase](i)
+ repo := do.MustInvoke[domain.TeamGroupUserRepo](i)
+ auth := do.MustInvoke[*middleware.AuthMiddleware](i)
+ audit := do.MustInvoke[*middleware.AuditMiddleware](i)
+ cfg := do.MustInvoke[*config.Config](i)
+ logger := do.MustInvoke[*slog.Logger](i)
+ captchaSvc := do.MustInvoke[*captcha.Captcha](i)
+
+ h := &TeamGroupUserHandler{
+ usecase: usecase,
+ repo: repo,
+ config: cfg,
+ authMiddleware: auth,
+ auditMiddleware: audit,
+ logger: logger.With("module", "handler.team_group_user"),
+ captcha: captchaSvc,
+ }
+
+ adminAuth := middleware.TeamAdminAuth(func(ctx context.Context, teamID, userID uuid.UUID) bool {
+ member, err := repo.GetMember(ctx, teamID, userID)
+ if err != nil {
+ return false
+ }
+ return member.Role == consts.TeamMemberRoleAdmin
+ })
+
+ a := w.Group("/api/v1/teams/admin")
+ a.POST("", web.BindHandler(h.AddAdmin), auth.TeamAuth(), adminAuth, audit.Audit("add_team_admin"))
+
+ u := w.Group("/api/v1/teams/users")
+ u.POST("/login", web.BindHandler(h.Login), audit.Audit("team_user_login"))
+ u.POST("/logout", web.BaseHandler(h.Logout), auth.TeamAuthCheck())
+ u.GET("/status", web.BaseHandler(h.Status), auth.TeamAuthCheck())
+ u.PUT("/passwords/change", web.BindHandler(h.ChangePassword), auth.TeamAuth(), audit.Audit("change_team_user_password"))
+ u.POST("", web.BindHandler(h.AddUser), auth.TeamAuth(), adminAuth, audit.Audit("add_team_user"))
+ u.GET("", web.BindHandler(h.MemberList), auth.TeamAuth(), adminAuth)
+ u.PUT("/:user_id", web.BindHandler(h.UpdateUser), auth.TeamAuth(), adminAuth, audit.Audit("update_team_user"))
+
+ g := w.Group("/api/v1/teams/groups")
+ g.GET("", web.BaseHandler(h.List), auth.TeamAuth())
+ g.POST("", web.BindHandler(h.Add), auth.TeamAuth(), adminAuth, audit.Audit("add_team_group"))
+ g.PUT("/:group_id", web.BindHandler(h.Update), auth.TeamAuth(), adminAuth, audit.Audit("update_team_group"))
+ g.DELETE("/:group_id", web.BaseHandler(h.Delete), auth.TeamAuth(), adminAuth, audit.Audit("delete_team_group"))
+
+ gu := w.Group("/api/v1/teams/groups/:group_id/users")
+ gu.Use(auth.TeamAuth())
+ gu.GET("", web.BindHandler(h.ListGroupUsers))
+ gu.PUT("", web.BindHandler(h.ModifyGroupUsers), adminAuth, audit.Audit("modify_team_group_users"))
+
+ return h, nil
+}
+
+// Login 登录
+func (h *TeamGroupUserHandler) Login(c *web.Context, req *domain.TeamLoginReq) error {
+ ctx := c.Request().Context()
+
+ // 验证验证码
+ if req.CaptchaToken != "" {
+ ok, err := h.captcha.Verify(req.CaptchaToken, nil)
+ if err != nil || !ok {
+ h.logger.WarnContext(ctx, "captcha verification failed", "error", err)
+ return errcode.ErrCaptchaVerifyFailed
+ }
+ }
+
+ user, err := h.usecase.Login(ctx, req)
+ if err != nil {
+ h.logger.WarnContext(ctx, "team login failed", "email", req.Email, "error", err)
+ return errcode.ErrLoginFailed
+ }
+
+ // 生成 Cookie
+ cookie, err := h.authMiddleware.GenerateCookieByUID(ctx, user.ID)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "generate cookie failed", "error", err)
+ return errcode.ErrInternalServer
+ }
+
+ // 保存到 Redis
+ err = h.authMiddleware.SetUserCookieIntoRedis(ctx, cookie, middleware.TeamUserSessionKey, &domain.User{
+ ID: user.ID,
+ Name: user.Name,
+ Email: user.Email,
+ })
+ if err != nil {
+ h.logger.ErrorContext(ctx, "set user cookie into redis failed", "error", err)
+ return errcode.ErrInternalServer
+ }
+
+ // 设置 Cookie
+ h.setCookie(c, cookie)
+
+ return c.JSON(http.StatusOK, map[string]any{
+ "success": true,
+ "message": "login success",
+ })
+}
+
+// Logout 登出
+func (h *TeamGroupUserHandler) Logout(c *web.Context) error {
+ ctx := c.Request().Context()
+
+ user := middleware.GetTeamUser(c)
+ if user == nil || user.User == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAITeamSession)
+ if err == nil && cookie.Value != "" {
+ err = h.authMiddleware.DeleteUserCookieFromRedis(ctx, middleware.TeamUserSessionKey, user.User.ID)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "delete user cookie from redis failed", "error", err)
+ }
+ }
+
+ h.clearCookie(c)
+
+ return c.JSON(http.StatusOK, map[string]string{"message": "logout success"})
+}
+
+// Status 获取状态
+func (h *TeamGroupUserHandler) Status(c *web.Context) error {
+ user := middleware.GetTeamUser(c)
+ if user == nil || user.User == nil {
+ return c.JSON(http.StatusOK, map[string]bool{"login": false})
+ }
+
+ return c.JSON(http.StatusOK, map[string]any{
+ "login": true,
+ "teamUser": user,
+ })
+}
+
+// ChangePassword 修改密码
+func (h *TeamGroupUserHandler) ChangePassword(c *web.Context, req *domain.ChangePasswordReq) error {
+ ctx := c.Request().Context()
+
+ user := middleware.GetTeamUser(c)
+ if user == nil || user.User == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ err := h.usecase.ChangePassword(ctx, user.User.ID, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "change password failed", "error", err)
+ return errcode.ErrChangePasswordFailed
+ }
+
+ return c.JSON(http.StatusOK, map[string]bool{"success": true})
+}
+
+// AddUser 添加用户
+func (h *TeamGroupUserHandler) AddUser(c *web.Context, req *domain.AddTeamUserReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ resp, err := h.usecase.AddUser(ctx, teamUser, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "add user failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// AddAdmin 添加管理员
+func (h *TeamGroupUserHandler) AddAdmin(c *web.Context, req *domain.AddTeamAdminReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ resp, err := h.usecase.AddAdmin(ctx, teamUser, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "add admin failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// MemberList 成员列表
+func (h *TeamGroupUserHandler) MemberList(c *web.Context, req *domain.MemberListReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ resp, err := h.usecase.MemberList(ctx, teamUser, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "member list failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// UpdateUser 更新用户
+func (h *TeamGroupUserHandler) UpdateUser(c *web.Context, req *domain.UpdateTeamUserReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ req.UserID = uuid.MustParse(c.Param("user_id"))
+
+ resp, err := h.usecase.UpdateUser(ctx, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "update user failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// List 分组列表
+func (h *TeamGroupUserHandler) List(c *web.Context) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ resp, err := h.usecase.List(ctx, teamUser)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "list groups failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// Add 添加分组
+func (h *TeamGroupUserHandler) Add(c *web.Context, req *domain.AddTeamGroupReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ resp, err := h.usecase.Add(ctx, teamUser, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "add group failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// Update 更新分组
+func (h *TeamGroupUserHandler) Update(c *web.Context, req *domain.UpdateTeamGroupReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ req.GroupID = uuid.MustParse(c.Param("group_id"))
+
+ resp, err := h.usecase.Update(ctx, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "update group failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// Delete 删除分组
+func (h *TeamGroupUserHandler) Delete(c *web.Context) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ groupID := uuid.MustParse(c.Param("group_id"))
+
+ err := h.usecase.Delete(ctx, teamUser, &domain.DeleteTeamGroupReq{GroupID: groupID})
+ if err != nil {
+ h.logger.ErrorContext(ctx, "delete group failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, map[string]bool{"success": true})
+}
+
+// ListGroupUsers 组成员列表
+func (h *TeamGroupUserHandler) ListGroupUsers(c *web.Context, req *domain.ListTeamGroupUsersReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ req.GroupID = uuid.MustParse(c.Param("group_id"))
+
+ resp, err := h.usecase.ListGroups(ctx, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "list group users failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+// ModifyGroupUsers 修改组成员
+func (h *TeamGroupUserHandler) ModifyGroupUsers(c *web.Context, req *domain.AddTeamGroupUsersReq) error {
+ ctx := c.Request().Context()
+
+ teamUser := middleware.GetTeamUser(c)
+ if teamUser == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ req.GroupID = uuid.MustParse(c.Param("group_id"))
+
+ resp, err := h.usecase.ModifyGroups(ctx, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "modify group users failed", "error", err)
+ return err
+ }
+
+ return c.JSON(http.StatusOK, resp)
+}
+
+func (h *TeamGroupUserHandler) setCookie(c *web.Context, cookie string) {
+ c.SetCookie(&http.Cookie{
+ Name: consts.MonkeyCodeAITeamSession,
+ Value: cookie,
+ Path: "/",
+ HttpOnly: true,
+ MaxAge: h.config.Session.Expire,
+ SameSite: http.SameSiteLaxMode,
+ })
+}
+
+func (h *TeamGroupUserHandler) clearCookie(c *web.Context) {
+ c.SetCookie(&http.Cookie{
+ Name: consts.MonkeyCodeAITeamSession,
+ Value: "",
+ Path: "/",
+ HttpOnly: true,
+ MaxAge: -1,
+ })
+}
diff --git a/backend/biz/team/register.go b/backend/biz/team/register.go
new file mode 100644
index 00000000..7d8369b1
--- /dev/null
+++ b/backend/biz/team/register.go
@@ -0,0 +1,22 @@
+package team
+
+import (
+ "github.com/samber/do"
+
+ v1 "github.com/chaitin/MonkeyCode/backend/biz/team/handler/http/v1"
+ "github.com/chaitin/MonkeyCode/backend/biz/team/repo"
+ "github.com/chaitin/MonkeyCode/backend/biz/team/usecase"
+)
+
+// RegisterTeam 注册 team 模块
+func RegisterTeam(i *do.Injector) error {
+ // 注册 repo
+ do.Provide(i, repo.NewTeamGroupUserRepo)
+
+ // 注册 usecase
+ do.Provide(i, usecase.NewTeamGroupUserUsecase)
+
+ // 注册 handler
+ _, err := do.Invoke[v1.TeamGroupUserHandler](i)
+ return err
+}
diff --git a/backend/biz/team/repo/user.go b/backend/biz/team/repo/user.go
new file mode 100644
index 00000000..04a5c721
--- /dev/null
+++ b/backend/biz/team/repo/user.go
@@ -0,0 +1,341 @@
+package repo
+
+import (
+ "context"
+ "log/slog"
+ "net/mail"
+ "strings"
+
+ "entgo.io/ent/dialect/sql"
+ "github.com/google/uuid"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+ "github.com/samber/lo"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+)
+
+// TeamGroupUserRepo 团队分组成员数据访问层
+type TeamGroupUserRepo struct {
+ client *db.Client
+ redis *redis.Client
+ config *config.Config
+ logger *slog.Logger
+}
+
+// NewTeamGroupUserRepo 创建团队分组成员数据访问层 (samber/do 风格)
+func NewTeamGroupUserRepo(i *do.Injector) (domain.TeamGroupUserRepo, error) {
+ return &TeamGroupUserRepo{
+ client: do.MustInvoke[*db.Client](i),
+ redis: do.MustInvoke[*redis.Client](i),
+ config: do.MustInvoke[*config.Config](i),
+ logger: do.MustInvoke[*slog.Logger](i).With("module", "repo.team_group_user"),
+ }, nil
+}
+
+// List 获取团队分组列表
+func (r *TeamGroupUserRepo) List(ctx context.Context, teamID uuid.UUID) ([]*db.TeamGroup, error) {
+ return r.client.TeamGroup.Query().
+ Where(teamgroup.TeamIDEQ(teamID)).
+ WithMembers(
+ func(uq *db.UserQuery) {
+ uq.Order(user.ByCreatedAt(sql.OrderDesc()))
+ },
+ ).
+ Order(teamgroup.ByCreatedAt(sql.OrderDesc())).
+ All(ctx)
+}
+
+// Get 获取团队分组
+func (r *TeamGroupUserRepo) Get(ctx context.Context, groupID uuid.UUID) (*db.TeamGroup, error) {
+ return r.client.TeamGroup.Get(ctx, groupID)
+}
+
+// Create 创建团队分组
+func (r *TeamGroupUserRepo) Create(ctx context.Context, teamID uuid.UUID, req *domain.AddTeamGroupReq) (*db.TeamGroup, error) {
+ return r.client.TeamGroup.Create().
+ SetTeamID(teamID).
+ SetName(req.Name).
+ Save(ctx)
+}
+
+// CreateUsers 创建团队成员
+func (r *TeamGroupUserRepo) CreateUsers(ctx context.Context, teamID uuid.UUID, req *domain.AddTeamUserReq) ([]*db.User, error) {
+ var users []*db.User
+
+ for _, emailAddr := range req.Emails {
+ // 检查邮箱是否已注册
+ existingUser, err := r.client.User.Query().Where(user.EmailEQ(emailAddr)).First(ctx)
+ if err == nil && existingUser != nil {
+ // 用户已存在，检查是否已在团队中
+ _, err := r.client.TeamMember.Query().Where(
+ teammember.TeamIDEQ(teamID),
+ teammember.UserIDEQ(existingUser.ID),
+ ).First(ctx)
+ if err == nil {
+ continue // 用户已在团队中
+ }
+ // 添加到团队
+ _, err = r.client.TeamMember.Create().
+ SetTeamID(teamID).
+ SetUserID(existingUser.ID).
+ SetRole(consts.TeamMemberRoleUser).
+ Save(ctx)
+ if err != nil {
+ r.logger.ErrorContext(ctx, "add user to team failed", "error", err)
+ continue
+ }
+ users = append(users, existingUser)
+ continue
+ }
+
+ // 创建新用户
+ newUser, err := r.client.User.Create().
+ SetName(emailAddr).
+ SetEmail(emailAddr).
+ SetPassword("").
+ SetRole(consts.UserRoleIndividual).
+ Save(ctx)
+ if err != nil {
+ r.logger.ErrorContext(ctx, "create user failed", "error", err, "email", emailAddr)
+ continue
+ }
+
+ // 添加到团队
+ _, err = r.client.TeamMember.Create().
+ SetTeamID(teamID).
+ SetUserID(newUser.ID).
+ SetRole(consts.TeamMemberRoleUser).
+ Save(ctx)
+ if err != nil {
+ r.logger.ErrorContext(ctx, "add user to team failed", "error", err)
+ continue
+ }
+ users = append(users, newUser)
+ }
+ return users, nil
+}
+
+// CreateAdmin 创建团队管理员
+func (r *TeamGroupUserRepo) CreateAdmin(ctx context.Context, teamID uuid.UUID, req *domain.AddTeamAdminReq) (*db.User, error) {
+ // 检查邮箱是否已注册
+ existingUser, err := r.client.User.Query().Where(user.EmailEQ(req.Email)).First(ctx)
+ if err == nil && existingUser != nil {
+ // 检查是否已在团队中
+ _, err := r.client.TeamMember.Query().Where(
+ teammember.TeamIDEQ(teamID),
+ teammember.UserIDEQ(existingUser.ID),
+ ).First(ctx)
+ if err == nil {
+ return nil, errcode.ErrUserAlreadyExists
+ }
+ // 添加到团队
+ _, err = r.client.TeamMember.Create().
+ SetTeamID(teamID).
+ SetUserID(existingUser.ID).
+ SetRole(consts.TeamMemberRoleAdmin).
+ Save(ctx)
+ if err != nil {
+ return nil, err
+ }
+ return existingUser, nil
+ }
+
+ // 创建新用户
+ newUser, err := r.client.User.Create().
+ SetName(req.Name).
+ SetEmail(req.Email).
+ SetPassword("").
+ SetRole(consts.UserRoleIndividual).
+ Save(ctx)
+ if err != nil {
+ return nil, err
+ }
+
+ // 添加到团队
+ _, err = r.client.TeamMember.Create().
+ SetTeamID(teamID).
+ SetUserID(newUser.ID).
+ SetRole(consts.TeamMemberRoleAdmin).
+ Save(ctx)
+ if err != nil {
+ return nil, err
+ }
+ return newUser, nil
+}
+
+// Update 更新团队分组
+func (r *TeamGroupUserRepo) Update(ctx context.Context, req *domain.UpdateTeamGroupReq) (*db.TeamGroup, error) {
+ return r.client.TeamGroup.UpdateOneID(req.GroupID).
+ SetName(req.Name).
+ Save(ctx)
+}
+
+// Delete 删除团队分组
+func (r *TeamGroupUserRepo) Delete(ctx context.Context, teamID, groupID uuid.UUID) error {
+ err := r.client.TeamGroup.DeleteOneID(groupID).Exec(ctx)
+ return err
+}
+
+// ListGroupUsers 获取团队组成员列表
+func (r *TeamGroupUserRepo) ListGroupUsers(ctx context.Context, groupID uuid.UUID) ([]*db.TeamGroupMember, error) {
+ return r.client.TeamGroupMember.Query().
+ Where(teamgroupmember.GroupIDEQ(groupID)).
+ WithUser().
+ All(ctx)
+}
+
+// ModifyGroupUsers 添加团队组成员
+func (r *TeamGroupUserRepo) ModifyGroupUsers(ctx context.Context, groupID uuid.UUID, userIDs []uuid.UUID) ([]*db.TeamGroupMember, error) {
+ var members []*db.TeamGroupMember
+
+ for _, userID := range userIDs {
+ // 检查是否已在组中
+ existing, err := r.client.TeamGroupMember.Query().
+ Where(
+ teamgroupmember.GroupIDEQ(groupID),
+ teamgroupmember.UserIDEQ(userID),
+ ).First(ctx)
+ if err == nil && existing != nil {
+ members = append(members, existing)
+ continue
+ }
+
+ // 添加到组
+ member, err := r.client.TeamGroupMember.Create().
+ SetGroupID(groupID).
+ SetUserID(userID).
+ Save(ctx)
+ if err != nil {
+ r.logger.ErrorContext(ctx, "add user to group failed", "error", err, "user_id", userID)
+ continue
+ }
+ members = append(members, member)
+ }
+ return members, nil
+}
+
+// DeleteGroupUser 删除团队组成员
+func (r *TeamGroupUserRepo) DeleteGroupUser(ctx context.Context, groupID, userID uuid.UUID) error {
+ _, err := r.client.TeamGroupMember.Delete().
+ Where(
+ teamgroupmember.GroupIDEQ(groupID),
+ teamgroupmember.UserIDEQ(userID),
+ ).Exec(ctx)
+ return err
+}
+
+// Login 团队用户登录
+func (r *TeamGroupUserRepo) Login(ctx context.Context, req *domain.TeamLoginReq) (*db.User, error) {
+ usr, err := r.client.User.Query().
+ Where(user.EmailEQ(req.Email)).
+ Where(user.RoleNEQ(consts.UserRoleEnterprise)).
+ WithTeamMembers(func(q *db.TeamMemberQuery) {
+ q.WithTeam()
+ }).
+ First(ctx)
+ if err != nil {
+ return nil, errcode.ErrLoginFailed.Wrap(err)
+ }
+
+ err = crypto.VerifyPassword(usr.Password, req.Password)
+ if err != nil {
+ r.logger.Error("invalid password", "email", req.Email, "error", err)
+ return nil, errcode.ErrLoginFailed
+ }
+ return usr, nil
+}
+
+// MemberList 获取团队成员列表
+func (r *TeamGroupUserRepo) MemberList(ctx context.Context, teamID uuid.UUID, role consts.TeamMemberRole) ([]*db.TeamMember, error) {
+ query := r.client.TeamMember.Query().
+ Where(teammember.TeamIDEQ(teamID)).
+ WithUser()
+
+ if role != "" {
+ query = query.Where(teammember.RoleEQ(role))
+ }
+
+ return query.All(ctx)
+}
+
+// ChangePassword 修改密码
+func (r *TeamGroupUserRepo) ChangePassword(ctx context.Context, userID uuid.UUID, currentPassword, newPassword string) error {
+ uu, err := r.client.User.Query().Where(user.IDEQ(userID)).First(ctx)
+ if err != nil {
+ return err
+ }
+
+ if uu.Password != "" {
+ err = crypto.VerifyPassword(uu.Password, currentPassword)
+ if err != nil {
+ return errcode.ErrInvalidPassword
+ }
+ }
+
+ hashedNewPassword, err := crypto.HashPassword(newPassword)
+ if err != nil {
+ return errcode.ErrPasswordHashFailed
+ }
+
+ return r.client.User.UpdateOneID(userID).SetPassword(hashedNewPassword).Exec(ctx)
+}
+
+// GetTeam 获取团队
+func (r *TeamGroupUserRepo) GetTeam(ctx context.Context, teamID uuid.UUID) (*db.Team, error) {
+ return r.client.Team.Get(ctx, teamID)
+}
+
+// UpdateUser 更新团队用户信息
+func (r *TeamGroupUserRepo) UpdateUser(ctx context.Context, userID uuid.UUID, req *domain.UpdateTeamUserReq) (*db.User, error) {
+ update := r.client.User.UpdateOneID(userID)
+ if req.IsBlocked != nil {
+ update = update.SetIsBlocked(*req.IsBlocked)
+ }
+ return update.Save(ctx)
+}
+
+// GetMembersByIDs 根据用户ID列表获取团队成员
+func (r *TeamGroupUserRepo) GetMembersByIDs(ctx context.Context, teamID uuid.UUID, userIDs []uuid.UUID) ([]*db.TeamMember, error) {
+ return r.client.TeamMember.Query().
+ Where(
+ teammember.TeamIDEQ(teamID),
+ teammember.UserIDIn(userIDs...),
+ ).
+ WithUser().
+ All(ctx)
+}
+
+// GetMember 获取团队成员
+func (r *TeamGroupUserRepo) GetMember(ctx context.Context, teamID, userID uuid.UUID) (*db.TeamMember, error) {
+ return r.client.TeamMember.Query().
+ Where(
+ teammember.TeamIDEQ(teamID),
+ teammember.UserIDEQ(userID),
+ ).
+ WithUser().
+ First(ctx)
+}
+
+// isValidEmail 验证邮箱格式
+func isValidEmail(email string) bool {
+ _, err := mail.ParseAddress(email)
+ return err == nil
+}
+
+// parseEmails 解析邮箱列表
+func parseEmails(emails string) []string {
+ return lo.Filter(strings.Split(emails, ","), func(email string, _ int) bool {
+ email = strings.TrimSpace(email)
+ return email != "" && isValidEmail(email)
+ })
+}
diff --git a/backend/biz/team/usecase/user.go b/backend/biz/team/usecase/user.go
new file mode 100644
index 00000000..507358b3
--- /dev/null
+++ b/backend/biz/team/usecase/user.go
@@ -0,0 +1,248 @@
+package usecase
+
+import (
+ "context"
+ "fmt"
+ "log/slog"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+ "github.com/chaitin/MonkeyCode/backend/pkg/cvt"
+ "github.com/chaitin/MonkeyCode/backend/pkg/email"
+)
+
+// TeamGroupUserUsecase 团队分组成员业务逻辑层
+type TeamGroupUserUsecase struct {
+ repo domain.TeamGroupUserRepo
+ logger *slog.Logger
+ config *config.Config
+ smtpClient *email.SMTPClient
+ redisClient *redis.Client
+}
+
+// NewTeamGroupUserUsecase 创建团队分组成员业务逻辑层实例
+func NewTeamGroupUserUsecase(i *do.Injector) (domain.TeamGroupUserUsecase, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+
+ smtpClient := email.NewSMTPClient(email.SMTPConfig{
+ Host: cfg.SMTP.Host,
+ Port: cfg.SMTP.Port,
+ Username: cfg.SMTP.Username,
+ Password: cfg.SMTP.Password,
+ From: cfg.SMTP.From,
+ })
+
+ return &TeamGroupUserUsecase{
+ repo: do.MustInvoke[domain.TeamGroupUserRepo](i),
+ logger: do.MustInvoke[*slog.Logger](i).With("module", "usecase.team_group_user"),
+ config: cfg,
+ smtpClient: smtpClient,
+ redisClient: do.MustInvoke[*redis.Client](i),
+ }, nil
+}
+
+// List 获取团队分组列表
+func (u *TeamGroupUserUsecase) List(ctx context.Context, teamUser *domain.TeamUser) (*domain.ListTeamGroupsResp, error) {
+ groups, err := u.repo.List(ctx, teamUser.GetTeamID())
+ if err != nil {
+ return nil, err
+ }
+ return &domain.ListTeamGroupsResp{
+ Groups: cvt.Iter(groups, func(_ int, group *db.TeamGroup) *domain.TeamGroup {
+ return cvt.From(group, &domain.TeamGroup{})
+ }),
+ }, nil
+}
+
+// Add 创建团队分组
+func (u *TeamGroupUserUsecase) Add(ctx context.Context, teamUser *domain.TeamUser, req *domain.AddTeamGroupReq) (*domain.TeamGroup, error) {
+ group, err := u.repo.Create(ctx, teamUser.GetTeamID(), req)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(group, &domain.TeamGroup{}), nil
+}
+
+// AddUser 创建团队成员
+func (u *TeamGroupUserUsecase) AddUser(ctx context.Context, teamUser *domain.TeamUser, req *domain.AddTeamUserReq) (*domain.AddTeamUserResp, error) {
+ users, err := u.repo.CreateUsers(ctx, teamUser.GetTeamID(), req)
+ if err != nil {
+ return nil, err
+ }
+ // 发送重置密码邮件（如果没有发送成功就用户自己请求重置）
+ for _, user := range users {
+ if user.Email != "" {
+ token, err := u.generateResetPWDToken(ctx, user.ID)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "generate reset password token failed", "error", err)
+ continue
+ }
+ // 存一份到 redis
+ key := fmt.Sprintf("reset_password_token:%s", user.ID.String())
+ if err := u.redisClient.Set(ctx, key, token, time.Hour*24).Err(); err != nil {
+ u.logger.ErrorContext(ctx, "set redis failed", "key", key, "token", token, "error", err)
+ continue
+ }
+ u.logger.InfoContext(ctx, "set redis success", "key", key, "token", token)
+ go u.sendResetPasswordEmail(ctx, user.Email, user.Name, token)
+ }
+ }
+ teamUsers := cvt.Iter(users, func(_ int, user *db.User) *domain.TeamUser {
+ return cvt.From(user, &domain.TeamUser{})
+ })
+ return &domain.AddTeamUserResp{Users: teamUsers}, nil
+}
+
+// AddAdmin 创建团队管理员
+func (u *TeamGroupUserUsecase) AddAdmin(ctx context.Context, teamUser *domain.TeamUser, req *domain.AddTeamAdminReq) (*domain.AddTeamAdminResp, error) {
+ user, err := u.repo.CreateAdmin(ctx, teamUser.GetTeamID(), req)
+ if err != nil {
+ return nil, err
+ }
+ if user.Email != "" {
+ token, err := u.generateResetPWDToken(ctx, user.ID)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "generate reset password token failed", "error", err)
+ return nil, err
+ }
+ // 存一份到 redis
+ key := fmt.Sprintf("reset_password_token:%s", user.ID.String())
+ if err := u.redisClient.Set(ctx, key, token, time.Hour*24).Err(); err != nil {
+ u.logger.ErrorContext(ctx, "set redis failed", "key", key, "token", token, "error", err)
+ return nil, err
+ }
+ u.logger.InfoContext(ctx, "set redis success", "key", key, "token", token)
+ go u.sendResetPasswordEmail(ctx, user.Email, user.Name, token)
+ }
+
+ teamUserResp := cvt.From(user, &domain.TeamUser{})
+ return &domain.AddTeamAdminResp{User: teamUserResp}, nil
+}
+
+// Update 更新团队分组
+func (u *TeamGroupUserUsecase) Update(ctx context.Context, req *domain.UpdateTeamGroupReq) (*domain.TeamGroup, error) {
+ group, err := u.repo.Update(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(group, &domain.TeamGroup{}), nil
+}
+
+// Delete 删除团队分组
+func (u *TeamGroupUserUsecase) Delete(ctx context.Context, teamUser *domain.TeamUser, req *domain.DeleteTeamGroupReq) error {
+ return u.repo.Delete(ctx, teamUser.GetTeamID(), req.GroupID)
+}
+
+// ListGroups 获取团队组成员列表
+func (u *TeamGroupUserUsecase) ListGroups(ctx context.Context, req *domain.ListTeamGroupUsersReq) (*domain.ListTeamGroupUsersResp, error) {
+ members, err := u.repo.ListGroupUsers(ctx, req.GroupID)
+ if err != nil {
+ return nil, err
+ }
+ return &domain.ListTeamGroupUsersResp{
+ Users: cvt.Iter(members, func(_ int, member *db.TeamGroupMember) *domain.User {
+ return cvt.From(member.Edges.User, &domain.User{})
+ }),
+ }, nil
+}
+
+// ModifyGroups 添加团队组成员
+func (u *TeamGroupUserUsecase) ModifyGroups(ctx context.Context, req *domain.AddTeamGroupUsersReq) (*domain.AddTeamGroupUsersResp, error) {
+ members, err := u.repo.ModifyGroupUsers(ctx, req.GroupID, req.UserIDs)
+ if err != nil {
+ return nil, err
+ }
+ return &domain.AddTeamGroupUsersResp{
+ Users: cvt.Iter(members, func(_ int, member *db.TeamGroupMember) *domain.User {
+ return cvt.From(member.Edges.User, &domain.User{})
+ }),
+ }, nil
+}
+
+// DeleteGroups 删除团队组成员
+func (u *TeamGroupUserUsecase) DeleteGroups(ctx context.Context, req *domain.DeleteTeamGroupUserReq) error {
+ return u.repo.DeleteGroupUser(ctx, req.GroupID, req.UserID)
+}
+
+// Login 团队用户登录
+func (u *TeamGroupUserUsecase) Login(ctx context.Context, req *domain.TeamLoginReq) (*domain.User, error) {
+ user, err := u.repo.Login(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(user, &domain.User{}), nil
+}
+
+// MemberList 获取团队成员列表
+func (u *TeamGroupUserUsecase) MemberList(ctx context.Context, teamUser *domain.TeamUser, req *domain.MemberListReq) (*domain.MemberListResp, error) {
+ team, err := u.repo.GetTeam(ctx, teamUser.GetTeamID())
+ if err != nil {
+ return nil, err
+ }
+ members, err := u.repo.MemberList(ctx, teamUser.GetTeamID(), req.Role)
+ if err != nil {
+ return nil, err
+ }
+ return &domain.MemberListResp{
+ MemberLimit: team.MemberLimit,
+ Members: cvt.Iter(members, func(_ int, member *db.TeamMember) *domain.TeamMemberInfo {
+ return &domain.TeamMemberInfo{
+ User: cvt.From(member.Edges.User, &domain.User{}),
+ Role: member.Role,
+ CreatedAt: member.CreatedAt.Unix(),
+ LastActiveAt: 0,
+ }
+ }),
+ }, nil
+}
+
+// ChangePassword 修改密码
+func (u *TeamGroupUserUsecase) ChangePassword(ctx context.Context, userID uuid.UUID, req *domain.ChangePasswordReq) error {
+ err := u.repo.ChangePassword(ctx, userID, req.CurrentPassword, req.NewPassword)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "change password failed", "error", err)
+ return err
+ }
+ return nil
+}
+
+// UpdateUser 更新用户信息
+func (u *TeamGroupUserUsecase) UpdateUser(ctx context.Context, req *domain.UpdateTeamUserReq) (*domain.UpdateTeamUserResp, error) {
+ user, err := u.repo.UpdateUser(ctx, req.UserID, req)
+ if err != nil {
+ return nil, err
+ }
+ return &domain.UpdateTeamUserResp{
+ User: cvt.From(user, &domain.User{}),
+ }, nil
+}
+
+// generateResetPWDToken 生成重置密码的 token
+func (u *TeamGroupUserUsecase) generateResetPWDToken(ctx context.Context, userID uuid.UUID) (string, error) {
+ token, err := crypto.Simple(userID.String(), time.Now().Add(time.Hour*24*3))
+ if err != nil {
+ return "", err
+ }
+ return token, nil
+}
+
+// sendResetPasswordEmail 发送重置密码邮件
+func (u *TeamGroupUserUsecase) sendResetPasswordEmail(ctx context.Context, email, username, token string) error {
+ resetURL := fmt.Sprintf("%s/resetpassword?token=%s", u.config.Server.BaseURL, token)
+ err := u.smtpClient.SendResetPasswordEmail(email, username, resetURL)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "send reset password email failed", "error", err)
+ return errcode.ErrHTTPRequest.Wrap(err)
+ }
+
+ u.logger.InfoContext(ctx, "send reset password email success", "email", email, "username", username)
+ return nil
+}
diff --git a/backend/biz/user/handler/v1/auth.go b/backend/biz/user/handler/v1/auth.go
new file mode 100644
index 00000000..17062567
--- /dev/null
+++ b/backend/biz/user/handler/v1/auth.go
@@ -0,0 +1,261 @@
+package v1
+
+import (
+ "fmt"
+ "log/slog"
+ "net/http"
+
+ "github.com/GoYoko/web"
+ "github.com/google/uuid"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/middleware"
+ "github.com/chaitin/MonkeyCode/backend/pkg/captcha"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+)
+
+// AuthHandler 认证处理器
+type AuthHandler struct {
+ config *config.Config
+ logger *slog.Logger
+ usecase domain.UserUsecase
+ redis *redis.Client
+ authMiddleware *middleware.AuthMiddleware
+ captcha *captcha.Captcha
+}
+
+// NewAuthHandler 创建认证处理器 (samber/do 风格)
+func NewAuthHandler(i *do.Injector) (*AuthHandler, error) {
+ w := do.MustInvoke[*web.Web](i)
+ cfg := do.MustInvoke[*config.Config](i)
+ logger := do.MustInvoke[*slog.Logger](i)
+ usecase := do.MustInvoke[domain.UserUsecase](i)
+ redisClient := do.MustInvoke[*redis.Client](i)
+ auth := do.MustInvoke[*middleware.AuthMiddleware](i)
+ captchaSvc := do.MustInvoke[*captcha.Captcha](i)
+
+ h := &AuthHandler{
+ config: cfg,
+ logger: logger.With("module", "auth.handler"),
+ usecase: usecase,
+ redis: redisClient,
+ authMiddleware: auth,
+ captcha: captchaSvc,
+ }
+
+ v1 := w.Group("/api/v1/users")
+
+ // 重置密码接口不需要鉴权
+ v1.PUT("/passwords/reset-request", web.BindHandler(h.SendResetPasswordEmail))
+ v1.GET("/passwords/accounts/:token", web.BindHandler(h.GetAccountInfo))
+ v1.PUT("/passwords/reset", web.BindHandler(h.ResetPassword))
+
+ // 密码登录
+ v1.POST("/password-login", web.BindHandler(h.PasswordLogin))
+ v1.PUT("/passwords/change", web.BindHandler(h.ChangePassword), auth.Check())
+ v1.GET("/status", web.BaseHandler(h.Status), auth.Check())
+ v1.POST("/logout", web.BaseHandler(h.Logout), auth.Auth())
+
+ return h, nil
+}
+
+// PasswordLogin 密码登录
+func (h *AuthHandler) PasswordLogin(c *web.Context, req *domain.TeamLoginReq) error {
+ ctx := c.Request().Context()
+
+ // 验证验证码
+ if req.CaptchaToken != "" {
+ ok, err := h.captcha.Verify(req.CaptchaToken, nil)
+ if err != nil || !ok {
+ h.logger.WarnContext(ctx, "captcha verification failed", "error", err)
+ return errcode.ErrCaptchaVerifyFailed
+ }
+ }
+
+ user, err := h.usecase.PasswordLogin(ctx, req)
+ if err != nil {
+ h.logger.WarnContext(ctx, "password login failed", "email", req.Email, "error", err)
+ return errcode.ErrLoginFailed
+ }
+
+ // 生成 Cookie
+ cookie, err := h.authMiddleware.GenerateCookieByUID(ctx, user.ID)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "generate cookie failed", "error", err)
+ return errcode.ErrInternalServer
+ }
+
+ // 保存到 Redis
+ err = h.authMiddleware.SetUserCookieIntoRedis(ctx, cookie, middleware.UserSessionKey, user)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "set user cookie into redis failed", "error", err)
+ return errcode.ErrInternalServer
+ }
+
+ // 设置 Cookie
+ h.setCookie(c, cookie)
+
+ return c.JSON(http.StatusOK, user)
+}
+
+// ChangePassword 修改密码
+func (h *AuthHandler) ChangePassword(c *web.Context, req *domain.ChangePasswordReq) error {
+ ctx := c.Request().Context()
+
+ user := middleware.GetUser(c)
+ if user == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ err := h.usecase.ChangePassword(ctx, user.ID, req, false)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "change password failed", "error", err)
+ return errcode.ErrChangePasswordFailed
+ }
+
+ return c.JSON(http.StatusOK, map[string]bool{"success": true})
+}
+
+// Logout 登出
+func (h *AuthHandler) Logout(c *web.Context) error {
+ ctx := c.Request().Context()
+
+ user := middleware.GetUser(c)
+ if user == nil {
+ return errcode.ErrUnauthorized
+ }
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAISession)
+ if err == nil && cookie.Value != "" {
+ err = h.authMiddleware.DeleteUserCookieFromRedis(ctx, middleware.UserSessionKey, user.ID)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "delete user cookie from redis failed", "error", err)
+ }
+ }
+
+ h.clearCookie(c)
+
+ return c.JSON(http.StatusOK, map[string]string{"message": "logout success"})
+}
+
+// Status 获取用户状态
+func (h *AuthHandler) Status(c *web.Context) error {
+ user := middleware.GetUser(c)
+ if user == nil {
+ return c.JSON(http.StatusOK, map[string]bool{"login": false})
+ }
+
+ return c.JSON(http.StatusOK, map[string]any{
+ "login": true,
+ "user": user,
+ })
+}
+
+// SendResetPasswordEmail 发送重置密码邮件
+func (h *AuthHandler) SendResetPasswordEmail(c *web.Context, req *domain.ResetUserPasswordEmailReq) error {
+ ctx := c.Request().Context()
+
+ // 验证验证码
+ if req.CaptchaToken != "" {
+ ok, err := h.captcha.Verify(req.CaptchaToken, nil)
+ if err != nil || !ok {
+ h.logger.WarnContext(ctx, "captcha verification failed", "error", err)
+ return errcode.ErrCaptchaVerifyFailed
+ }
+ }
+
+ err := h.usecase.SendResetPasswordEmail(ctx, req)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "send reset password email failed", "error", err)
+ return errcode.ErrInternalServer
+ }
+
+ return c.JSON(http.StatusOK, map[string]string{"message": "email sent"})
+}
+
+// GetAccountInfo 获取账户信息
+func (h *AuthHandler) GetAccountInfo(c *web.Context, param domain.GetAccountInfoReq) error {
+ ctx := c.Request().Context()
+
+ key := fmt.Sprintf("reset_password_token:%s", param.Token)
+ tokenStr, err := h.redis.Get(ctx, key).Result()
+ if err != nil {
+ h.logger.WarnContext(ctx, "token not found", "token", param.Token)
+ return errcode.ErrInvalidToken
+ }
+
+ // 验证 token
+ _, err = crypto.ValidateSimple(tokenStr)
+ if err != nil {
+ h.logger.WarnContext(ctx, "token validation failed", "error", err)
+ return errcode.ErrInvalidToken
+ }
+
+ return c.JSON(http.StatusOK, map[string]string{"token": param.Token})
+}
+
+// ResetPassword 重置密码
+func (h *AuthHandler) ResetPassword(c *web.Context, req *domain.ResetUserPasswordReq) error {
+ ctx := c.Request().Context()
+
+ key := fmt.Sprintf("reset_password_token:%s", req.Token)
+ tokenStr, err := h.redis.Get(ctx, key).Result()
+ if err != nil {
+ h.logger.WarnContext(ctx, "token not found", "token", req.Token)
+ return errcode.ErrInvalidToken
+ }
+
+ // 验证 token
+ userIDStr, err := crypto.ValidateSimple(tokenStr)
+ if err != nil {
+ h.logger.WarnContext(ctx, "token validation failed", "error", err)
+ return errcode.ErrInvalidToken
+ }
+
+ userID, err := uuid.Parse(userIDStr)
+ if err != nil {
+ h.logger.WarnContext(ctx, "invalid user id", "error", err)
+ return errcode.ErrInvalidToken
+ }
+
+ err = h.usecase.ChangePassword(ctx, userID, &domain.ChangePasswordReq{NewPassword: req.NewPassword}, true)
+ if err != nil {
+ h.logger.ErrorContext(ctx, "reset password failed", "error", err)
+ return errcode.ErrResetPasswordFailed
+ }
+
+ // 删除 token
+ h.redis.Del(ctx, key)
+
+ return c.JSON(http.StatusOK, map[string]bool{"success": true})
+}
+
+func (h *AuthHandler) setCookie(c *web.Context, cookie string) {
+ c.SetCookie(&http.Cookie{
+ Name: consts.MonkeyCodeAISession,
+ Value: cookie,
+ Path: "/",
+ HttpOnly: true,
+ MaxAge: h.config.Session.Expire,
+ SameSite: http.SameSiteLaxMode,
+ })
+}
+
+func (h *AuthHandler) clearCookie(c *web.Context) {
+ c.SetCookie(&http.Cookie{
+ Name: consts.MonkeyCodeAISession,
+ Value: "",
+ Path: "/",
+ HttpOnly: true,
+ MaxAge: -1,
+ })
+}
+
+func (h *AuthHandler) getBaseURL(c *web.Context) string {
+ return h.config.Server.BaseURL
+}
diff --git a/backend/biz/user/register.go b/backend/biz/user/register.go
new file mode 100644
index 00000000..e288232d
--- /dev/null
+++ b/backend/biz/user/register.go
@@ -0,0 +1,23 @@
+package user
+
+import (
+ "github.com/samber/do"
+
+ v1 "github.com/chaitin/MonkeyCode/backend/biz/user/handler/v1"
+ "github.com/chaitin/MonkeyCode/backend/biz/user/repo"
+ "github.com/chaitin/MonkeyCode/backend/biz/user/usecase"
+)
+
+// RegisterUser 注册 user 模块
+func RegisterUser(i *do.Injector) error {
+ // 注册 repo
+ do.Provide(i, repo.NewUserRepo)
+
+ // 注册 usecase
+ do.Provide(i, usecase.NewUserUsecase)
+
+ // 注册 handler（会自动注册路由）
+ do.Provide(i, v1.NewAuthHandler)
+
+ return nil
+}
diff --git a/backend/biz/user/repo/user.go b/backend/biz/user/repo/user.go
new file mode 100644
index 00000000..e9b83bdb
--- /dev/null
+++ b/backend/biz/user/repo/user.go
@@ -0,0 +1,115 @@
+package repo
+
+import (
+ "context"
+ "log/slog"
+
+ "github.com/google/uuid"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+)
+
+type userRepo struct {
+ db *db.Client
+ logger *slog.Logger
+ redis *redis.Client
+ config *config.Config
+}
+
+func NewUserRepo(i *do.Injector) (domain.UserRepo, error) {
+ return &userRepo{
+ db: do.MustInvoke[*db.Client](i),
+ logger: do.MustInvoke[*slog.Logger](i),
+ redis: do.MustInvoke[*redis.Client](i),
+ config: do.MustInvoke[*config.Config](i),
+ }, nil
+}
+
+// Get implements domain.UserRepo.
+func (u *userRepo) Get(ctx context.Context, uid uuid.UUID) (*db.User, error) {
+ return u.db.User.Get(ctx, uid)
+}
+
+// Update implements domain.UserRepo.
+func (u *userRepo) Update(ctx context.Context, uid uuid.UUID, name, avatarURL string) error {
+ update := u.db.User.UpdateOneID(uid)
+ if name != "" {
+ update = update.SetName(name)
+ }
+ if avatarURL != "" {
+ update = update.SetAvatarURL(avatarURL)
+ }
+ return update.Exec(ctx)
+}
+
+// GetUserWithTeams implements domain.UserRepo.
+func (u *userRepo) GetUserWithTeams(ctx context.Context, userID uuid.UUID) (*db.User, error) {
+ return u.db.User.Query().
+ Where(user.IDEQ(userID)).
+ WithTeamMembers(func(q *db.TeamMemberQuery) {
+ q.WithTeam()
+ }).
+ WithTeams().
+ First(ctx)
+}
+
+// PasswordLogin implements domain.UserRepo.
+func (u *userRepo) PasswordLogin(ctx context.Context, req *domain.TeamLoginReq) (*db.User, error) {
+ usr, err := u.db.User.Query().
+ Where(user.EmailEQ(req.Email)).
+ Where(user.RoleNEQ(consts.UserRoleEnterprise)).
+ WithTeamMembers(func(q *db.TeamMemberQuery) {
+ q.WithTeam()
+ }).
+ First(ctx)
+ if err != nil {
+ return nil, errcode.ErrLoginFailed.Wrap(err)
+ }
+
+ err = crypto.VerifyPassword(usr.Password, req.Password)
+ if err != nil {
+ u.logger.Error("invalid password", "email", req.Email, "error", err)
+ return nil, errcode.ErrLoginFailed
+ }
+ return usr, nil
+}
+
+// ChangePassword implements domain.UserRepo.
+func (u *userRepo) ChangePassword(ctx context.Context, userID uuid.UUID, currentPassword, newPassword string, isReset bool) error {
+ uu, err := u.db.User.Query().Where(user.IDEQ(userID)).First(ctx)
+ if err != nil {
+ return err
+ }
+
+ if !isReset && uu.Password != "" {
+ err = crypto.VerifyPassword(uu.Password, currentPassword)
+ if err != nil {
+ return errcode.ErrInvalidPassword
+ }
+ }
+
+ hashedNewPassword, err := crypto.HashPassword(newPassword)
+ if err != nil {
+ return errcode.ErrLoginFailed
+ }
+ err = u.db.User.UpdateOneID(userID).
+ SetPassword(hashedNewPassword).
+ Exec(ctx)
+ if err != nil {
+ return errcode.ErrDatabaseOperation.Wrap(err)
+ }
+ return nil
+}
+
+// GetUserByEmail implements domain.UserRepo.
+func (u *userRepo) GetUserByEmail(ctx context.Context, emails []string) ([]*db.User, error) {
+ return u.db.User.Query().WithTeams().Where(user.EmailIn(emails...)).All(ctx)
+}
diff --git a/backend/biz/user/usecase/user.go b/backend/biz/user/usecase/user.go
new file mode 100644
index 00000000..4076afc1
--- /dev/null
+++ b/backend/biz/user/usecase/user.go
@@ -0,0 +1,163 @@
+package usecase
+
+import (
+ "context"
+ "fmt"
+ "log/slog"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/errcode"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+ "github.com/chaitin/MonkeyCode/backend/pkg/cvt"
+ "github.com/chaitin/MonkeyCode/backend/pkg/email"
+)
+
+type userUsecase struct {
+ repo domain.UserRepo
+ logger *slog.Logger
+ redisClient *redis.Client
+ config *config.Config
+ emailClient *email.SMTPClient
+}
+
+func NewUserUsecase(i *do.Injector) (domain.UserUsecase, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ return &userUsecase{
+ repo: do.MustInvoke[domain.UserRepo](i),
+ logger: do.MustInvoke[*slog.Logger](i),
+ redisClient: do.MustInvoke[*redis.Client](i),
+ config: cfg,
+ emailClient: email.NewSMTPClient(email.SMTPConfig{
+ Host: cfg.SMTP.Host,
+ Port: cfg.SMTP.Port,
+ Username: cfg.SMTP.Username,
+ Password: cfg.SMTP.Password,
+ From: cfg.SMTP.From,
+ }),
+ }, nil
+}
+
+// Get implements domain.UserUsecase.
+func (u *userUsecase) Get(ctx context.Context, uid uuid.UUID) (*domain.User, error) {
+ us, err := u.repo.Get(ctx, uid)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(us, &domain.User{}), nil
+}
+
+// Update implements domain.UserUsecase.
+func (u *userUsecase) Update(ctx context.Context, uid uuid.UUID, avatarURL string, req domain.UpdateUserReq) (*domain.User, error) {
+ err := u.repo.Update(ctx, uid, req.Name, avatarURL)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "update user failed", "error", err, "user_id", uid)
+ return nil, err
+ }
+
+ user, err := u.Get(ctx, uid)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "get updated user failed", "error", err, "user_id", uid)
+ return nil, err
+ }
+ return user, nil
+}
+
+// GetUserWithTeams implements domain.UserUsecase.
+func (u *userUsecase) GetUserWithTeams(ctx context.Context, userID uuid.UUID) (*domain.TeamUserInfo, error) {
+ user, err := u.repo.GetUserWithTeams(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(user, &domain.TeamUserInfo{}), nil
+}
+
+// PasswordLogin implements domain.UserUsecase.
+func (u *userUsecase) PasswordLogin(ctx context.Context, req *domain.TeamLoginReq) (*domain.User, error) {
+ user, err := u.repo.PasswordLogin(ctx, req)
+ if err != nil {
+ return nil, err
+ }
+ return cvt.From(user, &domain.User{}), nil
+}
+
+// ChangePassword implements domain.UserUsecase.
+func (u *userUsecase) ChangePassword(ctx context.Context, userID uuid.UUID, req *domain.ChangePasswordReq, isReset bool) error {
+ err := u.repo.ChangePassword(ctx, userID, req.CurrentPassword, req.NewPassword, isReset)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "change password failed", "error", err)
+ return err
+ }
+ return nil
+}
+
+// SendResetPasswordEmail implements domain.UserUsecase.
+func (u *userUsecase) SendResetPasswordEmail(ctx context.Context, req *domain.ResetUserPasswordEmailReq) error {
+ users, err := u.repo.GetUserByEmail(ctx, req.Emails)
+ if err != nil {
+ return err
+ }
+
+ for _, user := range users {
+ token, err := u.generateResetPWDToken(ctx, user.ID)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "generate reset password token failed", "error", err)
+ continue
+ }
+
+ key := fmt.Sprintf("reset_password_token:%s", user.ID.String())
+ err = u.redisClient.Set(ctx, key, token, time.Hour*24).Err()
+ if err != nil {
+ u.logger.ErrorContext(ctx, "set redis key failed", "error", err)
+ continue
+ }
+ u.logger.InfoContext(ctx, "set redis key success", "key", key)
+ go u.sendEmail(ctx, user.Email, user.Name, token)
+ }
+ return nil
+}
+
+// generateResetPWDToken generates a reset password token.
+func (u *userUsecase) generateResetPWDToken(_ context.Context, userID uuid.UUID) (string, error) {
+ token, err := crypto.Simple(userID.String(), time.Now().Add(time.Hour*24))
+ if err != nil {
+ return "", err
+ }
+ return token, nil
+}
+
+// sendEmail sends a reset password email via SMTP.
+func (u *userUsecase) sendEmail(ctx context.Context, emailAddr, username, token string) {
+ resetURL := fmt.Sprintf("%s/resetpassword?token=%s", u.config.Server.BaseURL, token)
+ err := u.emailClient.SendResetPasswordEmail(emailAddr, username, resetURL)
+ if err != nil {
+ u.logger.ErrorContext(ctx, "send email failed", "error", err, "email", emailAddr)
+ return
+ }
+ u.logger.InfoContext(ctx, "send email success", "email", emailAddr, "username", username)
+}
+
+// GetUserByEmail implements domain.UserUsecase.
+func (u *userUsecase) GetUserByEmail(ctx context.Context, emails []string) ([]*domain.User, error) {
+ users, err := u.repo.GetUserByEmail(ctx, emails)
+ if err != nil && !db.IsNotFound(err) {
+ return nil, errcode.ErrDatabaseQuery.Wrap(err)
+ }
+ if len(users) == 0 {
+ u.logger.InfoContext(ctx, "no user found by email", "emails", emails)
+ return nil, nil
+ }
+
+ result := make([]*domain.User, 0, len(users))
+ cvt.Iter(users, func(_ int, user *db.User) error {
+ result = append(result, cvt.From(user, &domain.User{}))
+ return nil
+ })
+ return result, nil
+}
diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go
new file mode 100644
index 00000000..8c973694
--- /dev/null
+++ b/backend/cmd/server/main.go
@@ -0,0 +1,78 @@
+package main
+
+import (
+ "context"
+ "fmt"
+ "os"
+ "time"
+
+ "github.com/GoYoko/web"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/biz"
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/pkg"
+ "github.com/chaitin/MonkeyCode/backend/pkg/logger"
+ "github.com/chaitin/MonkeyCode/backend/pkg/service"
+ "github.com/chaitin/MonkeyCode/backend/pkg/store"
+)
+
+func main() {
+ // 初始化配置
+ cfg, err := config.Init("./config/server")
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
+ os.Exit(1)
+ }
+
+ // 创建 DI 容器
+ injector := do.New()
+
+ // 注入配置
+ do.ProvideValue(injector, cfg)
+
+ // 注册基础设施
+ if err := pkg.RegisterInfra(injector); err != nil {
+ fmt.Fprintf(os.Stderr, "failed to register infra: %v\n", err)
+ os.Exit(1)
+ }
+
+ // 注册业务模块
+ if err := biz.RegisterAll(injector); err != nil {
+ fmt.Fprintf(os.Stderr, "failed to register biz: %v\n", err)
+ os.Exit(1)
+ }
+
+ // 获取 logger
+ l := logger.NewLogger(cfg.Logger)
+
+ // 运行数据库迁移
+ if err := store.MigrateSQL(cfg, l); err != nil {
+ l.Warn("database migration warning", "error", err)
+ }
+
+ // 获取 web 实例并启动服务
+ w := do.MustInvoke[*web.Web](injector)
+ svc := service.NewService(
+ service.WithPprof(),
+ )
+ svc.Add(&server{w: w, addr: cfg.Server.Addr})
+
+ l.Info("starting server", "addr", cfg.Server.Addr)
+ if err := svc.Run(); err != nil {
+ l.Error("server error", "error", err)
+ }
+}
+
+type server struct {
+ w *web.Web
+ addr string
+}
+
+func (s *server) Name() string { return "MonkeyCode Service" }
+func (s *server) Start() error { return s.w.Run(s.addr) }
+func (s *server) Stop() error {
+ ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+ defer cancel()
+ return s.w.Echo().Shutdown(ctx)
+}
diff --git a/backend/config/config.go b/backend/config/config.go
new file mode 100644
index 00000000..ce2979eb
--- /dev/null
+++ b/backend/config/config.go
@@ -0,0 +1,86 @@
+package config
+
+import (
+ "strings"
+
+ "github.com/spf13/viper"
+
+ "github.com/chaitin/MonkeyCode/backend/pkg/logger"
+)
+
+type Config struct {
+ Debug bool `mapstructure:"debug"`
+
+ Server struct {
+ Addr string `mapstructure:"addr"`
+ BaseURL string `mapstructure:"base_url"`
+ } `mapstructure:"server"`
+
+ Database Database `mapstructure:"database"`
+
+ Redis struct {
+ Host string `mapstructure:"host"`
+ Port int `mapstructure:"port"`
+ Pass string `mapstructure:"pass"`
+ DB int `mapstructure:"db"`
+ } `mapstructure:"redis"`
+
+ Session Session `mapstructure:"session"`
+ SMTP SMTP `mapstructure:"smtp"`
+
+ RootPath string `mapstructure:"root_path"`
+ Logger *logger.Config `mapstructure:"logger"`
+ AdminToken string `mapstructure:"admin_token"`
+}
+
+type Session struct {
+ Secret string `mapstructure:"secret"`
+ Expire int `mapstructure:"expire"`
+}
+
+type SMTP struct {
+ Host string `mapstructure:"host"`
+ Port int `mapstructure:"port"`
+ Username string `mapstructure:"username"`
+ Password string `mapstructure:"password"`
+ From string `mapstructure:"from"`
+}
+
+type Database struct {
+ Master string `mapstructure:"master"`
+ Slave string `mapstructure:"slave"`
+ MaxOpenConns int `mapstructure:"max_open_conns"`
+ MaxIdleConns int `mapstructure:"max_idle_conns"`
+ ConnMaxLifetime int `mapstructure:"conn_max_lifetime"`
+}
+
+func Init(dir string) (*Config, error) {
+ v := viper.New()
+ v.AutomaticEnv()
+ v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+
+ v.SetDefault("debug", true)
+ v.SetDefault("server.addr", ":8888")
+ v.SetDefault("server.base_url", "http://localhost:8888")
+ v.SetDefault("database.max_open_conns", 100)
+ v.SetDefault("database.max_idle_conns", 50)
+ v.SetDefault("database.conn_max_lifetime", 30)
+ v.SetDefault("root_path", "/app")
+ v.SetDefault("logger.level", "info")
+ v.SetDefault("session.expire", 86400)
+ v.SetDefault("smtp.port", 587)
+
+ v.SetConfigType("yaml")
+ v.AddConfigPath(dir)
+ v.SetConfigName("config")
+ if err := v.ReadInConfig(); err != nil {
+ return nil, err
+ }
+
+ c := Config{}
+ if err := v.Unmarshal(&c); err != nil {
+ return nil, err
+ }
+
+ return &c, nil
+}
diff --git a/backend/config/server/config.yaml.example b/backend/config/server/config.yaml.example
new file mode 100644
index 00000000..e641fe32
--- /dev/null
+++ b/backend/config/server/config.yaml.example
@@ -0,0 +1,34 @@
+debug: true
+server:
+ addr: ":8888"
+ base_url: "http://localhost:8888"
+
+database:
+ master: "postgres://monkeycode:monkeycode@localhost:5432/monkeycode?sslmode=disable"
+ slave: ""
+ max_open_conns: 100
+ max_idle_conns: 50
+ conn_max_lifetime: 30
+
+redis:
+ host: "localhost"
+ port: 6379
+ pass: ""
+ db: 0
+
+session:
+ secret: "change-me-to-a-random-32-byte-key"
+ expire: 86400
+
+smtp:
+ host: "smtp.example.com"
+ port: 587
+ username: ""
+ password: ""
+ from: "noreply@example.com"
+
+root_path: "/app"
+admin_token: "change-me"
+
+logger:
+ level: "info"
diff --git a/backend/consts/auth.go b/backend/consts/auth.go
new file mode 100644
index 00000000..ceeb3929
--- /dev/null
+++ b/backend/consts/auth.go
@@ -0,0 +1,6 @@
+package consts
+
+const (
+ MonkeyCodeAISession = "monkeycode_ai_session"
+ MonkeyCodeAITeamSession = "monkeycode_ai_team_session"
+)
diff --git a/backend/consts/base.go b/backend/consts/base.go
new file mode 100644
index 00000000..bf205c58
--- /dev/null
+++ b/backend/consts/base.go
@@ -0,0 +1,11 @@
+package consts
+
+type OwnerType string
+
+const (
+ OwnerTypePrivate OwnerType = "private"
+ OwnerTypePublic OwnerType = "public"
+ OwnerTypeTeam OwnerType = "team"
+)
+
+const MonkeyCodeAITeamName string = "MonkeyCode-AI"
diff --git a/backend/consts/team.go b/backend/consts/team.go
new file mode 100644
index 00000000..2678f528
--- /dev/null
+++ b/backend/consts/team.go
@@ -0,0 +1,8 @@
+package consts
+
+type TeamMemberRole string
+
+const (
+ TeamMemberRoleAdmin TeamMemberRole = "admin"
+ TeamMemberRoleUser TeamMemberRole = "user"
+)
diff --git a/backend/consts/user.go b/backend/consts/user.go
new file mode 100644
index 00000000..5a2efc05
--- /dev/null
+++ b/backend/consts/user.go
@@ -0,0 +1,40 @@
+package consts
+
+const (
+ PRIVILEGED_USER_KEY = "privileged:user"
+)
+
+type UserPlatform string
+
+const (
+ UserPlatformBaizhi UserPlatform = "baizhi" // 百智云平台
+ UserPlatformGithub UserPlatform = "github"
+ UserPlatformGitLab UserPlatform = "gitlab"
+ UserPlatformGitea UserPlatform = "gitea"
+ UserPlatformGitee UserPlatform = "gitee"
+)
+
+type UserStatus string
+
+const (
+ UserStatusActive UserStatus = "active"
+ UserStatusInactive UserStatus = "inactive"
+)
+
+type UserRole string
+
+const (
+ UserRoleIndividual UserRole = "individual" // 个人用户
+ UserRoleEnterprise UserRole = "enterprise" // 企业用户
+ UserRoleSubAccount UserRole = "subaccount" // 企业子账户
+ UserRoleAdmin UserRole = "admin" // MonkeyCode-AI 管理员账号，用来配置公共资源. 如公共宿主机等
+)
+
+type DefaultConfigType string
+
+const (
+ DefaultConfigTypeModel DefaultConfigType = "model"
+ DefaultConfigTypeImage DefaultConfigType = "image"
+ DefaultConfigTypeHost DefaultConfigType = "host"
+ UserRoleGitTask UserRole = "gittask" // 全自动 git 任务插入的用户
+)
diff --git a/backend/db/audit.go b/backend/db/audit.go
new file mode 100644
index 00000000..b3d447a7
--- /dev/null
+++ b/backend/db/audit.go
@@ -0,0 +1,202 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// Audit is the model entity for the Audit schema.
+type Audit struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // UserID holds the value of the "user_id" field.
+ UserID uuid.UUID `json:"user_id,omitempty"`
+ // Operation holds the value of the "operation" field.
+ Operation string `json:"operation,omitempty"`
+ // SourceIP holds the value of the "source_ip" field.
+ SourceIP string `json:"source_ip,omitempty"`
+ // UserAgent holds the value of the "user_agent" field.
+ UserAgent string `json:"user_agent,omitempty"`
+ // Request holds the value of the "request" field.
+ Request string `json:"request,omitempty"`
+ // Response holds the value of the "response" field.
+ Response string `json:"response,omitempty"`
+ // CreatedAt holds the value of the "created_at" field.
+ CreatedAt time.Time `json:"created_at,omitempty"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the AuditQuery when eager-loading is set.
+ Edges AuditEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// AuditEdges holds the relations/edges for other nodes in the graph.
+type AuditEdges struct {
+ // User holds the value of the user edge.
+ User *User `json:"user,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e AuditEdges) UserOrErr() (*User, error) {
+ if e.User != nil {
+ return e.User, nil
+ } else if e.loadedTypes[0] {
+ return nil, &NotFoundError{label: user.Label}
+ }
+ return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Audit) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case audit.FieldOperation, audit.FieldSourceIP, audit.FieldUserAgent, audit.FieldRequest, audit.FieldResponse:
+ values[i] = new(sql.NullString)
+ case audit.FieldCreatedAt:
+ values[i] = new(sql.NullTime)
+ case audit.FieldID, audit.FieldUserID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Audit fields.
+func (_m *Audit) 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 audit.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case audit.FieldUserID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field user_id", values[i])
+ } else if value != nil {
+ _m.UserID = *value
+ }
+ case audit.FieldOperation:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field operation", values[i])
+ } else if value.Valid {
+ _m.Operation = value.String
+ }
+ case audit.FieldSourceIP:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field source_ip", values[i])
+ } else if value.Valid {
+ _m.SourceIP = value.String
+ }
+ case audit.FieldUserAgent:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field user_agent", values[i])
+ } else if value.Valid {
+ _m.UserAgent = value.String
+ }
+ case audit.FieldRequest:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field request", values[i])
+ } else if value.Valid {
+ _m.Request = value.String
+ }
+ case audit.FieldResponse:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field response", values[i])
+ } else if value.Valid {
+ _m.Response = value.String
+ }
+ case audit.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 {
+ _m.CreatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Audit.
+// This includes values selected through modifiers, order, etc.
+func (_m *Audit) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the Audit entity.
+func (_m *Audit) QueryUser() *UserQuery {
+ return NewAuditClient(_m.config).QueryUser(_m)
+}
+
+// Update returns a builder for updating this Audit.
+// Note that you need to call Audit.Unwrap() before calling this method if this Audit
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *Audit) Update() *AuditUpdateOne {
+ return NewAuditClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the Audit 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 (_m *Audit) Unwrap() *Audit {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: Audit is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *Audit) String() string {
+ var builder strings.Builder
+ builder.WriteString("Audit(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("user_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.UserID))
+ builder.WriteString(", ")
+ builder.WriteString("operation=")
+ builder.WriteString(_m.Operation)
+ builder.WriteString(", ")
+ builder.WriteString("source_ip=")
+ builder.WriteString(_m.SourceIP)
+ builder.WriteString(", ")
+ builder.WriteString("user_agent=")
+ builder.WriteString(_m.UserAgent)
+ builder.WriteString(", ")
+ builder.WriteString("request=")
+ builder.WriteString(_m.Request)
+ builder.WriteString(", ")
+ builder.WriteString("response=")
+ builder.WriteString(_m.Response)
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// Audits is a parsable slice of Audit.
+type Audits []*Audit
diff --git a/backend/db/audit/audit.go b/backend/db/audit/audit.go
new file mode 100644
index 00000000..90bd4f36
--- /dev/null
+++ b/backend/db/audit/audit.go
@@ -0,0 +1,126 @@
+// Code generated by ent, DO NOT EDIT.
+
+package audit
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the audit type in the database.
+ Label = "audit"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldUserID holds the string denoting the user_id field in the database.
+ FieldUserID = "user_id"
+ // FieldOperation holds the string denoting the operation field in the database.
+ FieldOperation = "operation"
+ // FieldSourceIP holds the string denoting the source_ip field in the database.
+ FieldSourceIP = "source_ip"
+ // FieldUserAgent holds the string denoting the user_agent field in the database.
+ FieldUserAgent = "user_agent"
+ // FieldRequest holds the string denoting the request field in the database.
+ FieldRequest = "request"
+ // FieldResponse holds the string denoting the response field in the database.
+ FieldResponse = "response"
+ // FieldCreatedAt holds the string denoting the created_at field in the database.
+ FieldCreatedAt = "created_at"
+ // EdgeUser holds the string denoting the user edge name in mutations.
+ EdgeUser = "user"
+ // Table holds the table name of the audit in the database.
+ Table = "audits"
+ // UserTable is the table that holds the user relation/edge.
+ UserTable = "audits"
+ // UserInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ UserInverseTable = "users"
+ // UserColumn is the table column denoting the user relation/edge.
+ UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for audit fields.
+var Columns = []string{
+ FieldID,
+ FieldUserID,
+ FieldOperation,
+ FieldSourceIP,
+ FieldUserAgent,
+ FieldRequest,
+ FieldResponse,
+ FieldCreatedAt,
+}
+
+// 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
+ }
+ }
+ return false
+}
+
+var (
+ // DefaultCreatedAt holds the default value on creation for the "created_at" field.
+ DefaultCreatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the Audit queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByOperation orders the results by the operation field.
+func ByOperation(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldOperation, opts...).ToFunc()
+}
+
+// BySourceIP orders the results by the source_ip field.
+func BySourceIP(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldSourceIP, opts...).ToFunc()
+}
+
+// ByUserAgent orders the results by the user_agent field.
+func ByUserAgent(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUserAgent, opts...).ToFunc()
+}
+
+// ByRequest orders the results by the request field.
+func ByRequest(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldRequest, opts...).ToFunc()
+}
+
+// ByResponse orders the results by the response field.
+func ByResponse(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldResponse, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newUserStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UserInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+ )
+}
diff --git a/backend/db/audit/where.go b/backend/db/audit/where.go
new file mode 100644
index 00000000..70cc0693
--- /dev/null
+++ b/backend/db/audit/where.go
@@ -0,0 +1,525 @@
+// Code generated by ent, DO NOT EDIT.
+
+package audit
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldID, id))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldUserID, v))
+}
+
+// Operation applies equality check predicate on the "operation" field. It's identical to OperationEQ.
+func Operation(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldOperation, v))
+}
+
+// SourceIP applies equality check predicate on the "source_ip" field. It's identical to SourceIPEQ.
+func SourceIP(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldSourceIP, v))
+}
+
+// UserAgent applies equality check predicate on the "user_agent" field. It's identical to UserAgentEQ.
+func UserAgent(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldUserAgent, v))
+}
+
+// Request applies equality check predicate on the "request" field. It's identical to RequestEQ.
+func Request(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldRequest, v))
+}
+
+// Response applies equality check predicate on the "response" field. It's identical to ResponseEQ.
+func Response(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldResponse, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...uuid.UUID) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// OperationEQ applies the EQ predicate on the "operation" field.
+func OperationEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldOperation, v))
+}
+
+// OperationNEQ applies the NEQ predicate on the "operation" field.
+func OperationNEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldOperation, v))
+}
+
+// OperationIn applies the In predicate on the "operation" field.
+func OperationIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldOperation, vs...))
+}
+
+// OperationNotIn applies the NotIn predicate on the "operation" field.
+func OperationNotIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldOperation, vs...))
+}
+
+// OperationGT applies the GT predicate on the "operation" field.
+func OperationGT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldOperation, v))
+}
+
+// OperationGTE applies the GTE predicate on the "operation" field.
+func OperationGTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldOperation, v))
+}
+
+// OperationLT applies the LT predicate on the "operation" field.
+func OperationLT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldOperation, v))
+}
+
+// OperationLTE applies the LTE predicate on the "operation" field.
+func OperationLTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldOperation, v))
+}
+
+// OperationContains applies the Contains predicate on the "operation" field.
+func OperationContains(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContains(FieldOperation, v))
+}
+
+// OperationHasPrefix applies the HasPrefix predicate on the "operation" field.
+func OperationHasPrefix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasPrefix(FieldOperation, v))
+}
+
+// OperationHasSuffix applies the HasSuffix predicate on the "operation" field.
+func OperationHasSuffix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasSuffix(FieldOperation, v))
+}
+
+// OperationEqualFold applies the EqualFold predicate on the "operation" field.
+func OperationEqualFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEqualFold(FieldOperation, v))
+}
+
+// OperationContainsFold applies the ContainsFold predicate on the "operation" field.
+func OperationContainsFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContainsFold(FieldOperation, v))
+}
+
+// SourceIPEQ applies the EQ predicate on the "source_ip" field.
+func SourceIPEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldSourceIP, v))
+}
+
+// SourceIPNEQ applies the NEQ predicate on the "source_ip" field.
+func SourceIPNEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldSourceIP, v))
+}
+
+// SourceIPIn applies the In predicate on the "source_ip" field.
+func SourceIPIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldSourceIP, vs...))
+}
+
+// SourceIPNotIn applies the NotIn predicate on the "source_ip" field.
+func SourceIPNotIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldSourceIP, vs...))
+}
+
+// SourceIPGT applies the GT predicate on the "source_ip" field.
+func SourceIPGT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldSourceIP, v))
+}
+
+// SourceIPGTE applies the GTE predicate on the "source_ip" field.
+func SourceIPGTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldSourceIP, v))
+}
+
+// SourceIPLT applies the LT predicate on the "source_ip" field.
+func SourceIPLT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldSourceIP, v))
+}
+
+// SourceIPLTE applies the LTE predicate on the "source_ip" field.
+func SourceIPLTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldSourceIP, v))
+}
+
+// SourceIPContains applies the Contains predicate on the "source_ip" field.
+func SourceIPContains(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContains(FieldSourceIP, v))
+}
+
+// SourceIPHasPrefix applies the HasPrefix predicate on the "source_ip" field.
+func SourceIPHasPrefix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasPrefix(FieldSourceIP, v))
+}
+
+// SourceIPHasSuffix applies the HasSuffix predicate on the "source_ip" field.
+func SourceIPHasSuffix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasSuffix(FieldSourceIP, v))
+}
+
+// SourceIPEqualFold applies the EqualFold predicate on the "source_ip" field.
+func SourceIPEqualFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEqualFold(FieldSourceIP, v))
+}
+
+// SourceIPContainsFold applies the ContainsFold predicate on the "source_ip" field.
+func SourceIPContainsFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContainsFold(FieldSourceIP, v))
+}
+
+// UserAgentEQ applies the EQ predicate on the "user_agent" field.
+func UserAgentEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldUserAgent, v))
+}
+
+// UserAgentNEQ applies the NEQ predicate on the "user_agent" field.
+func UserAgentNEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldUserAgent, v))
+}
+
+// UserAgentIn applies the In predicate on the "user_agent" field.
+func UserAgentIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldUserAgent, vs...))
+}
+
+// UserAgentNotIn applies the NotIn predicate on the "user_agent" field.
+func UserAgentNotIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldUserAgent, vs...))
+}
+
+// UserAgentGT applies the GT predicate on the "user_agent" field.
+func UserAgentGT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldUserAgent, v))
+}
+
+// UserAgentGTE applies the GTE predicate on the "user_agent" field.
+func UserAgentGTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldUserAgent, v))
+}
+
+// UserAgentLT applies the LT predicate on the "user_agent" field.
+func UserAgentLT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldUserAgent, v))
+}
+
+// UserAgentLTE applies the LTE predicate on the "user_agent" field.
+func UserAgentLTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldUserAgent, v))
+}
+
+// UserAgentContains applies the Contains predicate on the "user_agent" field.
+func UserAgentContains(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContains(FieldUserAgent, v))
+}
+
+// UserAgentHasPrefix applies the HasPrefix predicate on the "user_agent" field.
+func UserAgentHasPrefix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasPrefix(FieldUserAgent, v))
+}
+
+// UserAgentHasSuffix applies the HasSuffix predicate on the "user_agent" field.
+func UserAgentHasSuffix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasSuffix(FieldUserAgent, v))
+}
+
+// UserAgentEqualFold applies the EqualFold predicate on the "user_agent" field.
+func UserAgentEqualFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEqualFold(FieldUserAgent, v))
+}
+
+// UserAgentContainsFold applies the ContainsFold predicate on the "user_agent" field.
+func UserAgentContainsFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContainsFold(FieldUserAgent, v))
+}
+
+// RequestEQ applies the EQ predicate on the "request" field.
+func RequestEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldRequest, v))
+}
+
+// RequestNEQ applies the NEQ predicate on the "request" field.
+func RequestNEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldRequest, v))
+}
+
+// RequestIn applies the In predicate on the "request" field.
+func RequestIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldRequest, vs...))
+}
+
+// RequestNotIn applies the NotIn predicate on the "request" field.
+func RequestNotIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldRequest, vs...))
+}
+
+// RequestGT applies the GT predicate on the "request" field.
+func RequestGT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldRequest, v))
+}
+
+// RequestGTE applies the GTE predicate on the "request" field.
+func RequestGTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldRequest, v))
+}
+
+// RequestLT applies the LT predicate on the "request" field.
+func RequestLT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldRequest, v))
+}
+
+// RequestLTE applies the LTE predicate on the "request" field.
+func RequestLTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldRequest, v))
+}
+
+// RequestContains applies the Contains predicate on the "request" field.
+func RequestContains(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContains(FieldRequest, v))
+}
+
+// RequestHasPrefix applies the HasPrefix predicate on the "request" field.
+func RequestHasPrefix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasPrefix(FieldRequest, v))
+}
+
+// RequestHasSuffix applies the HasSuffix predicate on the "request" field.
+func RequestHasSuffix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasSuffix(FieldRequest, v))
+}
+
+// RequestEqualFold applies the EqualFold predicate on the "request" field.
+func RequestEqualFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEqualFold(FieldRequest, v))
+}
+
+// RequestContainsFold applies the ContainsFold predicate on the "request" field.
+func RequestContainsFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContainsFold(FieldRequest, v))
+}
+
+// ResponseEQ applies the EQ predicate on the "response" field.
+func ResponseEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldResponse, v))
+}
+
+// ResponseNEQ applies the NEQ predicate on the "response" field.
+func ResponseNEQ(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldResponse, v))
+}
+
+// ResponseIn applies the In predicate on the "response" field.
+func ResponseIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldResponse, vs...))
+}
+
+// ResponseNotIn applies the NotIn predicate on the "response" field.
+func ResponseNotIn(vs ...string) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldResponse, vs...))
+}
+
+// ResponseGT applies the GT predicate on the "response" field.
+func ResponseGT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldResponse, v))
+}
+
+// ResponseGTE applies the GTE predicate on the "response" field.
+func ResponseGTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldResponse, v))
+}
+
+// ResponseLT applies the LT predicate on the "response" field.
+func ResponseLT(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldResponse, v))
+}
+
+// ResponseLTE applies the LTE predicate on the "response" field.
+func ResponseLTE(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldResponse, v))
+}
+
+// ResponseContains applies the Contains predicate on the "response" field.
+func ResponseContains(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContains(FieldResponse, v))
+}
+
+// ResponseHasPrefix applies the HasPrefix predicate on the "response" field.
+func ResponseHasPrefix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasPrefix(FieldResponse, v))
+}
+
+// ResponseHasSuffix applies the HasSuffix predicate on the "response" field.
+func ResponseHasSuffix(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldHasSuffix(FieldResponse, v))
+}
+
+// ResponseIsNil applies the IsNil predicate on the "response" field.
+func ResponseIsNil() predicate.Audit {
+ return predicate.Audit(sql.FieldIsNull(FieldResponse))
+}
+
+// ResponseNotNil applies the NotNil predicate on the "response" field.
+func ResponseNotNil() predicate.Audit {
+ return predicate.Audit(sql.FieldNotNull(FieldResponse))
+}
+
+// ResponseEqualFold applies the EqualFold predicate on the "response" field.
+func ResponseEqualFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldEqualFold(FieldResponse, v))
+}
+
+// ResponseContainsFold applies the ContainsFold predicate on the "response" field.
+func ResponseContainsFold(v string) predicate.Audit {
+ return predicate.Audit(sql.FieldContainsFold(FieldResponse, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.Audit {
+ return predicate.Audit(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.Audit {
+ return predicate.Audit(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.Audit {
+ return predicate.Audit(func(s *sql.Selector) {
+ step := newUserStep()
+ 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.Audit) predicate.Audit {
+ return predicate.Audit(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Audit) predicate.Audit {
+ return predicate.Audit(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Audit) predicate.Audit {
+ return predicate.Audit(sql.NotPredicates(p))
+}
diff --git a/backend/db/audit_create.go b/backend/db/audit_create.go
new file mode 100644
index 00000000..8df0cbd0
--- /dev/null
+++ b/backend/db/audit_create.go
@@ -0,0 +1,874 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// AuditCreate is the builder for creating a Audit entity.
+type AuditCreate struct {
+ config
+ mutation *AuditMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetUserID sets the "user_id" field.
+func (_c *AuditCreate) SetUserID(v uuid.UUID) *AuditCreate {
+ _c.mutation.SetUserID(v)
+ return _c
+}
+
+// SetOperation sets the "operation" field.
+func (_c *AuditCreate) SetOperation(v string) *AuditCreate {
+ _c.mutation.SetOperation(v)
+ return _c
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (_c *AuditCreate) SetSourceIP(v string) *AuditCreate {
+ _c.mutation.SetSourceIP(v)
+ return _c
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (_c *AuditCreate) SetUserAgent(v string) *AuditCreate {
+ _c.mutation.SetUserAgent(v)
+ return _c
+}
+
+// SetRequest sets the "request" field.
+func (_c *AuditCreate) SetRequest(v string) *AuditCreate {
+ _c.mutation.SetRequest(v)
+ return _c
+}
+
+// SetResponse sets the "response" field.
+func (_c *AuditCreate) SetResponse(v string) *AuditCreate {
+ _c.mutation.SetResponse(v)
+ return _c
+}
+
+// SetNillableResponse sets the "response" field if the given value is not nil.
+func (_c *AuditCreate) SetNillableResponse(v *string) *AuditCreate {
+ if v != nil {
+ _c.SetResponse(*v)
+ }
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *AuditCreate) SetCreatedAt(v time.Time) *AuditCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *AuditCreate) SetNillableCreatedAt(v *time.Time) *AuditCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *AuditCreate) SetID(v uuid.UUID) *AuditCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_c *AuditCreate) SetUser(v *User) *AuditCreate {
+ return _c.SetUserID(v.ID)
+}
+
+// Mutation returns the AuditMutation object of the builder.
+func (_c *AuditCreate) Mutation() *AuditMutation {
+ return _c.mutation
+}
+
+// Save creates the Audit in the database.
+func (_c *AuditCreate) Save(ctx context.Context) (*Audit, error) {
+ _c.defaults()
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *AuditCreate) SaveX(ctx context.Context) *Audit {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *AuditCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *AuditCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *AuditCreate) defaults() {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ v := audit.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *AuditCreate) check() error {
+ if _, ok := _c.mutation.UserID(); !ok {
+ return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "Audit.user_id"`)}
+ }
+ if _, ok := _c.mutation.Operation(); !ok {
+ return &ValidationError{Name: "operation", err: errors.New(`db: missing required field "Audit.operation"`)}
+ }
+ if _, ok := _c.mutation.SourceIP(); !ok {
+ return &ValidationError{Name: "source_ip", err: errors.New(`db: missing required field "Audit.source_ip"`)}
+ }
+ if _, ok := _c.mutation.UserAgent(); !ok {
+ return &ValidationError{Name: "user_agent", err: errors.New(`db: missing required field "Audit.user_agent"`)}
+ }
+ if _, ok := _c.mutation.Request(); !ok {
+ return &ValidationError{Name: "request", err: errors.New(`db: missing required field "Audit.request"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Audit.created_at"`)}
+ }
+ if len(_c.mutation.UserIDs()) == 0 {
+ return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "Audit.user"`)}
+ }
+ return nil
+}
+
+func (_c *AuditCreate) sqlSave(ctx context.Context) (*Audit, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *AuditCreate) createSpec() (*Audit, *sqlgraph.CreateSpec) {
+ var (
+ _node = &Audit{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(audit.Table, sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.Operation(); ok {
+ _spec.SetField(audit.FieldOperation, field.TypeString, value)
+ _node.Operation = value
+ }
+ if value, ok := _c.mutation.SourceIP(); ok {
+ _spec.SetField(audit.FieldSourceIP, field.TypeString, value)
+ _node.SourceIP = value
+ }
+ if value, ok := _c.mutation.UserAgent(); ok {
+ _spec.SetField(audit.FieldUserAgent, field.TypeString, value)
+ _node.UserAgent = value
+ }
+ if value, ok := _c.mutation.Request(); ok {
+ _spec.SetField(audit.FieldRequest, field.TypeString, value)
+ _node.Request = value
+ }
+ if value, ok := _c.mutation.Response(); ok {
+ _spec.SetField(audit.FieldResponse, field.TypeString, value)
+ _node.Response = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(audit.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: audit.UserTable,
+ Columns: []string{audit.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.UserID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.Audit.Create().
+// SetUserID(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.AuditUpsert) {
+// SetUserID(v+v).
+// }).
+// Exec(ctx)
+func (_c *AuditCreate) OnConflict(opts ...sql.ConflictOption) *AuditUpsertOne {
+ _c.conflict = opts
+ return &AuditUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *AuditCreate) OnConflictColumns(columns ...string) *AuditUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &AuditUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // AuditUpsertOne is the builder for "upsert"-ing
+ // one Audit node.
+ AuditUpsertOne struct {
+ create *AuditCreate
+ }
+
+ // AuditUpsert is the "OnConflict" setter.
+ AuditUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetUserID sets the "user_id" field.
+func (u *AuditUpsert) SetUserID(v uuid.UUID) *AuditUpsert {
+ u.Set(audit.FieldUserID, v)
+ return u
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateUserID() *AuditUpsert {
+ u.SetExcluded(audit.FieldUserID)
+ return u
+}
+
+// SetOperation sets the "operation" field.
+func (u *AuditUpsert) SetOperation(v string) *AuditUpsert {
+ u.Set(audit.FieldOperation, v)
+ return u
+}
+
+// UpdateOperation sets the "operation" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateOperation() *AuditUpsert {
+ u.SetExcluded(audit.FieldOperation)
+ return u
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (u *AuditUpsert) SetSourceIP(v string) *AuditUpsert {
+ u.Set(audit.FieldSourceIP, v)
+ return u
+}
+
+// UpdateSourceIP sets the "source_ip" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateSourceIP() *AuditUpsert {
+ u.SetExcluded(audit.FieldSourceIP)
+ return u
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (u *AuditUpsert) SetUserAgent(v string) *AuditUpsert {
+ u.Set(audit.FieldUserAgent, v)
+ return u
+}
+
+// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateUserAgent() *AuditUpsert {
+ u.SetExcluded(audit.FieldUserAgent)
+ return u
+}
+
+// SetRequest sets the "request" field.
+func (u *AuditUpsert) SetRequest(v string) *AuditUpsert {
+ u.Set(audit.FieldRequest, v)
+ return u
+}
+
+// UpdateRequest sets the "request" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateRequest() *AuditUpsert {
+ u.SetExcluded(audit.FieldRequest)
+ return u
+}
+
+// SetResponse sets the "response" field.
+func (u *AuditUpsert) SetResponse(v string) *AuditUpsert {
+ u.Set(audit.FieldResponse, v)
+ return u
+}
+
+// UpdateResponse sets the "response" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateResponse() *AuditUpsert {
+ u.SetExcluded(audit.FieldResponse)
+ return u
+}
+
+// ClearResponse clears the value of the "response" field.
+func (u *AuditUpsert) ClearResponse() *AuditUpsert {
+ u.SetNull(audit.FieldResponse)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *AuditUpsert) SetCreatedAt(v time.Time) *AuditUpsert {
+ u.Set(audit.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *AuditUpsert) UpdateCreatedAt() *AuditUpsert {
+ u.SetExcluded(audit.FieldCreatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(audit.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *AuditUpsertOne) UpdateNewValues() *AuditUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(audit.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *AuditUpsertOne) Ignore() *AuditUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *AuditUpsertOne) DoNothing() *AuditUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the AuditCreate.OnConflict
+// documentation for more info.
+func (u *AuditUpsertOne) Update(set func(*AuditUpsert)) *AuditUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&AuditUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetUserID sets the "user_id" field.
+func (u *AuditUpsertOne) SetUserID(v uuid.UUID) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateUserID() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetOperation sets the "operation" field.
+func (u *AuditUpsertOne) SetOperation(v string) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetOperation(v)
+ })
+}
+
+// UpdateOperation sets the "operation" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateOperation() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateOperation()
+ })
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (u *AuditUpsertOne) SetSourceIP(v string) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetSourceIP(v)
+ })
+}
+
+// UpdateSourceIP sets the "source_ip" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateSourceIP() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateSourceIP()
+ })
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (u *AuditUpsertOne) SetUserAgent(v string) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetUserAgent(v)
+ })
+}
+
+// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateUserAgent() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateUserAgent()
+ })
+}
+
+// SetRequest sets the "request" field.
+func (u *AuditUpsertOne) SetRequest(v string) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetRequest(v)
+ })
+}
+
+// UpdateRequest sets the "request" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateRequest() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateRequest()
+ })
+}
+
+// SetResponse sets the "response" field.
+func (u *AuditUpsertOne) SetResponse(v string) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetResponse(v)
+ })
+}
+
+// UpdateResponse sets the "response" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateResponse() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateResponse()
+ })
+}
+
+// ClearResponse clears the value of the "response" field.
+func (u *AuditUpsertOne) ClearResponse() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.ClearResponse()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *AuditUpsertOne) SetCreatedAt(v time.Time) *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *AuditUpsertOne) UpdateCreatedAt() *AuditUpsertOne {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *AuditUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for AuditCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *AuditUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *AuditUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: AuditUpsertOne.ID is not supported by MySQL driver. Use AuditUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *AuditUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// AuditCreateBulk is the builder for creating many Audit entities in bulk.
+type AuditCreateBulk struct {
+ config
+ err error
+ builders []*AuditCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the Audit entities in the database.
+func (_c *AuditCreateBulk) Save(ctx context.Context) ([]*Audit, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*Audit, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*AuditMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *AuditCreateBulk) SaveX(ctx context.Context) []*Audit {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *AuditCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *AuditCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.Audit.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.AuditUpsert) {
+// SetUserID(v+v).
+// }).
+// Exec(ctx)
+func (_c *AuditCreateBulk) OnConflict(opts ...sql.ConflictOption) *AuditUpsertBulk {
+ _c.conflict = opts
+ return &AuditUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *AuditCreateBulk) OnConflictColumns(columns ...string) *AuditUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &AuditUpsertBulk{
+ create: _c,
+ }
+}
+
+// AuditUpsertBulk is the builder for "upsert"-ing
+// a bulk of Audit nodes.
+type AuditUpsertBulk struct {
+ create *AuditCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(audit.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *AuditUpsertBulk) UpdateNewValues() *AuditUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(audit.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.Audit.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *AuditUpsertBulk) Ignore() *AuditUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *AuditUpsertBulk) DoNothing() *AuditUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the AuditCreateBulk.OnConflict
+// documentation for more info.
+func (u *AuditUpsertBulk) Update(set func(*AuditUpsert)) *AuditUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&AuditUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetUserID sets the "user_id" field.
+func (u *AuditUpsertBulk) SetUserID(v uuid.UUID) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateUserID() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetOperation sets the "operation" field.
+func (u *AuditUpsertBulk) SetOperation(v string) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetOperation(v)
+ })
+}
+
+// UpdateOperation sets the "operation" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateOperation() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateOperation()
+ })
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (u *AuditUpsertBulk) SetSourceIP(v string) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetSourceIP(v)
+ })
+}
+
+// UpdateSourceIP sets the "source_ip" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateSourceIP() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateSourceIP()
+ })
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (u *AuditUpsertBulk) SetUserAgent(v string) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetUserAgent(v)
+ })
+}
+
+// UpdateUserAgent sets the "user_agent" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateUserAgent() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateUserAgent()
+ })
+}
+
+// SetRequest sets the "request" field.
+func (u *AuditUpsertBulk) SetRequest(v string) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetRequest(v)
+ })
+}
+
+// UpdateRequest sets the "request" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateRequest() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateRequest()
+ })
+}
+
+// SetResponse sets the "response" field.
+func (u *AuditUpsertBulk) SetResponse(v string) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetResponse(v)
+ })
+}
+
+// UpdateResponse sets the "response" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateResponse() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateResponse()
+ })
+}
+
+// ClearResponse clears the value of the "response" field.
+func (u *AuditUpsertBulk) ClearResponse() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.ClearResponse()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *AuditUpsertBulk) SetCreatedAt(v time.Time) *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *AuditUpsertBulk) UpdateCreatedAt() *AuditUpsertBulk {
+ return u.Update(func(s *AuditUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *AuditUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the AuditCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for AuditCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *AuditUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/audit_delete.go b/backend/db/audit_delete.go
new file mode 100644
index 00000000..e3e95973
--- /dev/null
+++ b/backend/db/audit_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// AuditDelete is the builder for deleting a Audit entity.
+type AuditDelete struct {
+ config
+ hooks []Hook
+ mutation *AuditMutation
+}
+
+// Where appends a list predicates to the AuditDelete builder.
+func (_d *AuditDelete) Where(ps ...predicate.Audit) *AuditDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *AuditDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *AuditDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *AuditDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(audit.Table, sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// AuditDeleteOne is the builder for deleting a single Audit entity.
+type AuditDeleteOne struct {
+ _d *AuditDelete
+}
+
+// Where appends a list predicates to the AuditDelete builder.
+func (_d *AuditDeleteOne) Where(ps ...predicate.Audit) *AuditDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *AuditDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{audit.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *AuditDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/audit_query.go b/backend/db/audit_query.go
new file mode 100644
index 00000000..28e1e174
--- /dev/null
+++ b/backend/db/audit_query.go
@@ -0,0 +1,657 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// AuditQuery is the builder for querying Audit entities.
+type AuditQuery struct {
+ config
+ ctx *QueryContext
+ order []audit.OrderOption
+ inters []Interceptor
+ predicates []predicate.Audit
+ withUser *UserQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the AuditQuery builder.
+func (_q *AuditQuery) Where(ps ...predicate.Audit) *AuditQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *AuditQuery) Limit(limit int) *AuditQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *AuditQuery) Offset(offset int) *AuditQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *AuditQuery) Unique(unique bool) *AuditQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *AuditQuery) Order(o ...audit.OrderOption) *AuditQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (_q *AuditQuery) QueryUser() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(audit.Table, audit.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, audit.UserTable, audit.UserColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first Audit entity from the query.
+// Returns a *NotFoundError when no Audit was found.
+func (_q *AuditQuery) First(ctx context.Context) (*Audit, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{audit.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *AuditQuery) FirstX(ctx context.Context) *Audit {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first Audit ID from the query.
+// Returns a *NotFoundError when no Audit ID was found.
+func (_q *AuditQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{audit.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *AuditQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single Audit entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Audit entity is found.
+// Returns a *NotFoundError when no Audit entities are found.
+func (_q *AuditQuery) Only(ctx context.Context) (*Audit, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{audit.Label}
+ default:
+ return nil, &NotSingularError{audit.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *AuditQuery) OnlyX(ctx context.Context) *Audit {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only Audit ID in the query.
+// Returns a *NotSingularError when more than one Audit ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *AuditQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{audit.Label}
+ default:
+ err = &NotSingularError{audit.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *AuditQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of Audits.
+func (_q *AuditQuery) All(ctx context.Context) ([]*Audit, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*Audit, *AuditQuery]()
+ return withInterceptors[[]*Audit](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *AuditQuery) AllX(ctx context.Context) []*Audit {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of Audit IDs.
+func (_q *AuditQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(audit.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *AuditQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *AuditQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*AuditQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *AuditQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *AuditQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *AuditQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the AuditQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *AuditQuery) Clone() *AuditQuery {
+ if _q == nil {
+ return nil
+ }
+ return &AuditQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]audit.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.Audit{}, _q.predicates...),
+ withUser: _q.withUser.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *AuditQuery) WithUser(opts ...func(*UserQuery)) *AuditQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withUser = query
+ return _q
+}
+
+// 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 {
+// UserID uuid.UUID `json:"user_id,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.Audit.Query().
+// GroupBy(audit.FieldUserID).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *AuditQuery) GroupBy(field string, fields ...string) *AuditGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &AuditGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = audit.Label
+ grbuild.scan = 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 {
+// UserID uuid.UUID `json:"user_id,omitempty"`
+// }
+//
+// client.Audit.Query().
+// Select(audit.FieldUserID).
+// Scan(ctx, &v)
+func (_q *AuditQuery) Select(fields ...string) *AuditSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &AuditSelect{AuditQuery: _q}
+ sbuild.label = audit.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a AuditSelect configured with the given aggregations.
+func (_q *AuditQuery) Aggregate(fns ...AggregateFunc) *AuditSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *AuditQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !audit.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *AuditQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Audit, error) {
+ var (
+ nodes = []*Audit{}
+ _spec = _q.querySpec()
+ loadedTypes = [1]bool{
+ _q.withUser != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*Audit).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &Audit{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withUser; query != nil {
+ if err := _q.loadUser(ctx, query, nodes, nil,
+ func(n *Audit, e *User) { n.Edges.User = e }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *AuditQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*Audit, init func(*Audit), assign func(*Audit, *User)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*Audit)
+ for i := range nodes {
+ fk := nodes[i].UserID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(user.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+
+func (_q *AuditQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *AuditQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(audit.Table, audit.Columns, sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, audit.FieldID)
+ for i := range fields {
+ if fields[i] != audit.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ if _q.withUser != nil {
+ _spec.Node.AddColumnOnce(audit.FieldUserID)
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *AuditQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(audit.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = audit.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *AuditQuery) ForUpdate(opts ...sql.LockOption) *AuditQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *AuditQuery) ForShare(opts ...sql.LockOption) *AuditQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *AuditQuery) Modify(modifiers ...func(s *sql.Selector)) *AuditSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// AuditGroupBy is the group-by builder for Audit entities.
+type AuditGroupBy struct {
+ selector
+ build *AuditQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *AuditGroupBy) Aggregate(fns ...AggregateFunc) *AuditGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *AuditGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*AuditQuery, *AuditGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *AuditGroupBy) sqlScan(ctx context.Context, root *AuditQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// AuditSelect is the builder for selecting fields of Audit entities.
+type AuditSelect struct {
+ *AuditQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *AuditSelect) Aggregate(fns ...AggregateFunc) *AuditSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *AuditSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*AuditQuery, *AuditSelect](ctx, _s.AuditQuery, _s, _s.inters, v)
+}
+
+func (_s *AuditSelect) sqlScan(ctx context.Context, root *AuditQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *AuditSelect) Modify(modifiers ...func(s *sql.Selector)) *AuditSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/audit_update.go b/backend/db/audit_update.go
new file mode 100644
index 00000000..dc99d2d0
--- /dev/null
+++ b/backend/db/audit_update.go
@@ -0,0 +1,546 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// AuditUpdate is the builder for updating Audit entities.
+type AuditUpdate struct {
+ config
+ hooks []Hook
+ mutation *AuditMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the AuditUpdate builder.
+func (_u *AuditUpdate) Where(ps ...predicate.Audit) *AuditUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *AuditUpdate) SetUserID(v uuid.UUID) *AuditUpdate {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableUserID(v *uuid.UUID) *AuditUpdate {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetOperation sets the "operation" field.
+func (_u *AuditUpdate) SetOperation(v string) *AuditUpdate {
+ _u.mutation.SetOperation(v)
+ return _u
+}
+
+// SetNillableOperation sets the "operation" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableOperation(v *string) *AuditUpdate {
+ if v != nil {
+ _u.SetOperation(*v)
+ }
+ return _u
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (_u *AuditUpdate) SetSourceIP(v string) *AuditUpdate {
+ _u.mutation.SetSourceIP(v)
+ return _u
+}
+
+// SetNillableSourceIP sets the "source_ip" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableSourceIP(v *string) *AuditUpdate {
+ if v != nil {
+ _u.SetSourceIP(*v)
+ }
+ return _u
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (_u *AuditUpdate) SetUserAgent(v string) *AuditUpdate {
+ _u.mutation.SetUserAgent(v)
+ return _u
+}
+
+// SetNillableUserAgent sets the "user_agent" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableUserAgent(v *string) *AuditUpdate {
+ if v != nil {
+ _u.SetUserAgent(*v)
+ }
+ return _u
+}
+
+// SetRequest sets the "request" field.
+func (_u *AuditUpdate) SetRequest(v string) *AuditUpdate {
+ _u.mutation.SetRequest(v)
+ return _u
+}
+
+// SetNillableRequest sets the "request" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableRequest(v *string) *AuditUpdate {
+ if v != nil {
+ _u.SetRequest(*v)
+ }
+ return _u
+}
+
+// SetResponse sets the "response" field.
+func (_u *AuditUpdate) SetResponse(v string) *AuditUpdate {
+ _u.mutation.SetResponse(v)
+ return _u
+}
+
+// SetNillableResponse sets the "response" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableResponse(v *string) *AuditUpdate {
+ if v != nil {
+ _u.SetResponse(*v)
+ }
+ return _u
+}
+
+// ClearResponse clears the value of the "response" field.
+func (_u *AuditUpdate) ClearResponse() *AuditUpdate {
+ _u.mutation.ClearResponse()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *AuditUpdate) SetCreatedAt(v time.Time) *AuditUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *AuditUpdate) SetNillableCreatedAt(v *time.Time) *AuditUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *AuditUpdate) SetUser(v *User) *AuditUpdate {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the AuditMutation object of the builder.
+func (_u *AuditUpdate) Mutation() *AuditMutation {
+ return _u.mutation
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *AuditUpdate) ClearUser() *AuditUpdate {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *AuditUpdate) Save(ctx context.Context) (int, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *AuditUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *AuditUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *AuditUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *AuditUpdate) check() error {
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "Audit.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *AuditUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AuditUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *AuditUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(audit.Table, audit.Columns, sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.Operation(); ok {
+ _spec.SetField(audit.FieldOperation, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.SourceIP(); ok {
+ _spec.SetField(audit.FieldSourceIP, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.UserAgent(); ok {
+ _spec.SetField(audit.FieldUserAgent, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Request(); ok {
+ _spec.SetField(audit.FieldRequest, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Response(); ok {
+ _spec.SetField(audit.FieldResponse, field.TypeString, value)
+ }
+ if _u.mutation.ResponseCleared() {
+ _spec.ClearField(audit.FieldResponse, field.TypeString)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(audit.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: audit.UserTable,
+ Columns: []string{audit.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: audit.UserTable,
+ Columns: []string{audit.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{audit.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// AuditUpdateOne is the builder for updating a single Audit entity.
+type AuditUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *AuditMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *AuditUpdateOne) SetUserID(v uuid.UUID) *AuditUpdateOne {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableUserID(v *uuid.UUID) *AuditUpdateOne {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetOperation sets the "operation" field.
+func (_u *AuditUpdateOne) SetOperation(v string) *AuditUpdateOne {
+ _u.mutation.SetOperation(v)
+ return _u
+}
+
+// SetNillableOperation sets the "operation" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableOperation(v *string) *AuditUpdateOne {
+ if v != nil {
+ _u.SetOperation(*v)
+ }
+ return _u
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (_u *AuditUpdateOne) SetSourceIP(v string) *AuditUpdateOne {
+ _u.mutation.SetSourceIP(v)
+ return _u
+}
+
+// SetNillableSourceIP sets the "source_ip" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableSourceIP(v *string) *AuditUpdateOne {
+ if v != nil {
+ _u.SetSourceIP(*v)
+ }
+ return _u
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (_u *AuditUpdateOne) SetUserAgent(v string) *AuditUpdateOne {
+ _u.mutation.SetUserAgent(v)
+ return _u
+}
+
+// SetNillableUserAgent sets the "user_agent" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableUserAgent(v *string) *AuditUpdateOne {
+ if v != nil {
+ _u.SetUserAgent(*v)
+ }
+ return _u
+}
+
+// SetRequest sets the "request" field.
+func (_u *AuditUpdateOne) SetRequest(v string) *AuditUpdateOne {
+ _u.mutation.SetRequest(v)
+ return _u
+}
+
+// SetNillableRequest sets the "request" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableRequest(v *string) *AuditUpdateOne {
+ if v != nil {
+ _u.SetRequest(*v)
+ }
+ return _u
+}
+
+// SetResponse sets the "response" field.
+func (_u *AuditUpdateOne) SetResponse(v string) *AuditUpdateOne {
+ _u.mutation.SetResponse(v)
+ return _u
+}
+
+// SetNillableResponse sets the "response" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableResponse(v *string) *AuditUpdateOne {
+ if v != nil {
+ _u.SetResponse(*v)
+ }
+ return _u
+}
+
+// ClearResponse clears the value of the "response" field.
+func (_u *AuditUpdateOne) ClearResponse() *AuditUpdateOne {
+ _u.mutation.ClearResponse()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *AuditUpdateOne) SetCreatedAt(v time.Time) *AuditUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *AuditUpdateOne) SetNillableCreatedAt(v *time.Time) *AuditUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *AuditUpdateOne) SetUser(v *User) *AuditUpdateOne {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the AuditMutation object of the builder.
+func (_u *AuditUpdateOne) Mutation() *AuditMutation {
+ return _u.mutation
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *AuditUpdateOne) ClearUser() *AuditUpdateOne {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Where appends a list predicates to the AuditUpdate builder.
+func (_u *AuditUpdateOne) Where(ps ...predicate.Audit) *AuditUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *AuditUpdateOne) Select(field string, fields ...string) *AuditUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated Audit entity.
+func (_u *AuditUpdateOne) Save(ctx context.Context) (*Audit, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *AuditUpdateOne) SaveX(ctx context.Context) *Audit {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *AuditUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *AuditUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *AuditUpdateOne) check() error {
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "Audit.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *AuditUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *AuditUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *AuditUpdateOne) sqlSave(ctx context.Context) (_node *Audit, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(audit.Table, audit.Columns, sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Audit.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, audit.FieldID)
+ for _, f := range fields {
+ if !audit.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != audit.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.Operation(); ok {
+ _spec.SetField(audit.FieldOperation, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.SourceIP(); ok {
+ _spec.SetField(audit.FieldSourceIP, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.UserAgent(); ok {
+ _spec.SetField(audit.FieldUserAgent, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Request(); ok {
+ _spec.SetField(audit.FieldRequest, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Response(); ok {
+ _spec.SetField(audit.FieldResponse, field.TypeString, value)
+ }
+ if _u.mutation.ResponseCleared() {
+ _spec.ClearField(audit.FieldResponse, field.TypeString)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(audit.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: audit.UserTable,
+ Columns: []string{audit.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: audit.UserTable,
+ Columns: []string{audit.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &Audit{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{audit.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/client.go b/backend/db/client.go
new file mode 100644
index 00000000..982e4380
--- /dev/null
+++ b/backend/db/client.go
@@ -0,0 +1,1522 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "log"
+ "reflect"
+
+ "github.com/chaitin/MonkeyCode/backend/db/migrate"
+ "github.com/google/uuid"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+
+ stdsql "database/sql"
+)
+
+// Client is the client that holds all ent builders.
+type Client struct {
+ config
+ // Schema is the client for creating, migrating and dropping schema.
+ Schema *migrate.Schema
+ // Audit is the client for interacting with the Audit builders.
+ Audit *AuditClient
+ // Team is the client for interacting with the Team builders.
+ Team *TeamClient
+ // TeamGroup is the client for interacting with the TeamGroup builders.
+ TeamGroup *TeamGroupClient
+ // TeamGroupMember is the client for interacting with the TeamGroupMember builders.
+ TeamGroupMember *TeamGroupMemberClient
+ // TeamMember is the client for interacting with the TeamMember builders.
+ TeamMember *TeamMemberClient
+ // User is the client for interacting with the User builders.
+ User *UserClient
+ // UserIdentity is the client for interacting with the UserIdentity builders.
+ UserIdentity *UserIdentityClient
+}
+
+// NewClient creates a new client configured with the given options.
+func NewClient(opts ...Option) *Client {
+ client := &Client{config: newConfig(opts...)}
+ client.init()
+ return client
+}
+
+func (c *Client) init() {
+ c.Schema = migrate.NewSchema(c.driver)
+ c.Audit = NewAuditClient(c.config)
+ c.Team = NewTeamClient(c.config)
+ c.TeamGroup = NewTeamGroupClient(c.config)
+ c.TeamGroupMember = NewTeamGroupMemberClient(c.config)
+ c.TeamMember = NewTeamMemberClient(c.config)
+ c.User = NewUserClient(c.config)
+ c.UserIdentity = NewUserIdentityClient(c.config)
+}
+
+type (
+ // config is the configuration for the client and its builder.
+ config struct {
+ // driver used for executing database requests.
+ driver dialect.Driver
+ // debug enable a debug logging.
+ debug bool
+ // log used for logging on debug mode.
+ log func(...any)
+ // hooks to execute on mutations.
+ hooks *hooks
+ // interceptors to execute on queries.
+ inters *inters
+ }
+ // Option function to configure the client.
+ Option func(*config)
+)
+
+// newConfig creates a new config for the client.
+func newConfig(opts ...Option) config {
+ cfg := config{log: log.Println, hooks: &hooks{}, inters: &inters{}}
+ cfg.options(opts...)
+ return cfg
+}
+
+// options applies the options on the config object.
+func (c *config) options(opts ...Option) {
+ for _, opt := range opts {
+ opt(c)
+ }
+ if c.debug {
+ c.driver = dialect.Debug(c.driver, c.log)
+ }
+}
+
+// Debug enables debug logging on the ent.Driver.
+func Debug() Option {
+ return func(c *config) {
+ c.debug = true
+ }
+}
+
+// Log sets the logging function for debug mode.
+func Log(fn func(...any)) Option {
+ return func(c *config) {
+ c.log = fn
+ }
+}
+
+// Driver configures the client driver.
+func Driver(driver dialect.Driver) Option {
+ return func(c *config) {
+ c.driver = driver
+ }
+}
+
+// Open opens a database/sql.DB specified by the driver name and
+// the data source name, and returns a new client attached to it.
+// Optional parameters can be added for configuring the client.
+func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
+ switch driverName {
+ case dialect.MySQL, dialect.Postgres, dialect.SQLite:
+ drv, err := sql.Open(driverName, dataSourceName)
+ if err != nil {
+ return nil, err
+ }
+ return NewClient(append(options, Driver(drv))...), nil
+ default:
+ return nil, fmt.Errorf("unsupported driver: %q", driverName)
+ }
+}
+
+// ErrTxStarted is returned when trying to start a new transaction from a transactional client.
+var ErrTxStarted = errors.New("db: cannot start a transaction within a transaction")
+
+// Tx returns a new transactional client. The provided context
+// is used until the transaction is committed or rolled back.
+func (c *Client) Tx(ctx context.Context) (*Tx, error) {
+ if _, ok := c.driver.(*txDriver); ok {
+ return nil, ErrTxStarted
+ }
+ tx, err := newTx(ctx, c.driver)
+ if err != nil {
+ return nil, fmt.Errorf("db: starting a transaction: %w", err)
+ }
+ cfg := c.config
+ cfg.driver = tx
+ return &Tx{
+ ctx: ctx,
+ config: cfg,
+ Audit: NewAuditClient(cfg),
+ Team: NewTeamClient(cfg),
+ TeamGroup: NewTeamGroupClient(cfg),
+ TeamGroupMember: NewTeamGroupMemberClient(cfg),
+ TeamMember: NewTeamMemberClient(cfg),
+ User: NewUserClient(cfg),
+ UserIdentity: NewUserIdentityClient(cfg),
+ }, nil
+}
+
+// BeginTx returns a transactional client with specified options.
+func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
+ if _, ok := c.driver.(*txDriver); ok {
+ return nil, errors.New("ent: cannot start a transaction within a transaction")
+ }
+ tx, err := c.driver.(interface {
+ BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
+ }).BeginTx(ctx, opts)
+ if err != nil {
+ return nil, fmt.Errorf("ent: starting a transaction: %w", err)
+ }
+ cfg := c.config
+ cfg.driver = &txDriver{tx: tx, drv: c.driver}
+ return &Tx{
+ ctx: ctx,
+ config: cfg,
+ Audit: NewAuditClient(cfg),
+ Team: NewTeamClient(cfg),
+ TeamGroup: NewTeamGroupClient(cfg),
+ TeamGroupMember: NewTeamGroupMemberClient(cfg),
+ TeamMember: NewTeamMemberClient(cfg),
+ User: NewUserClient(cfg),
+ UserIdentity: NewUserIdentityClient(cfg),
+ }, nil
+}
+
+// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
+//
+// client.Debug().
+// Audit.
+// Query().
+// Count(ctx)
+func (c *Client) Debug() *Client {
+ if c.debug {
+ return c
+ }
+ cfg := c.config
+ cfg.driver = dialect.Debug(c.driver, c.log)
+ client := &Client{config: cfg}
+ client.init()
+ return client
+}
+
+// Close closes the database connection and prevents new queries from starting.
+func (c *Client) Close() error {
+ return c.driver.Close()
+}
+
+// Use adds the mutation hooks to all the entity clients.
+// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
+func (c *Client) Use(hooks ...Hook) {
+ for _, n := range []interface{ Use(...Hook) }{
+ c.Audit, c.Team, c.TeamGroup, c.TeamGroupMember, c.TeamMember, c.User,
+ c.UserIdentity,
+ } {
+ n.Use(hooks...)
+ }
+}
+
+// Intercept adds the query interceptors to all the entity clients.
+// In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
+func (c *Client) Intercept(interceptors ...Interceptor) {
+ for _, n := range []interface{ Intercept(...Interceptor) }{
+ c.Audit, c.Team, c.TeamGroup, c.TeamGroupMember, c.TeamMember, c.User,
+ c.UserIdentity,
+ } {
+ n.Intercept(interceptors...)
+ }
+}
+
+// Mutate implements the ent.Mutator interface.
+func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
+ switch m := m.(type) {
+ case *AuditMutation:
+ return c.Audit.mutate(ctx, m)
+ case *TeamMutation:
+ return c.Team.mutate(ctx, m)
+ case *TeamGroupMutation:
+ return c.TeamGroup.mutate(ctx, m)
+ case *TeamGroupMemberMutation:
+ return c.TeamGroupMember.mutate(ctx, m)
+ case *TeamMemberMutation:
+ return c.TeamMember.mutate(ctx, m)
+ case *UserMutation:
+ return c.User.mutate(ctx, m)
+ case *UserIdentityMutation:
+ return c.UserIdentity.mutate(ctx, m)
+ default:
+ return nil, fmt.Errorf("db: unknown mutation type %T", m)
+ }
+}
+
+// AuditClient is a client for the Audit schema.
+type AuditClient struct {
+ config
+}
+
+// NewAuditClient returns a client for the Audit from the given config.
+func NewAuditClient(c config) *AuditClient {
+ return &AuditClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `audit.Hooks(f(g(h())))`.
+func (c *AuditClient) Use(hooks ...Hook) {
+ c.hooks.Audit = append(c.hooks.Audit, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `audit.Intercept(f(g(h())))`.
+func (c *AuditClient) Intercept(interceptors ...Interceptor) {
+ c.inters.Audit = append(c.inters.Audit, interceptors...)
+}
+
+// Create returns a builder for creating a Audit entity.
+func (c *AuditClient) Create() *AuditCreate {
+ mutation := newAuditMutation(c.config, OpCreate)
+ return &AuditCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Audit entities.
+func (c *AuditClient) CreateBulk(builders ...*AuditCreate) *AuditCreateBulk {
+ return &AuditCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *AuditClient) MapCreateBulk(slice any, setFunc func(*AuditCreate, int)) *AuditCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &AuditCreateBulk{err: fmt.Errorf("calling to AuditClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*AuditCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &AuditCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Audit.
+func (c *AuditClient) Update() *AuditUpdate {
+ mutation := newAuditMutation(c.config, OpUpdate)
+ return &AuditUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *AuditClient) UpdateOne(_m *Audit) *AuditUpdateOne {
+ mutation := newAuditMutation(c.config, OpUpdateOne, withAudit(_m))
+ return &AuditUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *AuditClient) UpdateOneID(id uuid.UUID) *AuditUpdateOne {
+ mutation := newAuditMutation(c.config, OpUpdateOne, withAuditID(id))
+ return &AuditUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Audit.
+func (c *AuditClient) Delete() *AuditDelete {
+ mutation := newAuditMutation(c.config, OpDelete)
+ return &AuditDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *AuditClient) DeleteOne(_m *Audit) *AuditDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *AuditClient) DeleteOneID(id uuid.UUID) *AuditDeleteOne {
+ builder := c.Delete().Where(audit.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &AuditDeleteOne{builder}
+}
+
+// Query returns a query builder for Audit.
+func (c *AuditClient) Query() *AuditQuery {
+ return &AuditQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeAudit},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a Audit entity by its id.
+func (c *AuditClient) Get(ctx context.Context, id uuid.UUID) (*Audit, error) {
+ return c.Query().Where(audit.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *AuditClient) GetX(ctx context.Context, id uuid.UUID) *Audit {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryUser queries the user edge of a Audit.
+func (c *AuditClient) QueryUser(_m *Audit) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(audit.Table, audit.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, audit.UserTable, audit.UserColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *AuditClient) Hooks() []Hook {
+ return c.hooks.Audit
+}
+
+// Interceptors returns the client interceptors.
+func (c *AuditClient) Interceptors() []Interceptor {
+ return c.inters.Audit
+}
+
+func (c *AuditClient) mutate(ctx context.Context, m *AuditMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&AuditCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&AuditUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&AuditUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&AuditDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown Audit mutation op: %q", m.Op())
+ }
+}
+
+// TeamClient is a client for the Team schema.
+type TeamClient struct {
+ config
+}
+
+// NewTeamClient returns a client for the Team from the given config.
+func NewTeamClient(c config) *TeamClient {
+ return &TeamClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `team.Hooks(f(g(h())))`.
+func (c *TeamClient) Use(hooks ...Hook) {
+ c.hooks.Team = append(c.hooks.Team, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `team.Intercept(f(g(h())))`.
+func (c *TeamClient) Intercept(interceptors ...Interceptor) {
+ c.inters.Team = append(c.inters.Team, interceptors...)
+}
+
+// Create returns a builder for creating a Team entity.
+func (c *TeamClient) Create() *TeamCreate {
+ mutation := newTeamMutation(c.config, OpCreate)
+ return &TeamCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Team entities.
+func (c *TeamClient) CreateBulk(builders ...*TeamCreate) *TeamCreateBulk {
+ return &TeamCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *TeamClient) MapCreateBulk(slice any, setFunc func(*TeamCreate, int)) *TeamCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &TeamCreateBulk{err: fmt.Errorf("calling to TeamClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*TeamCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &TeamCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Team.
+func (c *TeamClient) Update() *TeamUpdate {
+ mutation := newTeamMutation(c.config, OpUpdate)
+ return &TeamUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *TeamClient) UpdateOne(_m *Team) *TeamUpdateOne {
+ mutation := newTeamMutation(c.config, OpUpdateOne, withTeam(_m))
+ return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *TeamClient) UpdateOneID(id uuid.UUID) *TeamUpdateOne {
+ mutation := newTeamMutation(c.config, OpUpdateOne, withTeamID(id))
+ return &TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Team.
+func (c *TeamClient) Delete() *TeamDelete {
+ mutation := newTeamMutation(c.config, OpDelete)
+ return &TeamDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *TeamClient) DeleteOne(_m *Team) *TeamDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *TeamClient) DeleteOneID(id uuid.UUID) *TeamDeleteOne {
+ builder := c.Delete().Where(team.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &TeamDeleteOne{builder}
+}
+
+// Query returns a query builder for Team.
+func (c *TeamClient) Query() *TeamQuery {
+ return &TeamQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeTeam},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a Team entity by its id.
+func (c *TeamClient) Get(ctx context.Context, id uuid.UUID) (*Team, error) {
+ return c.Query().Where(team.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *TeamClient) GetX(ctx context.Context, id uuid.UUID) *Team {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryGroups queries the groups edge of a Team.
+func (c *TeamClient) QueryGroups(_m *Team) *TeamGroupQuery {
+ query := (&TeamGroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, id),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, team.GroupsTable, team.GroupsColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryMembers queries the members edge of a Team.
+func (c *TeamClient) QueryMembers(_m *Team) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, team.MembersTable, team.MembersPrimaryKey...),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeamMembers queries the team_members edge of a Team.
+func (c *TeamClient) QueryTeamMembers(_m *Team) *TeamMemberQuery {
+ query := (&TeamMemberClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, id),
+ sqlgraph.To(teammember.Table, teammember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, team.TeamMembersTable, team.TeamMembersColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *TeamClient) Hooks() []Hook {
+ hooks := c.hooks.Team
+ return append(hooks[:len(hooks):len(hooks)], team.Hooks[:]...)
+}
+
+// Interceptors returns the client interceptors.
+func (c *TeamClient) Interceptors() []Interceptor {
+ inters := c.inters.Team
+ return append(inters[:len(inters):len(inters)], team.Interceptors[:]...)
+}
+
+func (c *TeamClient) mutate(ctx context.Context, m *TeamMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&TeamCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&TeamUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&TeamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&TeamDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown Team mutation op: %q", m.Op())
+ }
+}
+
+// TeamGroupClient is a client for the TeamGroup schema.
+type TeamGroupClient struct {
+ config
+}
+
+// NewTeamGroupClient returns a client for the TeamGroup from the given config.
+func NewTeamGroupClient(c config) *TeamGroupClient {
+ return &TeamGroupClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `teamgroup.Hooks(f(g(h())))`.
+func (c *TeamGroupClient) Use(hooks ...Hook) {
+ c.hooks.TeamGroup = append(c.hooks.TeamGroup, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `teamgroup.Intercept(f(g(h())))`.
+func (c *TeamGroupClient) Intercept(interceptors ...Interceptor) {
+ c.inters.TeamGroup = append(c.inters.TeamGroup, interceptors...)
+}
+
+// Create returns a builder for creating a TeamGroup entity.
+func (c *TeamGroupClient) Create() *TeamGroupCreate {
+ mutation := newTeamGroupMutation(c.config, OpCreate)
+ return &TeamGroupCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of TeamGroup entities.
+func (c *TeamGroupClient) CreateBulk(builders ...*TeamGroupCreate) *TeamGroupCreateBulk {
+ return &TeamGroupCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *TeamGroupClient) MapCreateBulk(slice any, setFunc func(*TeamGroupCreate, int)) *TeamGroupCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &TeamGroupCreateBulk{err: fmt.Errorf("calling to TeamGroupClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*TeamGroupCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &TeamGroupCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for TeamGroup.
+func (c *TeamGroupClient) Update() *TeamGroupUpdate {
+ mutation := newTeamGroupMutation(c.config, OpUpdate)
+ return &TeamGroupUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *TeamGroupClient) UpdateOne(_m *TeamGroup) *TeamGroupUpdateOne {
+ mutation := newTeamGroupMutation(c.config, OpUpdateOne, withTeamGroup(_m))
+ return &TeamGroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *TeamGroupClient) UpdateOneID(id uuid.UUID) *TeamGroupUpdateOne {
+ mutation := newTeamGroupMutation(c.config, OpUpdateOne, withTeamGroupID(id))
+ return &TeamGroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for TeamGroup.
+func (c *TeamGroupClient) Delete() *TeamGroupDelete {
+ mutation := newTeamGroupMutation(c.config, OpDelete)
+ return &TeamGroupDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *TeamGroupClient) DeleteOne(_m *TeamGroup) *TeamGroupDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *TeamGroupClient) DeleteOneID(id uuid.UUID) *TeamGroupDeleteOne {
+ builder := c.Delete().Where(teamgroup.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &TeamGroupDeleteOne{builder}
+}
+
+// Query returns a query builder for TeamGroup.
+func (c *TeamGroupClient) Query() *TeamGroupQuery {
+ return &TeamGroupQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeTeamGroup},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a TeamGroup entity by its id.
+func (c *TeamGroupClient) Get(ctx context.Context, id uuid.UUID) (*TeamGroup, error) {
+ return c.Query().Where(teamgroup.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *TeamGroupClient) GetX(ctx context.Context, id uuid.UUID) *TeamGroup {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryMembers queries the members edge of a TeamGroup.
+func (c *TeamGroupClient) QueryMembers(_m *TeamGroup) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, teamgroup.MembersTable, teamgroup.MembersPrimaryKey...),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeam queries the team edge of a TeamGroup.
+func (c *TeamGroupClient) QueryTeam(_m *TeamGroup) *TeamQuery {
+ query := (&TeamClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, id),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, teamgroup.TeamTable, teamgroup.TeamColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeamGroupMembers queries the team_group_members edge of a TeamGroup.
+func (c *TeamGroupClient) QueryTeamGroupMembers(_m *TeamGroup) *TeamGroupMemberQuery {
+ query := (&TeamGroupMemberClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, id),
+ sqlgraph.To(teamgroupmember.Table, teamgroupmember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, teamgroup.TeamGroupMembersTable, teamgroup.TeamGroupMembersColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *TeamGroupClient) Hooks() []Hook {
+ hooks := c.hooks.TeamGroup
+ return append(hooks[:len(hooks):len(hooks)], teamgroup.Hooks[:]...)
+}
+
+// Interceptors returns the client interceptors.
+func (c *TeamGroupClient) Interceptors() []Interceptor {
+ inters := c.inters.TeamGroup
+ return append(inters[:len(inters):len(inters)], teamgroup.Interceptors[:]...)
+}
+
+func (c *TeamGroupClient) mutate(ctx context.Context, m *TeamGroupMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&TeamGroupCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&TeamGroupUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&TeamGroupUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&TeamGroupDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown TeamGroup mutation op: %q", m.Op())
+ }
+}
+
+// TeamGroupMemberClient is a client for the TeamGroupMember schema.
+type TeamGroupMemberClient struct {
+ config
+}
+
+// NewTeamGroupMemberClient returns a client for the TeamGroupMember from the given config.
+func NewTeamGroupMemberClient(c config) *TeamGroupMemberClient {
+ return &TeamGroupMemberClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `teamgroupmember.Hooks(f(g(h())))`.
+func (c *TeamGroupMemberClient) Use(hooks ...Hook) {
+ c.hooks.TeamGroupMember = append(c.hooks.TeamGroupMember, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `teamgroupmember.Intercept(f(g(h())))`.
+func (c *TeamGroupMemberClient) Intercept(interceptors ...Interceptor) {
+ c.inters.TeamGroupMember = append(c.inters.TeamGroupMember, interceptors...)
+}
+
+// Create returns a builder for creating a TeamGroupMember entity.
+func (c *TeamGroupMemberClient) Create() *TeamGroupMemberCreate {
+ mutation := newTeamGroupMemberMutation(c.config, OpCreate)
+ return &TeamGroupMemberCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of TeamGroupMember entities.
+func (c *TeamGroupMemberClient) CreateBulk(builders ...*TeamGroupMemberCreate) *TeamGroupMemberCreateBulk {
+ return &TeamGroupMemberCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *TeamGroupMemberClient) MapCreateBulk(slice any, setFunc func(*TeamGroupMemberCreate, int)) *TeamGroupMemberCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &TeamGroupMemberCreateBulk{err: fmt.Errorf("calling to TeamGroupMemberClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*TeamGroupMemberCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &TeamGroupMemberCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for TeamGroupMember.
+func (c *TeamGroupMemberClient) Update() *TeamGroupMemberUpdate {
+ mutation := newTeamGroupMemberMutation(c.config, OpUpdate)
+ return &TeamGroupMemberUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *TeamGroupMemberClient) UpdateOne(_m *TeamGroupMember) *TeamGroupMemberUpdateOne {
+ mutation := newTeamGroupMemberMutation(c.config, OpUpdateOne, withTeamGroupMember(_m))
+ return &TeamGroupMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *TeamGroupMemberClient) UpdateOneID(id uuid.UUID) *TeamGroupMemberUpdateOne {
+ mutation := newTeamGroupMemberMutation(c.config, OpUpdateOne, withTeamGroupMemberID(id))
+ return &TeamGroupMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for TeamGroupMember.
+func (c *TeamGroupMemberClient) Delete() *TeamGroupMemberDelete {
+ mutation := newTeamGroupMemberMutation(c.config, OpDelete)
+ return &TeamGroupMemberDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *TeamGroupMemberClient) DeleteOne(_m *TeamGroupMember) *TeamGroupMemberDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *TeamGroupMemberClient) DeleteOneID(id uuid.UUID) *TeamGroupMemberDeleteOne {
+ builder := c.Delete().Where(teamgroupmember.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &TeamGroupMemberDeleteOne{builder}
+}
+
+// Query returns a query builder for TeamGroupMember.
+func (c *TeamGroupMemberClient) Query() *TeamGroupMemberQuery {
+ return &TeamGroupMemberQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeTeamGroupMember},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a TeamGroupMember entity by its id.
+func (c *TeamGroupMemberClient) Get(ctx context.Context, id uuid.UUID) (*TeamGroupMember, error) {
+ return c.Query().Where(teamgroupmember.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *TeamGroupMemberClient) GetX(ctx context.Context, id uuid.UUID) *TeamGroupMember {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryGroup queries the group edge of a TeamGroupMember.
+func (c *TeamGroupMemberClient) QueryGroup(_m *TeamGroupMember) *TeamGroupQuery {
+ query := (&TeamGroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroupmember.Table, teamgroupmember.FieldID, id),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmember.GroupTable, teamgroupmember.GroupColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryUser queries the user edge of a TeamGroupMember.
+func (c *TeamGroupMemberClient) QueryUser(_m *TeamGroupMember) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroupmember.Table, teamgroupmember.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmember.UserTable, teamgroupmember.UserColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *TeamGroupMemberClient) Hooks() []Hook {
+ return c.hooks.TeamGroupMember
+}
+
+// Interceptors returns the client interceptors.
+func (c *TeamGroupMemberClient) Interceptors() []Interceptor {
+ return c.inters.TeamGroupMember
+}
+
+func (c *TeamGroupMemberClient) mutate(ctx context.Context, m *TeamGroupMemberMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&TeamGroupMemberCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&TeamGroupMemberUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&TeamGroupMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&TeamGroupMemberDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown TeamGroupMember mutation op: %q", m.Op())
+ }
+}
+
+// TeamMemberClient is a client for the TeamMember schema.
+type TeamMemberClient struct {
+ config
+}
+
+// NewTeamMemberClient returns a client for the TeamMember from the given config.
+func NewTeamMemberClient(c config) *TeamMemberClient {
+ return &TeamMemberClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `teammember.Hooks(f(g(h())))`.
+func (c *TeamMemberClient) Use(hooks ...Hook) {
+ c.hooks.TeamMember = append(c.hooks.TeamMember, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `teammember.Intercept(f(g(h())))`.
+func (c *TeamMemberClient) Intercept(interceptors ...Interceptor) {
+ c.inters.TeamMember = append(c.inters.TeamMember, interceptors...)
+}
+
+// Create returns a builder for creating a TeamMember entity.
+func (c *TeamMemberClient) Create() *TeamMemberCreate {
+ mutation := newTeamMemberMutation(c.config, OpCreate)
+ return &TeamMemberCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of TeamMember entities.
+func (c *TeamMemberClient) CreateBulk(builders ...*TeamMemberCreate) *TeamMemberCreateBulk {
+ return &TeamMemberCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *TeamMemberClient) MapCreateBulk(slice any, setFunc func(*TeamMemberCreate, int)) *TeamMemberCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &TeamMemberCreateBulk{err: fmt.Errorf("calling to TeamMemberClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*TeamMemberCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &TeamMemberCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for TeamMember.
+func (c *TeamMemberClient) Update() *TeamMemberUpdate {
+ mutation := newTeamMemberMutation(c.config, OpUpdate)
+ return &TeamMemberUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *TeamMemberClient) UpdateOne(_m *TeamMember) *TeamMemberUpdateOne {
+ mutation := newTeamMemberMutation(c.config, OpUpdateOne, withTeamMember(_m))
+ return &TeamMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *TeamMemberClient) UpdateOneID(id uuid.UUID) *TeamMemberUpdateOne {
+ mutation := newTeamMemberMutation(c.config, OpUpdateOne, withTeamMemberID(id))
+ return &TeamMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for TeamMember.
+func (c *TeamMemberClient) Delete() *TeamMemberDelete {
+ mutation := newTeamMemberMutation(c.config, OpDelete)
+ return &TeamMemberDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *TeamMemberClient) DeleteOne(_m *TeamMember) *TeamMemberDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *TeamMemberClient) DeleteOneID(id uuid.UUID) *TeamMemberDeleteOne {
+ builder := c.Delete().Where(teammember.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &TeamMemberDeleteOne{builder}
+}
+
+// Query returns a query builder for TeamMember.
+func (c *TeamMemberClient) Query() *TeamMemberQuery {
+ return &TeamMemberQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeTeamMember},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a TeamMember entity by its id.
+func (c *TeamMemberClient) Get(ctx context.Context, id uuid.UUID) (*TeamMember, error) {
+ return c.Query().Where(teammember.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *TeamMemberClient) GetX(ctx context.Context, id uuid.UUID) *TeamMember {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryTeam queries the team edge of a TeamMember.
+func (c *TeamMemberClient) QueryTeam(_m *TeamMember) *TeamQuery {
+ query := (&TeamClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teammember.Table, teammember.FieldID, id),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teammember.TeamTable, teammember.TeamColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryUser queries the user edge of a TeamMember.
+func (c *TeamMemberClient) QueryUser(_m *TeamMember) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teammember.Table, teammember.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teammember.UserTable, teammember.UserColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *TeamMemberClient) Hooks() []Hook {
+ return c.hooks.TeamMember
+}
+
+// Interceptors returns the client interceptors.
+func (c *TeamMemberClient) Interceptors() []Interceptor {
+ return c.inters.TeamMember
+}
+
+func (c *TeamMemberClient) mutate(ctx context.Context, m *TeamMemberMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&TeamMemberCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&TeamMemberUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&TeamMemberUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&TeamMemberDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown TeamMember mutation op: %q", m.Op())
+ }
+}
+
+// UserClient is a client for the User schema.
+type UserClient struct {
+ config
+}
+
+// NewUserClient returns a client for the User from the given config.
+func NewUserClient(c config) *UserClient {
+ return &UserClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `user.Hooks(f(g(h())))`.
+func (c *UserClient) Use(hooks ...Hook) {
+ c.hooks.User = append(c.hooks.User, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `user.Intercept(f(g(h())))`.
+func (c *UserClient) Intercept(interceptors ...Interceptor) {
+ c.inters.User = append(c.inters.User, interceptors...)
+}
+
+// Create returns a builder for creating a User entity.
+func (c *UserClient) Create() *UserCreate {
+ mutation := newUserMutation(c.config, OpCreate)
+ return &UserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of User entities.
+func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk {
+ return &UserCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*UserCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &UserCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for User.
+func (c *UserClient) Update() *UserUpdate {
+ mutation := newUserMutation(c.config, OpUpdate)
+ return &UserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserClient) UpdateOne(_m *User) *UserUpdateOne {
+ mutation := newUserMutation(c.config, OpUpdateOne, withUser(_m))
+ return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserClient) UpdateOneID(id uuid.UUID) *UserUpdateOne {
+ mutation := newUserMutation(c.config, OpUpdateOne, withUserID(id))
+ return &UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for User.
+func (c *UserClient) Delete() *UserDelete {
+ mutation := newUserMutation(c.config, OpDelete)
+ return &UserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserClient) DeleteOne(_m *User) *UserDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserClient) DeleteOneID(id uuid.UUID) *UserDeleteOne {
+ builder := c.Delete().Where(user.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &UserDeleteOne{builder}
+}
+
+// Query returns a query builder for User.
+func (c *UserClient) Query() *UserQuery {
+ return &UserQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeUser},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a User entity by its id.
+func (c *UserClient) Get(ctx context.Context, id uuid.UUID) (*User, error) {
+ return c.Query().Where(user.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserClient) GetX(ctx context.Context, id uuid.UUID) *User {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryIdentities queries the identities edge of a User.
+func (c *UserClient) QueryIdentities(_m *User) *UserIdentityQuery {
+ query := (&UserIdentityClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(useridentity.Table, useridentity.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, user.IdentitiesTable, user.IdentitiesColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryAudits queries the audits edge of a User.
+func (c *UserClient) QueryAudits(_m *User) *AuditQuery {
+ query := (&AuditClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(audit.Table, audit.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, user.AuditsTable, user.AuditsColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeams queries the teams edge of a User.
+func (c *UserClient) QueryTeams(_m *User) *TeamQuery {
+ query := (&TeamClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, user.TeamsTable, user.TeamsPrimaryKey...),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryGroups queries the groups edge of a User.
+func (c *UserClient) QueryGroups(_m *User) *TeamGroupQuery {
+ query := (&TeamGroupClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, user.GroupsTable, user.GroupsPrimaryKey...),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeamMembers queries the team_members edge of a User.
+func (c *UserClient) QueryTeamMembers(_m *User) *TeamMemberQuery {
+ query := (&TeamMemberClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(teammember.Table, teammember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, user.TeamMembersTable, user.TeamMembersColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// QueryTeamGroupMembers queries the team_group_members edge of a User.
+func (c *UserClient) QueryTeamGroupMembers(_m *User) *TeamGroupMemberQuery {
+ query := (&TeamGroupMemberClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, id),
+ sqlgraph.To(teamgroupmember.Table, teamgroupmember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, user.TeamGroupMembersTable, user.TeamGroupMembersColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserClient) Hooks() []Hook {
+ hooks := c.hooks.User
+ return append(hooks[:len(hooks):len(hooks)], user.Hooks[:]...)
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserClient) Interceptors() []Interceptor {
+ inters := c.inters.User
+ return append(inters[:len(inters):len(inters)], user.Interceptors[:]...)
+}
+
+func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&UserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&UserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&UserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&UserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown User mutation op: %q", m.Op())
+ }
+}
+
+// UserIdentityClient is a client for the UserIdentity schema.
+type UserIdentityClient struct {
+ config
+}
+
+// NewUserIdentityClient returns a client for the UserIdentity from the given config.
+func NewUserIdentityClient(c config) *UserIdentityClient {
+ return &UserIdentityClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `useridentity.Hooks(f(g(h())))`.
+func (c *UserIdentityClient) Use(hooks ...Hook) {
+ c.hooks.UserIdentity = append(c.hooks.UserIdentity, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `useridentity.Intercept(f(g(h())))`.
+func (c *UserIdentityClient) Intercept(interceptors ...Interceptor) {
+ c.inters.UserIdentity = append(c.inters.UserIdentity, interceptors...)
+}
+
+// Create returns a builder for creating a UserIdentity entity.
+func (c *UserIdentityClient) Create() *UserIdentityCreate {
+ mutation := newUserIdentityMutation(c.config, OpCreate)
+ return &UserIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of UserIdentity entities.
+func (c *UserIdentityClient) CreateBulk(builders ...*UserIdentityCreate) *UserIdentityCreateBulk {
+ return &UserIdentityCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *UserIdentityClient) MapCreateBulk(slice any, setFunc func(*UserIdentityCreate, int)) *UserIdentityCreateBulk {
+ rv := reflect.ValueOf(slice)
+ if rv.Kind() != reflect.Slice {
+ return &UserIdentityCreateBulk{err: fmt.Errorf("calling to UserIdentityClient.MapCreateBulk with wrong type %T, need slice", slice)}
+ }
+ builders := make([]*UserIdentityCreate, rv.Len())
+ for i := 0; i < rv.Len(); i++ {
+ builders[i] = c.Create()
+ setFunc(builders[i], i)
+ }
+ return &UserIdentityCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for UserIdentity.
+func (c *UserIdentityClient) Update() *UserIdentityUpdate {
+ mutation := newUserIdentityMutation(c.config, OpUpdate)
+ return &UserIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *UserIdentityClient) UpdateOne(_m *UserIdentity) *UserIdentityUpdateOne {
+ mutation := newUserIdentityMutation(c.config, OpUpdateOne, withUserIdentity(_m))
+ return &UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *UserIdentityClient) UpdateOneID(id uuid.UUID) *UserIdentityUpdateOne {
+ mutation := newUserIdentityMutation(c.config, OpUpdateOne, withUserIdentityID(id))
+ return &UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for UserIdentity.
+func (c *UserIdentityClient) Delete() *UserIdentityDelete {
+ mutation := newUserIdentityMutation(c.config, OpDelete)
+ return &UserIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *UserIdentityClient) DeleteOne(_m *UserIdentity) *UserIdentityDeleteOne {
+ return c.DeleteOneID(_m.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *UserIdentityClient) DeleteOneID(id uuid.UUID) *UserIdentityDeleteOne {
+ builder := c.Delete().Where(useridentity.ID(id))
+ builder.mutation.id = &id
+ builder.mutation.op = OpDeleteOne
+ return &UserIdentityDeleteOne{builder}
+}
+
+// Query returns a query builder for UserIdentity.
+func (c *UserIdentityClient) Query() *UserIdentityQuery {
+ return &UserIdentityQuery{
+ config: c.config,
+ ctx: &QueryContext{Type: TypeUserIdentity},
+ inters: c.Interceptors(),
+ }
+}
+
+// Get returns a UserIdentity entity by its id.
+func (c *UserIdentityClient) Get(ctx context.Context, id uuid.UUID) (*UserIdentity, error) {
+ return c.Query().Where(useridentity.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *UserIdentityClient) GetX(ctx context.Context, id uuid.UUID) *UserIdentity {
+ obj, err := c.Get(ctx, id)
+ if err != nil {
+ panic(err)
+ }
+ return obj
+}
+
+// QueryUser queries the user edge of a UserIdentity.
+func (c *UserIdentityClient) QueryUser(_m *UserIdentity) *UserQuery {
+ query := (&UserClient{config: c.config}).Query()
+ query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+ id := _m.ID
+ step := sqlgraph.NewStep(
+ sqlgraph.From(useridentity.Table, useridentity.FieldID, id),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, useridentity.UserTable, useridentity.UserColumn),
+ )
+ fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
+ return fromV, nil
+ }
+ return query
+}
+
+// Hooks returns the client hooks.
+func (c *UserIdentityClient) Hooks() []Hook {
+ hooks := c.hooks.UserIdentity
+ return append(hooks[:len(hooks):len(hooks)], useridentity.Hooks[:]...)
+}
+
+// Interceptors returns the client interceptors.
+func (c *UserIdentityClient) Interceptors() []Interceptor {
+ inters := c.inters.UserIdentity
+ return append(inters[:len(inters):len(inters)], useridentity.Interceptors[:]...)
+}
+
+func (c *UserIdentityClient) mutate(ctx context.Context, m *UserIdentityMutation) (Value, error) {
+ switch m.Op() {
+ case OpCreate:
+ return (&UserIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdate:
+ return (&UserIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpUpdateOne:
+ return (&UserIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+ case OpDelete, OpDeleteOne:
+ return (&UserIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+ default:
+ return nil, fmt.Errorf("db: unknown UserIdentity mutation op: %q", m.Op())
+ }
+}
+
+// hooks and interceptors per client, for fast access.
+type (
+ hooks struct {
+ Audit, Team, TeamGroup, TeamGroupMember, TeamMember, User,
+ UserIdentity []ent.Hook
+ }
+ inters struct {
+ Audit, Team, TeamGroup, TeamGroupMember, TeamMember, User,
+ UserIdentity []ent.Interceptor
+ }
+)
+
+// ExecContext allows calling the underlying ExecContext method of the driver if it is supported by it.
+// See, database/sql#DB.ExecContext for more information.
+func (c *config) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) {
+ ex, ok := c.driver.(interface {
+ ExecContext(context.Context, string, ...any) (stdsql.Result, error)
+ })
+ if !ok {
+ return nil, fmt.Errorf("Driver.ExecContext is not supported")
+ }
+ return ex.ExecContext(ctx, query, args...)
+}
+
+// QueryContext allows calling the underlying QueryContext method of the driver if it is supported by it.
+// See, database/sql#DB.QueryContext for more information.
+func (c *config) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) {
+ q, ok := c.driver.(interface {
+ QueryContext(context.Context, string, ...any) (*stdsql.Rows, error)
+ })
+ if !ok {
+ return nil, fmt.Errorf("Driver.QueryContext is not supported")
+ }
+ return q.QueryContext(ctx, query, args...)
+}
diff --git a/backend/db/cursor.go b/backend/db/cursor.go
new file mode 100644
index 00000000..7de8abd4
--- /dev/null
+++ b/backend/db/cursor.go
@@ -0,0 +1,247 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+// Extra imports required by this file.
+import (
+ "context"
+ "encoding/base64"
+ "fmt"
+ "strconv"
+ "strings"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/google/uuid"
+)
+
+type Cursor struct {
+ Cursor string `json:"cursor,omitempty"` // 游标
+ HasNextPage bool `json:"has_next_page"` // 是否有下一页
+}
+
+type createdAtCursor struct {
+ ID any `json:"id"`
+ CreatedAt time.Time `json:"created_at"`
+}
+
+func (i *createdAtCursor) marshal() (string, error) {
+ if i == nil {
+ return "", nil
+ }
+
+ milli := i.CreatedAt.UnixMilli()
+ b36 := strconv.FormatInt(milli, 36)
+
+ switch ii := i.ID.(type) {
+ case string:
+ return fmt.Sprintf("s.%s.%s", b36, ii), nil
+
+ case uuid.UUID:
+ bb, err := ii.MarshalBinary()
+ if err != nil {
+ return "", err
+ }
+ is := base64.RawURLEncoding.EncodeToString(bb)
+ return fmt.Sprintf("u.%s.%s", b36, is), nil
+ default:
+ return "", fmt.Errorf("unsupported ID type")
+ }
+}
+
+func unmarshalCreatedAt(s string) (*createdAtCursor, error) {
+ if s == "" {
+ return nil, nil
+ }
+ parts := strings.Split(s, ".")
+ if len(parts) != 3 {
+ return nil, fmt.Errorf("invalid cursor format")
+ }
+ milli, err := strconv.ParseInt(parts[1], 36, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parts[0] {
+ case "s":
+ return &createdAtCursor{
+ CreatedAt: time.UnixMilli(milli),
+ ID: parts[2],
+ }, nil
+
+ case "u":
+ id, err := base64.RawURLEncoding.DecodeString(parts[2])
+ if err != nil {
+ return nil, err
+ }
+ uuid, err := uuid.FromBytes(id)
+ if err != nil {
+ return nil, err
+ }
+ return &createdAtCursor{
+ CreatedAt: time.UnixMilli(milli),
+ ID: uuid,
+ }, nil
+ default:
+ return nil, fmt.Errorf("invalid cursor prefix")
+ }
+}
+
+type updateAtCursor struct {
+ ID any `json:"id"`
+ UpdatedAt time.Time `json:"updated_at"`
+}
+
+func (i *updateAtCursor) marshal() (string, error) {
+ if i == nil {
+ return "", nil
+ }
+
+ milli := i.UpdatedAt.UnixMilli()
+ b36 := strconv.FormatInt(milli, 36)
+
+ switch ii := i.ID.(type) {
+ case string:
+ return fmt.Sprintf("s.%s.%s", b36, ii), nil
+
+ case uuid.UUID:
+ bb, err := ii.MarshalBinary()
+ if err != nil {
+ return "", err
+ }
+ is := base64.RawURLEncoding.EncodeToString(bb)
+ return fmt.Sprintf("u.%s.%s", b36, is), nil
+ default:
+ return "", fmt.Errorf("unsupported ID type")
+ }
+}
+
+func unmarshalUpdatedAt(s string) (*updateAtCursor, error) {
+ if s == "" {
+ return nil, nil
+ }
+ parts := strings.Split(s, ".")
+ if len(parts) != 3 {
+ return nil, fmt.Errorf("invalid cursor format")
+ }
+ milli, err := strconv.ParseInt(parts[1], 36, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parts[0] {
+ case "s":
+ return &updateAtCursor{
+ UpdatedAt: time.UnixMilli(milli),
+ ID: parts[2],
+ }, nil
+
+ case "u":
+ id, err := base64.RawURLEncoding.DecodeString(parts[2])
+ if err != nil {
+ return nil, err
+ }
+ uuid, err := uuid.FromBytes(id)
+ if err != nil {
+ return nil, err
+ }
+ return &updateAtCursor{
+ UpdatedAt: time.UnixMilli(milli),
+ ID: uuid,
+ }, nil
+ default:
+ return nil, fmt.Errorf("invalid cursor prefix")
+ }
+}
+
+func (q *AuditQuery) After(ctx context.Context, cursor string, limit int) ([]*Audit, *Cursor, error) {
+ i, err := unmarshalCreatedAt(cursor)
+ if err != nil {
+ return nil, nil, err
+ }
+ q.Order(audit.ByCreatedAt(sql.OrderDesc()), audit.ByID(sql.OrderDesc()))
+ q.Limit(limit + 1)
+
+ if i != nil {
+ q.Where(func(s *sql.Selector) {
+ s.Where(sql.Or(
+ sql.LT(s.C("created_at"), i.CreatedAt),
+ sql.And(
+ sql.EQ(s.C("created_at"), i.CreatedAt),
+ sql.LT(s.C("id"), i.ID),
+ ),
+ ))
+ })
+ }
+ nodes, err := q.All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ res := &Cursor{}
+ if len(nodes) > limit {
+ res.HasNextPage = true
+ nodes = nodes[:limit]
+ }
+
+ if len(nodes) > 0 {
+ last := nodes[len(nodes)-1]
+ i := &createdAtCursor{
+ CreatedAt: last.CreatedAt,
+ ID: last.ID,
+ }
+ cursor, err := i.marshal()
+ if err != nil {
+ return nil, nil, err
+ }
+ res.Cursor = cursor
+ }
+ return nodes, res, nil
+}
+
+func (q *TeamGroupQuery) After(ctx context.Context, cursor string, limit int) ([]*TeamGroup, *Cursor, error) {
+ i, err := unmarshalCreatedAt(cursor)
+ if err != nil {
+ return nil, nil, err
+ }
+ q.Order(teamgroup.ByCreatedAt(sql.OrderDesc()), teamgroup.ByID(sql.OrderDesc()))
+ q.Limit(limit + 1)
+
+ if i != nil {
+ q.Where(func(s *sql.Selector) {
+ s.Where(sql.Or(
+ sql.LT(s.C("created_at"), i.CreatedAt),
+ sql.And(
+ sql.EQ(s.C("created_at"), i.CreatedAt),
+ sql.LT(s.C("id"), i.ID),
+ ),
+ ))
+ })
+ }
+ nodes, err := q.All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ res := &Cursor{}
+ if len(nodes) > limit {
+ res.HasNextPage = true
+ nodes = nodes[:limit]
+ }
+
+ if len(nodes) > 0 {
+ last := nodes[len(nodes)-1]
+ i := &createdAtCursor{
+ CreatedAt: last.CreatedAt,
+ ID: last.ID,
+ }
+ cursor, err := i.marshal()
+ if err != nil {
+ return nil, nil, err
+ }
+ res.Cursor = cursor
+ }
+ return nodes, res, nil
+}
diff --git a/backend/db/ent.go b/backend/db/ent.go
new file mode 100644
index 00000000..6045653a
--- /dev/null
+++ b/backend/db/ent.go
@@ -0,0 +1,620 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "reflect"
+ "sync"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+)
+
+// ent aliases to avoid import conflicts in user's code.
+type (
+ Op = ent.Op
+ Hook = ent.Hook
+ Value = ent.Value
+ Query = ent.Query
+ QueryContext = ent.QueryContext
+ Querier = ent.Querier
+ QuerierFunc = ent.QuerierFunc
+ Interceptor = ent.Interceptor
+ InterceptFunc = ent.InterceptFunc
+ Traverser = ent.Traverser
+ TraverseFunc = ent.TraverseFunc
+ Policy = ent.Policy
+ Mutator = ent.Mutator
+ Mutation = ent.Mutation
+ MutateFunc = ent.MutateFunc
+)
+
+type clientCtxKey struct{}
+
+// FromContext returns a Client stored inside a context, or nil if there isn't one.
+func FromContext(ctx context.Context) *Client {
+ c, _ := ctx.Value(clientCtxKey{}).(*Client)
+ return c
+}
+
+// NewContext returns a new context with the given Client attached.
+func NewContext(parent context.Context, c *Client) context.Context {
+ return context.WithValue(parent, clientCtxKey{}, c)
+}
+
+type txCtxKey struct{}
+
+// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
+func TxFromContext(ctx context.Context) *Tx {
+ tx, _ := ctx.Value(txCtxKey{}).(*Tx)
+ return tx
+}
+
+// NewTxContext returns a new context with the given Tx attached.
+func NewTxContext(parent context.Context, tx *Tx) context.Context {
+ return context.WithValue(parent, txCtxKey{}, tx)
+}
+
+// OrderFunc applies an ordering on the sql selector.
+// Deprecated: Use Asc/Desc functions or the package builders instead.
+type OrderFunc func(*sql.Selector)
+
+var (
+ initCheck sync.Once
+ columnCheck sql.ColumnCheck
+)
+
+// checkColumn checks if the column exists in the given table.
+func checkColumn(t, c string) error {
+ initCheck.Do(func() {
+ columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
+ audit.Table: audit.ValidColumn,
+ team.Table: team.ValidColumn,
+ teamgroup.Table: teamgroup.ValidColumn,
+ teamgroupmember.Table: teamgroupmember.ValidColumn,
+ teammember.Table: teammember.ValidColumn,
+ user.Table: user.ValidColumn,
+ useridentity.Table: useridentity.ValidColumn,
+ })
+ })
+ return columnCheck(t, c)
+}
+
+// Asc applies the given fields in ASC order.
+func Asc(fields ...string) func(*sql.Selector) {
+ return func(s *sql.Selector) {
+ for _, f := range fields {
+ if err := checkColumn(s.TableName(), f); err != nil {
+ s.AddError(&ValidationError{Name: f, err: fmt.Errorf("db: %w", err)})
+ }
+ s.OrderBy(sql.Asc(s.C(f)))
+ }
+ }
+}
+
+// Desc applies the given fields in DESC order.
+func Desc(fields ...string) func(*sql.Selector) {
+ return func(s *sql.Selector) {
+ for _, f := range fields {
+ if err := checkColumn(s.TableName(), f); err != nil {
+ s.AddError(&ValidationError{Name: f, err: fmt.Errorf("db: %w", err)})
+ }
+ s.OrderBy(sql.Desc(s.C(f)))
+ }
+ }
+}
+
+// AggregateFunc applies an aggregation step on the group-by traversal/selector.
+type AggregateFunc func(*sql.Selector) string
+
+// As is a pseudo aggregation function for renaming another other functions with custom names. For example:
+//
+// GroupBy(field1, field2).
+// Aggregate(db.As(db.Sum(field1), "sum_field1"), (db.As(db.Sum(field2), "sum_field2")).
+// Scan(ctx, &v)
+func As(fn AggregateFunc, end string) AggregateFunc {
+ return func(s *sql.Selector) string {
+ return sql.As(fn(s), end)
+ }
+}
+
+// Count applies the "count" aggregation function on each group.
+func Count() AggregateFunc {
+ return func(s *sql.Selector) string {
+ return sql.Count("*")
+ }
+}
+
+// Max applies the "max" aggregation function on the given field of each group.
+func Max(field string) AggregateFunc {
+ return func(s *sql.Selector) string {
+ if err := checkColumn(s.TableName(), field); err != nil {
+ s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+ return ""
+ }
+ return sql.Max(s.C(field))
+ }
+}
+
+// Mean applies the "mean" aggregation function on the given field of each group.
+func Mean(field string) AggregateFunc {
+ return func(s *sql.Selector) string {
+ if err := checkColumn(s.TableName(), field); err != nil {
+ s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+ return ""
+ }
+ return sql.Avg(s.C(field))
+ }
+}
+
+// Min applies the "min" aggregation function on the given field of each group.
+func Min(field string) AggregateFunc {
+ return func(s *sql.Selector) string {
+ if err := checkColumn(s.TableName(), field); err != nil {
+ s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+ return ""
+ }
+ return sql.Min(s.C(field))
+ }
+}
+
+// Sum applies the "sum" aggregation function on the given field of each group.
+func Sum(field string) AggregateFunc {
+ return func(s *sql.Selector) string {
+ if err := checkColumn(s.TableName(), field); err != nil {
+ s.AddError(&ValidationError{Name: field, err: fmt.Errorf("db: %w", err)})
+ return ""
+ }
+ return sql.Sum(s.C(field))
+ }
+}
+
+// ValidationError returns when validating a field or edge fails.
+type ValidationError struct {
+ Name string // Field or edge name.
+ err error
+}
+
+// Error implements the error interface.
+func (e *ValidationError) Error() string {
+ return e.err.Error()
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ValidationError) Unwrap() error {
+ return e.err
+}
+
+// IsValidationError returns a boolean indicating whether the error is a validation error.
+func IsValidationError(err error) bool {
+ if err == nil {
+ return false
+ }
+ var e *ValidationError
+ return errors.As(err, &e)
+}
+
+// NotFoundError returns when trying to fetch a specific entity and it was not found in the database.
+type NotFoundError struct {
+ label string
+}
+
+// Error implements the error interface.
+func (e *NotFoundError) Error() string {
+ return "db: " + e.label + " not found"
+}
+
+// IsNotFound returns a boolean indicating whether the error is a not found error.
+func IsNotFound(err error) bool {
+ if err == nil {
+ return false
+ }
+ var e *NotFoundError
+ return errors.As(err, &e)
+}
+
+// MaskNotFound masks not found error.
+func MaskNotFound(err error) error {
+ if IsNotFound(err) {
+ return nil
+ }
+ return err
+}
+
+// NotSingularError returns when trying to fetch a singular entity and more then one was found in the database.
+type NotSingularError struct {
+ label string
+}
+
+// Error implements the error interface.
+func (e *NotSingularError) Error() string {
+ return "db: " + e.label + " not singular"
+}
+
+// IsNotSingular returns a boolean indicating whether the error is a not singular error.
+func IsNotSingular(err error) bool {
+ if err == nil {
+ return false
+ }
+ var e *NotSingularError
+ return errors.As(err, &e)
+}
+
+// NotLoadedError returns when trying to get a node that was not loaded by the query.
+type NotLoadedError struct {
+ edge string
+}
+
+// Error implements the error interface.
+func (e *NotLoadedError) Error() string {
+ return "db: " + e.edge + " edge was not loaded"
+}
+
+// IsNotLoaded returns a boolean indicating whether the error is a not loaded error.
+func IsNotLoaded(err error) bool {
+ if err == nil {
+ return false
+ }
+ var e *NotLoadedError
+ return errors.As(err, &e)
+}
+
+// ConstraintError returns when trying to create/update one or more entities and
+// one or more of their constraints failed. For example, violation of edge or
+// field uniqueness.
+type ConstraintError struct {
+ msg string
+ wrap error
+}
+
+// Error implements the error interface.
+func (e ConstraintError) Error() string {
+ return "db: constraint failed: " + e.msg
+}
+
+// Unwrap implements the errors.Wrapper interface.
+func (e *ConstraintError) Unwrap() error {
+ return e.wrap
+}
+
+// IsConstraintError returns a boolean indicating whether the error is a constraint failure.
+func IsConstraintError(err error) bool {
+ if err == nil {
+ return false
+ }
+ var e *ConstraintError
+ return errors.As(err, &e)
+}
+
+// selector embedded by the different Select/GroupBy builders.
+type selector struct {
+ label string
+ flds *[]string
+ fns []AggregateFunc
+ scan func(context.Context, any) error
+}
+
+// ScanX is like Scan, but panics if an error occurs.
+func (s *selector) ScanX(ctx context.Context, v any) {
+ if err := s.scan(ctx, v); err != nil {
+ panic(err)
+ }
+}
+
+// Strings returns list of strings from a selector. It is only allowed when selecting one field.
+func (s *selector) Strings(ctx context.Context) ([]string, error) {
+ if len(*s.flds) > 1 {
+ return nil, errors.New("db: Strings is not achievable when selecting more than 1 field")
+ }
+ var v []string
+ if err := s.scan(ctx, &v); err != nil {
+ return nil, err
+ }
+ return v, nil
+}
+
+// StringsX is like Strings, but panics if an error occurs.
+func (s *selector) StringsX(ctx context.Context) []string {
+ v, err := s.Strings(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// String returns a single string from a selector. It is only allowed when selecting one field.
+func (s *selector) String(ctx context.Context) (_ string, err error) {
+ var v []string
+ if v, err = s.Strings(ctx); err != nil {
+ return
+ }
+ switch len(v) {
+ case 1:
+ return v[0], nil
+ case 0:
+ err = &NotFoundError{s.label}
+ default:
+ err = fmt.Errorf("db: Strings returned %d results when one was expected", len(v))
+ }
+ return
+}
+
+// StringX is like String, but panics if an error occurs.
+func (s *selector) StringX(ctx context.Context) string {
+ v, err := s.String(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Ints returns list of ints from a selector. It is only allowed when selecting one field.
+func (s *selector) Ints(ctx context.Context) ([]int, error) {
+ if len(*s.flds) > 1 {
+ return nil, errors.New("db: Ints is not achievable when selecting more than 1 field")
+ }
+ var v []int
+ if err := s.scan(ctx, &v); err != nil {
+ return nil, err
+ }
+ return v, nil
+}
+
+// IntsX is like Ints, but panics if an error occurs.
+func (s *selector) IntsX(ctx context.Context) []int {
+ v, err := s.Ints(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Int returns a single int from a selector. It is only allowed when selecting one field.
+func (s *selector) Int(ctx context.Context) (_ int, err error) {
+ var v []int
+ if v, err = s.Ints(ctx); err != nil {
+ return
+ }
+ switch len(v) {
+ case 1:
+ return v[0], nil
+ case 0:
+ err = &NotFoundError{s.label}
+ default:
+ err = fmt.Errorf("db: Ints returned %d results when one was expected", len(v))
+ }
+ return
+}
+
+// IntX is like Int, but panics if an error occurs.
+func (s *selector) IntX(ctx context.Context) int {
+ v, err := s.Int(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64s(ctx context.Context) ([]float64, error) {
+ if len(*s.flds) > 1 {
+ return nil, errors.New("db: Float64s is not achievable when selecting more than 1 field")
+ }
+ var v []float64
+ if err := s.scan(ctx, &v); err != nil {
+ return nil, err
+ }
+ return v, nil
+}
+
+// Float64sX is like Float64s, but panics if an error occurs.
+func (s *selector) Float64sX(ctx context.Context) []float64 {
+ v, err := s.Float64s(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
+func (s *selector) Float64(ctx context.Context) (_ float64, err error) {
+ var v []float64
+ if v, err = s.Float64s(ctx); err != nil {
+ return
+ }
+ switch len(v) {
+ case 1:
+ return v[0], nil
+ case 0:
+ err = &NotFoundError{s.label}
+ default:
+ err = fmt.Errorf("db: Float64s returned %d results when one was expected", len(v))
+ }
+ return
+}
+
+// Float64X is like Float64, but panics if an error occurs.
+func (s *selector) Float64X(ctx context.Context) float64 {
+ v, err := s.Float64(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Bools returns list of bools from a selector. It is only allowed when selecting one field.
+func (s *selector) Bools(ctx context.Context) ([]bool, error) {
+ if len(*s.flds) > 1 {
+ return nil, errors.New("db: Bools is not achievable when selecting more than 1 field")
+ }
+ var v []bool
+ if err := s.scan(ctx, &v); err != nil {
+ return nil, err
+ }
+ return v, nil
+}
+
+// BoolsX is like Bools, but panics if an error occurs.
+func (s *selector) BoolsX(ctx context.Context) []bool {
+ v, err := s.Bools(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Bool returns a single bool from a selector. It is only allowed when selecting one field.
+func (s *selector) Bool(ctx context.Context) (_ bool, err error) {
+ var v []bool
+ if v, err = s.Bools(ctx); err != nil {
+ return
+ }
+ switch len(v) {
+ case 1:
+ return v[0], nil
+ case 0:
+ err = &NotFoundError{s.label}
+ default:
+ err = fmt.Errorf("db: Bools returned %d results when one was expected", len(v))
+ }
+ return
+}
+
+// BoolX is like Bool, but panics if an error occurs.
+func (s *selector) BoolX(ctx context.Context) bool {
+ v, err := s.Bool(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// withHooks invokes the builder operation with the given hooks, if any.
+func withHooks[V Value, M any, PM interface {
+ *M
+ Mutation
+}](ctx context.Context, exec func(context.Context) (V, error), mutation PM, hooks []Hook) (value V, err error) {
+ if len(hooks) == 0 {
+ return exec(ctx)
+ }
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutationT, ok := any(m).(PM)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ // Set the mutation to the builder.
+ *mutation = *mutationT
+ return exec(ctx)
+ })
+ for i := len(hooks) - 1; i >= 0; i-- {
+ if hooks[i] == nil {
+ return value, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
+ }
+ mut = hooks[i](mut)
+ }
+ v, err := mut.Mutate(ctx, mutation)
+ if err != nil {
+ return value, err
+ }
+ nv, ok := v.(V)
+ if !ok {
+ return value, fmt.Errorf("unexpected node type %T returned from %T", v, mutation)
+ }
+ return nv, nil
+}
+
+// setContextOp returns a new context with the given QueryContext attached (including its op) in case it does not exist.
+func setContextOp(ctx context.Context, qc *QueryContext, op string) context.Context {
+ if ent.QueryFromContext(ctx) == nil {
+ qc.Op = op
+ ctx = ent.NewQueryContext(ctx, qc)
+ }
+ return ctx
+}
+
+func querierAll[V Value, Q interface {
+ sqlAll(context.Context, ...queryHook) (V, error)
+}]() Querier {
+ return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ query, ok := q.(Q)
+ if !ok {
+ return nil, fmt.Errorf("unexpected query type %T", q)
+ }
+ return query.sqlAll(ctx)
+ })
+}
+
+func querierCount[Q interface {
+ sqlCount(context.Context) (int, error)
+}]() Querier {
+ return QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ query, ok := q.(Q)
+ if !ok {
+ return nil, fmt.Errorf("unexpected query type %T", q)
+ }
+ return query.sqlCount(ctx)
+ })
+}
+
+func withInterceptors[V Value](ctx context.Context, q Query, qr Querier, inters []Interceptor) (v V, err error) {
+ for i := len(inters) - 1; i >= 0; i-- {
+ qr = inters[i].Intercept(qr)
+ }
+ rv, err := qr.Query(ctx, q)
+ if err != nil {
+ return v, err
+ }
+ vt, ok := rv.(V)
+ if !ok {
+ return v, fmt.Errorf("unexpected type %T returned from %T. expected type: %T", vt, q, v)
+ }
+ return vt, nil
+}
+
+func scanWithInterceptors[Q1 ent.Query, Q2 interface {
+ sqlScan(context.Context, Q1, any) error
+}](ctx context.Context, rootQuery Q1, selectOrGroup Q2, inters []Interceptor, v any) error {
+ rv := reflect.ValueOf(v)
+ var qr Querier = QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ query, ok := q.(Q1)
+ if !ok {
+ return nil, fmt.Errorf("unexpected query type %T", q)
+ }
+ if err := selectOrGroup.sqlScan(ctx, query, v); err != nil {
+ return nil, err
+ }
+ if k := rv.Kind(); k == reflect.Pointer && rv.Elem().CanInterface() {
+ return rv.Elem().Interface(), nil
+ }
+ return v, nil
+ })
+ for i := len(inters) - 1; i >= 0; i-- {
+ qr = inters[i].Intercept(qr)
+ }
+ vv, err := qr.Query(ctx, rootQuery)
+ if err != nil {
+ return err
+ }
+ switch rv2 := reflect.ValueOf(vv); {
+ case rv.IsNil(), rv2.IsNil(), rv.Kind() != reflect.Pointer:
+ case rv.Type() == rv2.Type():
+ rv.Elem().Set(rv2.Elem())
+ case rv.Elem().Type() == rv2.Type():
+ rv.Elem().Set(rv2)
+ }
+ return nil
+}
+
+// queryHook describes an internal hook for the different sqlAll methods.
+type queryHook func(context.Context, *sqlgraph.QuerySpec)
diff --git a/backend/db/enttest/enttest.go b/backend/db/enttest/enttest.go
new file mode 100644
index 00000000..de0e36a4
--- /dev/null
+++ b/backend/db/enttest/enttest.go
@@ -0,0 +1,84 @@
+// Code generated by ent, DO NOT EDIT.
+
+package enttest
+
+import (
+ "context"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+ // required by schema hooks.
+ _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+
+ "entgo.io/ent/dialect/sql/schema"
+ "github.com/chaitin/MonkeyCode/backend/db/migrate"
+)
+
+type (
+ // TestingT is the interface that is shared between
+ // testing.T and testing.B and used by enttest.
+ TestingT interface {
+ FailNow()
+ Error(...any)
+ }
+
+ // Option configures client creation.
+ Option func(*options)
+
+ options struct {
+ opts []db.Option
+ migrateOpts []schema.MigrateOption
+ }
+)
+
+// WithOptions forwards options to client creation.
+func WithOptions(opts ...db.Option) Option {
+ return func(o *options) {
+ o.opts = append(o.opts, opts...)
+ }
+}
+
+// WithMigrateOptions forwards options to auto migration.
+func WithMigrateOptions(opts ...schema.MigrateOption) Option {
+ return func(o *options) {
+ o.migrateOpts = append(o.migrateOpts, opts...)
+ }
+}
+
+func newOptions(opts []Option) *options {
+ o := &options{}
+ for _, opt := range opts {
+ opt(o)
+ }
+ return o
+}
+
+// Open calls db.Open and auto-run migration.
+func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *db.Client {
+ o := newOptions(opts)
+ c, err := db.Open(driverName, dataSourceName, o.opts...)
+ if err != nil {
+ t.Error(err)
+ t.FailNow()
+ }
+ migrateSchema(t, c, o)
+ return c
+}
+
+// NewClient calls db.NewClient and auto-run migration.
+func NewClient(t TestingT, opts ...Option) *db.Client {
+ o := newOptions(opts)
+ c := db.NewClient(o.opts...)
+ migrateSchema(t, c, o)
+ return c
+}
+func migrateSchema(t TestingT, c *db.Client, o *options) {
+ tables, err := schema.CopyTables(migrate.Tables)
+ if err != nil {
+ t.Error(err)
+ t.FailNow()
+ }
+ if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
+ t.Error(err)
+ t.FailNow()
+ }
+}
diff --git a/backend/db/hook/hook.go b/backend/db/hook/hook.go
new file mode 100644
index 00000000..7c360c43
--- /dev/null
+++ b/backend/db/hook/hook.go
@@ -0,0 +1,271 @@
+// Code generated by ent, DO NOT EDIT.
+
+package hook
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+)
+
+// The AuditFunc type is an adapter to allow the use of ordinary
+// function as Audit mutator.
+type AuditFunc func(context.Context, *db.AuditMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AuditFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.AuditMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.AuditMutation", m)
+}
+
+// The TeamFunc type is an adapter to allow the use of ordinary
+// function as Team mutator.
+type TeamFunc func(context.Context, *db.TeamMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f TeamFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.TeamMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.TeamMutation", m)
+}
+
+// The TeamGroupFunc type is an adapter to allow the use of ordinary
+// function as TeamGroup mutator.
+type TeamGroupFunc func(context.Context, *db.TeamGroupMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f TeamGroupFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.TeamGroupMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.TeamGroupMutation", m)
+}
+
+// The TeamGroupMemberFunc type is an adapter to allow the use of ordinary
+// function as TeamGroupMember mutator.
+type TeamGroupMemberFunc func(context.Context, *db.TeamGroupMemberMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f TeamGroupMemberFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.TeamGroupMemberMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.TeamGroupMemberMutation", m)
+}
+
+// The TeamMemberFunc type is an adapter to allow the use of ordinary
+// function as TeamMember mutator.
+type TeamMemberFunc func(context.Context, *db.TeamMemberMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f TeamMemberFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.TeamMemberMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.TeamMemberMutation", m)
+}
+
+// The UserFunc type is an adapter to allow the use of ordinary
+// function as User mutator.
+type UserFunc func(context.Context, *db.UserMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.UserMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserMutation", m)
+}
+
+// The UserIdentityFunc type is an adapter to allow the use of ordinary
+// function as UserIdentity mutator.
+type UserIdentityFunc func(context.Context, *db.UserIdentityMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserIdentityFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if mv, ok := m.(*db.UserIdentityMutation); ok {
+ return f(ctx, mv)
+ }
+ return nil, fmt.Errorf("unexpected mutation type %T. expect *db.UserIdentityMutation", m)
+}
+
+// Condition is a hook condition function.
+type Condition func(context.Context, db.Mutation) bool
+
+// And groups conditions with the AND operator.
+func And(first, second Condition, rest ...Condition) Condition {
+ return func(ctx context.Context, m db.Mutation) bool {
+ if !first(ctx, m) || !second(ctx, m) {
+ return false
+ }
+ for _, cond := range rest {
+ if !cond(ctx, m) {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+// Or groups conditions with the OR operator.
+func Or(first, second Condition, rest ...Condition) Condition {
+ return func(ctx context.Context, m db.Mutation) bool {
+ if first(ctx, m) || second(ctx, m) {
+ return true
+ }
+ for _, cond := range rest {
+ if cond(ctx, m) {
+ return true
+ }
+ }
+ return false
+ }
+}
+
+// Not negates a given condition.
+func Not(cond Condition) Condition {
+ return func(ctx context.Context, m db.Mutation) bool {
+ return !cond(ctx, m)
+ }
+}
+
+// HasOp is a condition testing mutation operation.
+func HasOp(op db.Op) Condition {
+ return func(_ context.Context, m db.Mutation) bool {
+ return m.Op().Is(op)
+ }
+}
+
+// HasAddedFields is a condition validating `.AddedField` on fields.
+func HasAddedFields(field string, fields ...string) Condition {
+ return func(_ context.Context, m db.Mutation) bool {
+ if _, exists := m.AddedField(field); !exists {
+ return false
+ }
+ for _, field := range fields {
+ if _, exists := m.AddedField(field); !exists {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+// HasClearedFields is a condition validating `.FieldCleared` on fields.
+func HasClearedFields(field string, fields ...string) Condition {
+ return func(_ context.Context, m db.Mutation) bool {
+ if exists := m.FieldCleared(field); !exists {
+ return false
+ }
+ for _, field := range fields {
+ if exists := m.FieldCleared(field); !exists {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+// HasFields is a condition validating `.Field` on fields.
+func HasFields(field string, fields ...string) Condition {
+ return func(_ context.Context, m db.Mutation) bool {
+ if _, exists := m.Field(field); !exists {
+ return false
+ }
+ for _, field := range fields {
+ if _, exists := m.Field(field); !exists {
+ return false
+ }
+ }
+ return true
+ }
+}
+
+// If executes the given hook under condition.
+//
+// hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
+func If(hk db.Hook, cond Condition) db.Hook {
+ return func(next db.Mutator) db.Mutator {
+ return db.MutateFunc(func(ctx context.Context, m db.Mutation) (db.Value, error) {
+ if cond(ctx, m) {
+ return hk(next).Mutate(ctx, m)
+ }
+ return next.Mutate(ctx, m)
+ })
+ }
+}
+
+// On executes the given hook only for the given operation.
+//
+// hook.On(Log, db.Delete|db.Create)
+func On(hk db.Hook, op db.Op) db.Hook {
+ return If(hk, HasOp(op))
+}
+
+// Unless skips the given hook only for the given operation.
+//
+// hook.Unless(Log, db.Update|db.UpdateOne)
+func Unless(hk db.Hook, op db.Op) db.Hook {
+ return If(hk, Not(HasOp(op)))
+}
+
+// FixedError is a hook returning a fixed error.
+func FixedError(err error) db.Hook {
+ return func(db.Mutator) db.Mutator {
+ return db.MutateFunc(func(context.Context, db.Mutation) (db.Value, error) {
+ return nil, err
+ })
+ }
+}
+
+// Reject returns a hook that rejects all operations that match op.
+//
+// func (T) Hooks() []db.Hook {
+// return []db.Hook{
+// Reject(db.Delete|db.Update),
+// }
+// }
+func Reject(op db.Op) db.Hook {
+ hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
+ return On(hk, op)
+}
+
+// Chain acts as a list of hooks and is effectively immutable.
+// Once created, it will always hold the same set of hooks in the same order.
+type Chain struct {
+ hooks []db.Hook
+}
+
+// NewChain creates a new chain of hooks.
+func NewChain(hooks ...db.Hook) Chain {
+ return Chain{append([]db.Hook(nil), hooks...)}
+}
+
+// Hook chains the list of hooks and returns the final hook.
+func (c Chain) Hook() db.Hook {
+ return func(mutator db.Mutator) db.Mutator {
+ for i := len(c.hooks) - 1; i >= 0; i-- {
+ mutator = c.hooks[i](mutator)
+ }
+ return mutator
+ }
+}
+
+// Append extends a chain, adding the specified hook
+// as the last ones in the mutation flow.
+func (c Chain) Append(hooks ...db.Hook) Chain {
+ newHooks := make([]db.Hook, 0, len(c.hooks)+len(hooks))
+ newHooks = append(newHooks, c.hooks...)
+ newHooks = append(newHooks, hooks...)
+ return Chain{newHooks}
+}
+
+// Extend extends a chain, adding the specified chain
+// as the last ones in the mutation flow.
+func (c Chain) Extend(chain Chain) Chain {
+ return c.Append(chain.hooks...)
+}
diff --git a/backend/db/intercept/intercept.go b/backend/db/intercept/intercept.go
new file mode 100644
index 00000000..a9ec22a9
--- /dev/null
+++ b/backend/db/intercept/intercept.go
@@ -0,0 +1,329 @@
+// Code generated by ent, DO NOT EDIT.
+
+package intercept
+
+import (
+ "context"
+ "fmt"
+
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+)
+
+// The Query interface represents an operation that queries a graph.
+// By using this interface, users can write generic code that manipulates
+// query builders of different types.
+type Query interface {
+ // Type returns the string representation of the query type.
+ Type() string
+ // Limit the number of records to be returned by this query.
+ Limit(int)
+ // Offset to start from.
+ Offset(int)
+ // Unique configures the query builder to filter duplicate records.
+ Unique(bool)
+ // Order specifies how the records should be ordered.
+ Order(...func(*sql.Selector))
+ // WhereP appends storage-level predicates to the query builder. Using this method, users
+ // can use type-assertion to append predicates that do not depend on any generated package.
+ WhereP(...func(*sql.Selector))
+}
+
+// The Func type is an adapter that allows ordinary functions to be used as interceptors.
+// Unlike traversal functions, interceptors are skipped during graph traversals. Note that the
+// implementation of Func is different from the one defined in entgo.io/ent.InterceptFunc.
+type Func func(context.Context, Query) error
+
+// Intercept calls f(ctx, q) and then applied the next Querier.
+func (f Func) Intercept(next db.Querier) db.Querier {
+ return db.QuerierFunc(func(ctx context.Context, q db.Query) (db.Value, error) {
+ query, err := NewQuery(q)
+ if err != nil {
+ return nil, err
+ }
+ if err := f(ctx, query); err != nil {
+ return nil, err
+ }
+ return next.Query(ctx, q)
+ })
+}
+
+// The TraverseFunc type is an adapter to allow the use of ordinary function as Traverser.
+// If f is a function with the appropriate signature, TraverseFunc(f) is a Traverser that calls f.
+type TraverseFunc func(context.Context, Query) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseFunc) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseFunc) Traverse(ctx context.Context, q db.Query) error {
+ query, err := NewQuery(q)
+ if err != nil {
+ return err
+ }
+ return f(ctx, query)
+}
+
+// The AuditFunc type is an adapter to allow the use of ordinary function as a Querier.
+type AuditFunc func(context.Context, *db.AuditQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f AuditFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.AuditQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.AuditQuery", q)
+}
+
+// The TraverseAudit type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseAudit func(context.Context, *db.AuditQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseAudit) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseAudit) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.AuditQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.AuditQuery", q)
+}
+
+// The TeamFunc type is an adapter to allow the use of ordinary function as a Querier.
+type TeamFunc func(context.Context, *db.TeamQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f TeamFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.TeamQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.TeamQuery", q)
+}
+
+// The TraverseTeam type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseTeam func(context.Context, *db.TeamQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseTeam) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseTeam) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.TeamQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.TeamQuery", q)
+}
+
+// The TeamGroupFunc type is an adapter to allow the use of ordinary function as a Querier.
+type TeamGroupFunc func(context.Context, *db.TeamGroupQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f TeamGroupFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.TeamGroupQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.TeamGroupQuery", q)
+}
+
+// The TraverseTeamGroup type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseTeamGroup func(context.Context, *db.TeamGroupQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseTeamGroup) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseTeamGroup) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.TeamGroupQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.TeamGroupQuery", q)
+}
+
+// The TeamGroupMemberFunc type is an adapter to allow the use of ordinary function as a Querier.
+type TeamGroupMemberFunc func(context.Context, *db.TeamGroupMemberQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f TeamGroupMemberFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.TeamGroupMemberQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.TeamGroupMemberQuery", q)
+}
+
+// The TraverseTeamGroupMember type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseTeamGroupMember func(context.Context, *db.TeamGroupMemberQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseTeamGroupMember) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseTeamGroupMember) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.TeamGroupMemberQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.TeamGroupMemberQuery", q)
+}
+
+// The TeamMemberFunc type is an adapter to allow the use of ordinary function as a Querier.
+type TeamMemberFunc func(context.Context, *db.TeamMemberQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f TeamMemberFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.TeamMemberQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.TeamMemberQuery", q)
+}
+
+// The TraverseTeamMember type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseTeamMember func(context.Context, *db.TeamMemberQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseTeamMember) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseTeamMember) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.TeamMemberQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.TeamMemberQuery", q)
+}
+
+// The UserFunc type is an adapter to allow the use of ordinary function as a Querier.
+type UserFunc func(context.Context, *db.UserQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f UserFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.UserQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.UserQuery", q)
+}
+
+// The TraverseUser type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseUser func(context.Context, *db.UserQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseUser) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseUser) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.UserQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.UserQuery", q)
+}
+
+// The UserIdentityFunc type is an adapter to allow the use of ordinary function as a Querier.
+type UserIdentityFunc func(context.Context, *db.UserIdentityQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f UserIdentityFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+ if q, ok := q.(*db.UserIdentityQuery); ok {
+ return f(ctx, q)
+ }
+ return nil, fmt.Errorf("unexpected query type %T. expect *db.UserIdentityQuery", q)
+}
+
+// The TraverseUserIdentity type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseUserIdentity func(context.Context, *db.UserIdentityQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseUserIdentity) Intercept(next db.Querier) db.Querier {
+ return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseUserIdentity) Traverse(ctx context.Context, q db.Query) error {
+ if q, ok := q.(*db.UserIdentityQuery); ok {
+ return f(ctx, q)
+ }
+ return fmt.Errorf("unexpected query type %T. expect *db.UserIdentityQuery", q)
+}
+
+// NewQuery returns the generic Query interface for the given typed query.
+func NewQuery(q db.Query) (Query, error) {
+ switch q := q.(type) {
+ case *db.AuditQuery:
+ return &query[*db.AuditQuery, predicate.Audit, audit.OrderOption]{typ: db.TypeAudit, tq: q}, nil
+ case *db.TeamQuery:
+ return &query[*db.TeamQuery, predicate.Team, team.OrderOption]{typ: db.TypeTeam, tq: q}, nil
+ case *db.TeamGroupQuery:
+ return &query[*db.TeamGroupQuery, predicate.TeamGroup, teamgroup.OrderOption]{typ: db.TypeTeamGroup, tq: q}, nil
+ case *db.TeamGroupMemberQuery:
+ return &query[*db.TeamGroupMemberQuery, predicate.TeamGroupMember, teamgroupmember.OrderOption]{typ: db.TypeTeamGroupMember, tq: q}, nil
+ case *db.TeamMemberQuery:
+ return &query[*db.TeamMemberQuery, predicate.TeamMember, teammember.OrderOption]{typ: db.TypeTeamMember, tq: q}, nil
+ case *db.UserQuery:
+ return &query[*db.UserQuery, predicate.User, user.OrderOption]{typ: db.TypeUser, tq: q}, nil
+ case *db.UserIdentityQuery:
+ return &query[*db.UserIdentityQuery, predicate.UserIdentity, useridentity.OrderOption]{typ: db.TypeUserIdentity, tq: q}, nil
+ default:
+ return nil, fmt.Errorf("unknown query type %T", q)
+ }
+}
+
+type query[T any, P ~func(*sql.Selector), R ~func(*sql.Selector)] struct {
+ typ string
+ tq interface {
+ Limit(int) T
+ Offset(int) T
+ Unique(bool) T
+ Order(...R) T
+ Where(...P) T
+ }
+}
+
+func (q query[T, P, R]) Type() string {
+ return q.typ
+}
+
+func (q query[T, P, R]) Limit(limit int) {
+ q.tq.Limit(limit)
+}
+
+func (q query[T, P, R]) Offset(offset int) {
+ q.tq.Offset(offset)
+}
+
+func (q query[T, P, R]) Unique(unique bool) {
+ q.tq.Unique(unique)
+}
+
+func (q query[T, P, R]) Order(orders ...func(*sql.Selector)) {
+ rs := make([]R, len(orders))
+ for i := range orders {
+ rs[i] = orders[i]
+ }
+ q.tq.Order(rs...)
+}
+
+func (q query[T, P, R]) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]P, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ q.tq.Where(p...)
+}
diff --git a/backend/db/migrate/migrate.go b/backend/db/migrate/migrate.go
new file mode 100644
index 00000000..1956a6bf
--- /dev/null
+++ b/backend/db/migrate/migrate.go
@@ -0,0 +1,64 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+ "context"
+ "fmt"
+ "io"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql/schema"
+)
+
+var (
+ // WithGlobalUniqueID sets the universal ids options to the migration.
+ // If this option is enabled, ent migration will allocate a 1<<32 range
+ // for the ids of each entity (table).
+ // Note that this option cannot be applied on tables that already exist.
+ WithGlobalUniqueID = schema.WithGlobalUniqueID
+ // WithDropColumn sets the drop column option to the migration.
+ // If this option is enabled, ent migration will drop old columns
+ // that were used for both fields and edges. This defaults to false.
+ WithDropColumn = schema.WithDropColumn
+ // WithDropIndex sets the drop index option to the migration.
+ // If this option is enabled, ent migration will drop old indexes
+ // that were defined in the schema. This defaults to false.
+ // Note that unique constraints are defined using `UNIQUE INDEX`,
+ // and therefore, it's recommended to enable this option to get more
+ // flexibility in the schema changes.
+ WithDropIndex = schema.WithDropIndex
+ // WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
+ WithForeignKeys = schema.WithForeignKeys
+)
+
+// Schema is the API for creating, migrating and dropping a schema.
+type Schema struct {
+ drv dialect.Driver
+}
+
+// NewSchema creates a new schema client.
+func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
+
+// Create creates all schema resources.
+func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
+ return Create(ctx, s, Tables, opts...)
+}
+
+// Create creates all table resources using the given schema driver.
+func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
+ migrate, err := schema.NewMigrate(s.drv, opts...)
+ if err != nil {
+ return fmt.Errorf("ent/migrate: %w", err)
+ }
+ return migrate.Create(ctx, tables...)
+}
+
+// WriteTo writes the schema changes to w instead of running them against the database.
+//
+// if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
+// log.Fatal(err)
+// }
+func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
+ return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
+}
diff --git a/backend/db/migrate/schema.go b/backend/db/migrate/schema.go
new file mode 100644
index 00000000..0bf2ba11
--- /dev/null
+++ b/backend/db/migrate/schema.go
@@ -0,0 +1,233 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/dialect/sql/schema"
+ "entgo.io/ent/schema/field"
+)
+
+var (
+ // AuditsColumns holds the columns for the "audits" table.
+ AuditsColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID},
+ {Name: "operation", Type: field.TypeString},
+ {Name: "source_ip", Type: field.TypeString},
+ {Name: "user_agent", Type: field.TypeString},
+ {Name: "request", Type: field.TypeString},
+ {Name: "response", Type: field.TypeString, Nullable: true},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "user_id", Type: field.TypeUUID},
+ }
+ // AuditsTable holds the schema information for the "audits" table.
+ AuditsTable = &schema.Table{
+ Name: "audits",
+ Columns: AuditsColumns,
+ PrimaryKey: []*schema.Column{AuditsColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "audits_users_audits",
+ Columns: []*schema.Column{AuditsColumns[7]},
+ RefColumns: []*schema.Column{UsersColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ },
+ }
+ // TeamsColumns holds the columns for the "teams" table.
+ TeamsColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "deleted_at", Type: field.TypeTime, Nullable: true},
+ {Name: "name", Type: field.TypeString},
+ {Name: "member_limit", Type: field.TypeInt},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "updated_at", Type: field.TypeTime},
+ }
+ // TeamsTable holds the schema information for the "teams" table.
+ TeamsTable = &schema.Table{
+ Name: "teams",
+ Columns: TeamsColumns,
+ PrimaryKey: []*schema.Column{TeamsColumns[0]},
+ }
+ // TeamGroupsColumns holds the columns for the "team_groups" table.
+ TeamGroupsColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "deleted_at", Type: field.TypeTime, Nullable: true},
+ {Name: "name", Type: field.TypeString},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "updated_at", Type: field.TypeTime},
+ {Name: "team_id", Type: field.TypeUUID},
+ }
+ // TeamGroupsTable holds the schema information for the "team_groups" table.
+ TeamGroupsTable = &schema.Table{
+ Name: "team_groups",
+ Columns: TeamGroupsColumns,
+ PrimaryKey: []*schema.Column{TeamGroupsColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "team_groups_teams_groups",
+ Columns: []*schema.Column{TeamGroupsColumns[5]},
+ RefColumns: []*schema.Column{TeamsColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ },
+ }
+ // TeamGroupMembersColumns holds the columns for the "team_group_members" table.
+ TeamGroupMembersColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "group_id", Type: field.TypeUUID},
+ {Name: "user_id", Type: field.TypeUUID},
+ }
+ // TeamGroupMembersTable holds the schema information for the "team_group_members" table.
+ TeamGroupMembersTable = &schema.Table{
+ Name: "team_group_members",
+ Columns: TeamGroupMembersColumns,
+ PrimaryKey: []*schema.Column{TeamGroupMembersColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "team_group_members_team_groups_group",
+ Columns: []*schema.Column{TeamGroupMembersColumns[2]},
+ RefColumns: []*schema.Column{TeamGroupsColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ {
+ Symbol: "team_group_members_users_user",
+ Columns: []*schema.Column{TeamGroupMembersColumns[3]},
+ RefColumns: []*schema.Column{UsersColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ },
+ Indexes: []*schema.Index{
+ {
+ Name: "teamgroupmember_user_id_group_id",
+ Unique: true,
+ Columns: []*schema.Column{TeamGroupMembersColumns[3], TeamGroupMembersColumns[2]},
+ },
+ },
+ }
+ // TeamMembersColumns holds the columns for the "team_members" table.
+ TeamMembersColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "role", Type: field.TypeString},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "team_id", Type: field.TypeUUID},
+ {Name: "user_id", Type: field.TypeUUID},
+ }
+ // TeamMembersTable holds the schema information for the "team_members" table.
+ TeamMembersTable = &schema.Table{
+ Name: "team_members",
+ Columns: TeamMembersColumns,
+ PrimaryKey: []*schema.Column{TeamMembersColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "team_members_teams_team",
+ Columns: []*schema.Column{TeamMembersColumns[3]},
+ RefColumns: []*schema.Column{TeamsColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ {
+ Symbol: "team_members_users_user",
+ Columns: []*schema.Column{TeamMembersColumns[4]},
+ RefColumns: []*schema.Column{UsersColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ },
+ Indexes: []*schema.Index{
+ {
+ Name: "teammember_user_id_team_id",
+ Unique: true,
+ Columns: []*schema.Column{TeamMembersColumns[4], TeamMembersColumns[3]},
+ },
+ },
+ }
+ // UsersColumns holds the columns for the "users" table.
+ UsersColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "deleted_at", Type: field.TypeTime, Nullable: true},
+ {Name: "name", Type: field.TypeString},
+ {Name: "email", Type: field.TypeString, Nullable: true},
+ {Name: "avatar_url", Type: field.TypeString, Nullable: true},
+ {Name: "password", Type: field.TypeString, Nullable: true},
+ {Name: "role", Type: field.TypeString},
+ {Name: "status", Type: field.TypeString},
+ {Name: "is_blocked", Type: field.TypeBool, Default: false},
+ {Name: "default_configs", Type: field.TypeJSON, Nullable: true},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "updated_at", Type: field.TypeTime},
+ }
+ // UsersTable holds the schema information for the "users" table.
+ UsersTable = &schema.Table{
+ Name: "users",
+ Columns: UsersColumns,
+ PrimaryKey: []*schema.Column{UsersColumns[0]},
+ }
+ // UserIdentitiesColumns holds the columns for the "user_identities" table.
+ UserIdentitiesColumns = []*schema.Column{
+ {Name: "id", Type: field.TypeUUID, Unique: true},
+ {Name: "deleted_at", Type: field.TypeTime, Nullable: true},
+ {Name: "platform", Type: field.TypeString},
+ {Name: "identity_id", Type: field.TypeString},
+ {Name: "username", Type: field.TypeString},
+ {Name: "email", Type: field.TypeString, Nullable: true},
+ {Name: "avatar_url", Type: field.TypeString, Nullable: true},
+ {Name: "created_at", Type: field.TypeTime},
+ {Name: "updated_at", Type: field.TypeTime, Nullable: true},
+ {Name: "user_id", Type: field.TypeUUID},
+ }
+ // UserIdentitiesTable holds the schema information for the "user_identities" table.
+ UserIdentitiesTable = &schema.Table{
+ Name: "user_identities",
+ Columns: UserIdentitiesColumns,
+ PrimaryKey: []*schema.Column{UserIdentitiesColumns[0]},
+ ForeignKeys: []*schema.ForeignKey{
+ {
+ Symbol: "user_identities_users_identities",
+ Columns: []*schema.Column{UserIdentitiesColumns[9]},
+ RefColumns: []*schema.Column{UsersColumns[0]},
+ OnDelete: schema.NoAction,
+ },
+ },
+ }
+ // Tables holds all the tables in the schema.
+ Tables = []*schema.Table{
+ AuditsTable,
+ TeamsTable,
+ TeamGroupsTable,
+ TeamGroupMembersTable,
+ TeamMembersTable,
+ UsersTable,
+ UserIdentitiesTable,
+ }
+)
+
+func init() {
+ AuditsTable.ForeignKeys[0].RefTable = UsersTable
+ AuditsTable.Annotation = &entsql.Annotation{
+ Table: "audits",
+ }
+ TeamsTable.Annotation = &entsql.Annotation{
+ Table: "teams",
+ }
+ TeamGroupsTable.ForeignKeys[0].RefTable = TeamsTable
+ TeamGroupsTable.Annotation = &entsql.Annotation{
+ Table: "team_groups",
+ }
+ TeamGroupMembersTable.ForeignKeys[0].RefTable = TeamGroupsTable
+ TeamGroupMembersTable.ForeignKeys[1].RefTable = UsersTable
+ TeamGroupMembersTable.Annotation = &entsql.Annotation{
+ Table: "team_group_members",
+ }
+ TeamMembersTable.ForeignKeys[0].RefTable = TeamsTable
+ TeamMembersTable.ForeignKeys[1].RefTable = UsersTable
+ TeamMembersTable.Annotation = &entsql.Annotation{
+ Table: "team_members",
+ }
+ UsersTable.Annotation = &entsql.Annotation{
+ Table: "users",
+ }
+ UserIdentitiesTable.ForeignKeys[0].RefTable = UsersTable
+ UserIdentitiesTable.Annotation = &entsql.Annotation{
+ Table: "user_identities",
+ }
+}
diff --git a/backend/db/mutation.go b/backend/db/mutation.go
new file mode 100644
index 00000000..1e225b01
--- /dev/null
+++ b/backend/db/mutation.go
@@ -0,0 +1,5940 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "sync"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+const (
+ // Operation types.
+ OpCreate = ent.OpCreate
+ OpDelete = ent.OpDelete
+ OpDeleteOne = ent.OpDeleteOne
+ OpUpdate = ent.OpUpdate
+ OpUpdateOne = ent.OpUpdateOne
+
+ // Node types.
+ TypeAudit = "Audit"
+ TypeTeam = "Team"
+ TypeTeamGroup = "TeamGroup"
+ TypeTeamGroupMember = "TeamGroupMember"
+ TypeTeamMember = "TeamMember"
+ TypeUser = "User"
+ TypeUserIdentity = "UserIdentity"
+)
+
+// AuditMutation represents an operation that mutates the Audit nodes in the graph.
+type AuditMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ operation *string
+ source_ip *string
+ user_agent *string
+ request *string
+ response *string
+ created_at *time.Time
+ clearedFields map[string]struct{}
+ user *uuid.UUID
+ cleareduser bool
+ done bool
+ oldValue func(context.Context) (*Audit, error)
+ predicates []predicate.Audit
+}
+
+var _ ent.Mutation = (*AuditMutation)(nil)
+
+// auditOption allows management of the mutation configuration using functional options.
+type auditOption func(*AuditMutation)
+
+// newAuditMutation creates new mutation for the Audit entity.
+func newAuditMutation(c config, op Op, opts ...auditOption) *AuditMutation {
+ m := &AuditMutation{
+ config: c,
+ op: op,
+ typ: TypeAudit,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withAuditID sets the ID field of the mutation.
+func withAuditID(id uuid.UUID) auditOption {
+ return func(m *AuditMutation) {
+ var (
+ err error
+ once sync.Once
+ value *Audit
+ )
+ m.oldValue = func(ctx context.Context) (*Audit, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().Audit.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withAudit sets the old Audit of the mutation.
+func withAudit(node *Audit) auditOption {
+ return func(m *AuditMutation) {
+ m.oldValue = func(context.Context) (*Audit, 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 AuditMutation) 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 AuditMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 Audit entities.
+func (m *AuditMutation) 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 *AuditMutation) 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 *AuditMutation) 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().Audit.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetUserID sets the "user_id" field.
+func (m *AuditMutation) SetUserID(u uuid.UUID) {
+ m.user = &u
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *AuditMutation) UserID() (r uuid.UUID, exists bool) {
+ v := m.user
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+ }
+ return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *AuditMutation) ResetUserID() {
+ m.user = nil
+}
+
+// SetOperation sets the "operation" field.
+func (m *AuditMutation) SetOperation(s string) {
+ m.operation = &s
+}
+
+// Operation returns the value of the "operation" field in the mutation.
+func (m *AuditMutation) Operation() (r string, exists bool) {
+ v := m.operation
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldOperation returns the old "operation" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldOperation(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldOperation is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldOperation requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldOperation: %w", err)
+ }
+ return oldValue.Operation, nil
+}
+
+// ResetOperation resets all changes to the "operation" field.
+func (m *AuditMutation) ResetOperation() {
+ m.operation = nil
+}
+
+// SetSourceIP sets the "source_ip" field.
+func (m *AuditMutation) SetSourceIP(s string) {
+ m.source_ip = &s
+}
+
+// SourceIP returns the value of the "source_ip" field in the mutation.
+func (m *AuditMutation) SourceIP() (r string, exists bool) {
+ v := m.source_ip
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldSourceIP returns the old "source_ip" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldSourceIP(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldSourceIP is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldSourceIP requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldSourceIP: %w", err)
+ }
+ return oldValue.SourceIP, nil
+}
+
+// ResetSourceIP resets all changes to the "source_ip" field.
+func (m *AuditMutation) ResetSourceIP() {
+ m.source_ip = nil
+}
+
+// SetUserAgent sets the "user_agent" field.
+func (m *AuditMutation) SetUserAgent(s string) {
+ m.user_agent = &s
+}
+
+// UserAgent returns the value of the "user_agent" field in the mutation.
+func (m *AuditMutation) UserAgent() (r string, exists bool) {
+ v := m.user_agent
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserAgent returns the old "user_agent" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldUserAgent(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserAgent is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserAgent requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserAgent: %w", err)
+ }
+ return oldValue.UserAgent, nil
+}
+
+// ResetUserAgent resets all changes to the "user_agent" field.
+func (m *AuditMutation) ResetUserAgent() {
+ m.user_agent = nil
+}
+
+// SetRequest sets the "request" field.
+func (m *AuditMutation) SetRequest(s string) {
+ m.request = &s
+}
+
+// Request returns the value of the "request" field in the mutation.
+func (m *AuditMutation) Request() (r string, exists bool) {
+ v := m.request
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldRequest returns the old "request" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldRequest(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldRequest is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldRequest requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldRequest: %w", err)
+ }
+ return oldValue.Request, nil
+}
+
+// ResetRequest resets all changes to the "request" field.
+func (m *AuditMutation) ResetRequest() {
+ m.request = nil
+}
+
+// SetResponse sets the "response" field.
+func (m *AuditMutation) SetResponse(s string) {
+ m.response = &s
+}
+
+// Response returns the value of the "response" field in the mutation.
+func (m *AuditMutation) Response() (r string, exists bool) {
+ v := m.response
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldResponse returns the old "response" field's value of the Audit entity.
+// If the Audit 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 *AuditMutation) OldResponse(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldResponse is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldResponse requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldResponse: %w", err)
+ }
+ return oldValue.Response, nil
+}
+
+// ClearResponse clears the value of the "response" field.
+func (m *AuditMutation) ClearResponse() {
+ m.response = nil
+ m.clearedFields[audit.FieldResponse] = struct{}{}
+}
+
+// ResponseCleared returns if the "response" field was cleared in this mutation.
+func (m *AuditMutation) ResponseCleared() bool {
+ _, ok := m.clearedFields[audit.FieldResponse]
+ return ok
+}
+
+// ResetResponse resets all changes to the "response" field.
+func (m *AuditMutation) ResetResponse() {
+ m.response = nil
+ delete(m.clearedFields, audit.FieldResponse)
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *AuditMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *AuditMutation) 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 Audit entity.
+// If the Audit 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 *AuditMutation) 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 *AuditMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *AuditMutation) ClearUser() {
+ m.cleareduser = true
+ m.clearedFields[audit.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *AuditMutation) UserCleared() bool {
+ return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *AuditMutation) UserIDs() (ids []uuid.UUID) {
+ if id := m.user; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *AuditMutation) ResetUser() {
+ m.user = nil
+ m.cleareduser = false
+}
+
+// Where appends a list predicates to the AuditMutation builder.
+func (m *AuditMutation) Where(ps ...predicate.Audit) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the AuditMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *AuditMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.Audit, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *AuditMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *AuditMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (Audit).
+func (m *AuditMutation) 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 *AuditMutation) Fields() []string {
+ fields := make([]string, 0, 7)
+ if m.user != nil {
+ fields = append(fields, audit.FieldUserID)
+ }
+ if m.operation != nil {
+ fields = append(fields, audit.FieldOperation)
+ }
+ if m.source_ip != nil {
+ fields = append(fields, audit.FieldSourceIP)
+ }
+ if m.user_agent != nil {
+ fields = append(fields, audit.FieldUserAgent)
+ }
+ if m.request != nil {
+ fields = append(fields, audit.FieldRequest)
+ }
+ if m.response != nil {
+ fields = append(fields, audit.FieldResponse)
+ }
+ if m.created_at != nil {
+ fields = append(fields, audit.FieldCreatedAt)
+ }
+ 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 *AuditMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case audit.FieldUserID:
+ return m.UserID()
+ case audit.FieldOperation:
+ return m.Operation()
+ case audit.FieldSourceIP:
+ return m.SourceIP()
+ case audit.FieldUserAgent:
+ return m.UserAgent()
+ case audit.FieldRequest:
+ return m.Request()
+ case audit.FieldResponse:
+ return m.Response()
+ case audit.FieldCreatedAt:
+ return m.CreatedAt()
+ }
+ 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 *AuditMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case audit.FieldUserID:
+ return m.OldUserID(ctx)
+ case audit.FieldOperation:
+ return m.OldOperation(ctx)
+ case audit.FieldSourceIP:
+ return m.OldSourceIP(ctx)
+ case audit.FieldUserAgent:
+ return m.OldUserAgent(ctx)
+ case audit.FieldRequest:
+ return m.OldRequest(ctx)
+ case audit.FieldResponse:
+ return m.OldResponse(ctx)
+ case audit.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown Audit 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 *AuditMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case audit.FieldUserID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserID(v)
+ return nil
+ case audit.FieldOperation:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetOperation(v)
+ return nil
+ case audit.FieldSourceIP:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetSourceIP(v)
+ return nil
+ case audit.FieldUserAgent:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserAgent(v)
+ return nil
+ case audit.FieldRequest:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetRequest(v)
+ return nil
+ case audit.FieldResponse:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetResponse(v)
+ return nil
+ case audit.FieldCreatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetCreatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown Audit field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *AuditMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *AuditMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *AuditMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown Audit numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *AuditMutation) ClearedFields() []string {
+ var fields []string
+ if m.FieldCleared(audit.FieldResponse) {
+ fields = append(fields, audit.FieldResponse)
+ }
+ return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *AuditMutation) 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 *AuditMutation) ClearField(name string) error {
+ switch name {
+ case audit.FieldResponse:
+ m.ClearResponse()
+ return nil
+ }
+ return fmt.Errorf("unknown Audit 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 *AuditMutation) ResetField(name string) error {
+ switch name {
+ case audit.FieldUserID:
+ m.ResetUserID()
+ return nil
+ case audit.FieldOperation:
+ m.ResetOperation()
+ return nil
+ case audit.FieldSourceIP:
+ m.ResetSourceIP()
+ return nil
+ case audit.FieldUserAgent:
+ m.ResetUserAgent()
+ return nil
+ case audit.FieldRequest:
+ m.ResetRequest()
+ return nil
+ case audit.FieldResponse:
+ m.ResetResponse()
+ return nil
+ case audit.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown Audit field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *AuditMutation) AddedEdges() []string {
+ edges := make([]string, 0, 1)
+ if m.user != nil {
+ edges = append(edges, audit.EdgeUser)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *AuditMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case audit.EdgeUser:
+ if id := m.user; id != nil {
+ return []ent.Value{*id}
+ }
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *AuditMutation) 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 *AuditMutation) RemovedIDs(name string) []ent.Value {
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *AuditMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 1)
+ if m.cleareduser {
+ edges = append(edges, audit.EdgeUser)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *AuditMutation) EdgeCleared(name string) bool {
+ switch name {
+ case audit.EdgeUser:
+ return m.cleareduser
+ }
+ return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *AuditMutation) ClearEdge(name string) error {
+ switch name {
+ case audit.EdgeUser:
+ m.ClearUser()
+ return nil
+ }
+ return fmt.Errorf("unknown Audit 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 *AuditMutation) ResetEdge(name string) error {
+ switch name {
+ case audit.EdgeUser:
+ m.ResetUser()
+ return nil
+ }
+ return fmt.Errorf("unknown Audit edge %s", name)
+}
+
+// TeamMutation represents an operation that mutates the Team nodes in the graph.
+type TeamMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ deleted_at *time.Time
+ name *string
+ member_limit *int
+ addmember_limit *int
+ created_at *time.Time
+ updated_at *time.Time
+ clearedFields map[string]struct{}
+ groups map[uuid.UUID]struct{}
+ removedgroups map[uuid.UUID]struct{}
+ clearedgroups bool
+ members map[uuid.UUID]struct{}
+ removedmembers map[uuid.UUID]struct{}
+ clearedmembers bool
+ team_members map[uuid.UUID]struct{}
+ removedteam_members map[uuid.UUID]struct{}
+ clearedteam_members bool
+ done bool
+ oldValue func(context.Context) (*Team, error)
+ predicates []predicate.Team
+}
+
+var _ ent.Mutation = (*TeamMutation)(nil)
+
+// teamOption allows management of the mutation configuration using functional options.
+type teamOption func(*TeamMutation)
+
+// newTeamMutation creates new mutation for the Team entity.
+func newTeamMutation(c config, op Op, opts ...teamOption) *TeamMutation {
+ m := &TeamMutation{
+ config: c,
+ op: op,
+ typ: TypeTeam,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withTeamID sets the ID field of the mutation.
+func withTeamID(id uuid.UUID) teamOption {
+ return func(m *TeamMutation) {
+ var (
+ err error
+ once sync.Once
+ value *Team
+ )
+ m.oldValue = func(ctx context.Context) (*Team, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().Team.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withTeam sets the old Team of the mutation.
+func withTeam(node *Team) teamOption {
+ return func(m *TeamMutation) {
+ m.oldValue = func(context.Context) (*Team, 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 TeamMutation) 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 TeamMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 Team entities.
+func (m *TeamMutation) 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 *TeamMutation) 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 *TeamMutation) 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().Team.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (m *TeamMutation) SetDeletedAt(t time.Time) {
+ m.deleted_at = &t
+}
+
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
+func (m *TeamMutation) DeletedAt() (r time.Time, exists bool) {
+ v := m.deleted_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldDeletedAt returns the old "deleted_at" field's value of the Team entity.
+// If the Team 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 *TeamMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
+ }
+ return oldValue.DeletedAt, nil
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (m *TeamMutation) ClearDeletedAt() {
+ m.deleted_at = nil
+ m.clearedFields[team.FieldDeletedAt] = struct{}{}
+}
+
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
+func (m *TeamMutation) DeletedAtCleared() bool {
+ _, ok := m.clearedFields[team.FieldDeletedAt]
+ return ok
+}
+
+// ResetDeletedAt resets all changes to the "deleted_at" field.
+func (m *TeamMutation) ResetDeletedAt() {
+ m.deleted_at = nil
+ delete(m.clearedFields, team.FieldDeletedAt)
+}
+
+// SetName sets the "name" field.
+func (m *TeamMutation) SetName(s string) {
+ m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *TeamMutation) Name() (r string, exists bool) {
+ v := m.name
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldName returns the old "name" field's value of the Team entity.
+// If the Team 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 *TeamMutation) OldName(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldName is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldName requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldName: %w", err)
+ }
+ return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *TeamMutation) ResetName() {
+ m.name = nil
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (m *TeamMutation) SetMemberLimit(i int) {
+ m.member_limit = &i
+ m.addmember_limit = nil
+}
+
+// MemberLimit returns the value of the "member_limit" field in the mutation.
+func (m *TeamMutation) MemberLimit() (r int, exists bool) {
+ v := m.member_limit
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldMemberLimit returns the old "member_limit" field's value of the Team entity.
+// If the Team 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 *TeamMutation) OldMemberLimit(ctx context.Context) (v int, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldMemberLimit is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldMemberLimit requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldMemberLimit: %w", err)
+ }
+ return oldValue.MemberLimit, nil
+}
+
+// AddMemberLimit adds i to the "member_limit" field.
+func (m *TeamMutation) AddMemberLimit(i int) {
+ if m.addmember_limit != nil {
+ *m.addmember_limit += i
+ } else {
+ m.addmember_limit = &i
+ }
+}
+
+// AddedMemberLimit returns the value that was added to the "member_limit" field in this mutation.
+func (m *TeamMutation) AddedMemberLimit() (r int, exists bool) {
+ v := m.addmember_limit
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// ResetMemberLimit resets all changes to the "member_limit" field.
+func (m *TeamMutation) ResetMemberLimit() {
+ m.member_limit = nil
+ m.addmember_limit = nil
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *TeamMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *TeamMutation) 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 Team entity.
+// If the Team 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 *TeamMutation) 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 *TeamMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *TeamMutation) SetUpdatedAt(t time.Time) {
+ m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *TeamMutation) 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 Team entity.
+// If the Team 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 *TeamMutation) 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 *TeamMutation) ResetUpdatedAt() {
+ m.updated_at = nil
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by ids.
+func (m *TeamMutation) AddGroupIDs(ids ...uuid.UUID) {
+ if m.groups == nil {
+ m.groups = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.groups[ids[i]] = struct{}{}
+ }
+}
+
+// ClearGroups clears the "groups" edge to the TeamGroup entity.
+func (m *TeamMutation) ClearGroups() {
+ m.clearedgroups = true
+}
+
+// GroupsCleared reports if the "groups" edge to the TeamGroup entity was cleared.
+func (m *TeamMutation) GroupsCleared() bool {
+ return m.clearedgroups
+}
+
+// RemoveGroupIDs removes the "groups" edge to the TeamGroup entity by IDs.
+func (m *TeamMutation) RemoveGroupIDs(ids ...uuid.UUID) {
+ if m.removedgroups == nil {
+ m.removedgroups = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.groups, ids[i])
+ m.removedgroups[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedGroups returns the removed IDs of the "groups" edge to the TeamGroup entity.
+func (m *TeamMutation) RemovedGroupsIDs() (ids []uuid.UUID) {
+ for id := range m.removedgroups {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// GroupsIDs returns the "groups" edge IDs in the mutation.
+func (m *TeamMutation) GroupsIDs() (ids []uuid.UUID) {
+ for id := range m.groups {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetGroups resets all changes to the "groups" edge.
+func (m *TeamMutation) ResetGroups() {
+ m.groups = nil
+ m.clearedgroups = false
+ m.removedgroups = nil
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by ids.
+func (m *TeamMutation) AddMemberIDs(ids ...uuid.UUID) {
+ if m.members == nil {
+ m.members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearMembers clears the "members" edge to the User entity.
+func (m *TeamMutation) ClearMembers() {
+ m.clearedmembers = true
+}
+
+// MembersCleared reports if the "members" edge to the User entity was cleared.
+func (m *TeamMutation) MembersCleared() bool {
+ return m.clearedmembers
+}
+
+// RemoveMemberIDs removes the "members" edge to the User entity by IDs.
+func (m *TeamMutation) RemoveMemberIDs(ids ...uuid.UUID) {
+ if m.removedmembers == nil {
+ m.removedmembers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.members, ids[i])
+ m.removedmembers[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedMembers returns the removed IDs of the "members" edge to the User entity.
+func (m *TeamMutation) RemovedMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedmembers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// MembersIDs returns the "members" edge IDs in the mutation.
+func (m *TeamMutation) MembersIDs() (ids []uuid.UUID) {
+ for id := range m.members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetMembers resets all changes to the "members" edge.
+func (m *TeamMutation) ResetMembers() {
+ m.members = nil
+ m.clearedmembers = false
+ m.removedmembers = nil
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by ids.
+func (m *TeamMutation) AddTeamMemberIDs(ids ...uuid.UUID) {
+ if m.team_members == nil {
+ m.team_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.team_members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearTeamMembers clears the "team_members" edge to the TeamMember entity.
+func (m *TeamMutation) ClearTeamMembers() {
+ m.clearedteam_members = true
+}
+
+// TeamMembersCleared reports if the "team_members" edge to the TeamMember entity was cleared.
+func (m *TeamMutation) TeamMembersCleared() bool {
+ return m.clearedteam_members
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to the TeamMember entity by IDs.
+func (m *TeamMutation) RemoveTeamMemberIDs(ids ...uuid.UUID) {
+ if m.removedteam_members == nil {
+ m.removedteam_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.team_members, ids[i])
+ m.removedteam_members[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedTeamMembers returns the removed IDs of the "team_members" edge to the TeamMember entity.
+func (m *TeamMutation) RemovedTeamMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedteam_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// TeamMembersIDs returns the "team_members" edge IDs in the mutation.
+func (m *TeamMutation) TeamMembersIDs() (ids []uuid.UUID) {
+ for id := range m.team_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetTeamMembers resets all changes to the "team_members" edge.
+func (m *TeamMutation) ResetTeamMembers() {
+ m.team_members = nil
+ m.clearedteam_members = false
+ m.removedteam_members = nil
+}
+
+// Where appends a list predicates to the TeamMutation builder.
+func (m *TeamMutation) Where(ps ...predicate.Team) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the TeamMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *TeamMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.Team, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *TeamMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *TeamMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (Team).
+func (m *TeamMutation) 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 *TeamMutation) Fields() []string {
+ fields := make([]string, 0, 5)
+ if m.deleted_at != nil {
+ fields = append(fields, team.FieldDeletedAt)
+ }
+ if m.name != nil {
+ fields = append(fields, team.FieldName)
+ }
+ if m.member_limit != nil {
+ fields = append(fields, team.FieldMemberLimit)
+ }
+ if m.created_at != nil {
+ fields = append(fields, team.FieldCreatedAt)
+ }
+ if m.updated_at != nil {
+ fields = append(fields, team.FieldUpdatedAt)
+ }
+ 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 *TeamMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case team.FieldDeletedAt:
+ return m.DeletedAt()
+ case team.FieldName:
+ return m.Name()
+ case team.FieldMemberLimit:
+ return m.MemberLimit()
+ case team.FieldCreatedAt:
+ return m.CreatedAt()
+ case team.FieldUpdatedAt:
+ return m.UpdatedAt()
+ }
+ 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 *TeamMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case team.FieldDeletedAt:
+ return m.OldDeletedAt(ctx)
+ case team.FieldName:
+ return m.OldName(ctx)
+ case team.FieldMemberLimit:
+ return m.OldMemberLimit(ctx)
+ case team.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ case team.FieldUpdatedAt:
+ return m.OldUpdatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown Team 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 *TeamMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case team.FieldDeletedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetDeletedAt(v)
+ return nil
+ case team.FieldName:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetName(v)
+ return nil
+ case team.FieldMemberLimit:
+ v, ok := value.(int)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetMemberLimit(v)
+ return nil
+ case team.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 team.FieldUpdatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUpdatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown Team field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *TeamMutation) AddedFields() []string {
+ var fields []string
+ if m.addmember_limit != nil {
+ fields = append(fields, team.FieldMemberLimit)
+ }
+ 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 *TeamMutation) AddedField(name string) (ent.Value, bool) {
+ switch name {
+ case team.FieldMemberLimit:
+ return m.AddedMemberLimit()
+ }
+ 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 *TeamMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ case team.FieldMemberLimit:
+ v, ok := value.(int)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.AddMemberLimit(v)
+ return nil
+ }
+ return fmt.Errorf("unknown Team numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *TeamMutation) ClearedFields() []string {
+ var fields []string
+ if m.FieldCleared(team.FieldDeletedAt) {
+ fields = append(fields, team.FieldDeletedAt)
+ }
+ return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *TeamMutation) 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 *TeamMutation) ClearField(name string) error {
+ switch name {
+ case team.FieldDeletedAt:
+ m.ClearDeletedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown Team 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 *TeamMutation) ResetField(name string) error {
+ switch name {
+ case team.FieldDeletedAt:
+ m.ResetDeletedAt()
+ return nil
+ case team.FieldName:
+ m.ResetName()
+ return nil
+ case team.FieldMemberLimit:
+ m.ResetMemberLimit()
+ return nil
+ case team.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ case team.FieldUpdatedAt:
+ m.ResetUpdatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown Team field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *TeamMutation) AddedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.groups != nil {
+ edges = append(edges, team.EdgeGroups)
+ }
+ if m.members != nil {
+ edges = append(edges, team.EdgeMembers)
+ }
+ if m.team_members != nil {
+ edges = append(edges, team.EdgeTeamMembers)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *TeamMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case team.EdgeGroups:
+ ids := make([]ent.Value, 0, len(m.groups))
+ for id := range m.groups {
+ ids = append(ids, id)
+ }
+ return ids
+ case team.EdgeMembers:
+ ids := make([]ent.Value, 0, len(m.members))
+ for id := range m.members {
+ ids = append(ids, id)
+ }
+ return ids
+ case team.EdgeTeamMembers:
+ ids := make([]ent.Value, 0, len(m.team_members))
+ for id := range m.team_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *TeamMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.removedgroups != nil {
+ edges = append(edges, team.EdgeGroups)
+ }
+ if m.removedmembers != nil {
+ edges = append(edges, team.EdgeMembers)
+ }
+ if m.removedteam_members != nil {
+ edges = append(edges, team.EdgeTeamMembers)
+ }
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *TeamMutation) RemovedIDs(name string) []ent.Value {
+ switch name {
+ case team.EdgeGroups:
+ ids := make([]ent.Value, 0, len(m.removedgroups))
+ for id := range m.removedgroups {
+ ids = append(ids, id)
+ }
+ return ids
+ case team.EdgeMembers:
+ ids := make([]ent.Value, 0, len(m.removedmembers))
+ for id := range m.removedmembers {
+ ids = append(ids, id)
+ }
+ return ids
+ case team.EdgeTeamMembers:
+ ids := make([]ent.Value, 0, len(m.removedteam_members))
+ for id := range m.removedteam_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *TeamMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.clearedgroups {
+ edges = append(edges, team.EdgeGroups)
+ }
+ if m.clearedmembers {
+ edges = append(edges, team.EdgeMembers)
+ }
+ if m.clearedteam_members {
+ edges = append(edges, team.EdgeTeamMembers)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *TeamMutation) EdgeCleared(name string) bool {
+ switch name {
+ case team.EdgeGroups:
+ return m.clearedgroups
+ case team.EdgeMembers:
+ return m.clearedmembers
+ case team.EdgeTeamMembers:
+ return m.clearedteam_members
+ }
+ 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 *TeamMutation) ClearEdge(name string) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown Team 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 *TeamMutation) ResetEdge(name string) error {
+ switch name {
+ case team.EdgeGroups:
+ m.ResetGroups()
+ return nil
+ case team.EdgeMembers:
+ m.ResetMembers()
+ return nil
+ case team.EdgeTeamMembers:
+ m.ResetTeamMembers()
+ return nil
+ }
+ return fmt.Errorf("unknown Team edge %s", name)
+}
+
+// TeamGroupMutation represents an operation that mutates the TeamGroup nodes in the graph.
+type TeamGroupMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ deleted_at *time.Time
+ name *string
+ created_at *time.Time
+ updated_at *time.Time
+ clearedFields map[string]struct{}
+ members map[uuid.UUID]struct{}
+ removedmembers map[uuid.UUID]struct{}
+ clearedmembers bool
+ team *uuid.UUID
+ clearedteam bool
+ team_group_members map[uuid.UUID]struct{}
+ removedteam_group_members map[uuid.UUID]struct{}
+ clearedteam_group_members bool
+ done bool
+ oldValue func(context.Context) (*TeamGroup, error)
+ predicates []predicate.TeamGroup
+}
+
+var _ ent.Mutation = (*TeamGroupMutation)(nil)
+
+// teamgroupOption allows management of the mutation configuration using functional options.
+type teamgroupOption func(*TeamGroupMutation)
+
+// newTeamGroupMutation creates new mutation for the TeamGroup entity.
+func newTeamGroupMutation(c config, op Op, opts ...teamgroupOption) *TeamGroupMutation {
+ m := &TeamGroupMutation{
+ config: c,
+ op: op,
+ typ: TypeTeamGroup,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withTeamGroupID sets the ID field of the mutation.
+func withTeamGroupID(id uuid.UUID) teamgroupOption {
+ return func(m *TeamGroupMutation) {
+ var (
+ err error
+ once sync.Once
+ value *TeamGroup
+ )
+ m.oldValue = func(ctx context.Context) (*TeamGroup, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().TeamGroup.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withTeamGroup sets the old TeamGroup of the mutation.
+func withTeamGroup(node *TeamGroup) teamgroupOption {
+ return func(m *TeamGroupMutation) {
+ m.oldValue = func(context.Context) (*TeamGroup, 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 TeamGroupMutation) 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 TeamGroupMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 TeamGroup entities.
+func (m *TeamGroupMutation) 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 *TeamGroupMutation) 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 *TeamGroupMutation) 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().TeamGroup.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (m *TeamGroupMutation) SetDeletedAt(t time.Time) {
+ m.deleted_at = &t
+}
+
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
+func (m *TeamGroupMutation) DeletedAt() (r time.Time, exists bool) {
+ v := m.deleted_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldDeletedAt returns the old "deleted_at" field's value of the TeamGroup entity.
+// If the TeamGroup 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 *TeamGroupMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
+ }
+ return oldValue.DeletedAt, nil
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (m *TeamGroupMutation) ClearDeletedAt() {
+ m.deleted_at = nil
+ m.clearedFields[teamgroup.FieldDeletedAt] = struct{}{}
+}
+
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
+func (m *TeamGroupMutation) DeletedAtCleared() bool {
+ _, ok := m.clearedFields[teamgroup.FieldDeletedAt]
+ return ok
+}
+
+// ResetDeletedAt resets all changes to the "deleted_at" field.
+func (m *TeamGroupMutation) ResetDeletedAt() {
+ m.deleted_at = nil
+ delete(m.clearedFields, teamgroup.FieldDeletedAt)
+}
+
+// SetTeamID sets the "team_id" field.
+func (m *TeamGroupMutation) SetTeamID(u uuid.UUID) {
+ m.team = &u
+}
+
+// TeamID returns the value of the "team_id" field in the mutation.
+func (m *TeamGroupMutation) TeamID() (r uuid.UUID, exists bool) {
+ v := m.team
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldTeamID returns the old "team_id" field's value of the TeamGroup entity.
+// If the TeamGroup 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 *TeamGroupMutation) OldTeamID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldTeamID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldTeamID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldTeamID: %w", err)
+ }
+ return oldValue.TeamID, nil
+}
+
+// ResetTeamID resets all changes to the "team_id" field.
+func (m *TeamGroupMutation) ResetTeamID() {
+ m.team = nil
+}
+
+// SetName sets the "name" field.
+func (m *TeamGroupMutation) SetName(s string) {
+ m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *TeamGroupMutation) Name() (r string, exists bool) {
+ v := m.name
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldName returns the old "name" field's value of the TeamGroup entity.
+// If the TeamGroup 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 *TeamGroupMutation) OldName(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldName is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldName requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldName: %w", err)
+ }
+ return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *TeamGroupMutation) ResetName() {
+ m.name = nil
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *TeamGroupMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *TeamGroupMutation) 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 TeamGroup entity.
+// If the TeamGroup 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 *TeamGroupMutation) 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 *TeamGroupMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *TeamGroupMutation) SetUpdatedAt(t time.Time) {
+ m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *TeamGroupMutation) 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 TeamGroup entity.
+// If the TeamGroup 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 *TeamGroupMutation) 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 *TeamGroupMutation) ResetUpdatedAt() {
+ m.updated_at = nil
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by ids.
+func (m *TeamGroupMutation) AddMemberIDs(ids ...uuid.UUID) {
+ if m.members == nil {
+ m.members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearMembers clears the "members" edge to the User entity.
+func (m *TeamGroupMutation) ClearMembers() {
+ m.clearedmembers = true
+}
+
+// MembersCleared reports if the "members" edge to the User entity was cleared.
+func (m *TeamGroupMutation) MembersCleared() bool {
+ return m.clearedmembers
+}
+
+// RemoveMemberIDs removes the "members" edge to the User entity by IDs.
+func (m *TeamGroupMutation) RemoveMemberIDs(ids ...uuid.UUID) {
+ if m.removedmembers == nil {
+ m.removedmembers = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.members, ids[i])
+ m.removedmembers[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedMembers returns the removed IDs of the "members" edge to the User entity.
+func (m *TeamGroupMutation) RemovedMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedmembers {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// MembersIDs returns the "members" edge IDs in the mutation.
+func (m *TeamGroupMutation) MembersIDs() (ids []uuid.UUID) {
+ for id := range m.members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetMembers resets all changes to the "members" edge.
+func (m *TeamGroupMutation) ResetMembers() {
+ m.members = nil
+ m.clearedmembers = false
+ m.removedmembers = nil
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (m *TeamGroupMutation) ClearTeam() {
+ m.clearedteam = true
+ m.clearedFields[teamgroup.FieldTeamID] = struct{}{}
+}
+
+// TeamCleared reports if the "team" edge to the Team entity was cleared.
+func (m *TeamGroupMutation) TeamCleared() bool {
+ return m.clearedteam
+}
+
+// TeamIDs returns the "team" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// TeamID instead. It exists only for internal usage by the builders.
+func (m *TeamGroupMutation) TeamIDs() (ids []uuid.UUID) {
+ if id := m.team; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetTeam resets all changes to the "team" edge.
+func (m *TeamGroupMutation) ResetTeam() {
+ m.team = nil
+ m.clearedteam = false
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by ids.
+func (m *TeamGroupMutation) AddTeamGroupMemberIDs(ids ...uuid.UUID) {
+ if m.team_group_members == nil {
+ m.team_group_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.team_group_members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearTeamGroupMembers clears the "team_group_members" edge to the TeamGroupMember entity.
+func (m *TeamGroupMutation) ClearTeamGroupMembers() {
+ m.clearedteam_group_members = true
+}
+
+// TeamGroupMembersCleared reports if the "team_group_members" edge to the TeamGroupMember entity was cleared.
+func (m *TeamGroupMutation) TeamGroupMembersCleared() bool {
+ return m.clearedteam_group_members
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (m *TeamGroupMutation) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) {
+ if m.removedteam_group_members == nil {
+ m.removedteam_group_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.team_group_members, ids[i])
+ m.removedteam_group_members[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedTeamGroupMembers returns the removed IDs of the "team_group_members" edge to the TeamGroupMember entity.
+func (m *TeamGroupMutation) RemovedTeamGroupMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedteam_group_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// TeamGroupMembersIDs returns the "team_group_members" edge IDs in the mutation.
+func (m *TeamGroupMutation) TeamGroupMembersIDs() (ids []uuid.UUID) {
+ for id := range m.team_group_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetTeamGroupMembers resets all changes to the "team_group_members" edge.
+func (m *TeamGroupMutation) ResetTeamGroupMembers() {
+ m.team_group_members = nil
+ m.clearedteam_group_members = false
+ m.removedteam_group_members = nil
+}
+
+// Where appends a list predicates to the TeamGroupMutation builder.
+func (m *TeamGroupMutation) Where(ps ...predicate.TeamGroup) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the TeamGroupMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *TeamGroupMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.TeamGroup, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *TeamGroupMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *TeamGroupMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (TeamGroup).
+func (m *TeamGroupMutation) 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 *TeamGroupMutation) Fields() []string {
+ fields := make([]string, 0, 5)
+ if m.deleted_at != nil {
+ fields = append(fields, teamgroup.FieldDeletedAt)
+ }
+ if m.team != nil {
+ fields = append(fields, teamgroup.FieldTeamID)
+ }
+ if m.name != nil {
+ fields = append(fields, teamgroup.FieldName)
+ }
+ if m.created_at != nil {
+ fields = append(fields, teamgroup.FieldCreatedAt)
+ }
+ if m.updated_at != nil {
+ fields = append(fields, teamgroup.FieldUpdatedAt)
+ }
+ 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 *TeamGroupMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case teamgroup.FieldDeletedAt:
+ return m.DeletedAt()
+ case teamgroup.FieldTeamID:
+ return m.TeamID()
+ case teamgroup.FieldName:
+ return m.Name()
+ case teamgroup.FieldCreatedAt:
+ return m.CreatedAt()
+ case teamgroup.FieldUpdatedAt:
+ return m.UpdatedAt()
+ }
+ 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 *TeamGroupMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case teamgroup.FieldDeletedAt:
+ return m.OldDeletedAt(ctx)
+ case teamgroup.FieldTeamID:
+ return m.OldTeamID(ctx)
+ case teamgroup.FieldName:
+ return m.OldName(ctx)
+ case teamgroup.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ case teamgroup.FieldUpdatedAt:
+ return m.OldUpdatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown TeamGroup 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 *TeamGroupMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case teamgroup.FieldDeletedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetDeletedAt(v)
+ return nil
+ case teamgroup.FieldTeamID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetTeamID(v)
+ return nil
+ case teamgroup.FieldName:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetName(v)
+ return nil
+ case teamgroup.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 teamgroup.FieldUpdatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUpdatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroup field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *TeamGroupMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *TeamGroupMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *TeamGroupMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown TeamGroup numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *TeamGroupMutation) ClearedFields() []string {
+ var fields []string
+ if m.FieldCleared(teamgroup.FieldDeletedAt) {
+ fields = append(fields, teamgroup.FieldDeletedAt)
+ }
+ return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *TeamGroupMutation) 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 *TeamGroupMutation) ClearField(name string) error {
+ switch name {
+ case teamgroup.FieldDeletedAt:
+ m.ClearDeletedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroup 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 *TeamGroupMutation) ResetField(name string) error {
+ switch name {
+ case teamgroup.FieldDeletedAt:
+ m.ResetDeletedAt()
+ return nil
+ case teamgroup.FieldTeamID:
+ m.ResetTeamID()
+ return nil
+ case teamgroup.FieldName:
+ m.ResetName()
+ return nil
+ case teamgroup.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ case teamgroup.FieldUpdatedAt:
+ m.ResetUpdatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroup field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *TeamGroupMutation) AddedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.members != nil {
+ edges = append(edges, teamgroup.EdgeMembers)
+ }
+ if m.team != nil {
+ edges = append(edges, teamgroup.EdgeTeam)
+ }
+ if m.team_group_members != nil {
+ edges = append(edges, teamgroup.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *TeamGroupMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case teamgroup.EdgeMembers:
+ ids := make([]ent.Value, 0, len(m.members))
+ for id := range m.members {
+ ids = append(ids, id)
+ }
+ return ids
+ case teamgroup.EdgeTeam:
+ if id := m.team; id != nil {
+ return []ent.Value{*id}
+ }
+ case teamgroup.EdgeTeamGroupMembers:
+ ids := make([]ent.Value, 0, len(m.team_group_members))
+ for id := range m.team_group_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *TeamGroupMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.removedmembers != nil {
+ edges = append(edges, teamgroup.EdgeMembers)
+ }
+ if m.removedteam_group_members != nil {
+ edges = append(edges, teamgroup.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *TeamGroupMutation) RemovedIDs(name string) []ent.Value {
+ switch name {
+ case teamgroup.EdgeMembers:
+ ids := make([]ent.Value, 0, len(m.removedmembers))
+ for id := range m.removedmembers {
+ ids = append(ids, id)
+ }
+ return ids
+ case teamgroup.EdgeTeamGroupMembers:
+ ids := make([]ent.Value, 0, len(m.removedteam_group_members))
+ for id := range m.removedteam_group_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *TeamGroupMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 3)
+ if m.clearedmembers {
+ edges = append(edges, teamgroup.EdgeMembers)
+ }
+ if m.clearedteam {
+ edges = append(edges, teamgroup.EdgeTeam)
+ }
+ if m.clearedteam_group_members {
+ edges = append(edges, teamgroup.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *TeamGroupMutation) EdgeCleared(name string) bool {
+ switch name {
+ case teamgroup.EdgeMembers:
+ return m.clearedmembers
+ case teamgroup.EdgeTeam:
+ return m.clearedteam
+ case teamgroup.EdgeTeamGroupMembers:
+ return m.clearedteam_group_members
+ }
+ 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 *TeamGroupMutation) ClearEdge(name string) error {
+ switch name {
+ case teamgroup.EdgeTeam:
+ m.ClearTeam()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroup 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 *TeamGroupMutation) ResetEdge(name string) error {
+ switch name {
+ case teamgroup.EdgeMembers:
+ m.ResetMembers()
+ return nil
+ case teamgroup.EdgeTeam:
+ m.ResetTeam()
+ return nil
+ case teamgroup.EdgeTeamGroupMembers:
+ m.ResetTeamGroupMembers()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroup edge %s", name)
+}
+
+// TeamGroupMemberMutation represents an operation that mutates the TeamGroupMember nodes in the graph.
+type TeamGroupMemberMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ created_at *time.Time
+ clearedFields map[string]struct{}
+ group *uuid.UUID
+ clearedgroup bool
+ user *uuid.UUID
+ cleareduser bool
+ done bool
+ oldValue func(context.Context) (*TeamGroupMember, error)
+ predicates []predicate.TeamGroupMember
+}
+
+var _ ent.Mutation = (*TeamGroupMemberMutation)(nil)
+
+// teamgroupmemberOption allows management of the mutation configuration using functional options.
+type teamgroupmemberOption func(*TeamGroupMemberMutation)
+
+// newTeamGroupMemberMutation creates new mutation for the TeamGroupMember entity.
+func newTeamGroupMemberMutation(c config, op Op, opts ...teamgroupmemberOption) *TeamGroupMemberMutation {
+ m := &TeamGroupMemberMutation{
+ config: c,
+ op: op,
+ typ: TypeTeamGroupMember,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withTeamGroupMemberID sets the ID field of the mutation.
+func withTeamGroupMemberID(id uuid.UUID) teamgroupmemberOption {
+ return func(m *TeamGroupMemberMutation) {
+ var (
+ err error
+ once sync.Once
+ value *TeamGroupMember
+ )
+ m.oldValue = func(ctx context.Context) (*TeamGroupMember, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().TeamGroupMember.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withTeamGroupMember sets the old TeamGroupMember of the mutation.
+func withTeamGroupMember(node *TeamGroupMember) teamgroupmemberOption {
+ return func(m *TeamGroupMemberMutation) {
+ m.oldValue = func(context.Context) (*TeamGroupMember, 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 TeamGroupMemberMutation) 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 TeamGroupMemberMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 TeamGroupMember entities.
+func (m *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) 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().TeamGroupMember.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetGroupID sets the "group_id" field.
+func (m *TeamGroupMemberMutation) SetGroupID(u uuid.UUID) {
+ m.group = &u
+}
+
+// GroupID returns the value of the "group_id" field in the mutation.
+func (m *TeamGroupMemberMutation) GroupID() (r uuid.UUID, exists bool) {
+ v := m.group
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldGroupID returns the old "group_id" field's value of the TeamGroupMember entity.
+// If the TeamGroupMember 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 *TeamGroupMemberMutation) OldGroupID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldGroupID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldGroupID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldGroupID: %w", err)
+ }
+ return oldValue.GroupID, nil
+}
+
+// ResetGroupID resets all changes to the "group_id" field.
+func (m *TeamGroupMemberMutation) ResetGroupID() {
+ m.group = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *TeamGroupMemberMutation) SetUserID(u uuid.UUID) {
+ m.user = &u
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *TeamGroupMemberMutation) UserID() (r uuid.UUID, exists bool) {
+ v := m.user
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the TeamGroupMember entity.
+// If the TeamGroupMember 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 *TeamGroupMemberMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+ }
+ return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *TeamGroupMemberMutation) ResetUserID() {
+ m.user = nil
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *TeamGroupMemberMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *TeamGroupMemberMutation) 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 TeamGroupMember entity.
+// If the TeamGroupMember 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 *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// ClearGroup clears the "group" edge to the TeamGroup entity.
+func (m *TeamGroupMemberMutation) ClearGroup() {
+ m.clearedgroup = true
+ m.clearedFields[teamgroupmember.FieldGroupID] = struct{}{}
+}
+
+// GroupCleared reports if the "group" edge to the TeamGroup entity was cleared.
+func (m *TeamGroupMemberMutation) GroupCleared() bool {
+ return m.clearedgroup
+}
+
+// GroupIDs returns the "group" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// GroupID instead. It exists only for internal usage by the builders.
+func (m *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) ResetGroup() {
+ m.group = nil
+ m.clearedgroup = false
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *TeamGroupMemberMutation) ClearUser() {
+ m.cleareduser = true
+ m.clearedFields[teamgroupmember.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *TeamGroupMemberMutation) UserCleared() bool {
+ return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *TeamGroupMemberMutation) UserIDs() (ids []uuid.UUID) {
+ if id := m.user; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *TeamGroupMemberMutation) ResetUser() {
+ m.user = nil
+ m.cleareduser = false
+}
+
+// Where appends a list predicates to the TeamGroupMemberMutation builder.
+func (m *TeamGroupMemberMutation) Where(ps ...predicate.TeamGroupMember) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the TeamGroupMemberMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *TeamGroupMemberMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.TeamGroupMember, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *TeamGroupMemberMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *TeamGroupMemberMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (TeamGroupMember).
+func (m *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) Fields() []string {
+ fields := make([]string, 0, 3)
+ if m.group != nil {
+ fields = append(fields, teamgroupmember.FieldGroupID)
+ }
+ if m.user != nil {
+ fields = append(fields, teamgroupmember.FieldUserID)
+ }
+ if m.created_at != nil {
+ fields = append(fields, teamgroupmember.FieldCreatedAt)
+ }
+ 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 *TeamGroupMemberMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case teamgroupmember.FieldGroupID:
+ return m.GroupID()
+ case teamgroupmember.FieldUserID:
+ return m.UserID()
+ case teamgroupmember.FieldCreatedAt:
+ return m.CreatedAt()
+ }
+ 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 *TeamGroupMemberMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case teamgroupmember.FieldGroupID:
+ return m.OldGroupID(ctx)
+ case teamgroupmember.FieldUserID:
+ return m.OldUserID(ctx)
+ case teamgroupmember.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown TeamGroupMember 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 *TeamGroupMemberMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case teamgroupmember.FieldGroupID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetGroupID(v)
+ return nil
+ case teamgroupmember.FieldUserID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserID(v)
+ return nil
+ case teamgroupmember.FieldCreatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetCreatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroupMember field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *TeamGroupMemberMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *TeamGroupMemberMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *TeamGroupMemberMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown TeamGroupMember numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *TeamGroupMemberMutation) ClearedFields() []string {
+ return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *TeamGroupMemberMutation) 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 *TeamGroupMemberMutation) ClearField(name string) error {
+ return fmt.Errorf("unknown TeamGroupMember 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 *TeamGroupMemberMutation) ResetField(name string) error {
+ switch name {
+ case teamgroupmember.FieldGroupID:
+ m.ResetGroupID()
+ return nil
+ case teamgroupmember.FieldUserID:
+ m.ResetUserID()
+ return nil
+ case teamgroupmember.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroupMember field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *TeamGroupMemberMutation) AddedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.group != nil {
+ edges = append(edges, teamgroupmember.EdgeGroup)
+ }
+ if m.user != nil {
+ edges = append(edges, teamgroupmember.EdgeUser)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *TeamGroupMemberMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case teamgroupmember.EdgeGroup:
+ if id := m.group; id != nil {
+ return []ent.Value{*id}
+ }
+ case teamgroupmember.EdgeUser:
+ if id := m.user; id != nil {
+ return []ent.Value{*id}
+ }
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *TeamGroupMemberMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 2)
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *TeamGroupMemberMutation) RemovedIDs(name string) []ent.Value {
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *TeamGroupMemberMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.clearedgroup {
+ edges = append(edges, teamgroupmember.EdgeGroup)
+ }
+ if m.cleareduser {
+ edges = append(edges, teamgroupmember.EdgeUser)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *TeamGroupMemberMutation) EdgeCleared(name string) bool {
+ switch name {
+ case teamgroupmember.EdgeGroup:
+ return m.clearedgroup
+ case teamgroupmember.EdgeUser:
+ return m.cleareduser
+ }
+ return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *TeamGroupMemberMutation) ClearEdge(name string) error {
+ switch name {
+ case teamgroupmember.EdgeGroup:
+ m.ClearGroup()
+ return nil
+ case teamgroupmember.EdgeUser:
+ m.ClearUser()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroupMember 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 *TeamGroupMemberMutation) ResetEdge(name string) error {
+ switch name {
+ case teamgroupmember.EdgeGroup:
+ m.ResetGroup()
+ return nil
+ case teamgroupmember.EdgeUser:
+ m.ResetUser()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamGroupMember edge %s", name)
+}
+
+// TeamMemberMutation represents an operation that mutates the TeamMember nodes in the graph.
+type TeamMemberMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ role *consts.TeamMemberRole
+ created_at *time.Time
+ clearedFields map[string]struct{}
+ team *uuid.UUID
+ clearedteam bool
+ user *uuid.UUID
+ cleareduser bool
+ done bool
+ oldValue func(context.Context) (*TeamMember, error)
+ predicates []predicate.TeamMember
+}
+
+var _ ent.Mutation = (*TeamMemberMutation)(nil)
+
+// teammemberOption allows management of the mutation configuration using functional options.
+type teammemberOption func(*TeamMemberMutation)
+
+// newTeamMemberMutation creates new mutation for the TeamMember entity.
+func newTeamMemberMutation(c config, op Op, opts ...teammemberOption) *TeamMemberMutation {
+ m := &TeamMemberMutation{
+ config: c,
+ op: op,
+ typ: TypeTeamMember,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withTeamMemberID sets the ID field of the mutation.
+func withTeamMemberID(id uuid.UUID) teammemberOption {
+ return func(m *TeamMemberMutation) {
+ var (
+ err error
+ once sync.Once
+ value *TeamMember
+ )
+ m.oldValue = func(ctx context.Context) (*TeamMember, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().TeamMember.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withTeamMember sets the old TeamMember of the mutation.
+func withTeamMember(node *TeamMember) teammemberOption {
+ return func(m *TeamMemberMutation) {
+ m.oldValue = func(context.Context) (*TeamMember, 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 TeamMemberMutation) 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 TeamMemberMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 TeamMember entities.
+func (m *TeamMemberMutation) 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 *TeamMemberMutation) 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 *TeamMemberMutation) 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().TeamMember.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetTeamID sets the "team_id" field.
+func (m *TeamMemberMutation) SetTeamID(u uuid.UUID) {
+ m.team = &u
+}
+
+// TeamID returns the value of the "team_id" field in the mutation.
+func (m *TeamMemberMutation) TeamID() (r uuid.UUID, exists bool) {
+ v := m.team
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldTeamID returns the old "team_id" field's value of the TeamMember entity.
+// If the TeamMember 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 *TeamMemberMutation) OldTeamID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldTeamID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldTeamID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldTeamID: %w", err)
+ }
+ return oldValue.TeamID, nil
+}
+
+// ResetTeamID resets all changes to the "team_id" field.
+func (m *TeamMemberMutation) ResetTeamID() {
+ m.team = nil
+}
+
+// SetUserID sets the "user_id" field.
+func (m *TeamMemberMutation) SetUserID(u uuid.UUID) {
+ m.user = &u
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *TeamMemberMutation) UserID() (r uuid.UUID, exists bool) {
+ v := m.user
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the TeamMember entity.
+// If the TeamMember 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 *TeamMemberMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+ }
+ return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *TeamMemberMutation) ResetUserID() {
+ m.user = nil
+}
+
+// SetRole sets the "role" field.
+func (m *TeamMemberMutation) SetRole(cmr consts.TeamMemberRole) {
+ m.role = &cmr
+}
+
+// Role returns the value of the "role" field in the mutation.
+func (m *TeamMemberMutation) Role() (r consts.TeamMemberRole, exists bool) {
+ v := m.role
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldRole returns the old "role" field's value of the TeamMember entity.
+// If the TeamMember 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 *TeamMemberMutation) OldRole(ctx context.Context) (v consts.TeamMemberRole, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldRole is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldRole requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldRole: %w", err)
+ }
+ return oldValue.Role, nil
+}
+
+// ResetRole resets all changes to the "role" field.
+func (m *TeamMemberMutation) ResetRole() {
+ m.role = nil
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *TeamMemberMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *TeamMemberMutation) 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 TeamMember entity.
+// If the TeamMember 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 *TeamMemberMutation) 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 *TeamMemberMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (m *TeamMemberMutation) ClearTeam() {
+ m.clearedteam = true
+ m.clearedFields[teammember.FieldTeamID] = struct{}{}
+}
+
+// TeamCleared reports if the "team" edge to the Team entity was cleared.
+func (m *TeamMemberMutation) TeamCleared() bool {
+ return m.clearedteam
+}
+
+// TeamIDs returns the "team" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// TeamID instead. It exists only for internal usage by the builders.
+func (m *TeamMemberMutation) TeamIDs() (ids []uuid.UUID) {
+ if id := m.team; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetTeam resets all changes to the "team" edge.
+func (m *TeamMemberMutation) ResetTeam() {
+ m.team = nil
+ m.clearedteam = false
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *TeamMemberMutation) ClearUser() {
+ m.cleareduser = true
+ m.clearedFields[teammember.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *TeamMemberMutation) UserCleared() bool {
+ return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *TeamMemberMutation) UserIDs() (ids []uuid.UUID) {
+ if id := m.user; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *TeamMemberMutation) ResetUser() {
+ m.user = nil
+ m.cleareduser = false
+}
+
+// Where appends a list predicates to the TeamMemberMutation builder.
+func (m *TeamMemberMutation) Where(ps ...predicate.TeamMember) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the TeamMemberMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *TeamMemberMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.TeamMember, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *TeamMemberMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *TeamMemberMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (TeamMember).
+func (m *TeamMemberMutation) 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 *TeamMemberMutation) Fields() []string {
+ fields := make([]string, 0, 4)
+ if m.team != nil {
+ fields = append(fields, teammember.FieldTeamID)
+ }
+ if m.user != nil {
+ fields = append(fields, teammember.FieldUserID)
+ }
+ if m.role != nil {
+ fields = append(fields, teammember.FieldRole)
+ }
+ if m.created_at != nil {
+ fields = append(fields, teammember.FieldCreatedAt)
+ }
+ 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 *TeamMemberMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case teammember.FieldTeamID:
+ return m.TeamID()
+ case teammember.FieldUserID:
+ return m.UserID()
+ case teammember.FieldRole:
+ return m.Role()
+ case teammember.FieldCreatedAt:
+ return m.CreatedAt()
+ }
+ 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 *TeamMemberMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case teammember.FieldTeamID:
+ return m.OldTeamID(ctx)
+ case teammember.FieldUserID:
+ return m.OldUserID(ctx)
+ case teammember.FieldRole:
+ return m.OldRole(ctx)
+ case teammember.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown TeamMember 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 *TeamMemberMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case teammember.FieldTeamID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetTeamID(v)
+ return nil
+ case teammember.FieldUserID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserID(v)
+ return nil
+ case teammember.FieldRole:
+ v, ok := value.(consts.TeamMemberRole)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetRole(v)
+ return nil
+ case teammember.FieldCreatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetCreatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown TeamMember field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *TeamMemberMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *TeamMemberMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *TeamMemberMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown TeamMember numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *TeamMemberMutation) ClearedFields() []string {
+ return nil
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *TeamMemberMutation) 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 *TeamMemberMutation) ClearField(name string) error {
+ return fmt.Errorf("unknown TeamMember 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 *TeamMemberMutation) ResetField(name string) error {
+ switch name {
+ case teammember.FieldTeamID:
+ m.ResetTeamID()
+ return nil
+ case teammember.FieldUserID:
+ m.ResetUserID()
+ return nil
+ case teammember.FieldRole:
+ m.ResetRole()
+ return nil
+ case teammember.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamMember field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *TeamMemberMutation) AddedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.team != nil {
+ edges = append(edges, teammember.EdgeTeam)
+ }
+ if m.user != nil {
+ edges = append(edges, teammember.EdgeUser)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *TeamMemberMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case teammember.EdgeTeam:
+ if id := m.team; id != nil {
+ return []ent.Value{*id}
+ }
+ case teammember.EdgeUser:
+ if id := m.user; id != nil {
+ return []ent.Value{*id}
+ }
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *TeamMemberMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 2)
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *TeamMemberMutation) RemovedIDs(name string) []ent.Value {
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *TeamMemberMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 2)
+ if m.clearedteam {
+ edges = append(edges, teammember.EdgeTeam)
+ }
+ if m.cleareduser {
+ edges = append(edges, teammember.EdgeUser)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *TeamMemberMutation) EdgeCleared(name string) bool {
+ switch name {
+ case teammember.EdgeTeam:
+ return m.clearedteam
+ case teammember.EdgeUser:
+ return m.cleareduser
+ }
+ return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *TeamMemberMutation) ClearEdge(name string) error {
+ switch name {
+ case teammember.EdgeTeam:
+ m.ClearTeam()
+ return nil
+ case teammember.EdgeUser:
+ m.ClearUser()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamMember 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 *TeamMemberMutation) ResetEdge(name string) error {
+ switch name {
+ case teammember.EdgeTeam:
+ m.ResetTeam()
+ return nil
+ case teammember.EdgeUser:
+ m.ResetUser()
+ return nil
+ }
+ return fmt.Errorf("unknown TeamMember edge %s", name)
+}
+
+// UserMutation represents an operation that mutates the User nodes in the graph.
+type UserMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ deleted_at *time.Time
+ name *string
+ email *string
+ avatar_url *string
+ password *string
+ role *consts.UserRole
+ status *consts.UserStatus
+ is_blocked *bool
+ default_configs *map[consts.DefaultConfigType]uuid.UUID
+ created_at *time.Time
+ updated_at *time.Time
+ clearedFields map[string]struct{}
+ identities map[uuid.UUID]struct{}
+ removedidentities map[uuid.UUID]struct{}
+ clearedidentities bool
+ audits map[uuid.UUID]struct{}
+ removedaudits map[uuid.UUID]struct{}
+ clearedaudits bool
+ teams map[uuid.UUID]struct{}
+ removedteams map[uuid.UUID]struct{}
+ clearedteams bool
+ groups map[uuid.UUID]struct{}
+ removedgroups map[uuid.UUID]struct{}
+ clearedgroups bool
+ team_members map[uuid.UUID]struct{}
+ removedteam_members map[uuid.UUID]struct{}
+ clearedteam_members bool
+ team_group_members map[uuid.UUID]struct{}
+ removedteam_group_members map[uuid.UUID]struct{}
+ clearedteam_group_members bool
+ done bool
+ oldValue func(context.Context) (*User, error)
+ predicates []predicate.User
+}
+
+var _ ent.Mutation = (*UserMutation)(nil)
+
+// userOption allows management of the mutation configuration using functional options.
+type userOption func(*UserMutation)
+
+// newUserMutation creates new mutation for the User entity.
+func newUserMutation(c config, op Op, opts ...userOption) *UserMutation {
+ m := &UserMutation{
+ config: c,
+ op: op,
+ typ: TypeUser,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withUserID sets the ID field of the mutation.
+func withUserID(id uuid.UUID) userOption {
+ return func(m *UserMutation) {
+ var (
+ err error
+ once sync.Once
+ value *User
+ )
+ m.oldValue = func(ctx context.Context) (*User, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().User.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withUser sets the old User of the mutation.
+func withUser(node *User) userOption {
+ return func(m *UserMutation) {
+ m.oldValue = func(context.Context) (*User, 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 UserMutation) 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 UserMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 User entities.
+func (m *UserMutation) 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 *UserMutation) 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 *UserMutation) 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().User.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (m *UserMutation) SetDeletedAt(t time.Time) {
+ m.deleted_at = &t
+}
+
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
+func (m *UserMutation) DeletedAt() (r time.Time, exists bool) {
+ v := m.deleted_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldDeletedAt returns the old "deleted_at" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
+ }
+ return oldValue.DeletedAt, nil
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (m *UserMutation) ClearDeletedAt() {
+ m.deleted_at = nil
+ m.clearedFields[user.FieldDeletedAt] = struct{}{}
+}
+
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
+func (m *UserMutation) DeletedAtCleared() bool {
+ _, ok := m.clearedFields[user.FieldDeletedAt]
+ return ok
+}
+
+// ResetDeletedAt resets all changes to the "deleted_at" field.
+func (m *UserMutation) ResetDeletedAt() {
+ m.deleted_at = nil
+ delete(m.clearedFields, user.FieldDeletedAt)
+}
+
+// SetName sets the "name" field.
+func (m *UserMutation) SetName(s string) {
+ m.name = &s
+}
+
+// Name returns the value of the "name" field in the mutation.
+func (m *UserMutation) Name() (r string, exists bool) {
+ v := m.name
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldName returns the old "name" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldName(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldName is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldName requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldName: %w", err)
+ }
+ return oldValue.Name, nil
+}
+
+// ResetName resets all changes to the "name" field.
+func (m *UserMutation) ResetName() {
+ m.name = nil
+}
+
+// SetEmail sets the "email" field.
+func (m *UserMutation) SetEmail(s string) {
+ m.email = &s
+}
+
+// Email returns the value of the "email" field in the mutation.
+func (m *UserMutation) Email() (r string, exists bool) {
+ v := m.email
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldEmail returns the old "email" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldEmail(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldEmail is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldEmail requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldEmail: %w", err)
+ }
+ return oldValue.Email, nil
+}
+
+// ClearEmail clears the value of the "email" field.
+func (m *UserMutation) ClearEmail() {
+ m.email = nil
+ m.clearedFields[user.FieldEmail] = struct{}{}
+}
+
+// EmailCleared returns if the "email" field was cleared in this mutation.
+func (m *UserMutation) EmailCleared() bool {
+ _, ok := m.clearedFields[user.FieldEmail]
+ return ok
+}
+
+// ResetEmail resets all changes to the "email" field.
+func (m *UserMutation) ResetEmail() {
+ m.email = nil
+ delete(m.clearedFields, user.FieldEmail)
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (m *UserMutation) SetAvatarURL(s string) {
+ m.avatar_url = &s
+}
+
+// AvatarURL returns the value of the "avatar_url" field in the mutation.
+func (m *UserMutation) AvatarURL() (r string, exists bool) {
+ v := m.avatar_url
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldAvatarURL returns the old "avatar_url" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldAvatarURL(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldAvatarURL is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldAvatarURL requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldAvatarURL: %w", err)
+ }
+ return oldValue.AvatarURL, nil
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (m *UserMutation) ClearAvatarURL() {
+ m.avatar_url = nil
+ m.clearedFields[user.FieldAvatarURL] = struct{}{}
+}
+
+// AvatarURLCleared returns if the "avatar_url" field was cleared in this mutation.
+func (m *UserMutation) AvatarURLCleared() bool {
+ _, ok := m.clearedFields[user.FieldAvatarURL]
+ return ok
+}
+
+// ResetAvatarURL resets all changes to the "avatar_url" field.
+func (m *UserMutation) ResetAvatarURL() {
+ m.avatar_url = nil
+ delete(m.clearedFields, user.FieldAvatarURL)
+}
+
+// SetPassword sets the "password" field.
+func (m *UserMutation) SetPassword(s string) {
+ m.password = &s
+}
+
+// Password returns the value of the "password" field in the mutation.
+func (m *UserMutation) Password() (r string, exists bool) {
+ v := m.password
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldPassword returns the old "password" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldPassword(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldPassword is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldPassword requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldPassword: %w", err)
+ }
+ return oldValue.Password, nil
+}
+
+// ClearPassword clears the value of the "password" field.
+func (m *UserMutation) ClearPassword() {
+ m.password = nil
+ m.clearedFields[user.FieldPassword] = struct{}{}
+}
+
+// PasswordCleared returns if the "password" field was cleared in this mutation.
+func (m *UserMutation) PasswordCleared() bool {
+ _, ok := m.clearedFields[user.FieldPassword]
+ return ok
+}
+
+// ResetPassword resets all changes to the "password" field.
+func (m *UserMutation) ResetPassword() {
+ m.password = nil
+ delete(m.clearedFields, user.FieldPassword)
+}
+
+// SetRole sets the "role" field.
+func (m *UserMutation) SetRole(cr consts.UserRole) {
+ m.role = &cr
+}
+
+// Role returns the value of the "role" field in the mutation.
+func (m *UserMutation) Role() (r consts.UserRole, exists bool) {
+ v := m.role
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldRole returns the old "role" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldRole(ctx context.Context) (v consts.UserRole, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldRole is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldRole requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldRole: %w", err)
+ }
+ return oldValue.Role, nil
+}
+
+// ResetRole resets all changes to the "role" field.
+func (m *UserMutation) ResetRole() {
+ m.role = nil
+}
+
+// SetStatus sets the "status" field.
+func (m *UserMutation) SetStatus(cs consts.UserStatus) {
+ m.status = &cs
+}
+
+// Status returns the value of the "status" field in the mutation.
+func (m *UserMutation) Status() (r consts.UserStatus, exists bool) {
+ v := m.status
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldStatus returns the old "status" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldStatus(ctx context.Context) (v consts.UserStatus, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldStatus is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldStatus requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldStatus: %w", err)
+ }
+ return oldValue.Status, nil
+}
+
+// ResetStatus resets all changes to the "status" field.
+func (m *UserMutation) ResetStatus() {
+ m.status = nil
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (m *UserMutation) SetIsBlocked(b bool) {
+ m.is_blocked = &b
+}
+
+// IsBlocked returns the value of the "is_blocked" field in the mutation.
+func (m *UserMutation) IsBlocked() (r bool, exists bool) {
+ v := m.is_blocked
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldIsBlocked returns the old "is_blocked" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldIsBlocked(ctx context.Context) (v bool, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldIsBlocked is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldIsBlocked requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldIsBlocked: %w", err)
+ }
+ return oldValue.IsBlocked, nil
+}
+
+// ResetIsBlocked resets all changes to the "is_blocked" field.
+func (m *UserMutation) ResetIsBlocked() {
+ m.is_blocked = nil
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (m *UserMutation) SetDefaultConfigs(mct map[consts.DefaultConfigType]uuid.UUID) {
+ m.default_configs = &mct
+}
+
+// DefaultConfigs returns the value of the "default_configs" field in the mutation.
+func (m *UserMutation) DefaultConfigs() (r map[consts.DefaultConfigType]uuid.UUID, exists bool) {
+ v := m.default_configs
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldDefaultConfigs returns the old "default_configs" field's value of the User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) OldDefaultConfigs(ctx context.Context) (v map[consts.DefaultConfigType]uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldDefaultConfigs is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldDefaultConfigs requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldDefaultConfigs: %w", err)
+ }
+ return oldValue.DefaultConfigs, nil
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (m *UserMutation) ClearDefaultConfigs() {
+ m.default_configs = nil
+ m.clearedFields[user.FieldDefaultConfigs] = struct{}{}
+}
+
+// DefaultConfigsCleared returns if the "default_configs" field was cleared in this mutation.
+func (m *UserMutation) DefaultConfigsCleared() bool {
+ _, ok := m.clearedFields[user.FieldDefaultConfigs]
+ return ok
+}
+
+// ResetDefaultConfigs resets all changes to the "default_configs" field.
+func (m *UserMutation) ResetDefaultConfigs() {
+ m.default_configs = nil
+ delete(m.clearedFields, user.FieldDefaultConfigs)
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserMutation) 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 User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) 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 *UserMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserMutation) SetUpdatedAt(t time.Time) {
+ m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserMutation) 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 User entity.
+// If the User object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserMutation) 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 *UserMutation) ResetUpdatedAt() {
+ m.updated_at = nil
+}
+
+// AddIdentityIDs adds the "identities" edge to the UserIdentity entity by ids.
+func (m *UserMutation) AddIdentityIDs(ids ...uuid.UUID) {
+ if m.identities == nil {
+ m.identities = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.identities[ids[i]] = struct{}{}
+ }
+}
+
+// ClearIdentities clears the "identities" edge to the UserIdentity entity.
+func (m *UserMutation) ClearIdentities() {
+ m.clearedidentities = true
+}
+
+// IdentitiesCleared reports if the "identities" edge to the UserIdentity entity was cleared.
+func (m *UserMutation) IdentitiesCleared() bool {
+ return m.clearedidentities
+}
+
+// RemoveIdentityIDs removes the "identities" edge to the UserIdentity entity by IDs.
+func (m *UserMutation) RemoveIdentityIDs(ids ...uuid.UUID) {
+ if m.removedidentities == nil {
+ m.removedidentities = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.identities, ids[i])
+ m.removedidentities[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedIdentities returns the removed IDs of the "identities" edge to the UserIdentity entity.
+func (m *UserMutation) RemovedIdentitiesIDs() (ids []uuid.UUID) {
+ for id := range m.removedidentities {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// IdentitiesIDs returns the "identities" edge IDs in the mutation.
+func (m *UserMutation) IdentitiesIDs() (ids []uuid.UUID) {
+ for id := range m.identities {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetIdentities resets all changes to the "identities" edge.
+func (m *UserMutation) ResetIdentities() {
+ m.identities = nil
+ m.clearedidentities = false
+ m.removedidentities = nil
+}
+
+// AddAuditIDs adds the "audits" edge to the Audit entity by ids.
+func (m *UserMutation) AddAuditIDs(ids ...uuid.UUID) {
+ if m.audits == nil {
+ m.audits = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.audits[ids[i]] = struct{}{}
+ }
+}
+
+// ClearAudits clears the "audits" edge to the Audit entity.
+func (m *UserMutation) ClearAudits() {
+ m.clearedaudits = true
+}
+
+// AuditsCleared reports if the "audits" edge to the Audit entity was cleared.
+func (m *UserMutation) AuditsCleared() bool {
+ return m.clearedaudits
+}
+
+// RemoveAuditIDs removes the "audits" edge to the Audit entity by IDs.
+func (m *UserMutation) RemoveAuditIDs(ids ...uuid.UUID) {
+ if m.removedaudits == nil {
+ m.removedaudits = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.audits, ids[i])
+ m.removedaudits[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedAudits returns the removed IDs of the "audits" edge to the Audit entity.
+func (m *UserMutation) RemovedAuditsIDs() (ids []uuid.UUID) {
+ for id := range m.removedaudits {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// AuditsIDs returns the "audits" edge IDs in the mutation.
+func (m *UserMutation) AuditsIDs() (ids []uuid.UUID) {
+ for id := range m.audits {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetAudits resets all changes to the "audits" edge.
+func (m *UserMutation) ResetAudits() {
+ m.audits = nil
+ m.clearedaudits = false
+ m.removedaudits = nil
+}
+
+// AddTeamIDs adds the "teams" edge to the Team entity by ids.
+func (m *UserMutation) AddTeamIDs(ids ...uuid.UUID) {
+ if m.teams == nil {
+ m.teams = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.teams[ids[i]] = struct{}{}
+ }
+}
+
+// ClearTeams clears the "teams" edge to the Team entity.
+func (m *UserMutation) ClearTeams() {
+ m.clearedteams = true
+}
+
+// TeamsCleared reports if the "teams" edge to the Team entity was cleared.
+func (m *UserMutation) TeamsCleared() bool {
+ return m.clearedteams
+}
+
+// RemoveTeamIDs removes the "teams" edge to the Team entity by IDs.
+func (m *UserMutation) RemoveTeamIDs(ids ...uuid.UUID) {
+ if m.removedteams == nil {
+ m.removedteams = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.teams, ids[i])
+ m.removedteams[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedTeams returns the removed IDs of the "teams" edge to the Team entity.
+func (m *UserMutation) RemovedTeamsIDs() (ids []uuid.UUID) {
+ for id := range m.removedteams {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// TeamsIDs returns the "teams" edge IDs in the mutation.
+func (m *UserMutation) TeamsIDs() (ids []uuid.UUID) {
+ for id := range m.teams {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetTeams resets all changes to the "teams" edge.
+func (m *UserMutation) ResetTeams() {
+ m.teams = nil
+ m.clearedteams = false
+ m.removedteams = nil
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by ids.
+func (m *UserMutation) AddGroupIDs(ids ...uuid.UUID) {
+ if m.groups == nil {
+ m.groups = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.groups[ids[i]] = struct{}{}
+ }
+}
+
+// ClearGroups clears the "groups" edge to the TeamGroup entity.
+func (m *UserMutation) ClearGroups() {
+ m.clearedgroups = true
+}
+
+// GroupsCleared reports if the "groups" edge to the TeamGroup entity was cleared.
+func (m *UserMutation) GroupsCleared() bool {
+ return m.clearedgroups
+}
+
+// RemoveGroupIDs removes the "groups" edge to the TeamGroup entity by IDs.
+func (m *UserMutation) RemoveGroupIDs(ids ...uuid.UUID) {
+ if m.removedgroups == nil {
+ m.removedgroups = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.groups, ids[i])
+ m.removedgroups[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedGroups returns the removed IDs of the "groups" edge to the TeamGroup entity.
+func (m *UserMutation) RemovedGroupsIDs() (ids []uuid.UUID) {
+ for id := range m.removedgroups {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// GroupsIDs returns the "groups" edge IDs in the mutation.
+func (m *UserMutation) GroupsIDs() (ids []uuid.UUID) {
+ for id := range m.groups {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetGroups resets all changes to the "groups" edge.
+func (m *UserMutation) ResetGroups() {
+ m.groups = nil
+ m.clearedgroups = false
+ m.removedgroups = nil
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by ids.
+func (m *UserMutation) AddTeamMemberIDs(ids ...uuid.UUID) {
+ if m.team_members == nil {
+ m.team_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.team_members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearTeamMembers clears the "team_members" edge to the TeamMember entity.
+func (m *UserMutation) ClearTeamMembers() {
+ m.clearedteam_members = true
+}
+
+// TeamMembersCleared reports if the "team_members" edge to the TeamMember entity was cleared.
+func (m *UserMutation) TeamMembersCleared() bool {
+ return m.clearedteam_members
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to the TeamMember entity by IDs.
+func (m *UserMutation) RemoveTeamMemberIDs(ids ...uuid.UUID) {
+ if m.removedteam_members == nil {
+ m.removedteam_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.team_members, ids[i])
+ m.removedteam_members[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedTeamMembers returns the removed IDs of the "team_members" edge to the TeamMember entity.
+func (m *UserMutation) RemovedTeamMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedteam_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// TeamMembersIDs returns the "team_members" edge IDs in the mutation.
+func (m *UserMutation) TeamMembersIDs() (ids []uuid.UUID) {
+ for id := range m.team_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetTeamMembers resets all changes to the "team_members" edge.
+func (m *UserMutation) ResetTeamMembers() {
+ m.team_members = nil
+ m.clearedteam_members = false
+ m.removedteam_members = nil
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by ids.
+func (m *UserMutation) AddTeamGroupMemberIDs(ids ...uuid.UUID) {
+ if m.team_group_members == nil {
+ m.team_group_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ m.team_group_members[ids[i]] = struct{}{}
+ }
+}
+
+// ClearTeamGroupMembers clears the "team_group_members" edge to the TeamGroupMember entity.
+func (m *UserMutation) ClearTeamGroupMembers() {
+ m.clearedteam_group_members = true
+}
+
+// TeamGroupMembersCleared reports if the "team_group_members" edge to the TeamGroupMember entity was cleared.
+func (m *UserMutation) TeamGroupMembersCleared() bool {
+ return m.clearedteam_group_members
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (m *UserMutation) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) {
+ if m.removedteam_group_members == nil {
+ m.removedteam_group_members = make(map[uuid.UUID]struct{})
+ }
+ for i := range ids {
+ delete(m.team_group_members, ids[i])
+ m.removedteam_group_members[ids[i]] = struct{}{}
+ }
+}
+
+// RemovedTeamGroupMembers returns the removed IDs of the "team_group_members" edge to the TeamGroupMember entity.
+func (m *UserMutation) RemovedTeamGroupMembersIDs() (ids []uuid.UUID) {
+ for id := range m.removedteam_group_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// TeamGroupMembersIDs returns the "team_group_members" edge IDs in the mutation.
+func (m *UserMutation) TeamGroupMembersIDs() (ids []uuid.UUID) {
+ for id := range m.team_group_members {
+ ids = append(ids, id)
+ }
+ return
+}
+
+// ResetTeamGroupMembers resets all changes to the "team_group_members" edge.
+func (m *UserMutation) ResetTeamGroupMembers() {
+ m.team_group_members = nil
+ m.clearedteam_group_members = false
+ m.removedteam_group_members = nil
+}
+
+// Where appends a list predicates to the UserMutation builder.
+func (m *UserMutation) Where(ps ...predicate.User) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.User, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (User).
+func (m *UserMutation) 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 *UserMutation) Fields() []string {
+ fields := make([]string, 0, 11)
+ if m.deleted_at != nil {
+ fields = append(fields, user.FieldDeletedAt)
+ }
+ if m.name != nil {
+ fields = append(fields, user.FieldName)
+ }
+ if m.email != nil {
+ fields = append(fields, user.FieldEmail)
+ }
+ if m.avatar_url != nil {
+ fields = append(fields, user.FieldAvatarURL)
+ }
+ if m.password != nil {
+ fields = append(fields, user.FieldPassword)
+ }
+ if m.role != nil {
+ fields = append(fields, user.FieldRole)
+ }
+ if m.status != nil {
+ fields = append(fields, user.FieldStatus)
+ }
+ if m.is_blocked != nil {
+ fields = append(fields, user.FieldIsBlocked)
+ }
+ if m.default_configs != nil {
+ fields = append(fields, user.FieldDefaultConfigs)
+ }
+ if m.created_at != nil {
+ fields = append(fields, user.FieldCreatedAt)
+ }
+ if m.updated_at != nil {
+ fields = append(fields, user.FieldUpdatedAt)
+ }
+ 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 *UserMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case user.FieldDeletedAt:
+ return m.DeletedAt()
+ case user.FieldName:
+ return m.Name()
+ case user.FieldEmail:
+ return m.Email()
+ case user.FieldAvatarURL:
+ return m.AvatarURL()
+ case user.FieldPassword:
+ return m.Password()
+ case user.FieldRole:
+ return m.Role()
+ case user.FieldStatus:
+ return m.Status()
+ case user.FieldIsBlocked:
+ return m.IsBlocked()
+ case user.FieldDefaultConfigs:
+ return m.DefaultConfigs()
+ case user.FieldCreatedAt:
+ return m.CreatedAt()
+ case user.FieldUpdatedAt:
+ return m.UpdatedAt()
+ }
+ 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 *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case user.FieldDeletedAt:
+ return m.OldDeletedAt(ctx)
+ case user.FieldName:
+ return m.OldName(ctx)
+ case user.FieldEmail:
+ return m.OldEmail(ctx)
+ case user.FieldAvatarURL:
+ return m.OldAvatarURL(ctx)
+ case user.FieldPassword:
+ return m.OldPassword(ctx)
+ case user.FieldRole:
+ return m.OldRole(ctx)
+ case user.FieldStatus:
+ return m.OldStatus(ctx)
+ case user.FieldIsBlocked:
+ return m.OldIsBlocked(ctx)
+ case user.FieldDefaultConfigs:
+ return m.OldDefaultConfigs(ctx)
+ case user.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ case user.FieldUpdatedAt:
+ return m.OldUpdatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown User 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 *UserMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case user.FieldDeletedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetDeletedAt(v)
+ return nil
+ case user.FieldName:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetName(v)
+ return nil
+ case user.FieldEmail:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetEmail(v)
+ return nil
+ case user.FieldAvatarURL:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetAvatarURL(v)
+ return nil
+ case user.FieldPassword:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetPassword(v)
+ return nil
+ case user.FieldRole:
+ v, ok := value.(consts.UserRole)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetRole(v)
+ return nil
+ case user.FieldStatus:
+ v, ok := value.(consts.UserStatus)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetStatus(v)
+ return nil
+ case user.FieldIsBlocked:
+ v, ok := value.(bool)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetIsBlocked(v)
+ return nil
+ case user.FieldDefaultConfigs:
+ v, ok := value.(map[consts.DefaultConfigType]uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetDefaultConfigs(v)
+ return nil
+ case user.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 user.FieldUpdatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUpdatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown User field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown User numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserMutation) ClearedFields() []string {
+ var fields []string
+ if m.FieldCleared(user.FieldDeletedAt) {
+ fields = append(fields, user.FieldDeletedAt)
+ }
+ if m.FieldCleared(user.FieldEmail) {
+ fields = append(fields, user.FieldEmail)
+ }
+ if m.FieldCleared(user.FieldAvatarURL) {
+ fields = append(fields, user.FieldAvatarURL)
+ }
+ if m.FieldCleared(user.FieldPassword) {
+ fields = append(fields, user.FieldPassword)
+ }
+ if m.FieldCleared(user.FieldDefaultConfigs) {
+ fields = append(fields, user.FieldDefaultConfigs)
+ }
+ return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserMutation) 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 *UserMutation) ClearField(name string) error {
+ switch name {
+ case user.FieldDeletedAt:
+ m.ClearDeletedAt()
+ return nil
+ case user.FieldEmail:
+ m.ClearEmail()
+ return nil
+ case user.FieldAvatarURL:
+ m.ClearAvatarURL()
+ return nil
+ case user.FieldPassword:
+ m.ClearPassword()
+ return nil
+ case user.FieldDefaultConfigs:
+ m.ClearDefaultConfigs()
+ return nil
+ }
+ return fmt.Errorf("unknown User 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 *UserMutation) ResetField(name string) error {
+ switch name {
+ case user.FieldDeletedAt:
+ m.ResetDeletedAt()
+ return nil
+ case user.FieldName:
+ m.ResetName()
+ return nil
+ case user.FieldEmail:
+ m.ResetEmail()
+ return nil
+ case user.FieldAvatarURL:
+ m.ResetAvatarURL()
+ return nil
+ case user.FieldPassword:
+ m.ResetPassword()
+ return nil
+ case user.FieldRole:
+ m.ResetRole()
+ return nil
+ case user.FieldStatus:
+ m.ResetStatus()
+ return nil
+ case user.FieldIsBlocked:
+ m.ResetIsBlocked()
+ return nil
+ case user.FieldDefaultConfigs:
+ m.ResetDefaultConfigs()
+ return nil
+ case user.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ case user.FieldUpdatedAt:
+ m.ResetUpdatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown User field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserMutation) AddedEdges() []string {
+ edges := make([]string, 0, 6)
+ if m.identities != nil {
+ edges = append(edges, user.EdgeIdentities)
+ }
+ if m.audits != nil {
+ edges = append(edges, user.EdgeAudits)
+ }
+ if m.teams != nil {
+ edges = append(edges, user.EdgeTeams)
+ }
+ if m.groups != nil {
+ edges = append(edges, user.EdgeGroups)
+ }
+ if m.team_members != nil {
+ edges = append(edges, user.EdgeTeamMembers)
+ }
+ if m.team_group_members != nil {
+ edges = append(edges, user.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case user.EdgeIdentities:
+ ids := make([]ent.Value, 0, len(m.identities))
+ for id := range m.identities {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeAudits:
+ ids := make([]ent.Value, 0, len(m.audits))
+ for id := range m.audits {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeams:
+ ids := make([]ent.Value, 0, len(m.teams))
+ for id := range m.teams {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeGroups:
+ ids := make([]ent.Value, 0, len(m.groups))
+ for id := range m.groups {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeamMembers:
+ ids := make([]ent.Value, 0, len(m.team_members))
+ for id := range m.team_members {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeamGroupMembers:
+ ids := make([]ent.Value, 0, len(m.team_group_members))
+ for id := range m.team_group_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserMutation) RemovedEdges() []string {
+ edges := make([]string, 0, 6)
+ if m.removedidentities != nil {
+ edges = append(edges, user.EdgeIdentities)
+ }
+ if m.removedaudits != nil {
+ edges = append(edges, user.EdgeAudits)
+ }
+ if m.removedteams != nil {
+ edges = append(edges, user.EdgeTeams)
+ }
+ if m.removedgroups != nil {
+ edges = append(edges, user.EdgeGroups)
+ }
+ if m.removedteam_members != nil {
+ edges = append(edges, user.EdgeTeamMembers)
+ }
+ if m.removedteam_group_members != nil {
+ edges = append(edges, user.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
+// the given name in this mutation.
+func (m *UserMutation) RemovedIDs(name string) []ent.Value {
+ switch name {
+ case user.EdgeIdentities:
+ ids := make([]ent.Value, 0, len(m.removedidentities))
+ for id := range m.removedidentities {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeAudits:
+ ids := make([]ent.Value, 0, len(m.removedaudits))
+ for id := range m.removedaudits {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeams:
+ ids := make([]ent.Value, 0, len(m.removedteams))
+ for id := range m.removedteams {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeGroups:
+ ids := make([]ent.Value, 0, len(m.removedgroups))
+ for id := range m.removedgroups {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeamMembers:
+ ids := make([]ent.Value, 0, len(m.removedteam_members))
+ for id := range m.removedteam_members {
+ ids = append(ids, id)
+ }
+ return ids
+ case user.EdgeTeamGroupMembers:
+ ids := make([]ent.Value, 0, len(m.removedteam_group_members))
+ for id := range m.removedteam_group_members {
+ ids = append(ids, id)
+ }
+ return ids
+ }
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 6)
+ if m.clearedidentities {
+ edges = append(edges, user.EdgeIdentities)
+ }
+ if m.clearedaudits {
+ edges = append(edges, user.EdgeAudits)
+ }
+ if m.clearedteams {
+ edges = append(edges, user.EdgeTeams)
+ }
+ if m.clearedgroups {
+ edges = append(edges, user.EdgeGroups)
+ }
+ if m.clearedteam_members {
+ edges = append(edges, user.EdgeTeamMembers)
+ }
+ if m.clearedteam_group_members {
+ edges = append(edges, user.EdgeTeamGroupMembers)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserMutation) EdgeCleared(name string) bool {
+ switch name {
+ case user.EdgeIdentities:
+ return m.clearedidentities
+ case user.EdgeAudits:
+ return m.clearedaudits
+ case user.EdgeTeams:
+ return m.clearedteams
+ case user.EdgeGroups:
+ return m.clearedgroups
+ case user.EdgeTeamMembers:
+ return m.clearedteam_members
+ case user.EdgeTeamGroupMembers:
+ return m.clearedteam_group_members
+ }
+ 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 *UserMutation) ClearEdge(name string) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown User 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 *UserMutation) ResetEdge(name string) error {
+ switch name {
+ case user.EdgeIdentities:
+ m.ResetIdentities()
+ return nil
+ case user.EdgeAudits:
+ m.ResetAudits()
+ return nil
+ case user.EdgeTeams:
+ m.ResetTeams()
+ return nil
+ case user.EdgeGroups:
+ m.ResetGroups()
+ return nil
+ case user.EdgeTeamMembers:
+ m.ResetTeamMembers()
+ return nil
+ case user.EdgeTeamGroupMembers:
+ m.ResetTeamGroupMembers()
+ return nil
+ }
+ return fmt.Errorf("unknown User edge %s", name)
+}
+
+// UserIdentityMutation represents an operation that mutates the UserIdentity nodes in the graph.
+type UserIdentityMutation struct {
+ config
+ op Op
+ typ string
+ id *uuid.UUID
+ deleted_at *time.Time
+ platform *consts.UserPlatform
+ identity_id *string
+ username *string
+ email *string
+ avatar_url *string
+ created_at *time.Time
+ updated_at *time.Time
+ clearedFields map[string]struct{}
+ user *uuid.UUID
+ cleareduser bool
+ done bool
+ oldValue func(context.Context) (*UserIdentity, error)
+ predicates []predicate.UserIdentity
+}
+
+var _ ent.Mutation = (*UserIdentityMutation)(nil)
+
+// useridentityOption allows management of the mutation configuration using functional options.
+type useridentityOption func(*UserIdentityMutation)
+
+// newUserIdentityMutation creates new mutation for the UserIdentity entity.
+func newUserIdentityMutation(c config, op Op, opts ...useridentityOption) *UserIdentityMutation {
+ m := &UserIdentityMutation{
+ config: c,
+ op: op,
+ typ: TypeUserIdentity,
+ clearedFields: make(map[string]struct{}),
+ }
+ for _, opt := range opts {
+ opt(m)
+ }
+ return m
+}
+
+// withUserIdentityID sets the ID field of the mutation.
+func withUserIdentityID(id uuid.UUID) useridentityOption {
+ return func(m *UserIdentityMutation) {
+ var (
+ err error
+ once sync.Once
+ value *UserIdentity
+ )
+ m.oldValue = func(ctx context.Context) (*UserIdentity, error) {
+ once.Do(func() {
+ if m.done {
+ err = errors.New("querying old values post mutation is not allowed")
+ } else {
+ value, err = m.Client().UserIdentity.Get(ctx, id)
+ }
+ })
+ return value, err
+ }
+ m.id = &id
+ }
+}
+
+// withUserIdentity sets the old UserIdentity of the mutation.
+func withUserIdentity(node *UserIdentity) useridentityOption {
+ return func(m *UserIdentityMutation) {
+ m.oldValue = func(context.Context) (*UserIdentity, 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 UserIdentityMutation) 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 UserIdentityMutation) Tx() (*Tx, error) {
+ if _, ok := m.driver.(*txDriver); !ok {
+ return nil, errors.New("db: 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 UserIdentity entities.
+func (m *UserIdentityMutation) 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 *UserIdentityMutation) 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 *UserIdentityMutation) 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().UserIdentity.Query().Where(m.predicates...).IDs(ctx)
+ default:
+ return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
+ }
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (m *UserIdentityMutation) SetDeletedAt(t time.Time) {
+ m.deleted_at = &t
+}
+
+// DeletedAt returns the value of the "deleted_at" field in the mutation.
+func (m *UserIdentityMutation) DeletedAt() (r time.Time, exists bool) {
+ v := m.deleted_at
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldDeletedAt returns the old "deleted_at" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldDeletedAt is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldDeletedAt requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldDeletedAt: %w", err)
+ }
+ return oldValue.DeletedAt, nil
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (m *UserIdentityMutation) ClearDeletedAt() {
+ m.deleted_at = nil
+ m.clearedFields[useridentity.FieldDeletedAt] = struct{}{}
+}
+
+// DeletedAtCleared returns if the "deleted_at" field was cleared in this mutation.
+func (m *UserIdentityMutation) DeletedAtCleared() bool {
+ _, ok := m.clearedFields[useridentity.FieldDeletedAt]
+ return ok
+}
+
+// ResetDeletedAt resets all changes to the "deleted_at" field.
+func (m *UserIdentityMutation) ResetDeletedAt() {
+ m.deleted_at = nil
+ delete(m.clearedFields, useridentity.FieldDeletedAt)
+}
+
+// SetUserID sets the "user_id" field.
+func (m *UserIdentityMutation) SetUserID(u uuid.UUID) {
+ m.user = &u
+}
+
+// UserID returns the value of the "user_id" field in the mutation.
+func (m *UserIdentityMutation) UserID() (r uuid.UUID, exists bool) {
+ v := m.user
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUserID returns the old "user_id" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldUserID(ctx context.Context) (v uuid.UUID, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUserID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUserID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUserID: %w", err)
+ }
+ return oldValue.UserID, nil
+}
+
+// ResetUserID resets all changes to the "user_id" field.
+func (m *UserIdentityMutation) ResetUserID() {
+ m.user = nil
+}
+
+// SetPlatform sets the "platform" field.
+func (m *UserIdentityMutation) SetPlatform(cp consts.UserPlatform) {
+ m.platform = &cp
+}
+
+// Platform returns the value of the "platform" field in the mutation.
+func (m *UserIdentityMutation) Platform() (r consts.UserPlatform, exists bool) {
+ v := m.platform
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldPlatform returns the old "platform" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldPlatform(ctx context.Context) (v consts.UserPlatform, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldPlatform is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldPlatform requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldPlatform: %w", err)
+ }
+ return oldValue.Platform, nil
+}
+
+// ResetPlatform resets all changes to the "platform" field.
+func (m *UserIdentityMutation) ResetPlatform() {
+ m.platform = nil
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (m *UserIdentityMutation) SetIdentityID(s string) {
+ m.identity_id = &s
+}
+
+// IdentityID returns the value of the "identity_id" field in the mutation.
+func (m *UserIdentityMutation) IdentityID() (r string, exists bool) {
+ v := m.identity_id
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldIdentityID returns the old "identity_id" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldIdentityID(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldIdentityID is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldIdentityID requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldIdentityID: %w", err)
+ }
+ return oldValue.IdentityID, nil
+}
+
+// ResetIdentityID resets all changes to the "identity_id" field.
+func (m *UserIdentityMutation) ResetIdentityID() {
+ m.identity_id = nil
+}
+
+// SetUsername sets the "username" field.
+func (m *UserIdentityMutation) SetUsername(s string) {
+ m.username = &s
+}
+
+// Username returns the value of the "username" field in the mutation.
+func (m *UserIdentityMutation) Username() (r string, exists bool) {
+ v := m.username
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldUsername returns the old "username" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldUsername(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldUsername is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldUsername requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldUsername: %w", err)
+ }
+ return oldValue.Username, nil
+}
+
+// ResetUsername resets all changes to the "username" field.
+func (m *UserIdentityMutation) ResetUsername() {
+ m.username = nil
+}
+
+// SetEmail sets the "email" field.
+func (m *UserIdentityMutation) SetEmail(s string) {
+ m.email = &s
+}
+
+// Email returns the value of the "email" field in the mutation.
+func (m *UserIdentityMutation) Email() (r string, exists bool) {
+ v := m.email
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldEmail returns the old "email" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldEmail(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldEmail is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldEmail requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldEmail: %w", err)
+ }
+ return oldValue.Email, nil
+}
+
+// ClearEmail clears the value of the "email" field.
+func (m *UserIdentityMutation) ClearEmail() {
+ m.email = nil
+ m.clearedFields[useridentity.FieldEmail] = struct{}{}
+}
+
+// EmailCleared returns if the "email" field was cleared in this mutation.
+func (m *UserIdentityMutation) EmailCleared() bool {
+ _, ok := m.clearedFields[useridentity.FieldEmail]
+ return ok
+}
+
+// ResetEmail resets all changes to the "email" field.
+func (m *UserIdentityMutation) ResetEmail() {
+ m.email = nil
+ delete(m.clearedFields, useridentity.FieldEmail)
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (m *UserIdentityMutation) SetAvatarURL(s string) {
+ m.avatar_url = &s
+}
+
+// AvatarURL returns the value of the "avatar_url" field in the mutation.
+func (m *UserIdentityMutation) AvatarURL() (r string, exists bool) {
+ v := m.avatar_url
+ if v == nil {
+ return
+ }
+ return *v, true
+}
+
+// OldAvatarURL returns the old "avatar_url" field's value of the UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) OldAvatarURL(ctx context.Context) (v string, err error) {
+ if !m.op.Is(OpUpdateOne) {
+ return v, errors.New("OldAvatarURL is only allowed on UpdateOne operations")
+ }
+ if m.id == nil || m.oldValue == nil {
+ return v, errors.New("OldAvatarURL requires an ID field in the mutation")
+ }
+ oldValue, err := m.oldValue(ctx)
+ if err != nil {
+ return v, fmt.Errorf("querying old value for OldAvatarURL: %w", err)
+ }
+ return oldValue.AvatarURL, nil
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (m *UserIdentityMutation) ClearAvatarURL() {
+ m.avatar_url = nil
+ m.clearedFields[useridentity.FieldAvatarURL] = struct{}{}
+}
+
+// AvatarURLCleared returns if the "avatar_url" field was cleared in this mutation.
+func (m *UserIdentityMutation) AvatarURLCleared() bool {
+ _, ok := m.clearedFields[useridentity.FieldAvatarURL]
+ return ok
+}
+
+// ResetAvatarURL resets all changes to the "avatar_url" field.
+func (m *UserIdentityMutation) ResetAvatarURL() {
+ m.avatar_url = nil
+ delete(m.clearedFields, useridentity.FieldAvatarURL)
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (m *UserIdentityMutation) SetCreatedAt(t time.Time) {
+ m.created_at = &t
+}
+
+// CreatedAt returns the value of the "created_at" field in the mutation.
+func (m *UserIdentityMutation) 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 UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) 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 *UserIdentityMutation) ResetCreatedAt() {
+ m.created_at = nil
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (m *UserIdentityMutation) SetUpdatedAt(t time.Time) {
+ m.updated_at = &t
+}
+
+// UpdatedAt returns the value of the "updated_at" field in the mutation.
+func (m *UserIdentityMutation) 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 UserIdentity entity.
+// If the UserIdentity 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 *UserIdentityMutation) 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
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (m *UserIdentityMutation) ClearUpdatedAt() {
+ m.updated_at = nil
+ m.clearedFields[useridentity.FieldUpdatedAt] = struct{}{}
+}
+
+// UpdatedAtCleared returns if the "updated_at" field was cleared in this mutation.
+func (m *UserIdentityMutation) UpdatedAtCleared() bool {
+ _, ok := m.clearedFields[useridentity.FieldUpdatedAt]
+ return ok
+}
+
+// ResetUpdatedAt resets all changes to the "updated_at" field.
+func (m *UserIdentityMutation) ResetUpdatedAt() {
+ m.updated_at = nil
+ delete(m.clearedFields, useridentity.FieldUpdatedAt)
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (m *UserIdentityMutation) ClearUser() {
+ m.cleareduser = true
+ m.clearedFields[useridentity.FieldUserID] = struct{}{}
+}
+
+// UserCleared reports if the "user" edge to the User entity was cleared.
+func (m *UserIdentityMutation) UserCleared() bool {
+ return m.cleareduser
+}
+
+// UserIDs returns the "user" edge IDs in the mutation.
+// Note that IDs always returns len(IDs) <= 1 for unique edges, and you should use
+// UserID instead. It exists only for internal usage by the builders.
+func (m *UserIdentityMutation) UserIDs() (ids []uuid.UUID) {
+ if id := m.user; id != nil {
+ ids = append(ids, *id)
+ }
+ return
+}
+
+// ResetUser resets all changes to the "user" edge.
+func (m *UserIdentityMutation) ResetUser() {
+ m.user = nil
+ m.cleareduser = false
+}
+
+// Where appends a list predicates to the UserIdentityMutation builder.
+func (m *UserIdentityMutation) Where(ps ...predicate.UserIdentity) {
+ m.predicates = append(m.predicates, ps...)
+}
+
+// WhereP appends storage-level predicates to the UserIdentityMutation builder. Using this method,
+// users can use type-assertion to append predicates that do not depend on any generated package.
+func (m *UserIdentityMutation) WhereP(ps ...func(*sql.Selector)) {
+ p := make([]predicate.UserIdentity, len(ps))
+ for i := range ps {
+ p[i] = ps[i]
+ }
+ m.Where(p...)
+}
+
+// Op returns the operation name.
+func (m *UserIdentityMutation) Op() Op {
+ return m.op
+}
+
+// SetOp allows setting the mutation operation.
+func (m *UserIdentityMutation) SetOp(op Op) {
+ m.op = op
+}
+
+// Type returns the node type of this mutation (UserIdentity).
+func (m *UserIdentityMutation) 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 *UserIdentityMutation) Fields() []string {
+ fields := make([]string, 0, 9)
+ if m.deleted_at != nil {
+ fields = append(fields, useridentity.FieldDeletedAt)
+ }
+ if m.user != nil {
+ fields = append(fields, useridentity.FieldUserID)
+ }
+ if m.platform != nil {
+ fields = append(fields, useridentity.FieldPlatform)
+ }
+ if m.identity_id != nil {
+ fields = append(fields, useridentity.FieldIdentityID)
+ }
+ if m.username != nil {
+ fields = append(fields, useridentity.FieldUsername)
+ }
+ if m.email != nil {
+ fields = append(fields, useridentity.FieldEmail)
+ }
+ if m.avatar_url != nil {
+ fields = append(fields, useridentity.FieldAvatarURL)
+ }
+ if m.created_at != nil {
+ fields = append(fields, useridentity.FieldCreatedAt)
+ }
+ if m.updated_at != nil {
+ fields = append(fields, useridentity.FieldUpdatedAt)
+ }
+ 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 *UserIdentityMutation) Field(name string) (ent.Value, bool) {
+ switch name {
+ case useridentity.FieldDeletedAt:
+ return m.DeletedAt()
+ case useridentity.FieldUserID:
+ return m.UserID()
+ case useridentity.FieldPlatform:
+ return m.Platform()
+ case useridentity.FieldIdentityID:
+ return m.IdentityID()
+ case useridentity.FieldUsername:
+ return m.Username()
+ case useridentity.FieldEmail:
+ return m.Email()
+ case useridentity.FieldAvatarURL:
+ return m.AvatarURL()
+ case useridentity.FieldCreatedAt:
+ return m.CreatedAt()
+ case useridentity.FieldUpdatedAt:
+ return m.UpdatedAt()
+ }
+ 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 *UserIdentityMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
+ switch name {
+ case useridentity.FieldDeletedAt:
+ return m.OldDeletedAt(ctx)
+ case useridentity.FieldUserID:
+ return m.OldUserID(ctx)
+ case useridentity.FieldPlatform:
+ return m.OldPlatform(ctx)
+ case useridentity.FieldIdentityID:
+ return m.OldIdentityID(ctx)
+ case useridentity.FieldUsername:
+ return m.OldUsername(ctx)
+ case useridentity.FieldEmail:
+ return m.OldEmail(ctx)
+ case useridentity.FieldAvatarURL:
+ return m.OldAvatarURL(ctx)
+ case useridentity.FieldCreatedAt:
+ return m.OldCreatedAt(ctx)
+ case useridentity.FieldUpdatedAt:
+ return m.OldUpdatedAt(ctx)
+ }
+ return nil, fmt.Errorf("unknown UserIdentity 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 *UserIdentityMutation) SetField(name string, value ent.Value) error {
+ switch name {
+ case useridentity.FieldDeletedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetDeletedAt(v)
+ return nil
+ case useridentity.FieldUserID:
+ v, ok := value.(uuid.UUID)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUserID(v)
+ return nil
+ case useridentity.FieldPlatform:
+ v, ok := value.(consts.UserPlatform)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetPlatform(v)
+ return nil
+ case useridentity.FieldIdentityID:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetIdentityID(v)
+ return nil
+ case useridentity.FieldUsername:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUsername(v)
+ return nil
+ case useridentity.FieldEmail:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetEmail(v)
+ return nil
+ case useridentity.FieldAvatarURL:
+ v, ok := value.(string)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetAvatarURL(v)
+ return nil
+ case useridentity.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 useridentity.FieldUpdatedAt:
+ v, ok := value.(time.Time)
+ if !ok {
+ return fmt.Errorf("unexpected type %T for field %s", value, name)
+ }
+ m.SetUpdatedAt(v)
+ return nil
+ }
+ return fmt.Errorf("unknown UserIdentity field %s", name)
+}
+
+// AddedFields returns all numeric fields that were incremented/decremented during
+// this mutation.
+func (m *UserIdentityMutation) AddedFields() []string {
+ return nil
+}
+
+// AddedField returns the numeric value that was incremented/decremented on a field
+// with the given name. The second boolean return value indicates that this field
+// was not set, or was not defined in the schema.
+func (m *UserIdentityMutation) AddedField(name string) (ent.Value, bool) {
+ return nil, false
+}
+
+// AddField adds the value to the field with the given name. It returns an error if
+// the field is not defined in the schema, or if the type mismatched the field
+// type.
+func (m *UserIdentityMutation) AddField(name string, value ent.Value) error {
+ switch name {
+ }
+ return fmt.Errorf("unknown UserIdentity numeric field %s", name)
+}
+
+// ClearedFields returns all nullable fields that were cleared during this
+// mutation.
+func (m *UserIdentityMutation) ClearedFields() []string {
+ var fields []string
+ if m.FieldCleared(useridentity.FieldDeletedAt) {
+ fields = append(fields, useridentity.FieldDeletedAt)
+ }
+ if m.FieldCleared(useridentity.FieldEmail) {
+ fields = append(fields, useridentity.FieldEmail)
+ }
+ if m.FieldCleared(useridentity.FieldAvatarURL) {
+ fields = append(fields, useridentity.FieldAvatarURL)
+ }
+ if m.FieldCleared(useridentity.FieldUpdatedAt) {
+ fields = append(fields, useridentity.FieldUpdatedAt)
+ }
+ return fields
+}
+
+// FieldCleared returns a boolean indicating if a field with the given name was
+// cleared in this mutation.
+func (m *UserIdentityMutation) 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 *UserIdentityMutation) ClearField(name string) error {
+ switch name {
+ case useridentity.FieldDeletedAt:
+ m.ClearDeletedAt()
+ return nil
+ case useridentity.FieldEmail:
+ m.ClearEmail()
+ return nil
+ case useridentity.FieldAvatarURL:
+ m.ClearAvatarURL()
+ return nil
+ case useridentity.FieldUpdatedAt:
+ m.ClearUpdatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown UserIdentity 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 *UserIdentityMutation) ResetField(name string) error {
+ switch name {
+ case useridentity.FieldDeletedAt:
+ m.ResetDeletedAt()
+ return nil
+ case useridentity.FieldUserID:
+ m.ResetUserID()
+ return nil
+ case useridentity.FieldPlatform:
+ m.ResetPlatform()
+ return nil
+ case useridentity.FieldIdentityID:
+ m.ResetIdentityID()
+ return nil
+ case useridentity.FieldUsername:
+ m.ResetUsername()
+ return nil
+ case useridentity.FieldEmail:
+ m.ResetEmail()
+ return nil
+ case useridentity.FieldAvatarURL:
+ m.ResetAvatarURL()
+ return nil
+ case useridentity.FieldCreatedAt:
+ m.ResetCreatedAt()
+ return nil
+ case useridentity.FieldUpdatedAt:
+ m.ResetUpdatedAt()
+ return nil
+ }
+ return fmt.Errorf("unknown UserIdentity field %s", name)
+}
+
+// AddedEdges returns all edge names that were set/added in this mutation.
+func (m *UserIdentityMutation) AddedEdges() []string {
+ edges := make([]string, 0, 1)
+ if m.user != nil {
+ edges = append(edges, useridentity.EdgeUser)
+ }
+ return edges
+}
+
+// AddedIDs returns all IDs (to other nodes) that were added for the given edge
+// name in this mutation.
+func (m *UserIdentityMutation) AddedIDs(name string) []ent.Value {
+ switch name {
+ case useridentity.EdgeUser:
+ if id := m.user; id != nil {
+ return []ent.Value{*id}
+ }
+ }
+ return nil
+}
+
+// RemovedEdges returns all edge names that were removed in this mutation.
+func (m *UserIdentityMutation) 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 *UserIdentityMutation) RemovedIDs(name string) []ent.Value {
+ return nil
+}
+
+// ClearedEdges returns all edge names that were cleared in this mutation.
+func (m *UserIdentityMutation) ClearedEdges() []string {
+ edges := make([]string, 0, 1)
+ if m.cleareduser {
+ edges = append(edges, useridentity.EdgeUser)
+ }
+ return edges
+}
+
+// EdgeCleared returns a boolean which indicates if the edge with the given name
+// was cleared in this mutation.
+func (m *UserIdentityMutation) EdgeCleared(name string) bool {
+ switch name {
+ case useridentity.EdgeUser:
+ return m.cleareduser
+ }
+ return false
+}
+
+// ClearEdge clears the value of the edge with the given name. It returns an error
+// if that edge is not defined in the schema.
+func (m *UserIdentityMutation) ClearEdge(name string) error {
+ switch name {
+ case useridentity.EdgeUser:
+ m.ClearUser()
+ return nil
+ }
+ return fmt.Errorf("unknown UserIdentity 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 *UserIdentityMutation) ResetEdge(name string) error {
+ switch name {
+ case useridentity.EdgeUser:
+ m.ResetUser()
+ return nil
+ }
+ return fmt.Errorf("unknown UserIdentity edge %s", name)
+}
diff --git a/backend/db/page.go b/backend/db/page.go
new file mode 100644
index 00000000..6e19a44a
--- /dev/null
+++ b/backend/db/page.go
@@ -0,0 +1,110 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import "context"
+
+// PageInfo 分页信息
+type PageInfo struct {
+ NextToken string `json:"next_token,omitempty"`
+ HasNextPage bool `json:"has_next_page"`
+ TotalCount int64 `json:"total_count"`
+}
+
+func (_m *AuditQuery) Page(ctx context.Context, page, size int) ([]*Audit, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *TeamQuery) Page(ctx context.Context, page, size int) ([]*Team, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *TeamGroupQuery) Page(ctx context.Context, page, size int) ([]*TeamGroup, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *TeamGroupMemberQuery) Page(ctx context.Context, page, size int) ([]*TeamGroupMember, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *TeamMemberQuery) Page(ctx context.Context, page, size int) ([]*TeamMember, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *UserQuery) Page(ctx context.Context, page, size int) ([]*User, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (_m *UserIdentityQuery) Page(ctx context.Context, page, size int) ([]*UserIdentity, *PageInfo, error) {
+ cnt, err := _m.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := _m.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
diff --git a/backend/db/predicate/predicate.go b/backend/db/predicate/predicate.go
new file mode 100644
index 00000000..f896b006
--- /dev/null
+++ b/backend/db/predicate/predicate.go
@@ -0,0 +1,28 @@
+// Code generated by ent, DO NOT EDIT.
+
+package predicate
+
+import (
+ "entgo.io/ent/dialect/sql"
+)
+
+// Audit is the predicate function for audit builders.
+type Audit func(*sql.Selector)
+
+// Team is the predicate function for team builders.
+type Team func(*sql.Selector)
+
+// TeamGroup is the predicate function for teamgroup builders.
+type TeamGroup func(*sql.Selector)
+
+// TeamGroupMember is the predicate function for teamgroupmember builders.
+type TeamGroupMember func(*sql.Selector)
+
+// TeamMember is the predicate function for teammember builders.
+type TeamMember func(*sql.Selector)
+
+// User is the predicate function for user builders.
+type User func(*sql.Selector)
+
+// UserIdentity is the predicate function for useridentity builders.
+type UserIdentity func(*sql.Selector)
diff --git a/backend/db/runtime.go b/backend/db/runtime.go
new file mode 100644
index 00000000..2693c251
--- /dev/null
+++ b/backend/db/runtime.go
@@ -0,0 +1,5 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+// The schema-stitching logic is generated in github.com/chaitin/MonkeyCode/backend/db/runtime/runtime.go
diff --git a/backend/db/runtime/runtime.go b/backend/db/runtime/runtime.go
new file mode 100644
index 00000000..c4443089
--- /dev/null
+++ b/backend/db/runtime/runtime.go
@@ -0,0 +1,133 @@
+// Code generated by ent, DO NOT EDIT.
+
+package runtime
+
+import (
+ "time"
+
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/chaitin/MonkeyCode/backend/ent/schema"
+)
+
+// The init function reads all schema descriptors with runtime code
+// (default values, validators, hooks and policies) and stitches it
+// to their package variables.
+func init() {
+ auditFields := schema.Audit{}.Fields()
+ _ = auditFields
+ // auditDescCreatedAt is the schema descriptor for created_at field.
+ auditDescCreatedAt := auditFields[7].Descriptor()
+ // audit.DefaultCreatedAt holds the default value on creation for the created_at field.
+ audit.DefaultCreatedAt = auditDescCreatedAt.Default.(func() time.Time)
+ teamMixin := schema.Team{}.Mixin()
+ teamMixinHooks0 := teamMixin[0].Hooks()
+ team.Hooks[0] = teamMixinHooks0[0]
+ teamMixinInters0 := teamMixin[0].Interceptors()
+ team.Interceptors[0] = teamMixinInters0[0]
+ teamFields := schema.Team{}.Fields()
+ _ = teamFields
+ // teamDescName is the schema descriptor for name field.
+ teamDescName := teamFields[1].Descriptor()
+ // team.NameValidator is a validator for the "name" field. It is called by the builders before save.
+ team.NameValidator = teamDescName.Validators[0].(func(string) error)
+ // teamDescCreatedAt is the schema descriptor for created_at field.
+ teamDescCreatedAt := teamFields[3].Descriptor()
+ // team.DefaultCreatedAt holds the default value on creation for the created_at field.
+ team.DefaultCreatedAt = teamDescCreatedAt.Default.(func() time.Time)
+ // teamDescUpdatedAt is the schema descriptor for updated_at field.
+ teamDescUpdatedAt := teamFields[4].Descriptor()
+ // team.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+ team.DefaultUpdatedAt = teamDescUpdatedAt.Default.(func() time.Time)
+ teamgroupMixin := schema.TeamGroup{}.Mixin()
+ teamgroupMixinHooks0 := teamgroupMixin[0].Hooks()
+ teamgroup.Hooks[0] = teamgroupMixinHooks0[0]
+ teamgroupMixinInters0 := teamgroupMixin[0].Interceptors()
+ teamgroup.Interceptors[0] = teamgroupMixinInters0[0]
+ teamgroupFields := schema.TeamGroup{}.Fields()
+ _ = teamgroupFields
+ // teamgroupDescCreatedAt is the schema descriptor for created_at field.
+ teamgroupDescCreatedAt := teamgroupFields[3].Descriptor()
+ // teamgroup.DefaultCreatedAt holds the default value on creation for the created_at field.
+ teamgroup.DefaultCreatedAt = teamgroupDescCreatedAt.Default.(func() time.Time)
+ // teamgroupDescUpdatedAt is the schema descriptor for updated_at field.
+ teamgroupDescUpdatedAt := teamgroupFields[4].Descriptor()
+ // teamgroup.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+ teamgroup.DefaultUpdatedAt = teamgroupDescUpdatedAt.Default.(func() time.Time)
+ // teamgroup.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+ teamgroup.UpdateDefaultUpdatedAt = teamgroupDescUpdatedAt.UpdateDefault.(func() time.Time)
+ teamgroupmemberFields := schema.TeamGroupMember{}.Fields()
+ _ = teamgroupmemberFields
+ // teamgroupmemberDescCreatedAt is the schema descriptor for created_at field.
+ teamgroupmemberDescCreatedAt := teamgroupmemberFields[3].Descriptor()
+ // teamgroupmember.DefaultCreatedAt holds the default value on creation for the created_at field.
+ teamgroupmember.DefaultCreatedAt = teamgroupmemberDescCreatedAt.Default.(func() time.Time)
+ teammemberFields := schema.TeamMember{}.Fields()
+ _ = teammemberFields
+ // teammemberDescCreatedAt is the schema descriptor for created_at field.
+ teammemberDescCreatedAt := teammemberFields[4].Descriptor()
+ // teammember.DefaultCreatedAt holds the default value on creation for the created_at field.
+ teammember.DefaultCreatedAt = teammemberDescCreatedAt.Default.(func() time.Time)
+ userMixin := schema.User{}.Mixin()
+ userMixinHooks0 := userMixin[0].Hooks()
+ user.Hooks[0] = userMixinHooks0[0]
+ userMixinInters0 := userMixin[0].Interceptors()
+ user.Interceptors[0] = userMixinInters0[0]
+ userFields := schema.User{}.Fields()
+ _ = userFields
+ // userDescName is the schema descriptor for name field.
+ userDescName := userFields[1].Descriptor()
+ // user.NameValidator is a validator for the "name" field. It is called by the builders before save.
+ user.NameValidator = userDescName.Validators[0].(func(string) error)
+ // userDescIsBlocked is the schema descriptor for is_blocked field.
+ userDescIsBlocked := userFields[7].Descriptor()
+ // user.DefaultIsBlocked holds the default value on creation for the is_blocked field.
+ user.DefaultIsBlocked = userDescIsBlocked.Default.(bool)
+ // userDescCreatedAt is the schema descriptor for created_at field.
+ userDescCreatedAt := userFields[9].Descriptor()
+ // user.DefaultCreatedAt holds the default value on creation for the created_at field.
+ user.DefaultCreatedAt = userDescCreatedAt.Default.(func() time.Time)
+ // userDescUpdatedAt is the schema descriptor for updated_at field.
+ userDescUpdatedAt := userFields[10].Descriptor()
+ // user.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+ user.DefaultUpdatedAt = userDescUpdatedAt.Default.(func() time.Time)
+ // user.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+ user.UpdateDefaultUpdatedAt = userDescUpdatedAt.UpdateDefault.(func() time.Time)
+ useridentityMixin := schema.UserIdentity{}.Mixin()
+ useridentityMixinHooks0 := useridentityMixin[0].Hooks()
+ useridentity.Hooks[0] = useridentityMixinHooks0[0]
+ useridentityMixinInters0 := useridentityMixin[0].Interceptors()
+ useridentity.Interceptors[0] = useridentityMixinInters0[0]
+ useridentityFields := schema.UserIdentity{}.Fields()
+ _ = useridentityFields
+ // useridentityDescPlatform is the schema descriptor for platform field.
+ useridentityDescPlatform := useridentityFields[2].Descriptor()
+ // useridentity.PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
+ useridentity.PlatformValidator = useridentityDescPlatform.Validators[0].(func(string) error)
+ // useridentityDescIdentityID is the schema descriptor for identity_id field.
+ useridentityDescIdentityID := useridentityFields[3].Descriptor()
+ // useridentity.IdentityIDValidator is a validator for the "identity_id" field. It is called by the builders before save.
+ useridentity.IdentityIDValidator = useridentityDescIdentityID.Validators[0].(func(string) error)
+ // useridentityDescUsername is the schema descriptor for username field.
+ useridentityDescUsername := useridentityFields[4].Descriptor()
+ // useridentity.UsernameValidator is a validator for the "username" field. It is called by the builders before save.
+ useridentity.UsernameValidator = useridentityDescUsername.Validators[0].(func(string) error)
+ // useridentityDescCreatedAt is the schema descriptor for created_at field.
+ useridentityDescCreatedAt := useridentityFields[7].Descriptor()
+ // useridentity.DefaultCreatedAt holds the default value on creation for the created_at field.
+ useridentity.DefaultCreatedAt = useridentityDescCreatedAt.Default.(func() time.Time)
+ // useridentityDescUpdatedAt is the schema descriptor for updated_at field.
+ useridentityDescUpdatedAt := useridentityFields[8].Descriptor()
+ // useridentity.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+ useridentity.UpdateDefaultUpdatedAt = useridentityDescUpdatedAt.UpdateDefault.(func() time.Time)
+}
+
+const (
+ Version = "v0.14.5" // Version of ent codegen.
+ Sum = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen.
+)
diff --git a/backend/db/team.go b/backend/db/team.go
new file mode 100644
index 00000000..400e58d1
--- /dev/null
+++ b/backend/db/team.go
@@ -0,0 +1,211 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/google/uuid"
+)
+
+// Team is the model entity for the Team schema.
+type Team struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // DeletedAt holds the value of the "deleted_at" field.
+ DeletedAt time.Time `json:"deleted_at,omitempty"`
+ // Name holds the value of the "name" field.
+ Name string `json:"name,omitempty"`
+ // MemberLimit holds the value of the "member_limit" field.
+ MemberLimit int `json:"member_limit,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"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the TeamQuery when eager-loading is set.
+ Edges TeamEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// TeamEdges holds the relations/edges for other nodes in the graph.
+type TeamEdges struct {
+ // Groups holds the value of the groups edge.
+ Groups []*TeamGroup `json:"groups,omitempty"`
+ // Members holds the value of the members edge.
+ Members []*User `json:"members,omitempty"`
+ // TeamMembers holds the value of the team_members edge.
+ TeamMembers []*TeamMember `json:"team_members,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [3]bool
+}
+
+// GroupsOrErr returns the Groups value or an error if the edge
+// was not loaded in eager-loading.
+func (e TeamEdges) GroupsOrErr() ([]*TeamGroup, error) {
+ if e.loadedTypes[0] {
+ return e.Groups, nil
+ }
+ return nil, &NotLoadedError{edge: "groups"}
+}
+
+// MembersOrErr returns the Members value or an error if the edge
+// was not loaded in eager-loading.
+func (e TeamEdges) MembersOrErr() ([]*User, error) {
+ if e.loadedTypes[1] {
+ return e.Members, nil
+ }
+ return nil, &NotLoadedError{edge: "members"}
+}
+
+// TeamMembersOrErr returns the TeamMembers value or an error if the edge
+// was not loaded in eager-loading.
+func (e TeamEdges) TeamMembersOrErr() ([]*TeamMember, error) {
+ if e.loadedTypes[2] {
+ return e.TeamMembers, nil
+ }
+ return nil, &NotLoadedError{edge: "team_members"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Team) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case team.FieldMemberLimit:
+ values[i] = new(sql.NullInt64)
+ case team.FieldName:
+ values[i] = new(sql.NullString)
+ case team.FieldDeletedAt, team.FieldCreatedAt, team.FieldUpdatedAt:
+ values[i] = new(sql.NullTime)
+ case team.FieldID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Team fields.
+func (_m *Team) 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 team.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case team.FieldDeletedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field deleted_at", values[i])
+ } else if value.Valid {
+ _m.DeletedAt = value.Time
+ }
+ case team.FieldName:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field name", values[i])
+ } else if value.Valid {
+ _m.Name = value.String
+ }
+ case team.FieldMemberLimit:
+ if value, ok := values[i].(*sql.NullInt64); !ok {
+ return fmt.Errorf("unexpected type %T for field member_limit", values[i])
+ } else if value.Valid {
+ _m.MemberLimit = int(value.Int64)
+ }
+ case team.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 {
+ _m.CreatedAt = value.Time
+ }
+ case team.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 {
+ _m.UpdatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Team.
+// This includes values selected through modifiers, order, etc.
+func (_m *Team) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryGroups queries the "groups" edge of the Team entity.
+func (_m *Team) QueryGroups() *TeamGroupQuery {
+ return NewTeamClient(_m.config).QueryGroups(_m)
+}
+
+// QueryMembers queries the "members" edge of the Team entity.
+func (_m *Team) QueryMembers() *UserQuery {
+ return NewTeamClient(_m.config).QueryMembers(_m)
+}
+
+// QueryTeamMembers queries the "team_members" edge of the Team entity.
+func (_m *Team) QueryTeamMembers() *TeamMemberQuery {
+ return NewTeamClient(_m.config).QueryTeamMembers(_m)
+}
+
+// Update returns a builder for updating this Team.
+// Note that you need to call Team.Unwrap() before calling this method if this Team
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *Team) Update() *TeamUpdateOne {
+ return NewTeamClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the Team 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 (_m *Team) Unwrap() *Team {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: Team is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *Team) String() string {
+ var builder strings.Builder
+ builder.WriteString("Team(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("deleted_at=")
+ builder.WriteString(_m.DeletedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("name=")
+ builder.WriteString(_m.Name)
+ builder.WriteString(", ")
+ builder.WriteString("member_limit=")
+ builder.WriteString(fmt.Sprintf("%v", _m.MemberLimit))
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("updated_at=")
+ builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// Teams is a parsable slice of Team.
+type Teams []*Team
diff --git a/backend/db/team/team.go b/backend/db/team/team.go
new file mode 100644
index 00000000..03b97445
--- /dev/null
+++ b/backend/db/team/team.go
@@ -0,0 +1,193 @@
+// Code generated by ent, DO NOT EDIT.
+
+package team
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the team type in the database.
+ Label = "team"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldDeletedAt holds the string denoting the deleted_at field in the database.
+ FieldDeletedAt = "deleted_at"
+ // FieldName holds the string denoting the name field in the database.
+ FieldName = "name"
+ // FieldMemberLimit holds the string denoting the member_limit field in the database.
+ FieldMemberLimit = "member_limit"
+ // 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"
+ // EdgeGroups holds the string denoting the groups edge name in mutations.
+ EdgeGroups = "groups"
+ // EdgeMembers holds the string denoting the members edge name in mutations.
+ EdgeMembers = "members"
+ // EdgeTeamMembers holds the string denoting the team_members edge name in mutations.
+ EdgeTeamMembers = "team_members"
+ // Table holds the table name of the team in the database.
+ Table = "teams"
+ // GroupsTable is the table that holds the groups relation/edge.
+ GroupsTable = "team_groups"
+ // GroupsInverseTable is the table name for the TeamGroup entity.
+ // It exists in this package in order to avoid circular dependency with the "teamgroup" package.
+ GroupsInverseTable = "team_groups"
+ // GroupsColumn is the table column denoting the groups relation/edge.
+ GroupsColumn = "team_id"
+ // MembersTable is the table that holds the members relation/edge. The primary key declared below.
+ MembersTable = "team_members"
+ // MembersInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ MembersInverseTable = "users"
+ // TeamMembersTable is the table that holds the team_members relation/edge.
+ TeamMembersTable = "team_members"
+ // TeamMembersInverseTable is the table name for the TeamMember entity.
+ // It exists in this package in order to avoid circular dependency with the "teammember" package.
+ TeamMembersInverseTable = "team_members"
+ // TeamMembersColumn is the table column denoting the team_members relation/edge.
+ TeamMembersColumn = "team_id"
+)
+
+// Columns holds all SQL columns for team fields.
+var Columns = []string{
+ FieldID,
+ FieldDeletedAt,
+ FieldName,
+ FieldMemberLimit,
+ FieldCreatedAt,
+ FieldUpdatedAt,
+}
+
+var (
+ // MembersPrimaryKey and MembersColumn2 are the table columns denoting the
+ // primary key for the members relation (M2M).
+ MembersPrimaryKey = []string{"user_id", "team_id"}
+)
+
+// 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
+ }
+ }
+ return false
+}
+
+// Note that the variables below are initialized by the runtime
+// package on the initialization of the application. Therefore,
+// it should be imported in the main as follows:
+//
+// import _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+var (
+ Hooks [1]ent.Hook
+ Interceptors [1]ent.Interceptor
+ // NameValidator is a validator for the "name" field. It is called by the builders before save.
+ NameValidator func(string) error
+ // 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
+)
+
+// OrderOption defines the ordering options for the Team queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByDeletedAt orders the results by the deleted_at field.
+func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDeletedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByMemberLimit orders the results by the member_limit field.
+func ByMemberLimit(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldMemberLimit, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByGroupsCount orders the results by groups count.
+func ByGroupsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newGroupsStep(), opts...)
+ }
+}
+
+// ByGroups orders the results by groups terms.
+func ByGroups(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByMembersCount orders the results by members count.
+func ByMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newMembersStep(), opts...)
+ }
+}
+
+// ByMembers orders the results by members terms.
+func ByMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByTeamMembersCount orders the results by team_members count.
+func ByTeamMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newTeamMembersStep(), opts...)
+ }
+}
+
+// ByTeamMembers orders the results by team_members terms.
+func ByTeamMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newGroupsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, GroupsTable, GroupsColumn),
+ )
+}
+func newMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(MembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, MembersTable, MembersPrimaryKey...),
+ )
+}
+func newTeamMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamMembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamMembersTable, TeamMembersColumn),
+ )
+}
diff --git a/backend/db/team/where.go b/backend/db/team/where.go
new file mode 100644
index 00000000..efe1c84e
--- /dev/null
+++ b/backend/db/team/where.go
@@ -0,0 +1,401 @@
+// Code generated by ent, DO NOT EDIT.
+
+package team
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldID, id))
+}
+
+// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
+func DeletedAt(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldName, v))
+}
+
+// MemberLimit applies equality check predicate on the "member_limit" field. It's identical to MemberLimitEQ.
+func MemberLimit(v int) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldMemberLimit, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
+func DeletedAtEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
+func DeletedAtNEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtIn applies the In predicate on the "deleted_at" field.
+func DeletedAtIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
+func DeletedAtNotIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtGT applies the GT predicate on the "deleted_at" field.
+func DeletedAtGT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldDeletedAt, v))
+}
+
+// DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
+func DeletedAtGTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldDeletedAt, v))
+}
+
+// DeletedAtLT applies the LT predicate on the "deleted_at" field.
+func DeletedAtLT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldDeletedAt, v))
+}
+
+// DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
+func DeletedAtLTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldDeletedAt, v))
+}
+
+// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
+func DeletedAtIsNil() predicate.Team {
+ return predicate.Team(sql.FieldIsNull(FieldDeletedAt))
+}
+
+// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
+func DeletedAtNotNil() predicate.Team {
+ return predicate.Team(sql.FieldNotNull(FieldDeletedAt))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Team {
+ return predicate.Team(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Team {
+ return predicate.Team(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Team {
+ return predicate.Team(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Team {
+ return predicate.Team(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Team {
+ return predicate.Team(sql.FieldContainsFold(FieldName, v))
+}
+
+// MemberLimitEQ applies the EQ predicate on the "member_limit" field.
+func MemberLimitEQ(v int) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldMemberLimit, v))
+}
+
+// MemberLimitNEQ applies the NEQ predicate on the "member_limit" field.
+func MemberLimitNEQ(v int) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldMemberLimit, v))
+}
+
+// MemberLimitIn applies the In predicate on the "member_limit" field.
+func MemberLimitIn(vs ...int) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldMemberLimit, vs...))
+}
+
+// MemberLimitNotIn applies the NotIn predicate on the "member_limit" field.
+func MemberLimitNotIn(vs ...int) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldMemberLimit, vs...))
+}
+
+// MemberLimitGT applies the GT predicate on the "member_limit" field.
+func MemberLimitGT(v int) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldMemberLimit, v))
+}
+
+// MemberLimitGTE applies the GTE predicate on the "member_limit" field.
+func MemberLimitGTE(v int) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldMemberLimit, v))
+}
+
+// MemberLimitLT applies the LT predicate on the "member_limit" field.
+func MemberLimitLT(v int) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldMemberLimit, v))
+}
+
+// MemberLimitLTE applies the LTE predicate on the "member_limit" field.
+func MemberLimitLTE(v int) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldMemberLimit, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.Team {
+ return predicate.Team(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.Team {
+ return predicate.Team(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// HasGroups applies the HasEdge predicate on the "groups" edge.
+func HasGroups() predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, GroupsTable, GroupsColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasGroupsWith applies the HasEdge predicate on the "groups" edge with a given conditions (other predicates).
+func HasGroupsWith(preds ...predicate.TeamGroup) predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := newGroupsStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasMembers applies the HasEdge predicate on the "members" edge.
+func HasMembers() predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, MembersTable, MembersPrimaryKey...),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasMembersWith applies the HasEdge predicate on the "members" edge with a given conditions (other predicates).
+func HasMembersWith(preds ...predicate.User) predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := newMembersStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeamMembers applies the HasEdge predicate on the "team_members" edge.
+func HasTeamMembers() predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamMembersTable, TeamMembersColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamMembersWith applies the HasEdge predicate on the "team_members" edge with a given conditions (other predicates).
+func HasTeamMembersWith(preds ...predicate.TeamMember) predicate.Team {
+ return predicate.Team(func(s *sql.Selector) {
+ step := newTeamMembersStep()
+ 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.Team) predicate.Team {
+ return predicate.Team(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Team) predicate.Team {
+ return predicate.Team(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Team) predicate.Team {
+ return predicate.Team(sql.NotPredicates(p))
+}
diff --git a/backend/db/team_create.go b/backend/db/team_create.go
new file mode 100644
index 00000000..6022b400
--- /dev/null
+++ b/backend/db/team_create.go
@@ -0,0 +1,892 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamCreate is the builder for creating a Team entity.
+type TeamCreate struct {
+ config
+ mutation *TeamMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_c *TeamCreate) SetDeletedAt(v time.Time) *TeamCreate {
+ _c.mutation.SetDeletedAt(v)
+ return _c
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_c *TeamCreate) SetNillableDeletedAt(v *time.Time) *TeamCreate {
+ if v != nil {
+ _c.SetDeletedAt(*v)
+ }
+ return _c
+}
+
+// SetName sets the "name" field.
+func (_c *TeamCreate) SetName(v string) *TeamCreate {
+ _c.mutation.SetName(v)
+ return _c
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (_c *TeamCreate) SetMemberLimit(v int) *TeamCreate {
+ _c.mutation.SetMemberLimit(v)
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *TeamCreate) SetCreatedAt(v time.Time) *TeamCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *TeamCreate) SetNillableCreatedAt(v *time.Time) *TeamCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *TeamCreate) SetUpdatedAt(v time.Time) *TeamCreate {
+ _c.mutation.SetUpdatedAt(v)
+ return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *TeamCreate) SetNillableUpdatedAt(v *time.Time) *TeamCreate {
+ if v != nil {
+ _c.SetUpdatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *TeamCreate) SetID(v uuid.UUID) *TeamCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_c *TeamCreate) AddGroupIDs(ids ...uuid.UUID) *TeamCreate {
+ _c.mutation.AddGroupIDs(ids...)
+ return _c
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_c *TeamCreate) AddGroups(v ...*TeamGroup) *TeamCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddGroupIDs(ids...)
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_c *TeamCreate) AddMemberIDs(ids ...uuid.UUID) *TeamCreate {
+ _c.mutation.AddMemberIDs(ids...)
+ return _c
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_c *TeamCreate) AddMembers(v ...*User) *TeamCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddMemberIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_c *TeamCreate) AddTeamMemberIDs(ids ...uuid.UUID) *TeamCreate {
+ _c.mutation.AddTeamMemberIDs(ids...)
+ return _c
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_c *TeamCreate) AddTeamMembers(v ...*TeamMember) *TeamCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddTeamMemberIDs(ids...)
+}
+
+// Mutation returns the TeamMutation object of the builder.
+func (_c *TeamCreate) Mutation() *TeamMutation {
+ return _c.mutation
+}
+
+// Save creates the Team in the database.
+func (_c *TeamCreate) Save(ctx context.Context) (*Team, error) {
+ if err := _c.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *TeamCreate) SaveX(ctx context.Context) *Team {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *TeamCreate) defaults() error {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ if team.DefaultCreatedAt == nil {
+ return fmt.Errorf("db: uninitialized team.DefaultCreatedAt (forgotten import db/runtime?)")
+ }
+ v := team.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ if team.DefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized team.DefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := team.DefaultUpdatedAt()
+ _c.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *TeamCreate) check() error {
+ if _, ok := _c.mutation.Name(); !ok {
+ return &ValidationError{Name: "name", err: errors.New(`db: missing required field "Team.name"`)}
+ }
+ if v, ok := _c.mutation.Name(); ok {
+ if err := team.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Team.name": %w`, err)}
+ }
+ }
+ if _, ok := _c.mutation.MemberLimit(); !ok {
+ return &ValidationError{Name: "member_limit", err: errors.New(`db: missing required field "Team.member_limit"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "Team.created_at"`)}
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "Team.updated_at"`)}
+ }
+ return nil
+}
+
+func (_c *TeamCreate) sqlSave(ctx context.Context) (*Team, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *TeamCreate) createSpec() (*Team, *sqlgraph.CreateSpec) {
+ var (
+ _node = &Team{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(team.Table, sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.DeletedAt(); ok {
+ _spec.SetField(team.FieldDeletedAt, field.TypeTime, value)
+ _node.DeletedAt = value
+ }
+ if value, ok := _c.mutation.Name(); ok {
+ _spec.SetField(team.FieldName, field.TypeString, value)
+ _node.Name = value
+ }
+ if value, ok := _c.mutation.MemberLimit(); ok {
+ _spec.SetField(team.FieldMemberLimit, field.TypeInt, value)
+ _node.MemberLimit = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(team.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if value, ok := _c.mutation.UpdatedAt(); ok {
+ _spec.SetField(team.FieldUpdatedAt, field.TypeTime, value)
+ _node.UpdatedAt = value
+ }
+ if nodes := _c.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _c.config, mutation: newTeamMemberMutation(_c.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.Team.Create().
+// SetDeletedAt(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamCreate) OnConflict(opts ...sql.ConflictOption) *TeamUpsertOne {
+ _c.conflict = opts
+ return &TeamUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamCreate) OnConflictColumns(columns ...string) *TeamUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // TeamUpsertOne is the builder for "upsert"-ing
+ // one Team node.
+ TeamUpsertOne struct {
+ create *TeamCreate
+ }
+
+ // TeamUpsert is the "OnConflict" setter.
+ TeamUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamUpsert) SetDeletedAt(v time.Time) *TeamUpsert {
+ u.Set(team.FieldDeletedAt, v)
+ return u
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamUpsert) UpdateDeletedAt() *TeamUpsert {
+ u.SetExcluded(team.FieldDeletedAt)
+ return u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamUpsert) ClearDeletedAt() *TeamUpsert {
+ u.SetNull(team.FieldDeletedAt)
+ return u
+}
+
+// SetName sets the "name" field.
+func (u *TeamUpsert) SetName(v string) *TeamUpsert {
+ u.Set(team.FieldName, v)
+ return u
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamUpsert) UpdateName() *TeamUpsert {
+ u.SetExcluded(team.FieldName)
+ return u
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (u *TeamUpsert) SetMemberLimit(v int) *TeamUpsert {
+ u.Set(team.FieldMemberLimit, v)
+ return u
+}
+
+// UpdateMemberLimit sets the "member_limit" field to the value that was provided on create.
+func (u *TeamUpsert) UpdateMemberLimit() *TeamUpsert {
+ u.SetExcluded(team.FieldMemberLimit)
+ return u
+}
+
+// AddMemberLimit adds v to the "member_limit" field.
+func (u *TeamUpsert) AddMemberLimit(v int) *TeamUpsert {
+ u.Add(team.FieldMemberLimit, v)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamUpsert) SetCreatedAt(v time.Time) *TeamUpsert {
+ u.Set(team.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamUpsert) UpdateCreatedAt() *TeamUpsert {
+ u.SetExcluded(team.FieldCreatedAt)
+ return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamUpsert) SetUpdatedAt(v time.Time) *TeamUpsert {
+ u.Set(team.FieldUpdatedAt, v)
+ return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamUpsert) UpdateUpdatedAt() *TeamUpsert {
+ u.SetExcluded(team.FieldUpdatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(team.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamUpsertOne) UpdateNewValues() *TeamUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(team.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamUpsertOne) Ignore() *TeamUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamUpsertOne) DoNothing() *TeamUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamCreate.OnConflict
+// documentation for more info.
+func (u *TeamUpsertOne) Update(set func(*TeamUpsert)) *TeamUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamUpsertOne) SetDeletedAt(v time.Time) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamUpsertOne) UpdateDeletedAt() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamUpsertOne) ClearDeletedAt() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *TeamUpsertOne) SetName(v string) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamUpsertOne) UpdateName() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (u *TeamUpsertOne) SetMemberLimit(v int) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetMemberLimit(v)
+ })
+}
+
+// AddMemberLimit adds v to the "member_limit" field.
+func (u *TeamUpsertOne) AddMemberLimit(v int) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.AddMemberLimit(v)
+ })
+}
+
+// UpdateMemberLimit sets the "member_limit" field to the value that was provided on create.
+func (u *TeamUpsertOne) UpdateMemberLimit() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateMemberLimit()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamUpsertOne) SetCreatedAt(v time.Time) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamUpsertOne) UpdateCreatedAt() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamUpsertOne) SetUpdatedAt(v time.Time) *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamUpsertOne) UpdateUpdatedAt() *TeamUpsertOne {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *TeamUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: TeamUpsertOne.ID is not supported by MySQL driver. Use TeamUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *TeamUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// TeamCreateBulk is the builder for creating many Team entities in bulk.
+type TeamCreateBulk struct {
+ config
+ err error
+ builders []*TeamCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the Team entities in the database.
+func (_c *TeamCreateBulk) Save(ctx context.Context) ([]*Team, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*Team, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*TeamMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *TeamCreateBulk) SaveX(ctx context.Context) []*Team {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.Team.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamCreateBulk) OnConflict(opts ...sql.ConflictOption) *TeamUpsertBulk {
+ _c.conflict = opts
+ return &TeamUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamCreateBulk) OnConflictColumns(columns ...string) *TeamUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamUpsertBulk{
+ create: _c,
+ }
+}
+
+// TeamUpsertBulk is the builder for "upsert"-ing
+// a bulk of Team nodes.
+type TeamUpsertBulk struct {
+ create *TeamCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(team.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamUpsertBulk) UpdateNewValues() *TeamUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(team.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.Team.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamUpsertBulk) Ignore() *TeamUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamUpsertBulk) DoNothing() *TeamUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamCreateBulk.OnConflict
+// documentation for more info.
+func (u *TeamUpsertBulk) Update(set func(*TeamUpsert)) *TeamUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamUpsertBulk) SetDeletedAt(v time.Time) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamUpsertBulk) UpdateDeletedAt() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamUpsertBulk) ClearDeletedAt() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *TeamUpsertBulk) SetName(v string) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamUpsertBulk) UpdateName() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (u *TeamUpsertBulk) SetMemberLimit(v int) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetMemberLimit(v)
+ })
+}
+
+// AddMemberLimit adds v to the "member_limit" field.
+func (u *TeamUpsertBulk) AddMemberLimit(v int) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.AddMemberLimit(v)
+ })
+}
+
+// UpdateMemberLimit sets the "member_limit" field to the value that was provided on create.
+func (u *TeamUpsertBulk) UpdateMemberLimit() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateMemberLimit()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamUpsertBulk) SetCreatedAt(v time.Time) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamUpsertBulk) UpdateCreatedAt() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamUpsertBulk) SetUpdatedAt(v time.Time) *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamUpsertBulk) UpdateUpdatedAt() *TeamUpsertBulk {
+ return u.Update(func(s *TeamUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the TeamCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/team_delete.go b/backend/db/team_delete.go
new file mode 100644
index 00000000..4a16b9c0
--- /dev/null
+++ b/backend/db/team_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+)
+
+// TeamDelete is the builder for deleting a Team entity.
+type TeamDelete struct {
+ config
+ hooks []Hook
+ mutation *TeamMutation
+}
+
+// Where appends a list predicates to the TeamDelete builder.
+func (_d *TeamDelete) Where(ps ...predicate.Team) *TeamDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *TeamDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *TeamDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(team.Table, sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// TeamDeleteOne is the builder for deleting a single Team entity.
+type TeamDeleteOne struct {
+ _d *TeamDelete
+}
+
+// Where appends a list predicates to the TeamDelete builder.
+func (_d *TeamDeleteOne) Where(ps ...predicate.Team) *TeamDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *TeamDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{team.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/team_query.go b/backend/db/team_query.go
new file mode 100644
index 00000000..9b7c784c
--- /dev/null
+++ b/backend/db/team_query.go
@@ -0,0 +1,836 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "database/sql/driver"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamQuery is the builder for querying Team entities.
+type TeamQuery struct {
+ config
+ ctx *QueryContext
+ order []team.OrderOption
+ inters []Interceptor
+ predicates []predicate.Team
+ withGroups *TeamGroupQuery
+ withMembers *UserQuery
+ withTeamMembers *TeamMemberQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the TeamQuery builder.
+func (_q *TeamQuery) Where(ps ...predicate.Team) *TeamQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *TeamQuery) Limit(limit int) *TeamQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *TeamQuery) Offset(offset int) *TeamQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *TeamQuery) Unique(unique bool) *TeamQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *TeamQuery) Order(o ...team.OrderOption) *TeamQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryGroups chains the current query on the "groups" edge.
+func (_q *TeamQuery) QueryGroups() *TeamGroupQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, selector),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, team.GroupsTable, team.GroupsColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryMembers chains the current query on the "members" edge.
+func (_q *TeamQuery) QueryMembers() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, team.MembersTable, team.MembersPrimaryKey...),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeamMembers chains the current query on the "team_members" edge.
+func (_q *TeamQuery) QueryTeamMembers() *TeamMemberQuery {
+ query := (&TeamMemberClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(team.Table, team.FieldID, selector),
+ sqlgraph.To(teammember.Table, teammember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, team.TeamMembersTable, team.TeamMembersColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first Team entity from the query.
+// Returns a *NotFoundError when no Team was found.
+func (_q *TeamQuery) First(ctx context.Context) (*Team, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{team.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *TeamQuery) FirstX(ctx context.Context) *Team {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first Team ID from the query.
+// Returns a *NotFoundError when no Team ID was found.
+func (_q *TeamQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{team.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *TeamQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single Team entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Team entity is found.
+// Returns a *NotFoundError when no Team entities are found.
+func (_q *TeamQuery) Only(ctx context.Context) (*Team, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{team.Label}
+ default:
+ return nil, &NotSingularError{team.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *TeamQuery) OnlyX(ctx context.Context) *Team {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only Team ID in the query.
+// Returns a *NotSingularError when more than one Team ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *TeamQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{team.Label}
+ default:
+ err = &NotSingularError{team.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *TeamQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of Teams.
+func (_q *TeamQuery) All(ctx context.Context) ([]*Team, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*Team, *TeamQuery]()
+ return withInterceptors[[]*Team](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *TeamQuery) AllX(ctx context.Context) []*Team {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of Team IDs.
+func (_q *TeamQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(team.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *TeamQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *TeamQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*TeamQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *TeamQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *TeamQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *TeamQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the TeamQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *TeamQuery) Clone() *TeamQuery {
+ if _q == nil {
+ return nil
+ }
+ return &TeamQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]team.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.Team{}, _q.predicates...),
+ withGroups: _q.withGroups.Clone(),
+ withMembers: _q.withMembers.Clone(),
+ withTeamMembers: _q.withTeamMembers.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithGroups tells the query-builder to eager-load the nodes that are connected to
+// the "groups" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamQuery) WithGroups(opts ...func(*TeamGroupQuery)) *TeamQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withGroups = query
+ return _q
+}
+
+// WithMembers tells the query-builder to eager-load the nodes that are connected to
+// the "members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamQuery) WithMembers(opts ...func(*UserQuery)) *TeamQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withMembers = query
+ return _q
+}
+
+// WithTeamMembers tells the query-builder to eager-load the nodes that are connected to
+// the "team_members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamQuery) WithTeamMembers(opts ...func(*TeamMemberQuery)) *TeamQuery {
+ query := (&TeamMemberClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeamMembers = query
+ return _q
+}
+
+// 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.Team.Query().
+// GroupBy(team.FieldDeletedAt).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *TeamQuery) GroupBy(field string, fields ...string) *TeamGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &TeamGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = team.Label
+ grbuild.scan = 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// }
+//
+// client.Team.Query().
+// Select(team.FieldDeletedAt).
+// Scan(ctx, &v)
+func (_q *TeamQuery) Select(fields ...string) *TeamSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &TeamSelect{TeamQuery: _q}
+ sbuild.label = team.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a TeamSelect configured with the given aggregations.
+func (_q *TeamQuery) Aggregate(fns ...AggregateFunc) *TeamSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *TeamQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !team.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *TeamQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Team, error) {
+ var (
+ nodes = []*Team{}
+ _spec = _q.querySpec()
+ loadedTypes = [3]bool{
+ _q.withGroups != nil,
+ _q.withMembers != nil,
+ _q.withTeamMembers != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*Team).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &Team{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withGroups; query != nil {
+ if err := _q.loadGroups(ctx, query, nodes,
+ func(n *Team) { n.Edges.Groups = []*TeamGroup{} },
+ func(n *Team, e *TeamGroup) { n.Edges.Groups = append(n.Edges.Groups, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withMembers; query != nil {
+ if err := _q.loadMembers(ctx, query, nodes,
+ func(n *Team) { n.Edges.Members = []*User{} },
+ func(n *Team, e *User) { n.Edges.Members = append(n.Edges.Members, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeamMembers; query != nil {
+ if err := _q.loadTeamMembers(ctx, query, nodes,
+ func(n *Team) { n.Edges.TeamMembers = []*TeamMember{} },
+ func(n *Team, e *TeamMember) { n.Edges.TeamMembers = append(n.Edges.TeamMembers, e) }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *TeamQuery) loadGroups(ctx context.Context, query *TeamGroupQuery, nodes []*Team, init func(*Team), assign func(*Team, *TeamGroup)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*Team)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(teamgroup.FieldTeamID)
+ }
+ query.Where(predicate.TeamGroup(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(team.GroupsColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.TeamID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "team_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+func (_q *TeamQuery) loadMembers(ctx context.Context, query *UserQuery, nodes []*Team, init func(*Team), assign func(*Team, *User)) error {
+ edgeIDs := make([]driver.Value, len(nodes))
+ byID := make(map[uuid.UUID]*Team)
+ nids := make(map[uuid.UUID]map[*Team]struct{})
+ for i, node := range nodes {
+ edgeIDs[i] = node.ID
+ byID[node.ID] = node
+ if init != nil {
+ init(node)
+ }
+ }
+ query.Where(func(s *sql.Selector) {
+ joinT := sql.Table(team.MembersTable)
+ s.Join(joinT).On(s.C(user.FieldID), joinT.C(team.MembersPrimaryKey[0]))
+ s.Where(sql.InValues(joinT.C(team.MembersPrimaryKey[1]), edgeIDs...))
+ columns := s.SelectedColumns()
+ s.Select(joinT.C(team.MembersPrimaryKey[1]))
+ s.AppendSelect(columns...)
+ s.SetDistinct(false)
+ })
+ if err := query.prepareQuery(ctx); err != nil {
+ return err
+ }
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
+ }
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*Team]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
+ }
+ })
+ })
+ neighbors, err := withInterceptors[[]*User](ctx, query, qr, query.inters)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected "members" node returned %v`, n.ID)
+ }
+ for kn := range nodes {
+ assign(kn, n)
+ }
+ }
+ return nil
+}
+func (_q *TeamQuery) loadTeamMembers(ctx context.Context, query *TeamMemberQuery, nodes []*Team, init func(*Team), assign func(*Team, *TeamMember)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*Team)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(teammember.FieldTeamID)
+ }
+ query.Where(predicate.TeamMember(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(team.TeamMembersColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.TeamID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "team_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+
+func (_q *TeamQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *TeamQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, team.FieldID)
+ for i := range fields {
+ if fields[i] != team.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *TeamQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(team.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = team.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *TeamQuery) ForUpdate(opts ...sql.LockOption) *TeamQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *TeamQuery) ForShare(opts ...sql.LockOption) *TeamQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *TeamQuery) Modify(modifiers ...func(s *sql.Selector)) *TeamSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// TeamGroupBy is the group-by builder for Team entities.
+type TeamGroupBy struct {
+ selector
+ build *TeamQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *TeamGroupBy) Aggregate(fns ...AggregateFunc) *TeamGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *TeamGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamQuery, *TeamGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *TeamGroupBy) sqlScan(ctx context.Context, root *TeamQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// TeamSelect is the builder for selecting fields of Team entities.
+type TeamSelect struct {
+ *TeamQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *TeamSelect) Aggregate(fns ...AggregateFunc) *TeamSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *TeamSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamQuery, *TeamSelect](ctx, _s.TeamQuery, _s, _s.inters, v)
+}
+
+func (_s *TeamSelect) sqlScan(ctx context.Context, root *TeamQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *TeamSelect) Modify(modifiers ...func(s *sql.Selector)) *TeamSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/team_update.go b/backend/db/team_update.go
new file mode 100644
index 00000000..593c878e
--- /dev/null
+++ b/backend/db/team_update.go
@@ -0,0 +1,940 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamUpdate is the builder for updating Team entities.
+type TeamUpdate struct {
+ config
+ hooks []Hook
+ mutation *TeamMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the TeamUpdate builder.
+func (_u *TeamUpdate) Where(ps ...predicate.Team) *TeamUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *TeamUpdate) SetDeletedAt(v time.Time) *TeamUpdate {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *TeamUpdate) SetNillableDeletedAt(v *time.Time) *TeamUpdate {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *TeamUpdate) ClearDeletedAt() *TeamUpdate {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *TeamUpdate) SetName(v string) *TeamUpdate {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *TeamUpdate) SetNillableName(v *string) *TeamUpdate {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (_u *TeamUpdate) SetMemberLimit(v int) *TeamUpdate {
+ _u.mutation.ResetMemberLimit()
+ _u.mutation.SetMemberLimit(v)
+ return _u
+}
+
+// SetNillableMemberLimit sets the "member_limit" field if the given value is not nil.
+func (_u *TeamUpdate) SetNillableMemberLimit(v *int) *TeamUpdate {
+ if v != nil {
+ _u.SetMemberLimit(*v)
+ }
+ return _u
+}
+
+// AddMemberLimit adds value to the "member_limit" field.
+func (_u *TeamUpdate) AddMemberLimit(v int) *TeamUpdate {
+ _u.mutation.AddMemberLimit(v)
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamUpdate) SetCreatedAt(v time.Time) *TeamUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamUpdate) SetNillableCreatedAt(v *time.Time) *TeamUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *TeamUpdate) SetUpdatedAt(v time.Time) *TeamUpdate {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_u *TeamUpdate) SetNillableUpdatedAt(v *time.Time) *TeamUpdate {
+ if v != nil {
+ _u.SetUpdatedAt(*v)
+ }
+ return _u
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_u *TeamUpdate) AddGroupIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.AddGroupIDs(ids...)
+ return _u
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_u *TeamUpdate) AddGroups(v ...*TeamGroup) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddGroupIDs(ids...)
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_u *TeamUpdate) AddMemberIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.AddMemberIDs(ids...)
+ return _u
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_u *TeamUpdate) AddMembers(v ...*User) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddMemberIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_u *TeamUpdate) AddTeamMemberIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.AddTeamMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_u *TeamUpdate) AddTeamMembers(v ...*TeamMember) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamMemberIDs(ids...)
+}
+
+// Mutation returns the TeamMutation object of the builder.
+func (_u *TeamUpdate) Mutation() *TeamMutation {
+ return _u.mutation
+}
+
+// ClearGroups clears all "groups" edges to the TeamGroup entity.
+func (_u *TeamUpdate) ClearGroups() *TeamUpdate {
+ _u.mutation.ClearGroups()
+ return _u
+}
+
+// RemoveGroupIDs removes the "groups" edge to TeamGroup entities by IDs.
+func (_u *TeamUpdate) RemoveGroupIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.RemoveGroupIDs(ids...)
+ return _u
+}
+
+// RemoveGroups removes "groups" edges to TeamGroup entities.
+func (_u *TeamUpdate) RemoveGroups(v ...*TeamGroup) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveGroupIDs(ids...)
+}
+
+// ClearMembers clears all "members" edges to the User entity.
+func (_u *TeamUpdate) ClearMembers() *TeamUpdate {
+ _u.mutation.ClearMembers()
+ return _u
+}
+
+// RemoveMemberIDs removes the "members" edge to User entities by IDs.
+func (_u *TeamUpdate) RemoveMemberIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.RemoveMemberIDs(ids...)
+ return _u
+}
+
+// RemoveMembers removes "members" edges to User entities.
+func (_u *TeamUpdate) RemoveMembers(v ...*User) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveMemberIDs(ids...)
+}
+
+// ClearTeamMembers clears all "team_members" edges to the TeamMember entity.
+func (_u *TeamUpdate) ClearTeamMembers() *TeamUpdate {
+ _u.mutation.ClearTeamMembers()
+ return _u
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to TeamMember entities by IDs.
+func (_u *TeamUpdate) RemoveTeamMemberIDs(ids ...uuid.UUID) *TeamUpdate {
+ _u.mutation.RemoveTeamMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamMembers removes "team_members" edges to TeamMember entities.
+func (_u *TeamUpdate) RemoveTeamMembers(v ...*TeamMember) *TeamUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamMemberIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *TeamUpdate) Save(ctx context.Context) (int, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *TeamUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamUpdate) check() error {
+ if v, ok := _u.mutation.Name(); ok {
+ if err := team.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Team.name": %w`, err)}
+ }
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(team.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(team.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(team.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.MemberLimit(); ok {
+ _spec.SetField(team.FieldMemberLimit, field.TypeInt, value)
+ }
+ if value, ok := _u.mutation.AddedMemberLimit(); ok {
+ _spec.AddField(team.FieldMemberLimit, field.TypeInt, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(team.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(team.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedGroupsIDs(); len(nodes) > 0 && !_u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedMembersIDs(); len(nodes) > 0 && !_u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{team.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// TeamUpdateOne is the builder for updating a single Team entity.
+type TeamUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *TeamMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *TeamUpdateOne) SetDeletedAt(v time.Time) *TeamUpdateOne {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *TeamUpdateOne) SetNillableDeletedAt(v *time.Time) *TeamUpdateOne {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *TeamUpdateOne) ClearDeletedAt() *TeamUpdateOne {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *TeamUpdateOne) SetName(v string) *TeamUpdateOne {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *TeamUpdateOne) SetNillableName(v *string) *TeamUpdateOne {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetMemberLimit sets the "member_limit" field.
+func (_u *TeamUpdateOne) SetMemberLimit(v int) *TeamUpdateOne {
+ _u.mutation.ResetMemberLimit()
+ _u.mutation.SetMemberLimit(v)
+ return _u
+}
+
+// SetNillableMemberLimit sets the "member_limit" field if the given value is not nil.
+func (_u *TeamUpdateOne) SetNillableMemberLimit(v *int) *TeamUpdateOne {
+ if v != nil {
+ _u.SetMemberLimit(*v)
+ }
+ return _u
+}
+
+// AddMemberLimit adds value to the "member_limit" field.
+func (_u *TeamUpdateOne) AddMemberLimit(v int) *TeamUpdateOne {
+ _u.mutation.AddMemberLimit(v)
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamUpdateOne) SetCreatedAt(v time.Time) *TeamUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamUpdateOne) SetNillableCreatedAt(v *time.Time) *TeamUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *TeamUpdateOne) SetUpdatedAt(v time.Time) *TeamUpdateOne {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_u *TeamUpdateOne) SetNillableUpdatedAt(v *time.Time) *TeamUpdateOne {
+ if v != nil {
+ _u.SetUpdatedAt(*v)
+ }
+ return _u
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_u *TeamUpdateOne) AddGroupIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.AddGroupIDs(ids...)
+ return _u
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_u *TeamUpdateOne) AddGroups(v ...*TeamGroup) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddGroupIDs(ids...)
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_u *TeamUpdateOne) AddMemberIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.AddMemberIDs(ids...)
+ return _u
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_u *TeamUpdateOne) AddMembers(v ...*User) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddMemberIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_u *TeamUpdateOne) AddTeamMemberIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.AddTeamMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_u *TeamUpdateOne) AddTeamMembers(v ...*TeamMember) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamMemberIDs(ids...)
+}
+
+// Mutation returns the TeamMutation object of the builder.
+func (_u *TeamUpdateOne) Mutation() *TeamMutation {
+ return _u.mutation
+}
+
+// ClearGroups clears all "groups" edges to the TeamGroup entity.
+func (_u *TeamUpdateOne) ClearGroups() *TeamUpdateOne {
+ _u.mutation.ClearGroups()
+ return _u
+}
+
+// RemoveGroupIDs removes the "groups" edge to TeamGroup entities by IDs.
+func (_u *TeamUpdateOne) RemoveGroupIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.RemoveGroupIDs(ids...)
+ return _u
+}
+
+// RemoveGroups removes "groups" edges to TeamGroup entities.
+func (_u *TeamUpdateOne) RemoveGroups(v ...*TeamGroup) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveGroupIDs(ids...)
+}
+
+// ClearMembers clears all "members" edges to the User entity.
+func (_u *TeamUpdateOne) ClearMembers() *TeamUpdateOne {
+ _u.mutation.ClearMembers()
+ return _u
+}
+
+// RemoveMemberIDs removes the "members" edge to User entities by IDs.
+func (_u *TeamUpdateOne) RemoveMemberIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.RemoveMemberIDs(ids...)
+ return _u
+}
+
+// RemoveMembers removes "members" edges to User entities.
+func (_u *TeamUpdateOne) RemoveMembers(v ...*User) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveMemberIDs(ids...)
+}
+
+// ClearTeamMembers clears all "team_members" edges to the TeamMember entity.
+func (_u *TeamUpdateOne) ClearTeamMembers() *TeamUpdateOne {
+ _u.mutation.ClearTeamMembers()
+ return _u
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to TeamMember entities by IDs.
+func (_u *TeamUpdateOne) RemoveTeamMemberIDs(ids ...uuid.UUID) *TeamUpdateOne {
+ _u.mutation.RemoveTeamMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamMembers removes "team_members" edges to TeamMember entities.
+func (_u *TeamUpdateOne) RemoveTeamMembers(v ...*TeamMember) *TeamUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamMemberIDs(ids...)
+}
+
+// Where appends a list predicates to the TeamUpdate builder.
+func (_u *TeamUpdateOne) Where(ps ...predicate.Team) *TeamUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *TeamUpdateOne) Select(field string, fields ...string) *TeamUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated Team entity.
+func (_u *TeamUpdateOne) Save(ctx context.Context) (*Team, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamUpdateOne) SaveX(ctx context.Context) *Team {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *TeamUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamUpdateOne) check() error {
+ if v, ok := _u.mutation.Name(); ok {
+ if err := team.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "Team.name": %w`, err)}
+ }
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamUpdateOne) sqlSave(ctx context.Context) (_node *Team, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(team.Table, team.Columns, sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "Team.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, team.FieldID)
+ for _, f := range fields {
+ if !team.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != team.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(team.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(team.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(team.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.MemberLimit(); ok {
+ _spec.SetField(team.FieldMemberLimit, field.TypeInt, value)
+ }
+ if value, ok := _u.mutation.AddedMemberLimit(); ok {
+ _spec.AddField(team.FieldMemberLimit, field.TypeInt, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(team.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(team.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedGroupsIDs(); len(nodes) > 0 && !_u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: team.GroupsTable,
+ Columns: []string{team.GroupsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedMembersIDs(); len(nodes) > 0 && !_u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: team.MembersTable,
+ Columns: team.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: team.TeamMembersTable,
+ Columns: []string{team.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &Team{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{team.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/teamgroup.go b/backend/db/teamgroup.go
new file mode 100644
index 00000000..6a3313fe
--- /dev/null
+++ b/backend/db/teamgroup.go
@@ -0,0 +1,212 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/google/uuid"
+)
+
+// TeamGroup is the model entity for the TeamGroup schema.
+type TeamGroup struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // DeletedAt holds the value of the "deleted_at" field.
+ DeletedAt time.Time `json:"deleted_at,omitempty"`
+ // TeamID holds the value of the "team_id" field.
+ TeamID uuid.UUID `json:"team_id,omitempty"`
+ // Name holds the value of the "name" field.
+ Name string `json:"name,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"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the TeamGroupQuery when eager-loading is set.
+ Edges TeamGroupEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// TeamGroupEdges holds the relations/edges for other nodes in the graph.
+type TeamGroupEdges struct {
+ // Members holds the value of the members edge.
+ Members []*User `json:"members,omitempty"`
+ // Team holds the value of the team edge.
+ Team *Team `json:"team,omitempty"`
+ // TeamGroupMembers holds the value of the team_group_members edge.
+ TeamGroupMembers []*TeamGroupMember `json:"team_group_members,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [3]bool
+}
+
+// MembersOrErr returns the Members value or an error if the edge
+// was not loaded in eager-loading.
+func (e TeamGroupEdges) MembersOrErr() ([]*User, error) {
+ if e.loadedTypes[0] {
+ return e.Members, nil
+ }
+ return nil, &NotLoadedError{edge: "members"}
+}
+
+// TeamOrErr returns the Team value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e TeamGroupEdges) TeamOrErr() (*Team, error) {
+ if e.Team != nil {
+ return e.Team, nil
+ } else if e.loadedTypes[1] {
+ return nil, &NotFoundError{label: team.Label}
+ }
+ return nil, &NotLoadedError{edge: "team"}
+}
+
+// TeamGroupMembersOrErr returns the TeamGroupMembers value or an error if the edge
+// was not loaded in eager-loading.
+func (e TeamGroupEdges) TeamGroupMembersOrErr() ([]*TeamGroupMember, error) {
+ if e.loadedTypes[2] {
+ return e.TeamGroupMembers, nil
+ }
+ return nil, &NotLoadedError{edge: "team_group_members"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*TeamGroup) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case teamgroup.FieldName:
+ values[i] = new(sql.NullString)
+ case teamgroup.FieldDeletedAt, teamgroup.FieldCreatedAt, teamgroup.FieldUpdatedAt:
+ values[i] = new(sql.NullTime)
+ case teamgroup.FieldID, teamgroup.FieldTeamID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the TeamGroup fields.
+func (_m *TeamGroup) 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 teamgroup.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case teamgroup.FieldDeletedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field deleted_at", values[i])
+ } else if value.Valid {
+ _m.DeletedAt = value.Time
+ }
+ case teamgroup.FieldTeamID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field team_id", values[i])
+ } else if value != nil {
+ _m.TeamID = *value
+ }
+ case teamgroup.FieldName:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field name", values[i])
+ } else if value.Valid {
+ _m.Name = value.String
+ }
+ case teamgroup.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 {
+ _m.CreatedAt = value.Time
+ }
+ case teamgroup.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 {
+ _m.UpdatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the TeamGroup.
+// This includes values selected through modifiers, order, etc.
+func (_m *TeamGroup) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryMembers queries the "members" edge of the TeamGroup entity.
+func (_m *TeamGroup) QueryMembers() *UserQuery {
+ return NewTeamGroupClient(_m.config).QueryMembers(_m)
+}
+
+// QueryTeam queries the "team" edge of the TeamGroup entity.
+func (_m *TeamGroup) QueryTeam() *TeamQuery {
+ return NewTeamGroupClient(_m.config).QueryTeam(_m)
+}
+
+// QueryTeamGroupMembers queries the "team_group_members" edge of the TeamGroup entity.
+func (_m *TeamGroup) QueryTeamGroupMembers() *TeamGroupMemberQuery {
+ return NewTeamGroupClient(_m.config).QueryTeamGroupMembers(_m)
+}
+
+// Update returns a builder for updating this TeamGroup.
+// Note that you need to call TeamGroup.Unwrap() before calling this method if this TeamGroup
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *TeamGroup) Update() *TeamGroupUpdateOne {
+ return NewTeamGroupClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the TeamGroup 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 (_m *TeamGroup) Unwrap() *TeamGroup {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: TeamGroup is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *TeamGroup) String() string {
+ var builder strings.Builder
+ builder.WriteString("TeamGroup(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("deleted_at=")
+ builder.WriteString(_m.DeletedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("team_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.TeamID))
+ builder.WriteString(", ")
+ builder.WriteString("name=")
+ builder.WriteString(_m.Name)
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("updated_at=")
+ builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// TeamGroups is a parsable slice of TeamGroup.
+type TeamGroups []*TeamGroup
diff --git a/backend/db/teamgroup/teamgroup.go b/backend/db/teamgroup/teamgroup.go
new file mode 100644
index 00000000..e3c27974
--- /dev/null
+++ b/backend/db/teamgroup/teamgroup.go
@@ -0,0 +1,186 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teamgroup
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the teamgroup type in the database.
+ Label = "team_group"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldDeletedAt holds the string denoting the deleted_at field in the database.
+ FieldDeletedAt = "deleted_at"
+ // FieldTeamID holds the string denoting the team_id field in the database.
+ FieldTeamID = "team_id"
+ // FieldName holds the string denoting the name field in the database.
+ FieldName = "name"
+ // 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"
+ // EdgeMembers holds the string denoting the members edge name in mutations.
+ EdgeMembers = "members"
+ // EdgeTeam holds the string denoting the team edge name in mutations.
+ EdgeTeam = "team"
+ // EdgeTeamGroupMembers holds the string denoting the team_group_members edge name in mutations.
+ EdgeTeamGroupMembers = "team_group_members"
+ // Table holds the table name of the teamgroup in the database.
+ Table = "team_groups"
+ // MembersTable is the table that holds the members relation/edge. The primary key declared below.
+ MembersTable = "team_group_members"
+ // MembersInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ MembersInverseTable = "users"
+ // TeamTable is the table that holds the team relation/edge.
+ TeamTable = "team_groups"
+ // TeamInverseTable is the table name for the Team entity.
+ // It exists in this package in order to avoid circular dependency with the "team" package.
+ TeamInverseTable = "teams"
+ // TeamColumn is the table column denoting the team relation/edge.
+ TeamColumn = "team_id"
+ // TeamGroupMembersTable is the table that holds the team_group_members relation/edge.
+ TeamGroupMembersTable = "team_group_members"
+ // TeamGroupMembersInverseTable is the table name for the TeamGroupMember entity.
+ // It exists in this package in order to avoid circular dependency with the "teamgroupmember" package.
+ TeamGroupMembersInverseTable = "team_group_members"
+ // TeamGroupMembersColumn is the table column denoting the team_group_members relation/edge.
+ TeamGroupMembersColumn = "group_id"
+)
+
+// Columns holds all SQL columns for teamgroup fields.
+var Columns = []string{
+ FieldID,
+ FieldDeletedAt,
+ FieldTeamID,
+ FieldName,
+ FieldCreatedAt,
+ FieldUpdatedAt,
+}
+
+var (
+ // MembersPrimaryKey and MembersColumn2 are the table columns denoting the
+ // primary key for the members relation (M2M).
+ MembersPrimaryKey = []string{"user_id", "group_id"}
+)
+
+// 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
+ }
+ }
+ return false
+}
+
+// Note that the variables below are initialized by the runtime
+// package on the initialization of the application. Therefore,
+// it should be imported in the main as follows:
+//
+// import _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+var (
+ Hooks [1]ent.Hook
+ Interceptors [1]ent.Interceptor
+ // 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
+)
+
+// OrderOption defines the ordering options for the TeamGroup queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByDeletedAt orders the results by the deleted_at field.
+func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDeletedAt, opts...).ToFunc()
+}
+
+// ByTeamID orders the results by the team_id field.
+func ByTeamID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldTeamID, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByMembersCount orders the results by members count.
+func ByMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newMembersStep(), opts...)
+ }
+}
+
+// ByMembers orders the results by members terms.
+func ByMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByTeamField orders the results by team field.
+func ByTeamField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByTeamGroupMembersCount orders the results by team_group_members count.
+func ByTeamGroupMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newTeamGroupMembersStep(), opts...)
+ }
+}
+
+// ByTeamGroupMembers orders the results by team_group_members terms.
+func ByTeamGroupMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamGroupMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(MembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, MembersTable, MembersPrimaryKey...),
+ )
+}
+func newTeamStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, TeamTable, TeamColumn),
+ )
+}
+func newTeamGroupMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamGroupMembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamGroupMembersTable, TeamGroupMembersColumn),
+ )
+}
diff --git a/backend/db/teamgroup/where.go b/backend/db/teamgroup/where.go
new file mode 100644
index 00000000..c99b620a
--- /dev/null
+++ b/backend/db/teamgroup/where.go
@@ -0,0 +1,381 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teamgroup
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLTE(FieldID, id))
+}
+
+// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
+func DeletedAt(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// TeamID applies equality check predicate on the "team_id" field. It's identical to TeamIDEQ.
+func TeamID(v uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldTeamID, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldName, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
+func DeletedAtEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
+func DeletedAtNEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtIn applies the In predicate on the "deleted_at" field.
+func DeletedAtIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
+func DeletedAtNotIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtGT applies the GT predicate on the "deleted_at" field.
+func DeletedAtGT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGT(FieldDeletedAt, v))
+}
+
+// DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
+func DeletedAtGTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGTE(FieldDeletedAt, v))
+}
+
+// DeletedAtLT applies the LT predicate on the "deleted_at" field.
+func DeletedAtLT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLT(FieldDeletedAt, v))
+}
+
+// DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
+func DeletedAtLTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLTE(FieldDeletedAt, v))
+}
+
+// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
+func DeletedAtIsNil() predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIsNull(FieldDeletedAt))
+}
+
+// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
+func DeletedAtNotNil() predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotNull(FieldDeletedAt))
+}
+
+// TeamIDEQ applies the EQ predicate on the "team_id" field.
+func TeamIDEQ(v uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldTeamID, v))
+}
+
+// TeamIDNEQ applies the NEQ predicate on the "team_id" field.
+func TeamIDNEQ(v uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldTeamID, v))
+}
+
+// TeamIDIn applies the In predicate on the "team_id" field.
+func TeamIDIn(vs ...uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldTeamID, vs...))
+}
+
+// TeamIDNotIn applies the NotIn predicate on the "team_id" field.
+func TeamIDNotIn(vs ...uuid.UUID) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldTeamID, vs...))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldContainsFold(FieldName, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// HasMembers applies the HasEdge predicate on the "members" edge.
+func HasMembers() predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, MembersTable, MembersPrimaryKey...),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasMembersWith applies the HasEdge predicate on the "members" edge with a given conditions (other predicates).
+func HasMembersWith(preds ...predicate.User) predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := newMembersStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeam applies the HasEdge predicate on the "team" edge.
+func HasTeam() predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, TeamTable, TeamColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamWith applies the HasEdge predicate on the "team" edge with a given conditions (other predicates).
+func HasTeamWith(preds ...predicate.Team) predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := newTeamStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeamGroupMembers applies the HasEdge predicate on the "team_group_members" edge.
+func HasTeamGroupMembers() predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamGroupMembersTable, TeamGroupMembersColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamGroupMembersWith applies the HasEdge predicate on the "team_group_members" edge with a given conditions (other predicates).
+func HasTeamGroupMembersWith(preds ...predicate.TeamGroupMember) predicate.TeamGroup {
+ return predicate.TeamGroup(func(s *sql.Selector) {
+ step := newTeamGroupMembersStep()
+ 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.TeamGroup) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.TeamGroup) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.TeamGroup) predicate.TeamGroup {
+ return predicate.TeamGroup(sql.NotPredicates(p))
+}
diff --git a/backend/db/teamgroup_create.go b/backend/db/teamgroup_create.go
new file mode 100644
index 00000000..be2b37f6
--- /dev/null
+++ b/backend/db/teamgroup_create.go
@@ -0,0 +1,857 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupCreate is the builder for creating a TeamGroup entity.
+type TeamGroupCreate struct {
+ config
+ mutation *TeamGroupMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_c *TeamGroupCreate) SetDeletedAt(v time.Time) *TeamGroupCreate {
+ _c.mutation.SetDeletedAt(v)
+ return _c
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_c *TeamGroupCreate) SetNillableDeletedAt(v *time.Time) *TeamGroupCreate {
+ if v != nil {
+ _c.SetDeletedAt(*v)
+ }
+ return _c
+}
+
+// SetTeamID sets the "team_id" field.
+func (_c *TeamGroupCreate) SetTeamID(v uuid.UUID) *TeamGroupCreate {
+ _c.mutation.SetTeamID(v)
+ return _c
+}
+
+// SetName sets the "name" field.
+func (_c *TeamGroupCreate) SetName(v string) *TeamGroupCreate {
+ _c.mutation.SetName(v)
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *TeamGroupCreate) SetCreatedAt(v time.Time) *TeamGroupCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *TeamGroupCreate) SetNillableCreatedAt(v *time.Time) *TeamGroupCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *TeamGroupCreate) SetUpdatedAt(v time.Time) *TeamGroupCreate {
+ _c.mutation.SetUpdatedAt(v)
+ return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *TeamGroupCreate) SetNillableUpdatedAt(v *time.Time) *TeamGroupCreate {
+ if v != nil {
+ _c.SetUpdatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *TeamGroupCreate) SetID(v uuid.UUID) *TeamGroupCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_c *TeamGroupCreate) AddMemberIDs(ids ...uuid.UUID) *TeamGroupCreate {
+ _c.mutation.AddMemberIDs(ids...)
+ return _c
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_c *TeamGroupCreate) AddMembers(v ...*User) *TeamGroupCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddMemberIDs(ids...)
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_c *TeamGroupCreate) SetTeam(v *Team) *TeamGroupCreate {
+ return _c.SetTeamID(v.ID)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_c *TeamGroupCreate) AddTeamGroupMemberIDs(ids ...uuid.UUID) *TeamGroupCreate {
+ _c.mutation.AddTeamGroupMemberIDs(ids...)
+ return _c
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_c *TeamGroupCreate) AddTeamGroupMembers(v ...*TeamGroupMember) *TeamGroupCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the TeamGroupMutation object of the builder.
+func (_c *TeamGroupCreate) Mutation() *TeamGroupMutation {
+ return _c.mutation
+}
+
+// Save creates the TeamGroup in the database.
+func (_c *TeamGroupCreate) Save(ctx context.Context) (*TeamGroup, error) {
+ if err := _c.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *TeamGroupCreate) SaveX(ctx context.Context) *TeamGroup {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamGroupCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamGroupCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *TeamGroupCreate) defaults() error {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ if teamgroup.DefaultCreatedAt == nil {
+ return fmt.Errorf("db: uninitialized teamgroup.DefaultCreatedAt (forgotten import db/runtime?)")
+ }
+ v := teamgroup.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ if teamgroup.DefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized teamgroup.DefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := teamgroup.DefaultUpdatedAt()
+ _c.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *TeamGroupCreate) check() error {
+ if _, ok := _c.mutation.TeamID(); !ok {
+ return &ValidationError{Name: "team_id", err: errors.New(`db: missing required field "TeamGroup.team_id"`)}
+ }
+ if _, ok := _c.mutation.Name(); !ok {
+ return &ValidationError{Name: "name", err: errors.New(`db: missing required field "TeamGroup.name"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "TeamGroup.created_at"`)}
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "TeamGroup.updated_at"`)}
+ }
+ if len(_c.mutation.TeamIDs()) == 0 {
+ return &ValidationError{Name: "team", err: errors.New(`db: missing required edge "TeamGroup.team"`)}
+ }
+ return nil
+}
+
+func (_c *TeamGroupCreate) sqlSave(ctx context.Context) (*TeamGroup, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *TeamGroupCreate) createSpec() (*TeamGroup, *sqlgraph.CreateSpec) {
+ var (
+ _node = &TeamGroup{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(teamgroup.Table, sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.DeletedAt(); ok {
+ _spec.SetField(teamgroup.FieldDeletedAt, field.TypeTime, value)
+ _node.DeletedAt = value
+ }
+ if value, ok := _c.mutation.Name(); ok {
+ _spec.SetField(teamgroup.FieldName, field.TypeString, value)
+ _node.Name = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroup.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if value, ok := _c.mutation.UpdatedAt(); ok {
+ _spec.SetField(teamgroup.FieldUpdatedAt, field.TypeTime, value)
+ _node.UpdatedAt = value
+ }
+ if nodes := _c.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _c.config, mutation: newTeamGroupMemberMutation(_c.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: teamgroup.TeamTable,
+ Columns: []string{teamgroup.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.TeamID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamGroup.Create().
+// SetDeletedAt(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamGroupUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamGroupCreate) OnConflict(opts ...sql.ConflictOption) *TeamGroupUpsertOne {
+ _c.conflict = opts
+ return &TeamGroupUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamGroupCreate) OnConflictColumns(columns ...string) *TeamGroupUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamGroupUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // TeamGroupUpsertOne is the builder for "upsert"-ing
+ // one TeamGroup node.
+ TeamGroupUpsertOne struct {
+ create *TeamGroupCreate
+ }
+
+ // TeamGroupUpsert is the "OnConflict" setter.
+ TeamGroupUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamGroupUpsert) SetDeletedAt(v time.Time) *TeamGroupUpsert {
+ u.Set(teamgroup.FieldDeletedAt, v)
+ return u
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamGroupUpsert) UpdateDeletedAt() *TeamGroupUpsert {
+ u.SetExcluded(teamgroup.FieldDeletedAt)
+ return u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamGroupUpsert) ClearDeletedAt() *TeamGroupUpsert {
+ u.SetNull(teamgroup.FieldDeletedAt)
+ return u
+}
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamGroupUpsert) SetTeamID(v uuid.UUID) *TeamGroupUpsert {
+ u.Set(teamgroup.FieldTeamID, v)
+ return u
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamGroupUpsert) UpdateTeamID() *TeamGroupUpsert {
+ u.SetExcluded(teamgroup.FieldTeamID)
+ return u
+}
+
+// SetName sets the "name" field.
+func (u *TeamGroupUpsert) SetName(v string) *TeamGroupUpsert {
+ u.Set(teamgroup.FieldName, v)
+ return u
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamGroupUpsert) UpdateName() *TeamGroupUpsert {
+ u.SetExcluded(teamgroup.FieldName)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupUpsert) SetCreatedAt(v time.Time) *TeamGroupUpsert {
+ u.Set(teamgroup.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupUpsert) UpdateCreatedAt() *TeamGroupUpsert {
+ u.SetExcluded(teamgroup.FieldCreatedAt)
+ return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamGroupUpsert) SetUpdatedAt(v time.Time) *TeamGroupUpsert {
+ u.Set(teamgroup.FieldUpdatedAt, v)
+ return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamGroupUpsert) UpdateUpdatedAt() *TeamGroupUpsert {
+ u.SetExcluded(teamgroup.FieldUpdatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teamgroup.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamGroupUpsertOne) UpdateNewValues() *TeamGroupUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(teamgroup.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamGroupUpsertOne) Ignore() *TeamGroupUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamGroupUpsertOne) DoNothing() *TeamGroupUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamGroupCreate.OnConflict
+// documentation for more info.
+func (u *TeamGroupUpsertOne) Update(set func(*TeamGroupUpsert)) *TeamGroupUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamGroupUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamGroupUpsertOne) SetDeletedAt(v time.Time) *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertOne) UpdateDeletedAt() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamGroupUpsertOne) ClearDeletedAt() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamGroupUpsertOne) SetTeamID(v uuid.UUID) *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetTeamID(v)
+ })
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamGroupUpsertOne) UpdateTeamID() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateTeamID()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *TeamGroupUpsertOne) SetName(v string) *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamGroupUpsertOne) UpdateName() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupUpsertOne) SetCreatedAt(v time.Time) *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertOne) UpdateCreatedAt() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamGroupUpsertOne) SetUpdatedAt(v time.Time) *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertOne) UpdateUpdatedAt() *TeamGroupUpsertOne {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamGroupUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamGroupCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamGroupUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *TeamGroupUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: TeamGroupUpsertOne.ID is not supported by MySQL driver. Use TeamGroupUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *TeamGroupUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// TeamGroupCreateBulk is the builder for creating many TeamGroup entities in bulk.
+type TeamGroupCreateBulk struct {
+ config
+ err error
+ builders []*TeamGroupCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the TeamGroup entities in the database.
+func (_c *TeamGroupCreateBulk) Save(ctx context.Context) ([]*TeamGroup, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*TeamGroup, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*TeamGroupMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *TeamGroupCreateBulk) SaveX(ctx context.Context) []*TeamGroup {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamGroupCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamGroupCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamGroup.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamGroupUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamGroupCreateBulk) OnConflict(opts ...sql.ConflictOption) *TeamGroupUpsertBulk {
+ _c.conflict = opts
+ return &TeamGroupUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamGroupCreateBulk) OnConflictColumns(columns ...string) *TeamGroupUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamGroupUpsertBulk{
+ create: _c,
+ }
+}
+
+// TeamGroupUpsertBulk is the builder for "upsert"-ing
+// a bulk of TeamGroup nodes.
+type TeamGroupUpsertBulk struct {
+ create *TeamGroupCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teamgroup.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamGroupUpsertBulk) UpdateNewValues() *TeamGroupUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(teamgroup.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamGroup.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamGroupUpsertBulk) Ignore() *TeamGroupUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamGroupUpsertBulk) DoNothing() *TeamGroupUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamGroupCreateBulk.OnConflict
+// documentation for more info.
+func (u *TeamGroupUpsertBulk) Update(set func(*TeamGroupUpsert)) *TeamGroupUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamGroupUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *TeamGroupUpsertBulk) SetDeletedAt(v time.Time) *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertBulk) UpdateDeletedAt() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *TeamGroupUpsertBulk) ClearDeletedAt() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamGroupUpsertBulk) SetTeamID(v uuid.UUID) *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetTeamID(v)
+ })
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamGroupUpsertBulk) UpdateTeamID() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateTeamID()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *TeamGroupUpsertBulk) SetName(v string) *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *TeamGroupUpsertBulk) UpdateName() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupUpsertBulk) SetCreatedAt(v time.Time) *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertBulk) UpdateCreatedAt() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *TeamGroupUpsertBulk) SetUpdatedAt(v time.Time) *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *TeamGroupUpsertBulk) UpdateUpdatedAt() *TeamGroupUpsertBulk {
+ return u.Update(func(s *TeamGroupUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamGroupUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the TeamGroupCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamGroupCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamGroupUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teamgroup_delete.go b/backend/db/teamgroup_delete.go
new file mode 100644
index 00000000..d1cd10f3
--- /dev/null
+++ b/backend/db/teamgroup_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+)
+
+// TeamGroupDelete is the builder for deleting a TeamGroup entity.
+type TeamGroupDelete struct {
+ config
+ hooks []Hook
+ mutation *TeamGroupMutation
+}
+
+// Where appends a list predicates to the TeamGroupDelete builder.
+func (_d *TeamGroupDelete) Where(ps ...predicate.TeamGroup) *TeamGroupDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *TeamGroupDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamGroupDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *TeamGroupDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(teamgroup.Table, sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// TeamGroupDeleteOne is the builder for deleting a single TeamGroup entity.
+type TeamGroupDeleteOne struct {
+ _d *TeamGroupDelete
+}
+
+// Where appends a list predicates to the TeamGroupDelete builder.
+func (_d *TeamGroupDeleteOne) Where(ps ...predicate.TeamGroup) *TeamGroupDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *TeamGroupDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{teamgroup.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamGroupDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teamgroup_query.go b/backend/db/teamgroup_query.go
new file mode 100644
index 00000000..36272f0e
--- /dev/null
+++ b/backend/db/teamgroup_query.go
@@ -0,0 +1,837 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "database/sql/driver"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupQuery is the builder for querying TeamGroup entities.
+type TeamGroupQuery struct {
+ config
+ ctx *QueryContext
+ order []teamgroup.OrderOption
+ inters []Interceptor
+ predicates []predicate.TeamGroup
+ withMembers *UserQuery
+ withTeam *TeamQuery
+ withTeamGroupMembers *TeamGroupMemberQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the TeamGroupQuery builder.
+func (_q *TeamGroupQuery) Where(ps ...predicate.TeamGroup) *TeamGroupQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *TeamGroupQuery) Limit(limit int) *TeamGroupQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *TeamGroupQuery) Offset(offset int) *TeamGroupQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *TeamGroupQuery) Unique(unique bool) *TeamGroupQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *TeamGroupQuery) Order(o ...teamgroup.OrderOption) *TeamGroupQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryMembers chains the current query on the "members" edge.
+func (_q *TeamGroupQuery) QueryMembers() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, true, teamgroup.MembersTable, teamgroup.MembersPrimaryKey...),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeam chains the current query on the "team" edge.
+func (_q *TeamGroupQuery) QueryTeam() *TeamQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, selector),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, teamgroup.TeamTable, teamgroup.TeamColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeamGroupMembers chains the current query on the "team_group_members" edge.
+func (_q *TeamGroupQuery) QueryTeamGroupMembers() *TeamGroupMemberQuery {
+ query := (&TeamGroupMemberClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroup.Table, teamgroup.FieldID, selector),
+ sqlgraph.To(teamgroupmember.Table, teamgroupmember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, teamgroup.TeamGroupMembersTable, teamgroup.TeamGroupMembersColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first TeamGroup entity from the query.
+// Returns a *NotFoundError when no TeamGroup was found.
+func (_q *TeamGroupQuery) First(ctx context.Context) (*TeamGroup, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{teamgroup.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *TeamGroupQuery) FirstX(ctx context.Context) *TeamGroup {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first TeamGroup ID from the query.
+// Returns a *NotFoundError when no TeamGroup ID was found.
+func (_q *TeamGroupQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{teamgroup.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *TeamGroupQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single TeamGroup entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one TeamGroup entity is found.
+// Returns a *NotFoundError when no TeamGroup entities are found.
+func (_q *TeamGroupQuery) Only(ctx context.Context) (*TeamGroup, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{teamgroup.Label}
+ default:
+ return nil, &NotSingularError{teamgroup.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *TeamGroupQuery) OnlyX(ctx context.Context) *TeamGroup {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only TeamGroup ID in the query.
+// Returns a *NotSingularError when more than one TeamGroup ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *TeamGroupQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{teamgroup.Label}
+ default:
+ err = &NotSingularError{teamgroup.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *TeamGroupQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of TeamGroups.
+func (_q *TeamGroupQuery) All(ctx context.Context) ([]*TeamGroup, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*TeamGroup, *TeamGroupQuery]()
+ return withInterceptors[[]*TeamGroup](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *TeamGroupQuery) AllX(ctx context.Context) []*TeamGroup {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of TeamGroup IDs.
+func (_q *TeamGroupQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(teamgroup.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *TeamGroupQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *TeamGroupQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*TeamGroupQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *TeamGroupQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *TeamGroupQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *TeamGroupQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the TeamGroupQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *TeamGroupQuery) Clone() *TeamGroupQuery {
+ if _q == nil {
+ return nil
+ }
+ return &TeamGroupQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]teamgroup.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.TeamGroup{}, _q.predicates...),
+ withMembers: _q.withMembers.Clone(),
+ withTeam: _q.withTeam.Clone(),
+ withTeamGroupMembers: _q.withTeamGroupMembers.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithMembers tells the query-builder to eager-load the nodes that are connected to
+// the "members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamGroupQuery) WithMembers(opts ...func(*UserQuery)) *TeamGroupQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withMembers = query
+ return _q
+}
+
+// WithTeam tells the query-builder to eager-load the nodes that are connected to
+// the "team" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamGroupQuery) WithTeam(opts ...func(*TeamQuery)) *TeamGroupQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeam = query
+ return _q
+}
+
+// WithTeamGroupMembers tells the query-builder to eager-load the nodes that are connected to
+// the "team_group_members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamGroupQuery) WithTeamGroupMembers(opts ...func(*TeamGroupMemberQuery)) *TeamGroupQuery {
+ query := (&TeamGroupMemberClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeamGroupMembers = query
+ return _q
+}
+
+// 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.TeamGroup.Query().
+// GroupBy(teamgroup.FieldDeletedAt).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *TeamGroupQuery) GroupBy(field string, fields ...string) *TeamGroupGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &TeamGroupGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = teamgroup.Label
+ grbuild.scan = 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// }
+//
+// client.TeamGroup.Query().
+// Select(teamgroup.FieldDeletedAt).
+// Scan(ctx, &v)
+func (_q *TeamGroupQuery) Select(fields ...string) *TeamGroupSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &TeamGroupSelect{TeamGroupQuery: _q}
+ sbuild.label = teamgroup.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a TeamGroupSelect configured with the given aggregations.
+func (_q *TeamGroupQuery) Aggregate(fns ...AggregateFunc) *TeamGroupSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *TeamGroupQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !teamgroup.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *TeamGroupQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*TeamGroup, error) {
+ var (
+ nodes = []*TeamGroup{}
+ _spec = _q.querySpec()
+ loadedTypes = [3]bool{
+ _q.withMembers != nil,
+ _q.withTeam != nil,
+ _q.withTeamGroupMembers != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*TeamGroup).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &TeamGroup{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withMembers; query != nil {
+ if err := _q.loadMembers(ctx, query, nodes,
+ func(n *TeamGroup) { n.Edges.Members = []*User{} },
+ func(n *TeamGroup, e *User) { n.Edges.Members = append(n.Edges.Members, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeam; query != nil {
+ if err := _q.loadTeam(ctx, query, nodes, nil,
+ func(n *TeamGroup, e *Team) { n.Edges.Team = e }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeamGroupMembers; query != nil {
+ if err := _q.loadTeamGroupMembers(ctx, query, nodes,
+ func(n *TeamGroup) { n.Edges.TeamGroupMembers = []*TeamGroupMember{} },
+ func(n *TeamGroup, e *TeamGroupMember) { n.Edges.TeamGroupMembers = append(n.Edges.TeamGroupMembers, e) }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *TeamGroupQuery) loadMembers(ctx context.Context, query *UserQuery, nodes []*TeamGroup, init func(*TeamGroup), assign func(*TeamGroup, *User)) error {
+ edgeIDs := make([]driver.Value, len(nodes))
+ byID := make(map[uuid.UUID]*TeamGroup)
+ nids := make(map[uuid.UUID]map[*TeamGroup]struct{})
+ for i, node := range nodes {
+ edgeIDs[i] = node.ID
+ byID[node.ID] = node
+ if init != nil {
+ init(node)
+ }
+ }
+ query.Where(func(s *sql.Selector) {
+ joinT := sql.Table(teamgroup.MembersTable)
+ s.Join(joinT).On(s.C(user.FieldID), joinT.C(teamgroup.MembersPrimaryKey[0]))
+ s.Where(sql.InValues(joinT.C(teamgroup.MembersPrimaryKey[1]), edgeIDs...))
+ columns := s.SelectedColumns()
+ s.Select(joinT.C(teamgroup.MembersPrimaryKey[1]))
+ s.AppendSelect(columns...)
+ s.SetDistinct(false)
+ })
+ if err := query.prepareQuery(ctx); err != nil {
+ return err
+ }
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
+ }
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*TeamGroup]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
+ }
+ })
+ })
+ neighbors, err := withInterceptors[[]*User](ctx, query, qr, query.inters)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected "members" node returned %v`, n.ID)
+ }
+ for kn := range nodes {
+ assign(kn, n)
+ }
+ }
+ return nil
+}
+func (_q *TeamGroupQuery) loadTeam(ctx context.Context, query *TeamQuery, nodes []*TeamGroup, init func(*TeamGroup), assign func(*TeamGroup, *Team)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*TeamGroup)
+ for i := range nodes {
+ fk := nodes[i].TeamID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(team.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 "team_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+func (_q *TeamGroupQuery) loadTeamGroupMembers(ctx context.Context, query *TeamGroupMemberQuery, nodes []*TeamGroup, init func(*TeamGroup), assign func(*TeamGroup, *TeamGroupMember)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*TeamGroup)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(teamgroupmember.FieldGroupID)
+ }
+ query.Where(predicate.TeamGroupMember(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(teamgroup.TeamGroupMembersColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.GroupID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "group_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+
+func (_q *TeamGroupQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *TeamGroupQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(teamgroup.Table, teamgroup.Columns, sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teamgroup.FieldID)
+ for i := range fields {
+ if fields[i] != teamgroup.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ if _q.withTeam != nil {
+ _spec.Node.AddColumnOnce(teamgroup.FieldTeamID)
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *TeamGroupQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(teamgroup.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = teamgroup.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *TeamGroupQuery) ForUpdate(opts ...sql.LockOption) *TeamGroupQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *TeamGroupQuery) ForShare(opts ...sql.LockOption) *TeamGroupQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *TeamGroupQuery) Modify(modifiers ...func(s *sql.Selector)) *TeamGroupSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// TeamGroupGroupBy is the group-by builder for TeamGroup entities.
+type TeamGroupGroupBy struct {
+ selector
+ build *TeamGroupQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *TeamGroupGroupBy) Aggregate(fns ...AggregateFunc) *TeamGroupGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *TeamGroupGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamGroupQuery, *TeamGroupGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *TeamGroupGroupBy) sqlScan(ctx context.Context, root *TeamGroupQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// TeamGroupSelect is the builder for selecting fields of TeamGroup entities.
+type TeamGroupSelect struct {
+ *TeamGroupQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *TeamGroupSelect) Aggregate(fns ...AggregateFunc) *TeamGroupSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *TeamGroupSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamGroupQuery, *TeamGroupSelect](ctx, _s.TeamGroupQuery, _s, _s.inters, v)
+}
+
+func (_s *TeamGroupSelect) sqlScan(ctx context.Context, root *TeamGroupQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *TeamGroupSelect) Modify(modifiers ...func(s *sql.Selector)) *TeamGroupSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/teamgroup_update.go b/backend/db/teamgroup_update.go
new file mode 100644
index 00000000..7372a6d3
--- /dev/null
+++ b/backend/db/teamgroup_update.go
@@ -0,0 +1,842 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupUpdate is the builder for updating TeamGroup entities.
+type TeamGroupUpdate struct {
+ config
+ hooks []Hook
+ mutation *TeamGroupMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the TeamGroupUpdate builder.
+func (_u *TeamGroupUpdate) Where(ps ...predicate.TeamGroup) *TeamGroupUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *TeamGroupUpdate) SetDeletedAt(v time.Time) *TeamGroupUpdate {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *TeamGroupUpdate) SetNillableDeletedAt(v *time.Time) *TeamGroupUpdate {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *TeamGroupUpdate) ClearDeletedAt() *TeamGroupUpdate {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetTeamID sets the "team_id" field.
+func (_u *TeamGroupUpdate) SetTeamID(v uuid.UUID) *TeamGroupUpdate {
+ _u.mutation.SetTeamID(v)
+ return _u
+}
+
+// SetNillableTeamID sets the "team_id" field if the given value is not nil.
+func (_u *TeamGroupUpdate) SetNillableTeamID(v *uuid.UUID) *TeamGroupUpdate {
+ if v != nil {
+ _u.SetTeamID(*v)
+ }
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *TeamGroupUpdate) SetName(v string) *TeamGroupUpdate {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *TeamGroupUpdate) SetNillableName(v *string) *TeamGroupUpdate {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamGroupUpdate) SetCreatedAt(v time.Time) *TeamGroupUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamGroupUpdate) SetNillableCreatedAt(v *time.Time) *TeamGroupUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *TeamGroupUpdate) SetUpdatedAt(v time.Time) *TeamGroupUpdate {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_u *TeamGroupUpdate) AddMemberIDs(ids ...uuid.UUID) *TeamGroupUpdate {
+ _u.mutation.AddMemberIDs(ids...)
+ return _u
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_u *TeamGroupUpdate) AddMembers(v ...*User) *TeamGroupUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddMemberIDs(ids...)
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_u *TeamGroupUpdate) SetTeam(v *Team) *TeamGroupUpdate {
+ return _u.SetTeamID(v.ID)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_u *TeamGroupUpdate) AddTeamGroupMemberIDs(ids ...uuid.UUID) *TeamGroupUpdate {
+ _u.mutation.AddTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_u *TeamGroupUpdate) AddTeamGroupMembers(v ...*TeamGroupMember) *TeamGroupUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the TeamGroupMutation object of the builder.
+func (_u *TeamGroupUpdate) Mutation() *TeamGroupMutation {
+ return _u.mutation
+}
+
+// ClearMembers clears all "members" edges to the User entity.
+func (_u *TeamGroupUpdate) ClearMembers() *TeamGroupUpdate {
+ _u.mutation.ClearMembers()
+ return _u
+}
+
+// RemoveMemberIDs removes the "members" edge to User entities by IDs.
+func (_u *TeamGroupUpdate) RemoveMemberIDs(ids ...uuid.UUID) *TeamGroupUpdate {
+ _u.mutation.RemoveMemberIDs(ids...)
+ return _u
+}
+
+// RemoveMembers removes "members" edges to User entities.
+func (_u *TeamGroupUpdate) RemoveMembers(v ...*User) *TeamGroupUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveMemberIDs(ids...)
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (_u *TeamGroupUpdate) ClearTeam() *TeamGroupUpdate {
+ _u.mutation.ClearTeam()
+ return _u
+}
+
+// ClearTeamGroupMembers clears all "team_group_members" edges to the TeamGroupMember entity.
+func (_u *TeamGroupUpdate) ClearTeamGroupMembers() *TeamGroupUpdate {
+ _u.mutation.ClearTeamGroupMembers()
+ return _u
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to TeamGroupMember entities by IDs.
+func (_u *TeamGroupUpdate) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) *TeamGroupUpdate {
+ _u.mutation.RemoveTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamGroupMembers removes "team_group_members" edges to TeamGroupMember entities.
+func (_u *TeamGroupUpdate) RemoveTeamGroupMembers(v ...*TeamGroupMember) *TeamGroupUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamGroupMemberIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *TeamGroupUpdate) Save(ctx context.Context) (int, error) {
+ if err := _u.defaults(); err != nil {
+ return 0, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamGroupUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *TeamGroupUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamGroupUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *TeamGroupUpdate) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok {
+ if teamgroup.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized teamgroup.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := teamgroup.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamGroupUpdate) check() error {
+ if _u.mutation.TeamCleared() && len(_u.mutation.TeamIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroup.team"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamGroupUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamGroupUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamGroupUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teamgroup.Table, teamgroup.Columns, sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(teamgroup.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(teamgroup.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(teamgroup.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroup.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(teamgroup.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedMembersIDs(); len(nodes) > 0 && !_u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: teamgroup.TeamTable,
+ Columns: []string{teamgroup.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: teamgroup.TeamTable,
+ Columns: []string{teamgroup.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamGroupMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teamgroup.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// TeamGroupUpdateOne is the builder for updating a single TeamGroup entity.
+type TeamGroupUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *TeamGroupMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *TeamGroupUpdateOne) SetDeletedAt(v time.Time) *TeamGroupUpdateOne {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *TeamGroupUpdateOne) SetNillableDeletedAt(v *time.Time) *TeamGroupUpdateOne {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *TeamGroupUpdateOne) ClearDeletedAt() *TeamGroupUpdateOne {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetTeamID sets the "team_id" field.
+func (_u *TeamGroupUpdateOne) SetTeamID(v uuid.UUID) *TeamGroupUpdateOne {
+ _u.mutation.SetTeamID(v)
+ return _u
+}
+
+// SetNillableTeamID sets the "team_id" field if the given value is not nil.
+func (_u *TeamGroupUpdateOne) SetNillableTeamID(v *uuid.UUID) *TeamGroupUpdateOne {
+ if v != nil {
+ _u.SetTeamID(*v)
+ }
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *TeamGroupUpdateOne) SetName(v string) *TeamGroupUpdateOne {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *TeamGroupUpdateOne) SetNillableName(v *string) *TeamGroupUpdateOne {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamGroupUpdateOne) SetCreatedAt(v time.Time) *TeamGroupUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamGroupUpdateOne) SetNillableCreatedAt(v *time.Time) *TeamGroupUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *TeamGroupUpdateOne) SetUpdatedAt(v time.Time) *TeamGroupUpdateOne {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// AddMemberIDs adds the "members" edge to the User entity by IDs.
+func (_u *TeamGroupUpdateOne) AddMemberIDs(ids ...uuid.UUID) *TeamGroupUpdateOne {
+ _u.mutation.AddMemberIDs(ids...)
+ return _u
+}
+
+// AddMembers adds the "members" edges to the User entity.
+func (_u *TeamGroupUpdateOne) AddMembers(v ...*User) *TeamGroupUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddMemberIDs(ids...)
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_u *TeamGroupUpdateOne) SetTeam(v *Team) *TeamGroupUpdateOne {
+ return _u.SetTeamID(v.ID)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_u *TeamGroupUpdateOne) AddTeamGroupMemberIDs(ids ...uuid.UUID) *TeamGroupUpdateOne {
+ _u.mutation.AddTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_u *TeamGroupUpdateOne) AddTeamGroupMembers(v ...*TeamGroupMember) *TeamGroupUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the TeamGroupMutation object of the builder.
+func (_u *TeamGroupUpdateOne) Mutation() *TeamGroupMutation {
+ return _u.mutation
+}
+
+// ClearMembers clears all "members" edges to the User entity.
+func (_u *TeamGroupUpdateOne) ClearMembers() *TeamGroupUpdateOne {
+ _u.mutation.ClearMembers()
+ return _u
+}
+
+// RemoveMemberIDs removes the "members" edge to User entities by IDs.
+func (_u *TeamGroupUpdateOne) RemoveMemberIDs(ids ...uuid.UUID) *TeamGroupUpdateOne {
+ _u.mutation.RemoveMemberIDs(ids...)
+ return _u
+}
+
+// RemoveMembers removes "members" edges to User entities.
+func (_u *TeamGroupUpdateOne) RemoveMembers(v ...*User) *TeamGroupUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveMemberIDs(ids...)
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (_u *TeamGroupUpdateOne) ClearTeam() *TeamGroupUpdateOne {
+ _u.mutation.ClearTeam()
+ return _u
+}
+
+// ClearTeamGroupMembers clears all "team_group_members" edges to the TeamGroupMember entity.
+func (_u *TeamGroupUpdateOne) ClearTeamGroupMembers() *TeamGroupUpdateOne {
+ _u.mutation.ClearTeamGroupMembers()
+ return _u
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to TeamGroupMember entities by IDs.
+func (_u *TeamGroupUpdateOne) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) *TeamGroupUpdateOne {
+ _u.mutation.RemoveTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamGroupMembers removes "team_group_members" edges to TeamGroupMember entities.
+func (_u *TeamGroupUpdateOne) RemoveTeamGroupMembers(v ...*TeamGroupMember) *TeamGroupUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamGroupMemberIDs(ids...)
+}
+
+// Where appends a list predicates to the TeamGroupUpdate builder.
+func (_u *TeamGroupUpdateOne) Where(ps ...predicate.TeamGroup) *TeamGroupUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *TeamGroupUpdateOne) Select(field string, fields ...string) *TeamGroupUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated TeamGroup entity.
+func (_u *TeamGroupUpdateOne) Save(ctx context.Context) (*TeamGroup, error) {
+ if err := _u.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamGroupUpdateOne) SaveX(ctx context.Context) *TeamGroup {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *TeamGroupUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamGroupUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *TeamGroupUpdateOne) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok {
+ if teamgroup.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized teamgroup.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := teamgroup.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamGroupUpdateOne) check() error {
+ if _u.mutation.TeamCleared() && len(_u.mutation.TeamIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroup.team"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamGroupUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamGroupUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamGroupUpdateOne) sqlSave(ctx context.Context) (_node *TeamGroup, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teamgroup.Table, teamgroup.Columns, sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "TeamGroup.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teamgroup.FieldID)
+ for _, f := range fields {
+ if !teamgroup.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != teamgroup.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(teamgroup.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(teamgroup.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(teamgroup.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroup.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(teamgroup.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedMembersIDs(); len(nodes) > 0 && !_u.mutation.MembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.MembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: true,
+ Table: teamgroup.MembersTable,
+ Columns: teamgroup.MembersPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: teamgroup.TeamTable,
+ Columns: []string{teamgroup.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: teamgroup.TeamTable,
+ Columns: []string{teamgroup.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamGroupMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: teamgroup.TeamGroupMembersTable,
+ Columns: []string{teamgroup.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &TeamGroup{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teamgroup.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/teamgroupmember.go b/backend/db/teamgroupmember.go
new file mode 100644
index 00000000..e8c05b62
--- /dev/null
+++ b/backend/db/teamgroupmember.go
@@ -0,0 +1,175 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupMember is the model entity for the TeamGroupMember schema.
+type TeamGroupMember struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // GroupID holds the value of the "group_id" field.
+ GroupID uuid.UUID `json:"group_id,omitempty"`
+ // UserID holds the value of the "user_id" field.
+ UserID uuid.UUID `json:"user_id,omitempty"`
+ // CreatedAt holds the value of the "created_at" field.
+ CreatedAt time.Time `json:"created_at,omitempty"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the TeamGroupMemberQuery when eager-loading is set.
+ Edges TeamGroupMemberEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// TeamGroupMemberEdges holds the relations/edges for other nodes in the graph.
+type TeamGroupMemberEdges struct {
+ // Group holds the value of the group edge.
+ Group *TeamGroup `json:"group,omitempty"`
+ // User holds the value of the user edge.
+ User *User `json:"user,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [2]bool
+}
+
+// GroupOrErr returns the Group value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e TeamGroupMemberEdges) GroupOrErr() (*TeamGroup, error) {
+ if e.Group != nil {
+ return e.Group, nil
+ } else if e.loadedTypes[0] {
+ return nil, &NotFoundError{label: teamgroup.Label}
+ }
+ return nil, &NotLoadedError{edge: "group"}
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e TeamGroupMemberEdges) UserOrErr() (*User, error) {
+ if e.User != nil {
+ return e.User, nil
+ } else if e.loadedTypes[1] {
+ return nil, &NotFoundError{label: user.Label}
+ }
+ return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*TeamGroupMember) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case teamgroupmember.FieldCreatedAt:
+ values[i] = new(sql.NullTime)
+ case teamgroupmember.FieldID, teamgroupmember.FieldGroupID, teamgroupmember.FieldUserID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the TeamGroupMember fields.
+func (_m *TeamGroupMember) 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 teamgroupmember.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case teamgroupmember.FieldGroupID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field group_id", values[i])
+ } else if value != nil {
+ _m.GroupID = *value
+ }
+ case teamgroupmember.FieldUserID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field user_id", values[i])
+ } else if value != nil {
+ _m.UserID = *value
+ }
+ case teamgroupmember.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 {
+ _m.CreatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the TeamGroupMember.
+// This includes values selected through modifiers, order, etc.
+func (_m *TeamGroupMember) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryGroup queries the "group" edge of the TeamGroupMember entity.
+func (_m *TeamGroupMember) QueryGroup() *TeamGroupQuery {
+ return NewTeamGroupMemberClient(_m.config).QueryGroup(_m)
+}
+
+// QueryUser queries the "user" edge of the TeamGroupMember entity.
+func (_m *TeamGroupMember) QueryUser() *UserQuery {
+ return NewTeamGroupMemberClient(_m.config).QueryUser(_m)
+}
+
+// Update returns a builder for updating this TeamGroupMember.
+// Note that you need to call TeamGroupMember.Unwrap() before calling this method if this TeamGroupMember
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *TeamGroupMember) Update() *TeamGroupMemberUpdateOne {
+ return NewTeamGroupMemberClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the TeamGroupMember 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 (_m *TeamGroupMember) Unwrap() *TeamGroupMember {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: TeamGroupMember is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *TeamGroupMember) String() string {
+ var builder strings.Builder
+ builder.WriteString("TeamGroupMember(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("group_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.GroupID))
+ builder.WriteString(", ")
+ builder.WriteString("user_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.UserID))
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// TeamGroupMembers is a parsable slice of TeamGroupMember.
+type TeamGroupMembers []*TeamGroupMember
diff --git a/backend/db/teamgroupmember/teamgroupmember.go b/backend/db/teamgroupmember/teamgroupmember.go
new file mode 100644
index 00000000..7889b8fc
--- /dev/null
+++ b/backend/db/teamgroupmember/teamgroupmember.go
@@ -0,0 +1,117 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teamgroupmember
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the teamgroupmember type in the database.
+ Label = "team_group_member"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldGroupID holds the string denoting the group_id field in the database.
+ FieldGroupID = "group_id"
+ // FieldUserID holds the string denoting the user_id field in the database.
+ FieldUserID = "user_id"
+ // FieldCreatedAt holds the string denoting the created_at field in the database.
+ FieldCreatedAt = "created_at"
+ // EdgeGroup holds the string denoting the group edge name in mutations.
+ EdgeGroup = "group"
+ // EdgeUser holds the string denoting the user edge name in mutations.
+ EdgeUser = "user"
+ // Table holds the table name of the teamgroupmember in the database.
+ Table = "team_group_members"
+ // GroupTable is the table that holds the group relation/edge.
+ GroupTable = "team_group_members"
+ // GroupInverseTable is the table name for the TeamGroup entity.
+ // It exists in this package in order to avoid circular dependency with the "teamgroup" package.
+ GroupInverseTable = "team_groups"
+ // GroupColumn is the table column denoting the group relation/edge.
+ GroupColumn = "group_id"
+ // UserTable is the table that holds the user relation/edge.
+ UserTable = "team_group_members"
+ // UserInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ UserInverseTable = "users"
+ // UserColumn is the table column denoting the user relation/edge.
+ UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for teamgroupmember fields.
+var Columns = []string{
+ FieldID,
+ FieldGroupID,
+ FieldUserID,
+ FieldCreatedAt,
+}
+
+// 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
+ }
+ }
+ return false
+}
+
+var (
+ // DefaultCreatedAt holds the default value on creation for the "created_at" field.
+ DefaultCreatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the TeamGroupMember queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByGroupID orders the results by the group_id field.
+func ByGroupID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldGroupID, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByGroupField orders the results by group field.
+func ByGroupField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newGroupStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, GroupTable, GroupColumn),
+ )
+}
+func newUserStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UserInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, UserTable, UserColumn),
+ )
+}
diff --git a/backend/db/teamgroupmember/where.go b/backend/db/teamgroupmember/where.go
new file mode 100644
index 00000000..4e1c45a1
--- /dev/null
+++ b/backend/db/teamgroupmember/where.go
@@ -0,0 +1,213 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teamgroupmember
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldLTE(FieldID, id))
+}
+
+// GroupID applies equality check predicate on the "group_id" field. It's identical to GroupIDEQ.
+func GroupID(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldGroupID, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldUserID, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// GroupIDEQ applies the EQ predicate on the "group_id" field.
+func GroupIDEQ(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldGroupID, v))
+}
+
+// GroupIDNEQ applies the NEQ predicate on the "group_id" field.
+func GroupIDNEQ(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNEQ(FieldGroupID, v))
+}
+
+// GroupIDIn applies the In predicate on the "group_id" field.
+func GroupIDIn(vs ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldIn(FieldGroupID, vs...))
+}
+
+// GroupIDNotIn applies the NotIn predicate on the "group_id" field.
+func GroupIDNotIn(vs ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNotIn(FieldGroupID, vs...))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...uuid.UUID) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// HasGroup applies the HasEdge predicate on the "group" edge.
+func HasGroup() predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, 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.TeamGroup) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(func(s *sql.Selector) {
+ step := newGroupStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, UserTable, UserColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(func(s *sql.Selector) {
+ step := newUserStep()
+ 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.TeamGroupMember) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.TeamGroupMember) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.TeamGroupMember) predicate.TeamGroupMember {
+ return predicate.TeamGroupMember(sql.NotPredicates(p))
+}
diff --git a/backend/db/teamgroupmember_create.go b/backend/db/teamgroupmember_create.go
new file mode 100644
index 00000000..a663118e
--- /dev/null
+++ b/backend/db/teamgroupmember_create.go
@@ -0,0 +1,659 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupMemberCreate is the builder for creating a TeamGroupMember entity.
+type TeamGroupMemberCreate struct {
+ config
+ mutation *TeamGroupMemberMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetGroupID sets the "group_id" field.
+func (_c *TeamGroupMemberCreate) SetGroupID(v uuid.UUID) *TeamGroupMemberCreate {
+ _c.mutation.SetGroupID(v)
+ return _c
+}
+
+// SetUserID sets the "user_id" field.
+func (_c *TeamGroupMemberCreate) SetUserID(v uuid.UUID) *TeamGroupMemberCreate {
+ _c.mutation.SetUserID(v)
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *TeamGroupMemberCreate) SetCreatedAt(v time.Time) *TeamGroupMemberCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *TeamGroupMemberCreate) SetNillableCreatedAt(v *time.Time) *TeamGroupMemberCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *TeamGroupMemberCreate) SetID(v uuid.UUID) *TeamGroupMemberCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// SetGroup sets the "group" edge to the TeamGroup entity.
+func (_c *TeamGroupMemberCreate) SetGroup(v *TeamGroup) *TeamGroupMemberCreate {
+ return _c.SetGroupID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_c *TeamGroupMemberCreate) SetUser(v *User) *TeamGroupMemberCreate {
+ return _c.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamGroupMemberMutation object of the builder.
+func (_c *TeamGroupMemberCreate) Mutation() *TeamGroupMemberMutation {
+ return _c.mutation
+}
+
+// Save creates the TeamGroupMember in the database.
+func (_c *TeamGroupMemberCreate) Save(ctx context.Context) (*TeamGroupMember, error) {
+ _c.defaults()
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *TeamGroupMemberCreate) SaveX(ctx context.Context) *TeamGroupMember {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamGroupMemberCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamGroupMemberCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *TeamGroupMemberCreate) defaults() {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ v := teamgroupmember.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *TeamGroupMemberCreate) check() error {
+ if _, ok := _c.mutation.GroupID(); !ok {
+ return &ValidationError{Name: "group_id", err: errors.New(`db: missing required field "TeamGroupMember.group_id"`)}
+ }
+ if _, ok := _c.mutation.UserID(); !ok {
+ return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "TeamGroupMember.user_id"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "TeamGroupMember.created_at"`)}
+ }
+ if len(_c.mutation.GroupIDs()) == 0 {
+ return &ValidationError{Name: "group", err: errors.New(`db: missing required edge "TeamGroupMember.group"`)}
+ }
+ if len(_c.mutation.UserIDs()) == 0 {
+ return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "TeamGroupMember.user"`)}
+ }
+ return nil
+}
+
+func (_c *TeamGroupMemberCreate) sqlSave(ctx context.Context) (*TeamGroupMember, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *TeamGroupMemberCreate) createSpec() (*TeamGroupMember, *sqlgraph.CreateSpec) {
+ var (
+ _node = &TeamGroupMember{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(teamgroupmember.Table, sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroupmember.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if nodes := _c.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.GroupTable,
+ Columns: []string{teamgroupmember.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.GroupID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.UserTable,
+ Columns: []string{teamgroupmember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.UserID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamGroupMember.Create().
+// SetGroupID(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamGroupMemberUpsert) {
+// SetGroupID(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamGroupMemberCreate) OnConflict(opts ...sql.ConflictOption) *TeamGroupMemberUpsertOne {
+ _c.conflict = opts
+ return &TeamGroupMemberUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamGroupMemberCreate) OnConflictColumns(columns ...string) *TeamGroupMemberUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamGroupMemberUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // TeamGroupMemberUpsertOne is the builder for "upsert"-ing
+ // one TeamGroupMember node.
+ TeamGroupMemberUpsertOne struct {
+ create *TeamGroupMemberCreate
+ }
+
+ // TeamGroupMemberUpsert is the "OnConflict" setter.
+ TeamGroupMemberUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetGroupID sets the "group_id" field.
+func (u *TeamGroupMemberUpsert) SetGroupID(v uuid.UUID) *TeamGroupMemberUpsert {
+ u.Set(teamgroupmember.FieldGroupID, v)
+ return u
+}
+
+// UpdateGroupID sets the "group_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsert) UpdateGroupID() *TeamGroupMemberUpsert {
+ u.SetExcluded(teamgroupmember.FieldGroupID)
+ return u
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamGroupMemberUpsert) SetUserID(v uuid.UUID) *TeamGroupMemberUpsert {
+ u.Set(teamgroupmember.FieldUserID, v)
+ return u
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsert) UpdateUserID() *TeamGroupMemberUpsert {
+ u.SetExcluded(teamgroupmember.FieldUserID)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupMemberUpsert) SetCreatedAt(v time.Time) *TeamGroupMemberUpsert {
+ u.Set(teamgroupmember.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsert) UpdateCreatedAt() *TeamGroupMemberUpsert {
+ u.SetExcluded(teamgroupmember.FieldCreatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teamgroupmember.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamGroupMemberUpsertOne) UpdateNewValues() *TeamGroupMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(teamgroupmember.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamGroupMemberUpsertOne) Ignore() *TeamGroupMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamGroupMemberUpsertOne) DoNothing() *TeamGroupMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamGroupMemberCreate.OnConflict
+// documentation for more info.
+func (u *TeamGroupMemberUpsertOne) Update(set func(*TeamGroupMemberUpsert)) *TeamGroupMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamGroupMemberUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetGroupID sets the "group_id" field.
+func (u *TeamGroupMemberUpsertOne) SetGroupID(v uuid.UUID) *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetGroupID(v)
+ })
+}
+
+// UpdateGroupID sets the "group_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertOne) UpdateGroupID() *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateGroupID()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamGroupMemberUpsertOne) SetUserID(v uuid.UUID) *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertOne) UpdateUserID() *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupMemberUpsertOne) SetCreatedAt(v time.Time) *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertOne) UpdateCreatedAt() *TeamGroupMemberUpsertOne {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamGroupMemberUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamGroupMemberCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamGroupMemberUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *TeamGroupMemberUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: TeamGroupMemberUpsertOne.ID is not supported by MySQL driver. Use TeamGroupMemberUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *TeamGroupMemberUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// TeamGroupMemberCreateBulk is the builder for creating many TeamGroupMember entities in bulk.
+type TeamGroupMemberCreateBulk struct {
+ config
+ err error
+ builders []*TeamGroupMemberCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the TeamGroupMember entities in the database.
+func (_c *TeamGroupMemberCreateBulk) Save(ctx context.Context) ([]*TeamGroupMember, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*TeamGroupMember, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*TeamGroupMemberMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *TeamGroupMemberCreateBulk) SaveX(ctx context.Context) []*TeamGroupMember {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamGroupMemberCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamGroupMemberCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamGroupMember.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamGroupMemberUpsert) {
+// SetGroupID(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamGroupMemberCreateBulk) OnConflict(opts ...sql.ConflictOption) *TeamGroupMemberUpsertBulk {
+ _c.conflict = opts
+ return &TeamGroupMemberUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamGroupMemberCreateBulk) OnConflictColumns(columns ...string) *TeamGroupMemberUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamGroupMemberUpsertBulk{
+ create: _c,
+ }
+}
+
+// TeamGroupMemberUpsertBulk is the builder for "upsert"-ing
+// a bulk of TeamGroupMember nodes.
+type TeamGroupMemberUpsertBulk struct {
+ create *TeamGroupMemberCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teamgroupmember.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamGroupMemberUpsertBulk) UpdateNewValues() *TeamGroupMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(teamgroupmember.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamGroupMember.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamGroupMemberUpsertBulk) Ignore() *TeamGroupMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamGroupMemberUpsertBulk) DoNothing() *TeamGroupMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamGroupMemberCreateBulk.OnConflict
+// documentation for more info.
+func (u *TeamGroupMemberUpsertBulk) Update(set func(*TeamGroupMemberUpsert)) *TeamGroupMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamGroupMemberUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetGroupID sets the "group_id" field.
+func (u *TeamGroupMemberUpsertBulk) SetGroupID(v uuid.UUID) *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetGroupID(v)
+ })
+}
+
+// UpdateGroupID sets the "group_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertBulk) UpdateGroupID() *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateGroupID()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamGroupMemberUpsertBulk) SetUserID(v uuid.UUID) *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertBulk) UpdateUserID() *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamGroupMemberUpsertBulk) SetCreatedAt(v time.Time) *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamGroupMemberUpsertBulk) UpdateCreatedAt() *TeamGroupMemberUpsertBulk {
+ return u.Update(func(s *TeamGroupMemberUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamGroupMemberUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the TeamGroupMemberCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamGroupMemberCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamGroupMemberUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teamgroupmember_delete.go b/backend/db/teamgroupmember_delete.go
new file mode 100644
index 00000000..e8d4e949
--- /dev/null
+++ b/backend/db/teamgroupmember_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+)
+
+// TeamGroupMemberDelete is the builder for deleting a TeamGroupMember entity.
+type TeamGroupMemberDelete struct {
+ config
+ hooks []Hook
+ mutation *TeamGroupMemberMutation
+}
+
+// Where appends a list predicates to the TeamGroupMemberDelete builder.
+func (_d *TeamGroupMemberDelete) Where(ps ...predicate.TeamGroupMember) *TeamGroupMemberDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *TeamGroupMemberDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamGroupMemberDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *TeamGroupMemberDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(teamgroupmember.Table, sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// TeamGroupMemberDeleteOne is the builder for deleting a single TeamGroupMember entity.
+type TeamGroupMemberDeleteOne struct {
+ _d *TeamGroupMemberDelete
+}
+
+// Where appends a list predicates to the TeamGroupMemberDelete builder.
+func (_d *TeamGroupMemberDeleteOne) Where(ps ...predicate.TeamGroupMember) *TeamGroupMemberDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *TeamGroupMemberDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{teamgroupmember.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamGroupMemberDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teamgroupmember_query.go b/backend/db/teamgroupmember_query.go
new file mode 100644
index 00000000..96753f73
--- /dev/null
+++ b/backend/db/teamgroupmember_query.go
@@ -0,0 +1,732 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupMemberQuery is the builder for querying TeamGroupMember entities.
+type TeamGroupMemberQuery struct {
+ config
+ ctx *QueryContext
+ order []teamgroupmember.OrderOption
+ inters []Interceptor
+ predicates []predicate.TeamGroupMember
+ withGroup *TeamGroupQuery
+ withUser *UserQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the TeamGroupMemberQuery builder.
+func (_q *TeamGroupMemberQuery) Where(ps ...predicate.TeamGroupMember) *TeamGroupMemberQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *TeamGroupMemberQuery) Limit(limit int) *TeamGroupMemberQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *TeamGroupMemberQuery) Offset(offset int) *TeamGroupMemberQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *TeamGroupMemberQuery) Unique(unique bool) *TeamGroupMemberQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *TeamGroupMemberQuery) Order(o ...teamgroupmember.OrderOption) *TeamGroupMemberQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryGroup chains the current query on the "group" edge.
+func (_q *TeamGroupMemberQuery) QueryGroup() *TeamGroupQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroupmember.Table, teamgroupmember.FieldID, selector),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmember.GroupTable, teamgroupmember.GroupColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (_q *TeamGroupMemberQuery) QueryUser() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teamgroupmember.Table, teamgroupmember.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmember.UserTable, teamgroupmember.UserColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first TeamGroupMember entity from the query.
+// Returns a *NotFoundError when no TeamGroupMember was found.
+func (_q *TeamGroupMemberQuery) First(ctx context.Context) (*TeamGroupMember, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{teamgroupmember.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) FirstX(ctx context.Context) *TeamGroupMember {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first TeamGroupMember ID from the query.
+// Returns a *NotFoundError when no TeamGroupMember ID was found.
+func (_q *TeamGroupMemberQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{teamgroupmember.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single TeamGroupMember entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one TeamGroupMember entity is found.
+// Returns a *NotFoundError when no TeamGroupMember entities are found.
+func (_q *TeamGroupMemberQuery) Only(ctx context.Context) (*TeamGroupMember, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{teamgroupmember.Label}
+ default:
+ return nil, &NotSingularError{teamgroupmember.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) OnlyX(ctx context.Context) *TeamGroupMember {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only TeamGroupMember ID in the query.
+// Returns a *NotSingularError when more than one TeamGroupMember ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *TeamGroupMemberQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{teamgroupmember.Label}
+ default:
+ err = &NotSingularError{teamgroupmember.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of TeamGroupMembers.
+func (_q *TeamGroupMemberQuery) All(ctx context.Context) ([]*TeamGroupMember, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*TeamGroupMember, *TeamGroupMemberQuery]()
+ return withInterceptors[[]*TeamGroupMember](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) AllX(ctx context.Context) []*TeamGroupMember {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of TeamGroupMember IDs.
+func (_q *TeamGroupMemberQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(teamgroupmember.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *TeamGroupMemberQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*TeamGroupMemberQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *TeamGroupMemberQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *TeamGroupMemberQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the TeamGroupMemberQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *TeamGroupMemberQuery) Clone() *TeamGroupMemberQuery {
+ if _q == nil {
+ return nil
+ }
+ return &TeamGroupMemberQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]teamgroupmember.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.TeamGroupMember{}, _q.predicates...),
+ withGroup: _q.withGroup.Clone(),
+ withUser: _q.withUser.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// 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 (_q *TeamGroupMemberQuery) WithGroup(opts ...func(*TeamGroupQuery)) *TeamGroupMemberQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withGroup = query
+ return _q
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamGroupMemberQuery) WithUser(opts ...func(*UserQuery)) *TeamGroupMemberQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withUser = query
+ return _q
+}
+
+// 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 {
+// GroupID uuid.UUID `json:"group_id,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.TeamGroupMember.Query().
+// GroupBy(teamgroupmember.FieldGroupID).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *TeamGroupMemberQuery) GroupBy(field string, fields ...string) *TeamGroupMemberGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &TeamGroupMemberGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = teamgroupmember.Label
+ grbuild.scan = 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 {
+// GroupID uuid.UUID `json:"group_id,omitempty"`
+// }
+//
+// client.TeamGroupMember.Query().
+// Select(teamgroupmember.FieldGroupID).
+// Scan(ctx, &v)
+func (_q *TeamGroupMemberQuery) Select(fields ...string) *TeamGroupMemberSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &TeamGroupMemberSelect{TeamGroupMemberQuery: _q}
+ sbuild.label = teamgroupmember.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a TeamGroupMemberSelect configured with the given aggregations.
+func (_q *TeamGroupMemberQuery) Aggregate(fns ...AggregateFunc) *TeamGroupMemberSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *TeamGroupMemberQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !teamgroupmember.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *TeamGroupMemberQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*TeamGroupMember, error) {
+ var (
+ nodes = []*TeamGroupMember{}
+ _spec = _q.querySpec()
+ loadedTypes = [2]bool{
+ _q.withGroup != nil,
+ _q.withUser != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*TeamGroupMember).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &TeamGroupMember{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withGroup; query != nil {
+ if err := _q.loadGroup(ctx, query, nodes, nil,
+ func(n *TeamGroupMember, e *TeamGroup) { n.Edges.Group = e }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withUser; query != nil {
+ if err := _q.loadUser(ctx, query, nodes, nil,
+ func(n *TeamGroupMember, e *User) { n.Edges.User = e }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *TeamGroupMemberQuery) loadGroup(ctx context.Context, query *TeamGroupQuery, nodes []*TeamGroupMember, init func(*TeamGroupMember), assign func(*TeamGroupMember, *TeamGroup)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*TeamGroupMember)
+ for i := range nodes {
+ fk := nodes[i].GroupID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(teamgroup.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_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+func (_q *TeamGroupMemberQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*TeamGroupMember, init func(*TeamGroupMember), assign func(*TeamGroupMember, *User)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*TeamGroupMember)
+ for i := range nodes {
+ fk := nodes[i].UserID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(user.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+
+func (_q *TeamGroupMemberQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *TeamGroupMemberQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(teamgroupmember.Table, teamgroupmember.Columns, sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teamgroupmember.FieldID)
+ for i := range fields {
+ if fields[i] != teamgroupmember.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ if _q.withGroup != nil {
+ _spec.Node.AddColumnOnce(teamgroupmember.FieldGroupID)
+ }
+ if _q.withUser != nil {
+ _spec.Node.AddColumnOnce(teamgroupmember.FieldUserID)
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *TeamGroupMemberQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(teamgroupmember.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = teamgroupmember.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *TeamGroupMemberQuery) ForUpdate(opts ...sql.LockOption) *TeamGroupMemberQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *TeamGroupMemberQuery) ForShare(opts ...sql.LockOption) *TeamGroupMemberQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *TeamGroupMemberQuery) Modify(modifiers ...func(s *sql.Selector)) *TeamGroupMemberSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// TeamGroupMemberGroupBy is the group-by builder for TeamGroupMember entities.
+type TeamGroupMemberGroupBy struct {
+ selector
+ build *TeamGroupMemberQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *TeamGroupMemberGroupBy) Aggregate(fns ...AggregateFunc) *TeamGroupMemberGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *TeamGroupMemberGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamGroupMemberQuery, *TeamGroupMemberGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *TeamGroupMemberGroupBy) sqlScan(ctx context.Context, root *TeamGroupMemberQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// TeamGroupMemberSelect is the builder for selecting fields of TeamGroupMember entities.
+type TeamGroupMemberSelect struct {
+ *TeamGroupMemberQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *TeamGroupMemberSelect) Aggregate(fns ...AggregateFunc) *TeamGroupMemberSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *TeamGroupMemberSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamGroupMemberQuery, *TeamGroupMemberSelect](ctx, _s.TeamGroupMemberQuery, _s, _s.inters, v)
+}
+
+func (_s *TeamGroupMemberSelect) sqlScan(ctx context.Context, root *TeamGroupMemberQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *TeamGroupMemberSelect) Modify(modifiers ...func(s *sql.Selector)) *TeamGroupMemberSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/teamgroupmember_update.go b/backend/db/teamgroupmember_update.go
new file mode 100644
index 00000000..258871c8
--- /dev/null
+++ b/backend/db/teamgroupmember_update.go
@@ -0,0 +1,473 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamGroupMemberUpdate is the builder for updating TeamGroupMember entities.
+type TeamGroupMemberUpdate struct {
+ config
+ hooks []Hook
+ mutation *TeamGroupMemberMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the TeamGroupMemberUpdate builder.
+func (_u *TeamGroupMemberUpdate) Where(ps ...predicate.TeamGroupMember) *TeamGroupMemberUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetGroupID sets the "group_id" field.
+func (_u *TeamGroupMemberUpdate) SetGroupID(v uuid.UUID) *TeamGroupMemberUpdate {
+ _u.mutation.SetGroupID(v)
+ return _u
+}
+
+// SetNillableGroupID sets the "group_id" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdate) SetNillableGroupID(v *uuid.UUID) *TeamGroupMemberUpdate {
+ if v != nil {
+ _u.SetGroupID(*v)
+ }
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *TeamGroupMemberUpdate) SetUserID(v uuid.UUID) *TeamGroupMemberUpdate {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdate) SetNillableUserID(v *uuid.UUID) *TeamGroupMemberUpdate {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamGroupMemberUpdate) SetCreatedAt(v time.Time) *TeamGroupMemberUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdate) SetNillableCreatedAt(v *time.Time) *TeamGroupMemberUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetGroup sets the "group" edge to the TeamGroup entity.
+func (_u *TeamGroupMemberUpdate) SetGroup(v *TeamGroup) *TeamGroupMemberUpdate {
+ return _u.SetGroupID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *TeamGroupMemberUpdate) SetUser(v *User) *TeamGroupMemberUpdate {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamGroupMemberMutation object of the builder.
+func (_u *TeamGroupMemberUpdate) Mutation() *TeamGroupMemberMutation {
+ return _u.mutation
+}
+
+// ClearGroup clears the "group" edge to the TeamGroup entity.
+func (_u *TeamGroupMemberUpdate) ClearGroup() *TeamGroupMemberUpdate {
+ _u.mutation.ClearGroup()
+ return _u
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *TeamGroupMemberUpdate) ClearUser() *TeamGroupMemberUpdate {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *TeamGroupMemberUpdate) Save(ctx context.Context) (int, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamGroupMemberUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *TeamGroupMemberUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamGroupMemberUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamGroupMemberUpdate) check() error {
+ if _u.mutation.GroupCleared() && len(_u.mutation.GroupIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroupMember.group"`)
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroupMember.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamGroupMemberUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamGroupMemberUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamGroupMemberUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teamgroupmember.Table, teamgroupmember.Columns, sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroupmember.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.GroupTable,
+ Columns: []string{teamgroupmember.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.GroupTable,
+ Columns: []string{teamgroupmember.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.UserTable,
+ Columns: []string{teamgroupmember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.UserTable,
+ Columns: []string{teamgroupmember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teamgroupmember.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// TeamGroupMemberUpdateOne is the builder for updating a single TeamGroupMember entity.
+type TeamGroupMemberUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *TeamGroupMemberMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetGroupID sets the "group_id" field.
+func (_u *TeamGroupMemberUpdateOne) SetGroupID(v uuid.UUID) *TeamGroupMemberUpdateOne {
+ _u.mutation.SetGroupID(v)
+ return _u
+}
+
+// SetNillableGroupID sets the "group_id" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdateOne) SetNillableGroupID(v *uuid.UUID) *TeamGroupMemberUpdateOne {
+ if v != nil {
+ _u.SetGroupID(*v)
+ }
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *TeamGroupMemberUpdateOne) SetUserID(v uuid.UUID) *TeamGroupMemberUpdateOne {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdateOne) SetNillableUserID(v *uuid.UUID) *TeamGroupMemberUpdateOne {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamGroupMemberUpdateOne) SetCreatedAt(v time.Time) *TeamGroupMemberUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamGroupMemberUpdateOne) SetNillableCreatedAt(v *time.Time) *TeamGroupMemberUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetGroup sets the "group" edge to the TeamGroup entity.
+func (_u *TeamGroupMemberUpdateOne) SetGroup(v *TeamGroup) *TeamGroupMemberUpdateOne {
+ return _u.SetGroupID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *TeamGroupMemberUpdateOne) SetUser(v *User) *TeamGroupMemberUpdateOne {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamGroupMemberMutation object of the builder.
+func (_u *TeamGroupMemberUpdateOne) Mutation() *TeamGroupMemberMutation {
+ return _u.mutation
+}
+
+// ClearGroup clears the "group" edge to the TeamGroup entity.
+func (_u *TeamGroupMemberUpdateOne) ClearGroup() *TeamGroupMemberUpdateOne {
+ _u.mutation.ClearGroup()
+ return _u
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *TeamGroupMemberUpdateOne) ClearUser() *TeamGroupMemberUpdateOne {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Where appends a list predicates to the TeamGroupMemberUpdate builder.
+func (_u *TeamGroupMemberUpdateOne) Where(ps ...predicate.TeamGroupMember) *TeamGroupMemberUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *TeamGroupMemberUpdateOne) Select(field string, fields ...string) *TeamGroupMemberUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated TeamGroupMember entity.
+func (_u *TeamGroupMemberUpdateOne) Save(ctx context.Context) (*TeamGroupMember, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamGroupMemberUpdateOne) SaveX(ctx context.Context) *TeamGroupMember {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *TeamGroupMemberUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamGroupMemberUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamGroupMemberUpdateOne) check() error {
+ if _u.mutation.GroupCleared() && len(_u.mutation.GroupIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroupMember.group"`)
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamGroupMember.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamGroupMemberUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamGroupMemberUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamGroupMemberUpdateOne) sqlSave(ctx context.Context) (_node *TeamGroupMember, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teamgroupmember.Table, teamgroupmember.Columns, sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "TeamGroupMember.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teamgroupmember.FieldID)
+ for _, f := range fields {
+ if !teamgroupmember.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != teamgroupmember.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teamgroupmember.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.GroupCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.GroupTable,
+ Columns: []string{teamgroupmember.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.GroupTable,
+ Columns: []string{teamgroupmember.GroupColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.UserTable,
+ Columns: []string{teamgroupmember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teamgroupmember.UserTable,
+ Columns: []string{teamgroupmember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &TeamGroupMember{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teamgroupmember.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/teammember.go b/backend/db/teammember.go
new file mode 100644
index 00000000..3b617b7e
--- /dev/null
+++ b/backend/db/teammember.go
@@ -0,0 +1,189 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamMember is the model entity for the TeamMember schema.
+type TeamMember struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // TeamID holds the value of the "team_id" field.
+ TeamID uuid.UUID `json:"team_id,omitempty"`
+ // UserID holds the value of the "user_id" field.
+ UserID uuid.UUID `json:"user_id,omitempty"`
+ // Role holds the value of the "role" field.
+ Role consts.TeamMemberRole `json:"role,omitempty"`
+ // CreatedAt holds the value of the "created_at" field.
+ CreatedAt time.Time `json:"created_at,omitempty"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the TeamMemberQuery when eager-loading is set.
+ Edges TeamMemberEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// TeamMemberEdges holds the relations/edges for other nodes in the graph.
+type TeamMemberEdges struct {
+ // Team holds the value of the team edge.
+ Team *Team `json:"team,omitempty"`
+ // User holds the value of the user edge.
+ User *User `json:"user,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [2]bool
+}
+
+// TeamOrErr returns the Team value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e TeamMemberEdges) TeamOrErr() (*Team, error) {
+ if e.Team != nil {
+ return e.Team, nil
+ } else if e.loadedTypes[0] {
+ return nil, &NotFoundError{label: team.Label}
+ }
+ return nil, &NotLoadedError{edge: "team"}
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e TeamMemberEdges) UserOrErr() (*User, error) {
+ if e.User != nil {
+ return e.User, nil
+ } else if e.loadedTypes[1] {
+ return nil, &NotFoundError{label: user.Label}
+ }
+ return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*TeamMember) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case teammember.FieldRole:
+ values[i] = new(sql.NullString)
+ case teammember.FieldCreatedAt:
+ values[i] = new(sql.NullTime)
+ case teammember.FieldID, teammember.FieldTeamID, teammember.FieldUserID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the TeamMember fields.
+func (_m *TeamMember) 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 teammember.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case teammember.FieldTeamID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field team_id", values[i])
+ } else if value != nil {
+ _m.TeamID = *value
+ }
+ case teammember.FieldUserID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field user_id", values[i])
+ } else if value != nil {
+ _m.UserID = *value
+ }
+ case teammember.FieldRole:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field role", values[i])
+ } else if value.Valid {
+ _m.Role = consts.TeamMemberRole(value.String)
+ }
+ case teammember.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 {
+ _m.CreatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the TeamMember.
+// This includes values selected through modifiers, order, etc.
+func (_m *TeamMember) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryTeam queries the "team" edge of the TeamMember entity.
+func (_m *TeamMember) QueryTeam() *TeamQuery {
+ return NewTeamMemberClient(_m.config).QueryTeam(_m)
+}
+
+// QueryUser queries the "user" edge of the TeamMember entity.
+func (_m *TeamMember) QueryUser() *UserQuery {
+ return NewTeamMemberClient(_m.config).QueryUser(_m)
+}
+
+// Update returns a builder for updating this TeamMember.
+// Note that you need to call TeamMember.Unwrap() before calling this method if this TeamMember
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *TeamMember) Update() *TeamMemberUpdateOne {
+ return NewTeamMemberClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the TeamMember 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 (_m *TeamMember) Unwrap() *TeamMember {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: TeamMember is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *TeamMember) String() string {
+ var builder strings.Builder
+ builder.WriteString("TeamMember(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("team_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.TeamID))
+ builder.WriteString(", ")
+ builder.WriteString("user_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.UserID))
+ builder.WriteString(", ")
+ builder.WriteString("role=")
+ builder.WriteString(fmt.Sprintf("%v", _m.Role))
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// TeamMembers is a parsable slice of TeamMember.
+type TeamMembers []*TeamMember
diff --git a/backend/db/teammember/teammember.go b/backend/db/teammember/teammember.go
new file mode 100644
index 00000000..0512e009
--- /dev/null
+++ b/backend/db/teammember/teammember.go
@@ -0,0 +1,125 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teammember
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the teammember type in the database.
+ Label = "team_member"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldTeamID holds the string denoting the team_id field in the database.
+ FieldTeamID = "team_id"
+ // FieldUserID holds the string denoting the user_id field in the database.
+ FieldUserID = "user_id"
+ // FieldRole holds the string denoting the role field in the database.
+ FieldRole = "role"
+ // FieldCreatedAt holds the string denoting the created_at field in the database.
+ FieldCreatedAt = "created_at"
+ // EdgeTeam holds the string denoting the team edge name in mutations.
+ EdgeTeam = "team"
+ // EdgeUser holds the string denoting the user edge name in mutations.
+ EdgeUser = "user"
+ // Table holds the table name of the teammember in the database.
+ Table = "team_members"
+ // TeamTable is the table that holds the team relation/edge.
+ TeamTable = "team_members"
+ // TeamInverseTable is the table name for the Team entity.
+ // It exists in this package in order to avoid circular dependency with the "team" package.
+ TeamInverseTable = "teams"
+ // TeamColumn is the table column denoting the team relation/edge.
+ TeamColumn = "team_id"
+ // UserTable is the table that holds the user relation/edge.
+ UserTable = "team_members"
+ // UserInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ UserInverseTable = "users"
+ // UserColumn is the table column denoting the user relation/edge.
+ UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for teammember fields.
+var Columns = []string{
+ FieldID,
+ FieldTeamID,
+ FieldUserID,
+ FieldRole,
+ FieldCreatedAt,
+}
+
+// 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
+ }
+ }
+ return false
+}
+
+var (
+ // DefaultCreatedAt holds the default value on creation for the "created_at" field.
+ DefaultCreatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the TeamMember queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByTeamID orders the results by the team_id field.
+func ByTeamID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldTeamID, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByRole orders the results by the role field.
+func ByRole(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldRole, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByTeamField orders the results by team field.
+func ByTeamField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamStep(), sql.OrderByField(field, opts...))
+ }
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newTeamStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, TeamTable, TeamColumn),
+ )
+}
+func newUserStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UserInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, UserTable, UserColumn),
+ )
+}
diff --git a/backend/db/teammember/where.go b/backend/db/teammember/where.go
new file mode 100644
index 00000000..3468fcd9
--- /dev/null
+++ b/backend/db/teammember/where.go
@@ -0,0 +1,304 @@
+// Code generated by ent, DO NOT EDIT.
+
+package teammember
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldLTE(FieldID, id))
+}
+
+// TeamID applies equality check predicate on the "team_id" field. It's identical to TeamIDEQ.
+func TeamID(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldTeamID, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldUserID, v))
+}
+
+// Role applies equality check predicate on the "role" field. It's identical to RoleEQ.
+func Role(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldEQ(FieldRole, vc))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// TeamIDEQ applies the EQ predicate on the "team_id" field.
+func TeamIDEQ(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldTeamID, v))
+}
+
+// TeamIDNEQ applies the NEQ predicate on the "team_id" field.
+func TeamIDNEQ(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNEQ(FieldTeamID, v))
+}
+
+// TeamIDIn applies the In predicate on the "team_id" field.
+func TeamIDIn(vs ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldIn(FieldTeamID, vs...))
+}
+
+// TeamIDNotIn applies the NotIn predicate on the "team_id" field.
+func TeamIDNotIn(vs ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNotIn(FieldTeamID, vs...))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...uuid.UUID) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// RoleEQ applies the EQ predicate on the "role" field.
+func RoleEQ(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldEQ(FieldRole, vc))
+}
+
+// RoleNEQ applies the NEQ predicate on the "role" field.
+func RoleNEQ(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldNEQ(FieldRole, vc))
+}
+
+// RoleIn applies the In predicate on the "role" field.
+func RoleIn(vs ...consts.TeamMemberRole) predicate.TeamMember {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.TeamMember(sql.FieldIn(FieldRole, v...))
+}
+
+// RoleNotIn applies the NotIn predicate on the "role" field.
+func RoleNotIn(vs ...consts.TeamMemberRole) predicate.TeamMember {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.TeamMember(sql.FieldNotIn(FieldRole, v...))
+}
+
+// RoleGT applies the GT predicate on the "role" field.
+func RoleGT(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldGT(FieldRole, vc))
+}
+
+// RoleGTE applies the GTE predicate on the "role" field.
+func RoleGTE(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldGTE(FieldRole, vc))
+}
+
+// RoleLT applies the LT predicate on the "role" field.
+func RoleLT(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldLT(FieldRole, vc))
+}
+
+// RoleLTE applies the LTE predicate on the "role" field.
+func RoleLTE(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldLTE(FieldRole, vc))
+}
+
+// RoleContains applies the Contains predicate on the "role" field.
+func RoleContains(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldContains(FieldRole, vc))
+}
+
+// RoleHasPrefix applies the HasPrefix predicate on the "role" field.
+func RoleHasPrefix(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldHasPrefix(FieldRole, vc))
+}
+
+// RoleHasSuffix applies the HasSuffix predicate on the "role" field.
+func RoleHasSuffix(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldHasSuffix(FieldRole, vc))
+}
+
+// RoleEqualFold applies the EqualFold predicate on the "role" field.
+func RoleEqualFold(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldEqualFold(FieldRole, vc))
+}
+
+// RoleContainsFold applies the ContainsFold predicate on the "role" field.
+func RoleContainsFold(v consts.TeamMemberRole) predicate.TeamMember {
+ vc := string(v)
+ return predicate.TeamMember(sql.FieldContainsFold(FieldRole, vc))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.TeamMember {
+ return predicate.TeamMember(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// HasTeam applies the HasEdge predicate on the "team" edge.
+func HasTeam() predicate.TeamMember {
+ return predicate.TeamMember(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, TeamTable, TeamColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamWith applies the HasEdge predicate on the "team" edge with a given conditions (other predicates).
+func HasTeamWith(preds ...predicate.Team) predicate.TeamMember {
+ return predicate.TeamMember(func(s *sql.Selector) {
+ step := newTeamStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.TeamMember {
+ return predicate.TeamMember(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, UserTable, UserColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.TeamMember {
+ return predicate.TeamMember(func(s *sql.Selector) {
+ step := newUserStep()
+ 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.TeamMember) predicate.TeamMember {
+ return predicate.TeamMember(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.TeamMember) predicate.TeamMember {
+ return predicate.TeamMember(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.TeamMember) predicate.TeamMember {
+ return predicate.TeamMember(sql.NotPredicates(p))
+}
diff --git a/backend/db/teammember_create.go b/backend/db/teammember_create.go
new file mode 100644
index 00000000..18cb285a
--- /dev/null
+++ b/backend/db/teammember_create.go
@@ -0,0 +1,713 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamMemberCreate is the builder for creating a TeamMember entity.
+type TeamMemberCreate struct {
+ config
+ mutation *TeamMemberMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetTeamID sets the "team_id" field.
+func (_c *TeamMemberCreate) SetTeamID(v uuid.UUID) *TeamMemberCreate {
+ _c.mutation.SetTeamID(v)
+ return _c
+}
+
+// SetUserID sets the "user_id" field.
+func (_c *TeamMemberCreate) SetUserID(v uuid.UUID) *TeamMemberCreate {
+ _c.mutation.SetUserID(v)
+ return _c
+}
+
+// SetRole sets the "role" field.
+func (_c *TeamMemberCreate) SetRole(v consts.TeamMemberRole) *TeamMemberCreate {
+ _c.mutation.SetRole(v)
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *TeamMemberCreate) SetCreatedAt(v time.Time) *TeamMemberCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *TeamMemberCreate) SetNillableCreatedAt(v *time.Time) *TeamMemberCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *TeamMemberCreate) SetID(v uuid.UUID) *TeamMemberCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_c *TeamMemberCreate) SetTeam(v *Team) *TeamMemberCreate {
+ return _c.SetTeamID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_c *TeamMemberCreate) SetUser(v *User) *TeamMemberCreate {
+ return _c.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamMemberMutation object of the builder.
+func (_c *TeamMemberCreate) Mutation() *TeamMemberMutation {
+ return _c.mutation
+}
+
+// Save creates the TeamMember in the database.
+func (_c *TeamMemberCreate) Save(ctx context.Context) (*TeamMember, error) {
+ _c.defaults()
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *TeamMemberCreate) SaveX(ctx context.Context) *TeamMember {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamMemberCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamMemberCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *TeamMemberCreate) defaults() {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ v := teammember.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *TeamMemberCreate) check() error {
+ if _, ok := _c.mutation.TeamID(); !ok {
+ return &ValidationError{Name: "team_id", err: errors.New(`db: missing required field "TeamMember.team_id"`)}
+ }
+ if _, ok := _c.mutation.UserID(); !ok {
+ return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "TeamMember.user_id"`)}
+ }
+ if _, ok := _c.mutation.Role(); !ok {
+ return &ValidationError{Name: "role", err: errors.New(`db: missing required field "TeamMember.role"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "TeamMember.created_at"`)}
+ }
+ if len(_c.mutation.TeamIDs()) == 0 {
+ return &ValidationError{Name: "team", err: errors.New(`db: missing required edge "TeamMember.team"`)}
+ }
+ if len(_c.mutation.UserIDs()) == 0 {
+ return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "TeamMember.user"`)}
+ }
+ return nil
+}
+
+func (_c *TeamMemberCreate) sqlSave(ctx context.Context) (*TeamMember, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *TeamMemberCreate) createSpec() (*TeamMember, *sqlgraph.CreateSpec) {
+ var (
+ _node = &TeamMember{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(teammember.Table, sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.Role(); ok {
+ _spec.SetField(teammember.FieldRole, field.TypeString, value)
+ _node.Role = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(teammember.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if nodes := _c.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.TeamTable,
+ Columns: []string{teammember.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.TeamID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.UserTable,
+ Columns: []string{teammember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.UserID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamMember.Create().
+// SetTeamID(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamMemberUpsert) {
+// SetTeamID(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamMemberCreate) OnConflict(opts ...sql.ConflictOption) *TeamMemberUpsertOne {
+ _c.conflict = opts
+ return &TeamMemberUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamMemberCreate) OnConflictColumns(columns ...string) *TeamMemberUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamMemberUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // TeamMemberUpsertOne is the builder for "upsert"-ing
+ // one TeamMember node.
+ TeamMemberUpsertOne struct {
+ create *TeamMemberCreate
+ }
+
+ // TeamMemberUpsert is the "OnConflict" setter.
+ TeamMemberUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamMemberUpsert) SetTeamID(v uuid.UUID) *TeamMemberUpsert {
+ u.Set(teammember.FieldTeamID, v)
+ return u
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamMemberUpsert) UpdateTeamID() *TeamMemberUpsert {
+ u.SetExcluded(teammember.FieldTeamID)
+ return u
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamMemberUpsert) SetUserID(v uuid.UUID) *TeamMemberUpsert {
+ u.Set(teammember.FieldUserID, v)
+ return u
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamMemberUpsert) UpdateUserID() *TeamMemberUpsert {
+ u.SetExcluded(teammember.FieldUserID)
+ return u
+}
+
+// SetRole sets the "role" field.
+func (u *TeamMemberUpsert) SetRole(v consts.TeamMemberRole) *TeamMemberUpsert {
+ u.Set(teammember.FieldRole, v)
+ return u
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *TeamMemberUpsert) UpdateRole() *TeamMemberUpsert {
+ u.SetExcluded(teammember.FieldRole)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamMemberUpsert) SetCreatedAt(v time.Time) *TeamMemberUpsert {
+ u.Set(teammember.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamMemberUpsert) UpdateCreatedAt() *TeamMemberUpsert {
+ u.SetExcluded(teammember.FieldCreatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teammember.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamMemberUpsertOne) UpdateNewValues() *TeamMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(teammember.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamMemberUpsertOne) Ignore() *TeamMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamMemberUpsertOne) DoNothing() *TeamMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamMemberCreate.OnConflict
+// documentation for more info.
+func (u *TeamMemberUpsertOne) Update(set func(*TeamMemberUpsert)) *TeamMemberUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamMemberUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamMemberUpsertOne) SetTeamID(v uuid.UUID) *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetTeamID(v)
+ })
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamMemberUpsertOne) UpdateTeamID() *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateTeamID()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamMemberUpsertOne) SetUserID(v uuid.UUID) *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamMemberUpsertOne) UpdateUserID() *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetRole sets the "role" field.
+func (u *TeamMemberUpsertOne) SetRole(v consts.TeamMemberRole) *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetRole(v)
+ })
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *TeamMemberUpsertOne) UpdateRole() *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateRole()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamMemberUpsertOne) SetCreatedAt(v time.Time) *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamMemberUpsertOne) UpdateCreatedAt() *TeamMemberUpsertOne {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamMemberUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamMemberCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamMemberUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *TeamMemberUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: TeamMemberUpsertOne.ID is not supported by MySQL driver. Use TeamMemberUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *TeamMemberUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// TeamMemberCreateBulk is the builder for creating many TeamMember entities in bulk.
+type TeamMemberCreateBulk struct {
+ config
+ err error
+ builders []*TeamMemberCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the TeamMember entities in the database.
+func (_c *TeamMemberCreateBulk) Save(ctx context.Context) ([]*TeamMember, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*TeamMember, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*TeamMemberMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *TeamMemberCreateBulk) SaveX(ctx context.Context) []*TeamMember {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *TeamMemberCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *TeamMemberCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.TeamMember.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.TeamMemberUpsert) {
+// SetTeamID(v+v).
+// }).
+// Exec(ctx)
+func (_c *TeamMemberCreateBulk) OnConflict(opts ...sql.ConflictOption) *TeamMemberUpsertBulk {
+ _c.conflict = opts
+ return &TeamMemberUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *TeamMemberCreateBulk) OnConflictColumns(columns ...string) *TeamMemberUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &TeamMemberUpsertBulk{
+ create: _c,
+ }
+}
+
+// TeamMemberUpsertBulk is the builder for "upsert"-ing
+// a bulk of TeamMember nodes.
+type TeamMemberUpsertBulk struct {
+ create *TeamMemberCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(teammember.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *TeamMemberUpsertBulk) UpdateNewValues() *TeamMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(teammember.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.TeamMember.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *TeamMemberUpsertBulk) Ignore() *TeamMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *TeamMemberUpsertBulk) DoNothing() *TeamMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the TeamMemberCreateBulk.OnConflict
+// documentation for more info.
+func (u *TeamMemberUpsertBulk) Update(set func(*TeamMemberUpsert)) *TeamMemberUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&TeamMemberUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetTeamID sets the "team_id" field.
+func (u *TeamMemberUpsertBulk) SetTeamID(v uuid.UUID) *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetTeamID(v)
+ })
+}
+
+// UpdateTeamID sets the "team_id" field to the value that was provided on create.
+func (u *TeamMemberUpsertBulk) UpdateTeamID() *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateTeamID()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *TeamMemberUpsertBulk) SetUserID(v uuid.UUID) *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *TeamMemberUpsertBulk) UpdateUserID() *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetRole sets the "role" field.
+func (u *TeamMemberUpsertBulk) SetRole(v consts.TeamMemberRole) *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetRole(v)
+ })
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *TeamMemberUpsertBulk) UpdateRole() *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateRole()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *TeamMemberUpsertBulk) SetCreatedAt(v time.Time) *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *TeamMemberUpsertBulk) UpdateCreatedAt() *TeamMemberUpsertBulk {
+ return u.Update(func(s *TeamMemberUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *TeamMemberUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the TeamMemberCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for TeamMemberCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *TeamMemberUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teammember_delete.go b/backend/db/teammember_delete.go
new file mode 100644
index 00000000..44fd21f5
--- /dev/null
+++ b/backend/db/teammember_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+)
+
+// TeamMemberDelete is the builder for deleting a TeamMember entity.
+type TeamMemberDelete struct {
+ config
+ hooks []Hook
+ mutation *TeamMemberMutation
+}
+
+// Where appends a list predicates to the TeamMemberDelete builder.
+func (_d *TeamMemberDelete) Where(ps ...predicate.TeamMember) *TeamMemberDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *TeamMemberDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamMemberDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *TeamMemberDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(teammember.Table, sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// TeamMemberDeleteOne is the builder for deleting a single TeamMember entity.
+type TeamMemberDeleteOne struct {
+ _d *TeamMemberDelete
+}
+
+// Where appends a list predicates to the TeamMemberDelete builder.
+func (_d *TeamMemberDeleteOne) Where(ps ...predicate.TeamMember) *TeamMemberDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *TeamMemberDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{teammember.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *TeamMemberDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/teammember_query.go b/backend/db/teammember_query.go
new file mode 100644
index 00000000..51e38eff
--- /dev/null
+++ b/backend/db/teammember_query.go
@@ -0,0 +1,732 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamMemberQuery is the builder for querying TeamMember entities.
+type TeamMemberQuery struct {
+ config
+ ctx *QueryContext
+ order []teammember.OrderOption
+ inters []Interceptor
+ predicates []predicate.TeamMember
+ withTeam *TeamQuery
+ withUser *UserQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the TeamMemberQuery builder.
+func (_q *TeamMemberQuery) Where(ps ...predicate.TeamMember) *TeamMemberQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *TeamMemberQuery) Limit(limit int) *TeamMemberQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *TeamMemberQuery) Offset(offset int) *TeamMemberQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *TeamMemberQuery) Unique(unique bool) *TeamMemberQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *TeamMemberQuery) Order(o ...teammember.OrderOption) *TeamMemberQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryTeam chains the current query on the "team" edge.
+func (_q *TeamMemberQuery) QueryTeam() *TeamQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teammember.Table, teammember.FieldID, selector),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teammember.TeamTable, teammember.TeamColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (_q *TeamMemberQuery) QueryUser() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(teammember.Table, teammember.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, false, teammember.UserTable, teammember.UserColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first TeamMember entity from the query.
+// Returns a *NotFoundError when no TeamMember was found.
+func (_q *TeamMemberQuery) First(ctx context.Context) (*TeamMember, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{teammember.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *TeamMemberQuery) FirstX(ctx context.Context) *TeamMember {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first TeamMember ID from the query.
+// Returns a *NotFoundError when no TeamMember ID was found.
+func (_q *TeamMemberQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{teammember.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *TeamMemberQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single TeamMember entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one TeamMember entity is found.
+// Returns a *NotFoundError when no TeamMember entities are found.
+func (_q *TeamMemberQuery) Only(ctx context.Context) (*TeamMember, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{teammember.Label}
+ default:
+ return nil, &NotSingularError{teammember.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *TeamMemberQuery) OnlyX(ctx context.Context) *TeamMember {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only TeamMember ID in the query.
+// Returns a *NotSingularError when more than one TeamMember ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *TeamMemberQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{teammember.Label}
+ default:
+ err = &NotSingularError{teammember.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *TeamMemberQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of TeamMembers.
+func (_q *TeamMemberQuery) All(ctx context.Context) ([]*TeamMember, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*TeamMember, *TeamMemberQuery]()
+ return withInterceptors[[]*TeamMember](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *TeamMemberQuery) AllX(ctx context.Context) []*TeamMember {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of TeamMember IDs.
+func (_q *TeamMemberQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(teammember.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *TeamMemberQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *TeamMemberQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*TeamMemberQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *TeamMemberQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *TeamMemberQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *TeamMemberQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the TeamMemberQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *TeamMemberQuery) Clone() *TeamMemberQuery {
+ if _q == nil {
+ return nil
+ }
+ return &TeamMemberQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]teammember.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.TeamMember{}, _q.predicates...),
+ withTeam: _q.withTeam.Clone(),
+ withUser: _q.withUser.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithTeam tells the query-builder to eager-load the nodes that are connected to
+// the "team" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamMemberQuery) WithTeam(opts ...func(*TeamQuery)) *TeamMemberQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeam = query
+ return _q
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *TeamMemberQuery) WithUser(opts ...func(*UserQuery)) *TeamMemberQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withUser = query
+ return _q
+}
+
+// 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 {
+// TeamID uuid.UUID `json:"team_id,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.TeamMember.Query().
+// GroupBy(teammember.FieldTeamID).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *TeamMemberQuery) GroupBy(field string, fields ...string) *TeamMemberGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &TeamMemberGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = teammember.Label
+ grbuild.scan = 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 {
+// TeamID uuid.UUID `json:"team_id,omitempty"`
+// }
+//
+// client.TeamMember.Query().
+// Select(teammember.FieldTeamID).
+// Scan(ctx, &v)
+func (_q *TeamMemberQuery) Select(fields ...string) *TeamMemberSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &TeamMemberSelect{TeamMemberQuery: _q}
+ sbuild.label = teammember.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a TeamMemberSelect configured with the given aggregations.
+func (_q *TeamMemberQuery) Aggregate(fns ...AggregateFunc) *TeamMemberSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *TeamMemberQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !teammember.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *TeamMemberQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*TeamMember, error) {
+ var (
+ nodes = []*TeamMember{}
+ _spec = _q.querySpec()
+ loadedTypes = [2]bool{
+ _q.withTeam != nil,
+ _q.withUser != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*TeamMember).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &TeamMember{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withTeam; query != nil {
+ if err := _q.loadTeam(ctx, query, nodes, nil,
+ func(n *TeamMember, e *Team) { n.Edges.Team = e }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withUser; query != nil {
+ if err := _q.loadUser(ctx, query, nodes, nil,
+ func(n *TeamMember, e *User) { n.Edges.User = e }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *TeamMemberQuery) loadTeam(ctx context.Context, query *TeamQuery, nodes []*TeamMember, init func(*TeamMember), assign func(*TeamMember, *Team)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*TeamMember)
+ for i := range nodes {
+ fk := nodes[i].TeamID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(team.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 "team_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+func (_q *TeamMemberQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*TeamMember, init func(*TeamMember), assign func(*TeamMember, *User)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*TeamMember)
+ for i := range nodes {
+ fk := nodes[i].UserID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(user.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+
+func (_q *TeamMemberQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *TeamMemberQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(teammember.Table, teammember.Columns, sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teammember.FieldID)
+ for i := range fields {
+ if fields[i] != teammember.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ if _q.withTeam != nil {
+ _spec.Node.AddColumnOnce(teammember.FieldTeamID)
+ }
+ if _q.withUser != nil {
+ _spec.Node.AddColumnOnce(teammember.FieldUserID)
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *TeamMemberQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(teammember.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = teammember.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *TeamMemberQuery) ForUpdate(opts ...sql.LockOption) *TeamMemberQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *TeamMemberQuery) ForShare(opts ...sql.LockOption) *TeamMemberQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *TeamMemberQuery) Modify(modifiers ...func(s *sql.Selector)) *TeamMemberSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// TeamMemberGroupBy is the group-by builder for TeamMember entities.
+type TeamMemberGroupBy struct {
+ selector
+ build *TeamMemberQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *TeamMemberGroupBy) Aggregate(fns ...AggregateFunc) *TeamMemberGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *TeamMemberGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamMemberQuery, *TeamMemberGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *TeamMemberGroupBy) sqlScan(ctx context.Context, root *TeamMemberQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// TeamMemberSelect is the builder for selecting fields of TeamMember entities.
+type TeamMemberSelect struct {
+ *TeamMemberQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *TeamMemberSelect) Aggregate(fns ...AggregateFunc) *TeamMemberSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *TeamMemberSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*TeamMemberQuery, *TeamMemberSelect](ctx, _s.TeamMemberQuery, _s, _s.inters, v)
+}
+
+func (_s *TeamMemberSelect) sqlScan(ctx context.Context, root *TeamMemberQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *TeamMemberSelect) Modify(modifiers ...func(s *sql.Selector)) *TeamMemberSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/teammember_update.go b/backend/db/teammember_update.go
new file mode 100644
index 00000000..20236d39
--- /dev/null
+++ b/backend/db/teammember_update.go
@@ -0,0 +1,508 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// TeamMemberUpdate is the builder for updating TeamMember entities.
+type TeamMemberUpdate struct {
+ config
+ hooks []Hook
+ mutation *TeamMemberMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the TeamMemberUpdate builder.
+func (_u *TeamMemberUpdate) Where(ps ...predicate.TeamMember) *TeamMemberUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetTeamID sets the "team_id" field.
+func (_u *TeamMemberUpdate) SetTeamID(v uuid.UUID) *TeamMemberUpdate {
+ _u.mutation.SetTeamID(v)
+ return _u
+}
+
+// SetNillableTeamID sets the "team_id" field if the given value is not nil.
+func (_u *TeamMemberUpdate) SetNillableTeamID(v *uuid.UUID) *TeamMemberUpdate {
+ if v != nil {
+ _u.SetTeamID(*v)
+ }
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *TeamMemberUpdate) SetUserID(v uuid.UUID) *TeamMemberUpdate {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *TeamMemberUpdate) SetNillableUserID(v *uuid.UUID) *TeamMemberUpdate {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetRole sets the "role" field.
+func (_u *TeamMemberUpdate) SetRole(v consts.TeamMemberRole) *TeamMemberUpdate {
+ _u.mutation.SetRole(v)
+ return _u
+}
+
+// SetNillableRole sets the "role" field if the given value is not nil.
+func (_u *TeamMemberUpdate) SetNillableRole(v *consts.TeamMemberRole) *TeamMemberUpdate {
+ if v != nil {
+ _u.SetRole(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamMemberUpdate) SetCreatedAt(v time.Time) *TeamMemberUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamMemberUpdate) SetNillableCreatedAt(v *time.Time) *TeamMemberUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_u *TeamMemberUpdate) SetTeam(v *Team) *TeamMemberUpdate {
+ return _u.SetTeamID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *TeamMemberUpdate) SetUser(v *User) *TeamMemberUpdate {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamMemberMutation object of the builder.
+func (_u *TeamMemberUpdate) Mutation() *TeamMemberMutation {
+ return _u.mutation
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (_u *TeamMemberUpdate) ClearTeam() *TeamMemberUpdate {
+ _u.mutation.ClearTeam()
+ return _u
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *TeamMemberUpdate) ClearUser() *TeamMemberUpdate {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *TeamMemberUpdate) Save(ctx context.Context) (int, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamMemberUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *TeamMemberUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamMemberUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamMemberUpdate) check() error {
+ if _u.mutation.TeamCleared() && len(_u.mutation.TeamIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamMember.team"`)
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamMember.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamMemberUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamMemberUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamMemberUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teammember.Table, teammember.Columns, sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.Role(); ok {
+ _spec.SetField(teammember.FieldRole, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teammember.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.TeamCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.TeamTable,
+ Columns: []string{teammember.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.TeamTable,
+ Columns: []string{teammember.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.UserTable,
+ Columns: []string{teammember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.UserTable,
+ Columns: []string{teammember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teammember.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// TeamMemberUpdateOne is the builder for updating a single TeamMember entity.
+type TeamMemberUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *TeamMemberMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetTeamID sets the "team_id" field.
+func (_u *TeamMemberUpdateOne) SetTeamID(v uuid.UUID) *TeamMemberUpdateOne {
+ _u.mutation.SetTeamID(v)
+ return _u
+}
+
+// SetNillableTeamID sets the "team_id" field if the given value is not nil.
+func (_u *TeamMemberUpdateOne) SetNillableTeamID(v *uuid.UUID) *TeamMemberUpdateOne {
+ if v != nil {
+ _u.SetTeamID(*v)
+ }
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *TeamMemberUpdateOne) SetUserID(v uuid.UUID) *TeamMemberUpdateOne {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *TeamMemberUpdateOne) SetNillableUserID(v *uuid.UUID) *TeamMemberUpdateOne {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetRole sets the "role" field.
+func (_u *TeamMemberUpdateOne) SetRole(v consts.TeamMemberRole) *TeamMemberUpdateOne {
+ _u.mutation.SetRole(v)
+ return _u
+}
+
+// SetNillableRole sets the "role" field if the given value is not nil.
+func (_u *TeamMemberUpdateOne) SetNillableRole(v *consts.TeamMemberRole) *TeamMemberUpdateOne {
+ if v != nil {
+ _u.SetRole(*v)
+ }
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *TeamMemberUpdateOne) SetCreatedAt(v time.Time) *TeamMemberUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *TeamMemberUpdateOne) SetNillableCreatedAt(v *time.Time) *TeamMemberUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetTeam sets the "team" edge to the Team entity.
+func (_u *TeamMemberUpdateOne) SetTeam(v *Team) *TeamMemberUpdateOne {
+ return _u.SetTeamID(v.ID)
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *TeamMemberUpdateOne) SetUser(v *User) *TeamMemberUpdateOne {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the TeamMemberMutation object of the builder.
+func (_u *TeamMemberUpdateOne) Mutation() *TeamMemberMutation {
+ return _u.mutation
+}
+
+// ClearTeam clears the "team" edge to the Team entity.
+func (_u *TeamMemberUpdateOne) ClearTeam() *TeamMemberUpdateOne {
+ _u.mutation.ClearTeam()
+ return _u
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *TeamMemberUpdateOne) ClearUser() *TeamMemberUpdateOne {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Where appends a list predicates to the TeamMemberUpdate builder.
+func (_u *TeamMemberUpdateOne) Where(ps ...predicate.TeamMember) *TeamMemberUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *TeamMemberUpdateOne) Select(field string, fields ...string) *TeamMemberUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated TeamMember entity.
+func (_u *TeamMemberUpdateOne) Save(ctx context.Context) (*TeamMember, error) {
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *TeamMemberUpdateOne) SaveX(ctx context.Context) *TeamMember {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *TeamMemberUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *TeamMemberUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *TeamMemberUpdateOne) check() error {
+ if _u.mutation.TeamCleared() && len(_u.mutation.TeamIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamMember.team"`)
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "TeamMember.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *TeamMemberUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TeamMemberUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *TeamMemberUpdateOne) sqlSave(ctx context.Context) (_node *TeamMember, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(teammember.Table, teammember.Columns, sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "TeamMember.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, teammember.FieldID)
+ for _, f := range fields {
+ if !teammember.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != teammember.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.Role(); ok {
+ _spec.SetField(teammember.FieldRole, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(teammember.FieldCreatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.TeamCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.TeamTable,
+ Columns: []string{teammember.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.TeamTable,
+ Columns: []string{teammember.TeamColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.UserTable,
+ Columns: []string{teammember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: false,
+ Table: teammember.UserTable,
+ Columns: []string{teammember.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &TeamMember{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{teammember.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/tx.go b/backend/db/tx.go
new file mode 100644
index 00000000..b9a078eb
--- /dev/null
+++ b/backend/db/tx.go
@@ -0,0 +1,254 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ stdsql "database/sql"
+ "fmt"
+ "sync"
+
+ "entgo.io/ent/dialect"
+)
+
+// Tx is a transactional client that is created by calling Client.Tx().
+type Tx struct {
+ config
+ // Audit is the client for interacting with the Audit builders.
+ Audit *AuditClient
+ // Team is the client for interacting with the Team builders.
+ Team *TeamClient
+ // TeamGroup is the client for interacting with the TeamGroup builders.
+ TeamGroup *TeamGroupClient
+ // TeamGroupMember is the client for interacting with the TeamGroupMember builders.
+ TeamGroupMember *TeamGroupMemberClient
+ // TeamMember is the client for interacting with the TeamMember builders.
+ TeamMember *TeamMemberClient
+ // User is the client for interacting with the User builders.
+ User *UserClient
+ // UserIdentity is the client for interacting with the UserIdentity builders.
+ UserIdentity *UserIdentityClient
+
+ // lazily loaded.
+ client *Client
+ clientOnce sync.Once
+ // ctx lives for the life of the transaction. It is
+ // the same context used by the underlying connection.
+ ctx context.Context
+}
+
+type (
+ // Committer is the interface that wraps the Commit method.
+ Committer interface {
+ Commit(context.Context, *Tx) error
+ }
+
+ // The CommitFunc type is an adapter to allow the use of ordinary
+ // function as a Committer. If f is a function with the appropriate
+ // signature, CommitFunc(f) is a Committer that calls f.
+ CommitFunc func(context.Context, *Tx) error
+
+ // CommitHook defines the "commit middleware". A function that gets a Committer
+ // and returns a Committer. For example:
+ //
+ // hook := func(next ent.Committer) ent.Committer {
+ // return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
+ // // Do some stuff before.
+ // if err := next.Commit(ctx, tx); err != nil {
+ // return err
+ // }
+ // // Do some stuff after.
+ // return nil
+ // })
+ // }
+ //
+ CommitHook func(Committer) Committer
+)
+
+// Commit calls f(ctx, m).
+func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error {
+ return f(ctx, tx)
+}
+
+// Commit commits the transaction.
+func (tx *Tx) Commit() error {
+ txDriver := tx.config.driver.(*txDriver)
+ var fn Committer = CommitFunc(func(context.Context, *Tx) error {
+ return txDriver.tx.Commit()
+ })
+ txDriver.mu.Lock()
+ hooks := append([]CommitHook(nil), txDriver.onCommit...)
+ txDriver.mu.Unlock()
+ for i := len(hooks) - 1; i >= 0; i-- {
+ fn = hooks[i](fn)
+ }
+ return fn.Commit(tx.ctx, tx)
+}
+
+// OnCommit adds a hook to call on commit.
+func (tx *Tx) OnCommit(f CommitHook) {
+ txDriver := tx.config.driver.(*txDriver)
+ txDriver.mu.Lock()
+ txDriver.onCommit = append(txDriver.onCommit, f)
+ txDriver.mu.Unlock()
+}
+
+type (
+ // Rollbacker is the interface that wraps the Rollback method.
+ Rollbacker interface {
+ Rollback(context.Context, *Tx) error
+ }
+
+ // The RollbackFunc type is an adapter to allow the use of ordinary
+ // function as a Rollbacker. If f is a function with the appropriate
+ // signature, RollbackFunc(f) is a Rollbacker that calls f.
+ RollbackFunc func(context.Context, *Tx) error
+
+ // RollbackHook defines the "rollback middleware". A function that gets a Rollbacker
+ // and returns a Rollbacker. For example:
+ //
+ // hook := func(next ent.Rollbacker) ent.Rollbacker {
+ // return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
+ // // Do some stuff before.
+ // if err := next.Rollback(ctx, tx); err != nil {
+ // return err
+ // }
+ // // Do some stuff after.
+ // return nil
+ // })
+ // }
+ //
+ RollbackHook func(Rollbacker) Rollbacker
+)
+
+// Rollback calls f(ctx, m).
+func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error {
+ return f(ctx, tx)
+}
+
+// Rollback rollbacks the transaction.
+func (tx *Tx) Rollback() error {
+ txDriver := tx.config.driver.(*txDriver)
+ var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error {
+ return txDriver.tx.Rollback()
+ })
+ txDriver.mu.Lock()
+ hooks := append([]RollbackHook(nil), txDriver.onRollback...)
+ txDriver.mu.Unlock()
+ for i := len(hooks) - 1; i >= 0; i-- {
+ fn = hooks[i](fn)
+ }
+ return fn.Rollback(tx.ctx, tx)
+}
+
+// OnRollback adds a hook to call on rollback.
+func (tx *Tx) OnRollback(f RollbackHook) {
+ txDriver := tx.config.driver.(*txDriver)
+ txDriver.mu.Lock()
+ txDriver.onRollback = append(txDriver.onRollback, f)
+ txDriver.mu.Unlock()
+}
+
+// Client returns a Client that binds to current transaction.
+func (tx *Tx) Client() *Client {
+ tx.clientOnce.Do(func() {
+ tx.client = &Client{config: tx.config}
+ tx.client.init()
+ })
+ return tx.client
+}
+
+func (tx *Tx) init() {
+ tx.Audit = NewAuditClient(tx.config)
+ tx.Team = NewTeamClient(tx.config)
+ tx.TeamGroup = NewTeamGroupClient(tx.config)
+ tx.TeamGroupMember = NewTeamGroupMemberClient(tx.config)
+ tx.TeamMember = NewTeamMemberClient(tx.config)
+ tx.User = NewUserClient(tx.config)
+ tx.UserIdentity = NewUserIdentityClient(tx.config)
+}
+
+// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.
+// The idea is to support transactions without adding any extra code to the builders.
+// When a builder calls to driver.Tx(), it gets the same dialect.Tx instance.
+// Commit and Rollback are nop for the internal builders and the user must call one
+// of them in order to commit or rollback the transaction.
+//
+// If a closed transaction is embedded in one of the generated entities, and the entity
+// applies a query, for example: Audit.QueryXXX(), the query will be executed
+// through the driver which created this transaction.
+//
+// Note that txDriver is not goroutine safe.
+type txDriver struct {
+ // the driver we started the transaction from.
+ drv dialect.Driver
+ // tx is the underlying transaction.
+ tx dialect.Tx
+ // completion hooks.
+ mu sync.Mutex
+ onCommit []CommitHook
+ onRollback []RollbackHook
+}
+
+// newTx creates a new transactional driver.
+func newTx(ctx context.Context, drv dialect.Driver) (*txDriver, error) {
+ tx, err := drv.Tx(ctx)
+ if err != nil {
+ return nil, err
+ }
+ return &txDriver{tx: tx, drv: drv}, nil
+}
+
+// Tx returns the transaction wrapper (txDriver) to avoid Commit or Rollback calls
+// from the internal builders. Should be called only by the internal builders.
+func (tx *txDriver) Tx(context.Context) (dialect.Tx, error) { return tx, nil }
+
+// Dialect returns the dialect of the driver we started the transaction from.
+func (tx *txDriver) Dialect() string { return tx.drv.Dialect() }
+
+// Close is a nop close.
+func (*txDriver) Close() error { return nil }
+
+// Commit is a nop commit for the internal builders.
+// User must call `Tx.Commit` in order to commit the transaction.
+func (*txDriver) Commit() error { return nil }
+
+// Rollback is a nop rollback for the internal builders.
+// User must call `Tx.Rollback` in order to rollback the transaction.
+func (*txDriver) Rollback() error { return nil }
+
+// Exec calls tx.Exec.
+func (tx *txDriver) Exec(ctx context.Context, query string, args, v any) error {
+ return tx.tx.Exec(ctx, query, args, v)
+}
+
+// Query calls tx.Query.
+func (tx *txDriver) Query(ctx context.Context, query string, args, v any) error {
+ return tx.tx.Query(ctx, query, args, v)
+}
+
+var _ dialect.Driver = (*txDriver)(nil)
+
+// ExecContext allows calling the underlying ExecContext method of the transaction if it is supported by it.
+// See, database/sql#Tx.ExecContext for more information.
+func (tx *txDriver) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) {
+ ex, ok := tx.tx.(interface {
+ ExecContext(context.Context, string, ...any) (stdsql.Result, error)
+ })
+ if !ok {
+ return nil, fmt.Errorf("Tx.ExecContext is not supported")
+ }
+ return ex.ExecContext(ctx, query, args...)
+}
+
+// QueryContext allows calling the underlying QueryContext method of the transaction if it is supported by it.
+// See, database/sql#Tx.QueryContext for more information.
+func (tx *txDriver) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) {
+ q, ok := tx.tx.(interface {
+ QueryContext(context.Context, string, ...any) (*stdsql.Rows, error)
+ })
+ if !ok {
+ return nil, fmt.Errorf("Tx.QueryContext is not supported")
+ }
+ return q.QueryContext(ctx, query, args...)
+}
diff --git a/backend/db/user.go b/backend/db/user.go
new file mode 100644
index 00000000..ced0d33f
--- /dev/null
+++ b/backend/db/user.go
@@ -0,0 +1,331 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "encoding/json"
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/google/uuid"
+)
+
+// User is the model entity for the User schema.
+type User struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // DeletedAt holds the value of the "deleted_at" field.
+ DeletedAt time.Time `json:"deleted_at,omitempty"`
+ // Name holds the value of the "name" field.
+ Name string `json:"name,omitempty"`
+ // Email holds the value of the "email" field.
+ Email string `json:"email,omitempty"`
+ // AvatarURL holds the value of the "avatar_url" field.
+ AvatarURL string `json:"avatar_url,omitempty"`
+ // Password holds the value of the "password" field.
+ Password string `json:"password,omitempty"`
+ // Role holds the value of the "role" field.
+ Role consts.UserRole `json:"role,omitempty"`
+ // Status holds the value of the "status" field.
+ Status consts.UserStatus `json:"status,omitempty"`
+ // IsBlocked holds the value of the "is_blocked" field.
+ IsBlocked bool `json:"is_blocked,omitempty"`
+ // DefaultConfigs holds the value of the "default_configs" field.
+ DefaultConfigs map[consts.DefaultConfigType]uuid.UUID `json:"default_configs,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"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the UserQuery when eager-loading is set.
+ Edges UserEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// UserEdges holds the relations/edges for other nodes in the graph.
+type UserEdges struct {
+ // Identities holds the value of the identities edge.
+ Identities []*UserIdentity `json:"identities,omitempty"`
+ // Audits holds the value of the audits edge.
+ Audits []*Audit `json:"audits,omitempty"`
+ // Teams holds the value of the teams edge.
+ Teams []*Team `json:"teams,omitempty"`
+ // Groups holds the value of the groups edge.
+ Groups []*TeamGroup `json:"groups,omitempty"`
+ // TeamMembers holds the value of the team_members edge.
+ TeamMembers []*TeamMember `json:"team_members,omitempty"`
+ // TeamGroupMembers holds the value of the team_group_members edge.
+ TeamGroupMembers []*TeamGroupMember `json:"team_group_members,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [6]bool
+}
+
+// IdentitiesOrErr returns the Identities value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) IdentitiesOrErr() ([]*UserIdentity, error) {
+ if e.loadedTypes[0] {
+ return e.Identities, nil
+ }
+ return nil, &NotLoadedError{edge: "identities"}
+}
+
+// AuditsOrErr returns the Audits value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) AuditsOrErr() ([]*Audit, error) {
+ if e.loadedTypes[1] {
+ return e.Audits, nil
+ }
+ return nil, &NotLoadedError{edge: "audits"}
+}
+
+// TeamsOrErr returns the Teams value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) TeamsOrErr() ([]*Team, error) {
+ if e.loadedTypes[2] {
+ return e.Teams, nil
+ }
+ return nil, &NotLoadedError{edge: "teams"}
+}
+
+// GroupsOrErr returns the Groups value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) GroupsOrErr() ([]*TeamGroup, error) {
+ if e.loadedTypes[3] {
+ return e.Groups, nil
+ }
+ return nil, &NotLoadedError{edge: "groups"}
+}
+
+// TeamMembersOrErr returns the TeamMembers value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) TeamMembersOrErr() ([]*TeamMember, error) {
+ if e.loadedTypes[4] {
+ return e.TeamMembers, nil
+ }
+ return nil, &NotLoadedError{edge: "team_members"}
+}
+
+// TeamGroupMembersOrErr returns the TeamGroupMembers value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) TeamGroupMembersOrErr() ([]*TeamGroupMember, error) {
+ if e.loadedTypes[5] {
+ return e.TeamGroupMembers, nil
+ }
+ return nil, &NotLoadedError{edge: "team_group_members"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*User) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case user.FieldDefaultConfigs:
+ values[i] = new([]byte)
+ case user.FieldIsBlocked:
+ values[i] = new(sql.NullBool)
+ case user.FieldName, user.FieldEmail, user.FieldAvatarURL, user.FieldPassword, user.FieldRole, user.FieldStatus:
+ values[i] = new(sql.NullString)
+ case user.FieldDeletedAt, user.FieldCreatedAt, user.FieldUpdatedAt:
+ values[i] = new(sql.NullTime)
+ case user.FieldID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the User fields.
+func (_m *User) 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 user.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case user.FieldDeletedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field deleted_at", values[i])
+ } else if value.Valid {
+ _m.DeletedAt = value.Time
+ }
+ case user.FieldName:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field name", values[i])
+ } else if value.Valid {
+ _m.Name = value.String
+ }
+ case user.FieldEmail:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field email", values[i])
+ } else if value.Valid {
+ _m.Email = value.String
+ }
+ case user.FieldAvatarURL:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field avatar_url", values[i])
+ } else if value.Valid {
+ _m.AvatarURL = value.String
+ }
+ case user.FieldPassword:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field password", values[i])
+ } else if value.Valid {
+ _m.Password = value.String
+ }
+ case user.FieldRole:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field role", values[i])
+ } else if value.Valid {
+ _m.Role = consts.UserRole(value.String)
+ }
+ case user.FieldStatus:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field status", values[i])
+ } else if value.Valid {
+ _m.Status = consts.UserStatus(value.String)
+ }
+ case user.FieldIsBlocked:
+ if value, ok := values[i].(*sql.NullBool); !ok {
+ return fmt.Errorf("unexpected type %T for field is_blocked", values[i])
+ } else if value.Valid {
+ _m.IsBlocked = value.Bool
+ }
+ case user.FieldDefaultConfigs:
+ if value, ok := values[i].(*[]byte); !ok {
+ return fmt.Errorf("unexpected type %T for field default_configs", values[i])
+ } else if value != nil && len(*value) > 0 {
+ if err := json.Unmarshal(*value, &_m.DefaultConfigs); err != nil {
+ return fmt.Errorf("unmarshal field default_configs: %w", err)
+ }
+ }
+ case user.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 {
+ _m.CreatedAt = value.Time
+ }
+ case user.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 {
+ _m.UpdatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the User.
+// This includes values selected through modifiers, order, etc.
+func (_m *User) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryIdentities queries the "identities" edge of the User entity.
+func (_m *User) QueryIdentities() *UserIdentityQuery {
+ return NewUserClient(_m.config).QueryIdentities(_m)
+}
+
+// QueryAudits queries the "audits" edge of the User entity.
+func (_m *User) QueryAudits() *AuditQuery {
+ return NewUserClient(_m.config).QueryAudits(_m)
+}
+
+// QueryTeams queries the "teams" edge of the User entity.
+func (_m *User) QueryTeams() *TeamQuery {
+ return NewUserClient(_m.config).QueryTeams(_m)
+}
+
+// QueryGroups queries the "groups" edge of the User entity.
+func (_m *User) QueryGroups() *TeamGroupQuery {
+ return NewUserClient(_m.config).QueryGroups(_m)
+}
+
+// QueryTeamMembers queries the "team_members" edge of the User entity.
+func (_m *User) QueryTeamMembers() *TeamMemberQuery {
+ return NewUserClient(_m.config).QueryTeamMembers(_m)
+}
+
+// QueryTeamGroupMembers queries the "team_group_members" edge of the User entity.
+func (_m *User) QueryTeamGroupMembers() *TeamGroupMemberQuery {
+ return NewUserClient(_m.config).QueryTeamGroupMembers(_m)
+}
+
+// Update returns a builder for updating this User.
+// Note that you need to call User.Unwrap() before calling this method if this User
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *User) Update() *UserUpdateOne {
+ return NewUserClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the User 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 (_m *User) Unwrap() *User {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: User is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *User) String() string {
+ var builder strings.Builder
+ builder.WriteString("User(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("deleted_at=")
+ builder.WriteString(_m.DeletedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("name=")
+ builder.WriteString(_m.Name)
+ builder.WriteString(", ")
+ builder.WriteString("email=")
+ builder.WriteString(_m.Email)
+ builder.WriteString(", ")
+ builder.WriteString("avatar_url=")
+ builder.WriteString(_m.AvatarURL)
+ builder.WriteString(", ")
+ builder.WriteString("password=")
+ builder.WriteString(_m.Password)
+ builder.WriteString(", ")
+ builder.WriteString("role=")
+ builder.WriteString(fmt.Sprintf("%v", _m.Role))
+ builder.WriteString(", ")
+ builder.WriteString("status=")
+ builder.WriteString(fmt.Sprintf("%v", _m.Status))
+ builder.WriteString(", ")
+ builder.WriteString("is_blocked=")
+ builder.WriteString(fmt.Sprintf("%v", _m.IsBlocked))
+ builder.WriteString(", ")
+ builder.WriteString("default_configs=")
+ builder.WriteString(fmt.Sprintf("%v", _m.DefaultConfigs))
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("updated_at=")
+ builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// Users is a parsable slice of User.
+type Users []*User
diff --git a/backend/db/user/user.go b/backend/db/user/user.go
new file mode 100644
index 00000000..3f2a1d8e
--- /dev/null
+++ b/backend/db/user/user.go
@@ -0,0 +1,331 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the user type in the database.
+ Label = "user"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldDeletedAt holds the string denoting the deleted_at field in the database.
+ FieldDeletedAt = "deleted_at"
+ // FieldName holds the string denoting the name field in the database.
+ FieldName = "name"
+ // FieldEmail holds the string denoting the email field in the database.
+ FieldEmail = "email"
+ // FieldAvatarURL holds the string denoting the avatar_url field in the database.
+ FieldAvatarURL = "avatar_url"
+ // FieldPassword holds the string denoting the password field in the database.
+ FieldPassword = "password"
+ // FieldRole holds the string denoting the role field in the database.
+ FieldRole = "role"
+ // FieldStatus holds the string denoting the status field in the database.
+ FieldStatus = "status"
+ // FieldIsBlocked holds the string denoting the is_blocked field in the database.
+ FieldIsBlocked = "is_blocked"
+ // FieldDefaultConfigs holds the string denoting the default_configs field in the database.
+ FieldDefaultConfigs = "default_configs"
+ // 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"
+ // EdgeIdentities holds the string denoting the identities edge name in mutations.
+ EdgeIdentities = "identities"
+ // EdgeAudits holds the string denoting the audits edge name in mutations.
+ EdgeAudits = "audits"
+ // EdgeTeams holds the string denoting the teams edge name in mutations.
+ EdgeTeams = "teams"
+ // EdgeGroups holds the string denoting the groups edge name in mutations.
+ EdgeGroups = "groups"
+ // EdgeTeamMembers holds the string denoting the team_members edge name in mutations.
+ EdgeTeamMembers = "team_members"
+ // EdgeTeamGroupMembers holds the string denoting the team_group_members edge name in mutations.
+ EdgeTeamGroupMembers = "team_group_members"
+ // Table holds the table name of the user in the database.
+ Table = "users"
+ // IdentitiesTable is the table that holds the identities relation/edge.
+ IdentitiesTable = "user_identities"
+ // IdentitiesInverseTable is the table name for the UserIdentity entity.
+ // It exists in this package in order to avoid circular dependency with the "useridentity" package.
+ IdentitiesInverseTable = "user_identities"
+ // IdentitiesColumn is the table column denoting the identities relation/edge.
+ IdentitiesColumn = "user_id"
+ // AuditsTable is the table that holds the audits relation/edge.
+ AuditsTable = "audits"
+ // AuditsInverseTable is the table name for the Audit entity.
+ // It exists in this package in order to avoid circular dependency with the "audit" package.
+ AuditsInverseTable = "audits"
+ // AuditsColumn is the table column denoting the audits relation/edge.
+ AuditsColumn = "user_id"
+ // TeamsTable is the table that holds the teams relation/edge. The primary key declared below.
+ TeamsTable = "team_members"
+ // TeamsInverseTable is the table name for the Team entity.
+ // It exists in this package in order to avoid circular dependency with the "team" package.
+ TeamsInverseTable = "teams"
+ // GroupsTable is the table that holds the groups relation/edge. The primary key declared below.
+ GroupsTable = "team_group_members"
+ // GroupsInverseTable is the table name for the TeamGroup entity.
+ // It exists in this package in order to avoid circular dependency with the "teamgroup" package.
+ GroupsInverseTable = "team_groups"
+ // TeamMembersTable is the table that holds the team_members relation/edge.
+ TeamMembersTable = "team_members"
+ // TeamMembersInverseTable is the table name for the TeamMember entity.
+ // It exists in this package in order to avoid circular dependency with the "teammember" package.
+ TeamMembersInverseTable = "team_members"
+ // TeamMembersColumn is the table column denoting the team_members relation/edge.
+ TeamMembersColumn = "user_id"
+ // TeamGroupMembersTable is the table that holds the team_group_members relation/edge.
+ TeamGroupMembersTable = "team_group_members"
+ // TeamGroupMembersInverseTable is the table name for the TeamGroupMember entity.
+ // It exists in this package in order to avoid circular dependency with the "teamgroupmember" package.
+ TeamGroupMembersInverseTable = "team_group_members"
+ // TeamGroupMembersColumn is the table column denoting the team_group_members relation/edge.
+ TeamGroupMembersColumn = "user_id"
+)
+
+// Columns holds all SQL columns for user fields.
+var Columns = []string{
+ FieldID,
+ FieldDeletedAt,
+ FieldName,
+ FieldEmail,
+ FieldAvatarURL,
+ FieldPassword,
+ FieldRole,
+ FieldStatus,
+ FieldIsBlocked,
+ FieldDefaultConfigs,
+ FieldCreatedAt,
+ FieldUpdatedAt,
+}
+
+var (
+ // TeamsPrimaryKey and TeamsColumn2 are the table columns denoting the
+ // primary key for the teams relation (M2M).
+ TeamsPrimaryKey = []string{"user_id", "team_id"}
+ // GroupsPrimaryKey and GroupsColumn2 are the table columns denoting the
+ // primary key for the groups relation (M2M).
+ GroupsPrimaryKey = []string{"user_id", "group_id"}
+)
+
+// 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
+ }
+ }
+ return false
+}
+
+// Note that the variables below are initialized by the runtime
+// package on the initialization of the application. Therefore,
+// it should be imported in the main as follows:
+//
+// import _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+var (
+ Hooks [1]ent.Hook
+ Interceptors [1]ent.Interceptor
+ // NameValidator is a validator for the "name" field. It is called by the builders before save.
+ NameValidator func(string) error
+ // DefaultIsBlocked holds the default value on creation for the "is_blocked" field.
+ DefaultIsBlocked bool
+ // 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
+)
+
+// OrderOption defines the ordering options for the User queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByDeletedAt orders the results by the deleted_at field.
+func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDeletedAt, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByEmail orders the results by the email field.
+func ByEmail(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldEmail, opts...).ToFunc()
+}
+
+// ByAvatarURL orders the results by the avatar_url field.
+func ByAvatarURL(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldAvatarURL, opts...).ToFunc()
+}
+
+// ByPassword orders the results by the password field.
+func ByPassword(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPassword, opts...).ToFunc()
+}
+
+// ByRole orders the results by the role field.
+func ByRole(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldRole, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByIsBlocked orders the results by the is_blocked field.
+func ByIsBlocked(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldIsBlocked, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByIdentitiesCount orders the results by identities count.
+func ByIdentitiesCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newIdentitiesStep(), opts...)
+ }
+}
+
+// ByIdentities orders the results by identities terms.
+func ByIdentities(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newIdentitiesStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByAuditsCount orders the results by audits count.
+func ByAuditsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newAuditsStep(), opts...)
+ }
+}
+
+// ByAudits orders the results by audits terms.
+func ByAudits(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newAuditsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByTeamsCount orders the results by teams count.
+func ByTeamsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newTeamsStep(), opts...)
+ }
+}
+
+// ByTeams orders the results by teams terms.
+func ByTeams(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByGroupsCount orders the results by groups count.
+func ByGroupsCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newGroupsStep(), opts...)
+ }
+}
+
+// ByGroups orders the results by groups terms.
+func ByGroups(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newGroupsStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByTeamMembersCount orders the results by team_members count.
+func ByTeamMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newTeamMembersStep(), opts...)
+ }
+}
+
+// ByTeamMembers orders the results by team_members terms.
+func ByTeamMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+
+// ByTeamGroupMembersCount orders the results by team_group_members count.
+func ByTeamGroupMembersCount(opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborsCount(s, newTeamGroupMembersStep(), opts...)
+ }
+}
+
+// ByTeamGroupMembers orders the results by team_group_members terms.
+func ByTeamGroupMembers(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newTeamGroupMembersStep(), append([]sql.OrderTerm{term}, terms...)...)
+ }
+}
+func newIdentitiesStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(IdentitiesInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, IdentitiesTable, IdentitiesColumn),
+ )
+}
+func newAuditsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(AuditsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, AuditsTable, AuditsColumn),
+ )
+}
+func newTeamsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, TeamsTable, TeamsPrimaryKey...),
+ )
+}
+func newGroupsStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(GroupsInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, GroupsTable, GroupsPrimaryKey...),
+ )
+}
+func newTeamMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamMembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamMembersTable, TeamMembersColumn),
+ )
+}
+func newTeamGroupMembersStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(TeamGroupMembersInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamGroupMembersTable, TeamGroupMembersColumn),
+ )
+}
diff --git a/backend/db/user/where.go b/backend/db/user/where.go
new file mode 100644
index 00000000..fb121b69
--- /dev/null
+++ b/backend/db/user/where.go
@@ -0,0 +1,871 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldID, id))
+}
+
+// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
+func DeletedAt(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldName, v))
+}
+
+// Email applies equality check predicate on the "email" field. It's identical to EmailEQ.
+func Email(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldEmail, v))
+}
+
+// AvatarURL applies equality check predicate on the "avatar_url" field. It's identical to AvatarURLEQ.
+func AvatarURL(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldAvatarURL, v))
+}
+
+// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ.
+func Password(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldPassword, v))
+}
+
+// Role applies equality check predicate on the "role" field. It's identical to RoleEQ.
+func Role(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEQ(FieldRole, vc))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEQ(FieldStatus, vc))
+}
+
+// IsBlocked applies equality check predicate on the "is_blocked" field. It's identical to IsBlockedEQ.
+func IsBlocked(v bool) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldIsBlocked, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
+func DeletedAtEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
+func DeletedAtNEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtIn applies the In predicate on the "deleted_at" field.
+func DeletedAtIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
+func DeletedAtNotIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtGT applies the GT predicate on the "deleted_at" field.
+func DeletedAtGT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGT(FieldDeletedAt, v))
+}
+
+// DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
+func DeletedAtGTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldDeletedAt, v))
+}
+
+// DeletedAtLT applies the LT predicate on the "deleted_at" field.
+func DeletedAtLT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLT(FieldDeletedAt, v))
+}
+
+// DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
+func DeletedAtLTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldDeletedAt, v))
+}
+
+// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
+func DeletedAtIsNil() predicate.User {
+ return predicate.User(sql.FieldIsNull(FieldDeletedAt))
+}
+
+// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
+func DeletedAtNotNil() predicate.User {
+ return predicate.User(sql.FieldNotNull(FieldDeletedAt))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.User {
+ return predicate.User(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.User {
+ return predicate.User(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.User {
+ return predicate.User(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.User {
+ return predicate.User(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.User {
+ return predicate.User(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.User {
+ return predicate.User(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.User {
+ return predicate.User(sql.FieldContainsFold(FieldName, v))
+}
+
+// EmailEQ applies the EQ predicate on the "email" field.
+func EmailEQ(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldEmail, v))
+}
+
+// EmailNEQ applies the NEQ predicate on the "email" field.
+func EmailNEQ(v string) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldEmail, v))
+}
+
+// EmailIn applies the In predicate on the "email" field.
+func EmailIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldIn(FieldEmail, vs...))
+}
+
+// EmailNotIn applies the NotIn predicate on the "email" field.
+func EmailNotIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldEmail, vs...))
+}
+
+// EmailGT applies the GT predicate on the "email" field.
+func EmailGT(v string) predicate.User {
+ return predicate.User(sql.FieldGT(FieldEmail, v))
+}
+
+// EmailGTE applies the GTE predicate on the "email" field.
+func EmailGTE(v string) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldEmail, v))
+}
+
+// EmailLT applies the LT predicate on the "email" field.
+func EmailLT(v string) predicate.User {
+ return predicate.User(sql.FieldLT(FieldEmail, v))
+}
+
+// EmailLTE applies the LTE predicate on the "email" field.
+func EmailLTE(v string) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldEmail, v))
+}
+
+// EmailContains applies the Contains predicate on the "email" field.
+func EmailContains(v string) predicate.User {
+ return predicate.User(sql.FieldContains(FieldEmail, v))
+}
+
+// EmailHasPrefix applies the HasPrefix predicate on the "email" field.
+func EmailHasPrefix(v string) predicate.User {
+ return predicate.User(sql.FieldHasPrefix(FieldEmail, v))
+}
+
+// EmailHasSuffix applies the HasSuffix predicate on the "email" field.
+func EmailHasSuffix(v string) predicate.User {
+ return predicate.User(sql.FieldHasSuffix(FieldEmail, v))
+}
+
+// EmailIsNil applies the IsNil predicate on the "email" field.
+func EmailIsNil() predicate.User {
+ return predicate.User(sql.FieldIsNull(FieldEmail))
+}
+
+// EmailNotNil applies the NotNil predicate on the "email" field.
+func EmailNotNil() predicate.User {
+ return predicate.User(sql.FieldNotNull(FieldEmail))
+}
+
+// EmailEqualFold applies the EqualFold predicate on the "email" field.
+func EmailEqualFold(v string) predicate.User {
+ return predicate.User(sql.FieldEqualFold(FieldEmail, v))
+}
+
+// EmailContainsFold applies the ContainsFold predicate on the "email" field.
+func EmailContainsFold(v string) predicate.User {
+ return predicate.User(sql.FieldContainsFold(FieldEmail, v))
+}
+
+// AvatarURLEQ applies the EQ predicate on the "avatar_url" field.
+func AvatarURLEQ(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldAvatarURL, v))
+}
+
+// AvatarURLNEQ applies the NEQ predicate on the "avatar_url" field.
+func AvatarURLNEQ(v string) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldAvatarURL, v))
+}
+
+// AvatarURLIn applies the In predicate on the "avatar_url" field.
+func AvatarURLIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldIn(FieldAvatarURL, vs...))
+}
+
+// AvatarURLNotIn applies the NotIn predicate on the "avatar_url" field.
+func AvatarURLNotIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldAvatarURL, vs...))
+}
+
+// AvatarURLGT applies the GT predicate on the "avatar_url" field.
+func AvatarURLGT(v string) predicate.User {
+ return predicate.User(sql.FieldGT(FieldAvatarURL, v))
+}
+
+// AvatarURLGTE applies the GTE predicate on the "avatar_url" field.
+func AvatarURLGTE(v string) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldAvatarURL, v))
+}
+
+// AvatarURLLT applies the LT predicate on the "avatar_url" field.
+func AvatarURLLT(v string) predicate.User {
+ return predicate.User(sql.FieldLT(FieldAvatarURL, v))
+}
+
+// AvatarURLLTE applies the LTE predicate on the "avatar_url" field.
+func AvatarURLLTE(v string) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldAvatarURL, v))
+}
+
+// AvatarURLContains applies the Contains predicate on the "avatar_url" field.
+func AvatarURLContains(v string) predicate.User {
+ return predicate.User(sql.FieldContains(FieldAvatarURL, v))
+}
+
+// AvatarURLHasPrefix applies the HasPrefix predicate on the "avatar_url" field.
+func AvatarURLHasPrefix(v string) predicate.User {
+ return predicate.User(sql.FieldHasPrefix(FieldAvatarURL, v))
+}
+
+// AvatarURLHasSuffix applies the HasSuffix predicate on the "avatar_url" field.
+func AvatarURLHasSuffix(v string) predicate.User {
+ return predicate.User(sql.FieldHasSuffix(FieldAvatarURL, v))
+}
+
+// AvatarURLIsNil applies the IsNil predicate on the "avatar_url" field.
+func AvatarURLIsNil() predicate.User {
+ return predicate.User(sql.FieldIsNull(FieldAvatarURL))
+}
+
+// AvatarURLNotNil applies the NotNil predicate on the "avatar_url" field.
+func AvatarURLNotNil() predicate.User {
+ return predicate.User(sql.FieldNotNull(FieldAvatarURL))
+}
+
+// AvatarURLEqualFold applies the EqualFold predicate on the "avatar_url" field.
+func AvatarURLEqualFold(v string) predicate.User {
+ return predicate.User(sql.FieldEqualFold(FieldAvatarURL, v))
+}
+
+// AvatarURLContainsFold applies the ContainsFold predicate on the "avatar_url" field.
+func AvatarURLContainsFold(v string) predicate.User {
+ return predicate.User(sql.FieldContainsFold(FieldAvatarURL, v))
+}
+
+// PasswordEQ applies the EQ predicate on the "password" field.
+func PasswordEQ(v string) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldPassword, v))
+}
+
+// PasswordNEQ applies the NEQ predicate on the "password" field.
+func PasswordNEQ(v string) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldPassword, v))
+}
+
+// PasswordIn applies the In predicate on the "password" field.
+func PasswordIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldIn(FieldPassword, vs...))
+}
+
+// PasswordNotIn applies the NotIn predicate on the "password" field.
+func PasswordNotIn(vs ...string) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldPassword, vs...))
+}
+
+// PasswordGT applies the GT predicate on the "password" field.
+func PasswordGT(v string) predicate.User {
+ return predicate.User(sql.FieldGT(FieldPassword, v))
+}
+
+// PasswordGTE applies the GTE predicate on the "password" field.
+func PasswordGTE(v string) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldPassword, v))
+}
+
+// PasswordLT applies the LT predicate on the "password" field.
+func PasswordLT(v string) predicate.User {
+ return predicate.User(sql.FieldLT(FieldPassword, v))
+}
+
+// PasswordLTE applies the LTE predicate on the "password" field.
+func PasswordLTE(v string) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldPassword, v))
+}
+
+// PasswordContains applies the Contains predicate on the "password" field.
+func PasswordContains(v string) predicate.User {
+ return predicate.User(sql.FieldContains(FieldPassword, v))
+}
+
+// PasswordHasPrefix applies the HasPrefix predicate on the "password" field.
+func PasswordHasPrefix(v string) predicate.User {
+ return predicate.User(sql.FieldHasPrefix(FieldPassword, v))
+}
+
+// PasswordHasSuffix applies the HasSuffix predicate on the "password" field.
+func PasswordHasSuffix(v string) predicate.User {
+ return predicate.User(sql.FieldHasSuffix(FieldPassword, v))
+}
+
+// PasswordIsNil applies the IsNil predicate on the "password" field.
+func PasswordIsNil() predicate.User {
+ return predicate.User(sql.FieldIsNull(FieldPassword))
+}
+
+// PasswordNotNil applies the NotNil predicate on the "password" field.
+func PasswordNotNil() predicate.User {
+ return predicate.User(sql.FieldNotNull(FieldPassword))
+}
+
+// PasswordEqualFold applies the EqualFold predicate on the "password" field.
+func PasswordEqualFold(v string) predicate.User {
+ return predicate.User(sql.FieldEqualFold(FieldPassword, v))
+}
+
+// PasswordContainsFold applies the ContainsFold predicate on the "password" field.
+func PasswordContainsFold(v string) predicate.User {
+ return predicate.User(sql.FieldContainsFold(FieldPassword, v))
+}
+
+// RoleEQ applies the EQ predicate on the "role" field.
+func RoleEQ(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEQ(FieldRole, vc))
+}
+
+// RoleNEQ applies the NEQ predicate on the "role" field.
+func RoleNEQ(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldNEQ(FieldRole, vc))
+}
+
+// RoleIn applies the In predicate on the "role" field.
+func RoleIn(vs ...consts.UserRole) predicate.User {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.User(sql.FieldIn(FieldRole, v...))
+}
+
+// RoleNotIn applies the NotIn predicate on the "role" field.
+func RoleNotIn(vs ...consts.UserRole) predicate.User {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.User(sql.FieldNotIn(FieldRole, v...))
+}
+
+// RoleGT applies the GT predicate on the "role" field.
+func RoleGT(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldGT(FieldRole, vc))
+}
+
+// RoleGTE applies the GTE predicate on the "role" field.
+func RoleGTE(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldGTE(FieldRole, vc))
+}
+
+// RoleLT applies the LT predicate on the "role" field.
+func RoleLT(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldLT(FieldRole, vc))
+}
+
+// RoleLTE applies the LTE predicate on the "role" field.
+func RoleLTE(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldLTE(FieldRole, vc))
+}
+
+// RoleContains applies the Contains predicate on the "role" field.
+func RoleContains(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldContains(FieldRole, vc))
+}
+
+// RoleHasPrefix applies the HasPrefix predicate on the "role" field.
+func RoleHasPrefix(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldHasPrefix(FieldRole, vc))
+}
+
+// RoleHasSuffix applies the HasSuffix predicate on the "role" field.
+func RoleHasSuffix(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldHasSuffix(FieldRole, vc))
+}
+
+// RoleEqualFold applies the EqualFold predicate on the "role" field.
+func RoleEqualFold(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEqualFold(FieldRole, vc))
+}
+
+// RoleContainsFold applies the ContainsFold predicate on the "role" field.
+func RoleContainsFold(v consts.UserRole) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldContainsFold(FieldRole, vc))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEQ(FieldStatus, vc))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldNEQ(FieldStatus, vc))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...consts.UserStatus) predicate.User {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.User(sql.FieldIn(FieldStatus, v...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...consts.UserStatus) predicate.User {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.User(sql.FieldNotIn(FieldStatus, v...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldGT(FieldStatus, vc))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldGTE(FieldStatus, vc))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldLT(FieldStatus, vc))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldLTE(FieldStatus, vc))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldContains(FieldStatus, vc))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldHasPrefix(FieldStatus, vc))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldHasSuffix(FieldStatus, vc))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldEqualFold(FieldStatus, vc))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v consts.UserStatus) predicate.User {
+ vc := string(v)
+ return predicate.User(sql.FieldContainsFold(FieldStatus, vc))
+}
+
+// IsBlockedEQ applies the EQ predicate on the "is_blocked" field.
+func IsBlockedEQ(v bool) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldIsBlocked, v))
+}
+
+// IsBlockedNEQ applies the NEQ predicate on the "is_blocked" field.
+func IsBlockedNEQ(v bool) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldIsBlocked, v))
+}
+
+// DefaultConfigsIsNil applies the IsNil predicate on the "default_configs" field.
+func DefaultConfigsIsNil() predicate.User {
+ return predicate.User(sql.FieldIsNull(FieldDefaultConfigs))
+}
+
+// DefaultConfigsNotNil applies the NotNil predicate on the "default_configs" field.
+func DefaultConfigsNotNil() predicate.User {
+ return predicate.User(sql.FieldNotNull(FieldDefaultConfigs))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.User {
+ return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.User {
+ return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.User {
+ return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// HasIdentities applies the HasEdge predicate on the "identities" edge.
+func HasIdentities() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, IdentitiesTable, IdentitiesColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasIdentitiesWith applies the HasEdge predicate on the "identities" edge with a given conditions (other predicates).
+func HasIdentitiesWith(preds ...predicate.UserIdentity) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newIdentitiesStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasAudits applies the HasEdge predicate on the "audits" edge.
+func HasAudits() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, AuditsTable, AuditsColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasAuditsWith applies the HasEdge predicate on the "audits" edge with a given conditions (other predicates).
+func HasAuditsWith(preds ...predicate.Audit) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newAuditsStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeams applies the HasEdge predicate on the "teams" edge.
+func HasTeams() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, TeamsTable, TeamsPrimaryKey...),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamsWith applies the HasEdge predicate on the "teams" edge with a given conditions (other predicates).
+func HasTeamsWith(preds ...predicate.Team) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newTeamsStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasGroups applies the HasEdge predicate on the "groups" edge.
+func HasGroups() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, GroupsTable, GroupsPrimaryKey...),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasGroupsWith applies the HasEdge predicate on the "groups" edge with a given conditions (other predicates).
+func HasGroupsWith(preds ...predicate.TeamGroup) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newGroupsStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeamMembers applies the HasEdge predicate on the "team_members" edge.
+func HasTeamMembers() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamMembersTable, TeamMembersColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamMembersWith applies the HasEdge predicate on the "team_members" edge with a given conditions (other predicates).
+func HasTeamMembersWith(preds ...predicate.TeamMember) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newTeamMembersStep()
+ sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+ for _, p := range preds {
+ p(s)
+ }
+ })
+ })
+}
+
+// HasTeamGroupMembers applies the HasEdge predicate on the "team_group_members" edge.
+func HasTeamGroupMembers() predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, TeamGroupMembersTable, TeamGroupMembersColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasTeamGroupMembersWith applies the HasEdge predicate on the "team_group_members" edge with a given conditions (other predicates).
+func HasTeamGroupMembersWith(preds ...predicate.TeamGroupMember) predicate.User {
+ return predicate.User(func(s *sql.Selector) {
+ step := newTeamGroupMembersStep()
+ 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.User) predicate.User {
+ return predicate.User(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.User) predicate.User {
+ return predicate.User(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.User) predicate.User {
+ return predicate.User(sql.NotPredicates(p))
+}
diff --git a/backend/db/user_create.go b/backend/db/user_create.go
new file mode 100644
index 00000000..ad3817e4
--- /dev/null
+++ b/backend/db/user_create.go
@@ -0,0 +1,1395 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserCreate is the builder for creating a User entity.
+type UserCreate struct {
+ config
+ mutation *UserMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_c *UserCreate) SetDeletedAt(v time.Time) *UserCreate {
+ _c.mutation.SetDeletedAt(v)
+ return _c
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_c *UserCreate) SetNillableDeletedAt(v *time.Time) *UserCreate {
+ if v != nil {
+ _c.SetDeletedAt(*v)
+ }
+ return _c
+}
+
+// SetName sets the "name" field.
+func (_c *UserCreate) SetName(v string) *UserCreate {
+ _c.mutation.SetName(v)
+ return _c
+}
+
+// SetEmail sets the "email" field.
+func (_c *UserCreate) SetEmail(v string) *UserCreate {
+ _c.mutation.SetEmail(v)
+ return _c
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_c *UserCreate) SetNillableEmail(v *string) *UserCreate {
+ if v != nil {
+ _c.SetEmail(*v)
+ }
+ return _c
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_c *UserCreate) SetAvatarURL(v string) *UserCreate {
+ _c.mutation.SetAvatarURL(v)
+ return _c
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_c *UserCreate) SetNillableAvatarURL(v *string) *UserCreate {
+ if v != nil {
+ _c.SetAvatarURL(*v)
+ }
+ return _c
+}
+
+// SetPassword sets the "password" field.
+func (_c *UserCreate) SetPassword(v string) *UserCreate {
+ _c.mutation.SetPassword(v)
+ return _c
+}
+
+// SetNillablePassword sets the "password" field if the given value is not nil.
+func (_c *UserCreate) SetNillablePassword(v *string) *UserCreate {
+ if v != nil {
+ _c.SetPassword(*v)
+ }
+ return _c
+}
+
+// SetRole sets the "role" field.
+func (_c *UserCreate) SetRole(v consts.UserRole) *UserCreate {
+ _c.mutation.SetRole(v)
+ return _c
+}
+
+// SetStatus sets the "status" field.
+func (_c *UserCreate) SetStatus(v consts.UserStatus) *UserCreate {
+ _c.mutation.SetStatus(v)
+ return _c
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (_c *UserCreate) SetIsBlocked(v bool) *UserCreate {
+ _c.mutation.SetIsBlocked(v)
+ return _c
+}
+
+// SetNillableIsBlocked sets the "is_blocked" field if the given value is not nil.
+func (_c *UserCreate) SetNillableIsBlocked(v *bool) *UserCreate {
+ if v != nil {
+ _c.SetIsBlocked(*v)
+ }
+ return _c
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (_c *UserCreate) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserCreate {
+ _c.mutation.SetDefaultConfigs(v)
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *UserCreate) SetCreatedAt(v time.Time) *UserCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *UserCreate) SetNillableCreatedAt(v *time.Time) *UserCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *UserCreate) SetUpdatedAt(v time.Time) *UserCreate {
+ _c.mutation.SetUpdatedAt(v)
+ return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *UserCreate) SetNillableUpdatedAt(v *time.Time) *UserCreate {
+ if v != nil {
+ _c.SetUpdatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *UserCreate) SetID(v uuid.UUID) *UserCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// AddIdentityIDs adds the "identities" edge to the UserIdentity entity by IDs.
+func (_c *UserCreate) AddIdentityIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddIdentityIDs(ids...)
+ return _c
+}
+
+// AddIdentities adds the "identities" edges to the UserIdentity entity.
+func (_c *UserCreate) AddIdentities(v ...*UserIdentity) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddIdentityIDs(ids...)
+}
+
+// AddAuditIDs adds the "audits" edge to the Audit entity by IDs.
+func (_c *UserCreate) AddAuditIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddAuditIDs(ids...)
+ return _c
+}
+
+// AddAudits adds the "audits" edges to the Audit entity.
+func (_c *UserCreate) AddAudits(v ...*Audit) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddAuditIDs(ids...)
+}
+
+// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
+func (_c *UserCreate) AddTeamIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddTeamIDs(ids...)
+ return _c
+}
+
+// AddTeams adds the "teams" edges to the Team entity.
+func (_c *UserCreate) AddTeams(v ...*Team) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddTeamIDs(ids...)
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_c *UserCreate) AddGroupIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddGroupIDs(ids...)
+ return _c
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_c *UserCreate) AddGroups(v ...*TeamGroup) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddGroupIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_c *UserCreate) AddTeamMemberIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddTeamMemberIDs(ids...)
+ return _c
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_c *UserCreate) AddTeamMembers(v ...*TeamMember) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddTeamMemberIDs(ids...)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_c *UserCreate) AddTeamGroupMemberIDs(ids ...uuid.UUID) *UserCreate {
+ _c.mutation.AddTeamGroupMemberIDs(ids...)
+ return _c
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_c *UserCreate) AddTeamGroupMembers(v ...*TeamGroupMember) *UserCreate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _c.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (_c *UserCreate) Mutation() *UserMutation {
+ return _c.mutation
+}
+
+// Save creates the User in the database.
+func (_c *UserCreate) Save(ctx context.Context) (*User, error) {
+ if err := _c.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *UserCreate) SaveX(ctx context.Context) *User {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *UserCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *UserCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *UserCreate) defaults() error {
+ if _, ok := _c.mutation.IsBlocked(); !ok {
+ v := user.DefaultIsBlocked
+ _c.mutation.SetIsBlocked(v)
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ if user.DefaultCreatedAt == nil {
+ return fmt.Errorf("db: uninitialized user.DefaultCreatedAt (forgotten import db/runtime?)")
+ }
+ v := user.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ if user.DefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized user.DefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := user.DefaultUpdatedAt()
+ _c.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *UserCreate) check() error {
+ if _, ok := _c.mutation.Name(); !ok {
+ return &ValidationError{Name: "name", err: errors.New(`db: missing required field "User.name"`)}
+ }
+ if v, ok := _c.mutation.Name(); ok {
+ if err := user.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "User.name": %w`, err)}
+ }
+ }
+ if _, ok := _c.mutation.Role(); !ok {
+ return &ValidationError{Name: "role", err: errors.New(`db: missing required field "User.role"`)}
+ }
+ if _, ok := _c.mutation.Status(); !ok {
+ return &ValidationError{Name: "status", err: errors.New(`db: missing required field "User.status"`)}
+ }
+ if _, ok := _c.mutation.IsBlocked(); !ok {
+ return &ValidationError{Name: "is_blocked", err: errors.New(`db: missing required field "User.is_blocked"`)}
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "User.created_at"`)}
+ }
+ if _, ok := _c.mutation.UpdatedAt(); !ok {
+ return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "User.updated_at"`)}
+ }
+ return nil
+}
+
+func (_c *UserCreate) sqlSave(ctx context.Context) (*User, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
+ var (
+ _node = &User{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.DeletedAt(); ok {
+ _spec.SetField(user.FieldDeletedAt, field.TypeTime, value)
+ _node.DeletedAt = value
+ }
+ if value, ok := _c.mutation.Name(); ok {
+ _spec.SetField(user.FieldName, field.TypeString, value)
+ _node.Name = value
+ }
+ if value, ok := _c.mutation.Email(); ok {
+ _spec.SetField(user.FieldEmail, field.TypeString, value)
+ _node.Email = value
+ }
+ if value, ok := _c.mutation.AvatarURL(); ok {
+ _spec.SetField(user.FieldAvatarURL, field.TypeString, value)
+ _node.AvatarURL = value
+ }
+ if value, ok := _c.mutation.Password(); ok {
+ _spec.SetField(user.FieldPassword, field.TypeString, value)
+ _node.Password = value
+ }
+ if value, ok := _c.mutation.Role(); ok {
+ _spec.SetField(user.FieldRole, field.TypeString, value)
+ _node.Role = value
+ }
+ if value, ok := _c.mutation.Status(); ok {
+ _spec.SetField(user.FieldStatus, field.TypeString, value)
+ _node.Status = value
+ }
+ if value, ok := _c.mutation.IsBlocked(); ok {
+ _spec.SetField(user.FieldIsBlocked, field.TypeBool, value)
+ _node.IsBlocked = value
+ }
+ if value, ok := _c.mutation.DefaultConfigs(); ok {
+ _spec.SetField(user.FieldDefaultConfigs, field.TypeJSON, value)
+ _node.DefaultConfigs = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(user.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if value, ok := _c.mutation.UpdatedAt(); ok {
+ _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
+ _node.UpdatedAt = value
+ }
+ if nodes := _c.mutation.IdentitiesIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.AuditsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _c.config, mutation: newTeamMemberMutation(_c.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _c.config, mutation: newTeamGroupMemberMutation(_c.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ if nodes := _c.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.User.Create().
+// SetDeletedAt(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.UserUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *UserCreate) OnConflict(opts ...sql.ConflictOption) *UserUpsertOne {
+ _c.conflict = opts
+ return &UserUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *UserCreate) OnConflictColumns(columns ...string) *UserUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &UserUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // UserUpsertOne is the builder for "upsert"-ing
+ // one User node.
+ UserUpsertOne struct {
+ create *UserCreate
+ }
+
+ // UserUpsert is the "OnConflict" setter.
+ UserUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserUpsert) SetDeletedAt(v time.Time) *UserUpsert {
+ u.Set(user.FieldDeletedAt, v)
+ return u
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserUpsert) UpdateDeletedAt() *UserUpsert {
+ u.SetExcluded(user.FieldDeletedAt)
+ return u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserUpsert) ClearDeletedAt() *UserUpsert {
+ u.SetNull(user.FieldDeletedAt)
+ return u
+}
+
+// SetName sets the "name" field.
+func (u *UserUpsert) SetName(v string) *UserUpsert {
+ u.Set(user.FieldName, v)
+ return u
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *UserUpsert) UpdateName() *UserUpsert {
+ u.SetExcluded(user.FieldName)
+ return u
+}
+
+// SetEmail sets the "email" field.
+func (u *UserUpsert) SetEmail(v string) *UserUpsert {
+ u.Set(user.FieldEmail, v)
+ return u
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserUpsert) UpdateEmail() *UserUpsert {
+ u.SetExcluded(user.FieldEmail)
+ return u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserUpsert) ClearEmail() *UserUpsert {
+ u.SetNull(user.FieldEmail)
+ return u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserUpsert) SetAvatarURL(v string) *UserUpsert {
+ u.Set(user.FieldAvatarURL, v)
+ return u
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserUpsert) UpdateAvatarURL() *UserUpsert {
+ u.SetExcluded(user.FieldAvatarURL)
+ return u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserUpsert) ClearAvatarURL() *UserUpsert {
+ u.SetNull(user.FieldAvatarURL)
+ return u
+}
+
+// SetPassword sets the "password" field.
+func (u *UserUpsert) SetPassword(v string) *UserUpsert {
+ u.Set(user.FieldPassword, v)
+ return u
+}
+
+// UpdatePassword sets the "password" field to the value that was provided on create.
+func (u *UserUpsert) UpdatePassword() *UserUpsert {
+ u.SetExcluded(user.FieldPassword)
+ return u
+}
+
+// ClearPassword clears the value of the "password" field.
+func (u *UserUpsert) ClearPassword() *UserUpsert {
+ u.SetNull(user.FieldPassword)
+ return u
+}
+
+// SetRole sets the "role" field.
+func (u *UserUpsert) SetRole(v consts.UserRole) *UserUpsert {
+ u.Set(user.FieldRole, v)
+ return u
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *UserUpsert) UpdateRole() *UserUpsert {
+ u.SetExcluded(user.FieldRole)
+ return u
+}
+
+// SetStatus sets the "status" field.
+func (u *UserUpsert) SetStatus(v consts.UserStatus) *UserUpsert {
+ u.Set(user.FieldStatus, v)
+ return u
+}
+
+// UpdateStatus sets the "status" field to the value that was provided on create.
+func (u *UserUpsert) UpdateStatus() *UserUpsert {
+ u.SetExcluded(user.FieldStatus)
+ return u
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (u *UserUpsert) SetIsBlocked(v bool) *UserUpsert {
+ u.Set(user.FieldIsBlocked, v)
+ return u
+}
+
+// UpdateIsBlocked sets the "is_blocked" field to the value that was provided on create.
+func (u *UserUpsert) UpdateIsBlocked() *UserUpsert {
+ u.SetExcluded(user.FieldIsBlocked)
+ return u
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (u *UserUpsert) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserUpsert {
+ u.Set(user.FieldDefaultConfigs, v)
+ return u
+}
+
+// UpdateDefaultConfigs sets the "default_configs" field to the value that was provided on create.
+func (u *UserUpsert) UpdateDefaultConfigs() *UserUpsert {
+ u.SetExcluded(user.FieldDefaultConfigs)
+ return u
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (u *UserUpsert) ClearDefaultConfigs() *UserUpsert {
+ u.SetNull(user.FieldDefaultConfigs)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserUpsert) SetCreatedAt(v time.Time) *UserUpsert {
+ u.Set(user.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserUpsert) UpdateCreatedAt() *UserUpsert {
+ u.SetExcluded(user.FieldCreatedAt)
+ return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserUpsert) SetUpdatedAt(v time.Time) *UserUpsert {
+ u.Set(user.FieldUpdatedAt, v)
+ return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserUpsert) UpdateUpdatedAt() *UserUpsert {
+ u.SetExcluded(user.FieldUpdatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(user.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *UserUpsertOne) UpdateNewValues() *UserUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(user.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *UserUpsertOne) Ignore() *UserUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *UserUpsertOne) DoNothing() *UserUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the UserCreate.OnConflict
+// documentation for more info.
+func (u *UserUpsertOne) Update(set func(*UserUpsert)) *UserUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&UserUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserUpsertOne) SetDeletedAt(v time.Time) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateDeletedAt() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserUpsertOne) ClearDeletedAt() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *UserUpsertOne) SetName(v string) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateName() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetEmail sets the "email" field.
+func (u *UserUpsertOne) SetEmail(v string) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetEmail(v)
+ })
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateEmail() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateEmail()
+ })
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserUpsertOne) ClearEmail() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearEmail()
+ })
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserUpsertOne) SetAvatarURL(v string) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetAvatarURL(v)
+ })
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateAvatarURL() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateAvatarURL()
+ })
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserUpsertOne) ClearAvatarURL() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearAvatarURL()
+ })
+}
+
+// SetPassword sets the "password" field.
+func (u *UserUpsertOne) SetPassword(v string) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetPassword(v)
+ })
+}
+
+// UpdatePassword sets the "password" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdatePassword() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdatePassword()
+ })
+}
+
+// ClearPassword clears the value of the "password" field.
+func (u *UserUpsertOne) ClearPassword() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearPassword()
+ })
+}
+
+// SetRole sets the "role" field.
+func (u *UserUpsertOne) SetRole(v consts.UserRole) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetRole(v)
+ })
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateRole() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateRole()
+ })
+}
+
+// SetStatus sets the "status" field.
+func (u *UserUpsertOne) SetStatus(v consts.UserStatus) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetStatus(v)
+ })
+}
+
+// UpdateStatus sets the "status" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateStatus() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateStatus()
+ })
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (u *UserUpsertOne) SetIsBlocked(v bool) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetIsBlocked(v)
+ })
+}
+
+// UpdateIsBlocked sets the "is_blocked" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateIsBlocked() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateIsBlocked()
+ })
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (u *UserUpsertOne) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetDefaultConfigs(v)
+ })
+}
+
+// UpdateDefaultConfigs sets the "default_configs" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateDefaultConfigs() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateDefaultConfigs()
+ })
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (u *UserUpsertOne) ClearDefaultConfigs() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearDefaultConfigs()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserUpsertOne) SetCreatedAt(v time.Time) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateCreatedAt() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserUpsertOne) SetUpdatedAt(v time.Time) *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserUpsertOne) UpdateUpdatedAt() *UserUpsertOne {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *UserUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for UserCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *UserUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *UserUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: UserUpsertOne.ID is not supported by MySQL driver. Use UserUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *UserUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// UserCreateBulk is the builder for creating many User entities in bulk.
+type UserCreateBulk struct {
+ config
+ err error
+ builders []*UserCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the User entities in the database.
+func (_c *UserCreateBulk) Save(ctx context.Context) ([]*User, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*User, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*UserMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *UserCreateBulk) SaveX(ctx context.Context) []*User {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *UserCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *UserCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.User.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.UserUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *UserCreateBulk) OnConflict(opts ...sql.ConflictOption) *UserUpsertBulk {
+ _c.conflict = opts
+ return &UserUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *UserCreateBulk) OnConflictColumns(columns ...string) *UserUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &UserUpsertBulk{
+ create: _c,
+ }
+}
+
+// UserUpsertBulk is the builder for "upsert"-ing
+// a bulk of User nodes.
+type UserUpsertBulk struct {
+ create *UserCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(user.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *UserUpsertBulk) UpdateNewValues() *UserUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(user.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.User.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *UserUpsertBulk) Ignore() *UserUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *UserUpsertBulk) DoNothing() *UserUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the UserCreateBulk.OnConflict
+// documentation for more info.
+func (u *UserUpsertBulk) Update(set func(*UserUpsert)) *UserUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&UserUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserUpsertBulk) SetDeletedAt(v time.Time) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateDeletedAt() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserUpsertBulk) ClearDeletedAt() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetName sets the "name" field.
+func (u *UserUpsertBulk) SetName(v string) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetName(v)
+ })
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateName() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateName()
+ })
+}
+
+// SetEmail sets the "email" field.
+func (u *UserUpsertBulk) SetEmail(v string) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetEmail(v)
+ })
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateEmail() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateEmail()
+ })
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserUpsertBulk) ClearEmail() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearEmail()
+ })
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserUpsertBulk) SetAvatarURL(v string) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetAvatarURL(v)
+ })
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateAvatarURL() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateAvatarURL()
+ })
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserUpsertBulk) ClearAvatarURL() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearAvatarURL()
+ })
+}
+
+// SetPassword sets the "password" field.
+func (u *UserUpsertBulk) SetPassword(v string) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetPassword(v)
+ })
+}
+
+// UpdatePassword sets the "password" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdatePassword() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdatePassword()
+ })
+}
+
+// ClearPassword clears the value of the "password" field.
+func (u *UserUpsertBulk) ClearPassword() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearPassword()
+ })
+}
+
+// SetRole sets the "role" field.
+func (u *UserUpsertBulk) SetRole(v consts.UserRole) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetRole(v)
+ })
+}
+
+// UpdateRole sets the "role" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateRole() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateRole()
+ })
+}
+
+// SetStatus sets the "status" field.
+func (u *UserUpsertBulk) SetStatus(v consts.UserStatus) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetStatus(v)
+ })
+}
+
+// UpdateStatus sets the "status" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateStatus() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateStatus()
+ })
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (u *UserUpsertBulk) SetIsBlocked(v bool) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetIsBlocked(v)
+ })
+}
+
+// UpdateIsBlocked sets the "is_blocked" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateIsBlocked() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateIsBlocked()
+ })
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (u *UserUpsertBulk) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetDefaultConfigs(v)
+ })
+}
+
+// UpdateDefaultConfigs sets the "default_configs" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateDefaultConfigs() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateDefaultConfigs()
+ })
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (u *UserUpsertBulk) ClearDefaultConfigs() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.ClearDefaultConfigs()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserUpsertBulk) SetCreatedAt(v time.Time) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateCreatedAt() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserUpsertBulk) SetUpdatedAt(v time.Time) *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserUpsertBulk) UpdateUpdatedAt() *UserUpsertBulk {
+ return u.Update(func(s *UserUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *UserUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the UserCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for UserCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *UserUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/user_delete.go b/backend/db/user_delete.go
new file mode 100644
index 00000000..907e0228
--- /dev/null
+++ b/backend/db/user_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+)
+
+// UserDelete is the builder for deleting a User entity.
+type UserDelete struct {
+ config
+ hooks []Hook
+ mutation *UserMutation
+}
+
+// Where appends a list predicates to the UserDelete builder.
+func (_d *UserDelete) Where(ps ...predicate.User) *UserDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *UserDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *UserDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *UserDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(user.Table, sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// UserDeleteOne is the builder for deleting a single User entity.
+type UserDeleteOne struct {
+ _d *UserDelete
+}
+
+// Where appends a list predicates to the UserDelete builder.
+func (_d *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *UserDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{user.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *UserDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/user_query.go b/backend/db/user_query.go
new file mode 100644
index 00000000..a2396ee7
--- /dev/null
+++ b/backend/db/user_query.go
@@ -0,0 +1,1089 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "database/sql/driver"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserQuery is the builder for querying User entities.
+type UserQuery struct {
+ config
+ ctx *QueryContext
+ order []user.OrderOption
+ inters []Interceptor
+ predicates []predicate.User
+ withIdentities *UserIdentityQuery
+ withAudits *AuditQuery
+ withTeams *TeamQuery
+ withGroups *TeamGroupQuery
+ withTeamMembers *TeamMemberQuery
+ withTeamGroupMembers *TeamGroupMemberQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserQuery builder.
+func (_q *UserQuery) Where(ps ...predicate.User) *UserQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *UserQuery) Limit(limit int) *UserQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *UserQuery) Offset(offset int) *UserQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *UserQuery) Unique(unique bool) *UserQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *UserQuery) Order(o ...user.OrderOption) *UserQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryIdentities chains the current query on the "identities" edge.
+func (_q *UserQuery) QueryIdentities() *UserIdentityQuery {
+ query := (&UserIdentityClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(useridentity.Table, useridentity.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, user.IdentitiesTable, user.IdentitiesColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryAudits chains the current query on the "audits" edge.
+func (_q *UserQuery) QueryAudits() *AuditQuery {
+ query := (&AuditClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(audit.Table, audit.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, false, user.AuditsTable, user.AuditsColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeams chains the current query on the "teams" edge.
+func (_q *UserQuery) QueryTeams() *TeamQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(team.Table, team.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, user.TeamsTable, user.TeamsPrimaryKey...),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryGroups chains the current query on the "groups" edge.
+func (_q *UserQuery) QueryGroups() *TeamGroupQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
+ sqlgraph.Edge(sqlgraph.M2M, false, user.GroupsTable, user.GroupsPrimaryKey...),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeamMembers chains the current query on the "team_members" edge.
+func (_q *UserQuery) QueryTeamMembers() *TeamMemberQuery {
+ query := (&TeamMemberClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(teammember.Table, teammember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, user.TeamMembersTable, user.TeamMembersColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// QueryTeamGroupMembers chains the current query on the "team_group_members" edge.
+func (_q *UserQuery) QueryTeamGroupMembers() *TeamGroupMemberQuery {
+ query := (&TeamGroupMemberClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(user.Table, user.FieldID, selector),
+ sqlgraph.To(teamgroupmember.Table, teamgroupmember.FieldID),
+ sqlgraph.Edge(sqlgraph.O2M, true, user.TeamGroupMembersTable, user.TeamGroupMembersColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first User entity from the query.
+// Returns a *NotFoundError when no User was found.
+func (_q *UserQuery) First(ctx context.Context) (*User, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{user.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *UserQuery) FirstX(ctx context.Context) *User {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first User ID from the query.
+// Returns a *NotFoundError when no User ID was found.
+func (_q *UserQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{user.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *UserQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single User entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one User entity is found.
+// Returns a *NotFoundError when no User entities are found.
+func (_q *UserQuery) Only(ctx context.Context) (*User, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{user.Label}
+ default:
+ return nil, &NotSingularError{user.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *UserQuery) OnlyX(ctx context.Context) *User {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only User ID in the query.
+// Returns a *NotSingularError when more than one User ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *UserQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{user.Label}
+ default:
+ err = &NotSingularError{user.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *UserQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of Users.
+func (_q *UserQuery) All(ctx context.Context) ([]*User, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*User, *UserQuery]()
+ return withInterceptors[[]*User](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *UserQuery) AllX(ctx context.Context) []*User {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of User IDs.
+func (_q *UserQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(user.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *UserQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *UserQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*UserQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *UserQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *UserQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *UserQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the UserQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *UserQuery) Clone() *UserQuery {
+ if _q == nil {
+ return nil
+ }
+ return &UserQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]user.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.User{}, _q.predicates...),
+ withIdentities: _q.withIdentities.Clone(),
+ withAudits: _q.withAudits.Clone(),
+ withTeams: _q.withTeams.Clone(),
+ withGroups: _q.withGroups.Clone(),
+ withTeamMembers: _q.withTeamMembers.Clone(),
+ withTeamGroupMembers: _q.withTeamGroupMembers.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithIdentities tells the query-builder to eager-load the nodes that are connected to
+// the "identities" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithIdentities(opts ...func(*UserIdentityQuery)) *UserQuery {
+ query := (&UserIdentityClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withIdentities = query
+ return _q
+}
+
+// WithAudits tells the query-builder to eager-load the nodes that are connected to
+// the "audits" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithAudits(opts ...func(*AuditQuery)) *UserQuery {
+ query := (&AuditClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withAudits = query
+ return _q
+}
+
+// WithTeams tells the query-builder to eager-load the nodes that are connected to
+// the "teams" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithTeams(opts ...func(*TeamQuery)) *UserQuery {
+ query := (&TeamClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeams = query
+ return _q
+}
+
+// WithGroups tells the query-builder to eager-load the nodes that are connected to
+// the "groups" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithGroups(opts ...func(*TeamGroupQuery)) *UserQuery {
+ query := (&TeamGroupClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withGroups = query
+ return _q
+}
+
+// WithTeamMembers tells the query-builder to eager-load the nodes that are connected to
+// the "team_members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithTeamMembers(opts ...func(*TeamMemberQuery)) *UserQuery {
+ query := (&TeamMemberClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeamMembers = query
+ return _q
+}
+
+// WithTeamGroupMembers tells the query-builder to eager-load the nodes that are connected to
+// the "team_group_members" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserQuery) WithTeamGroupMembers(opts ...func(*TeamGroupMemberQuery)) *UserQuery {
+ query := (&TeamGroupMemberClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withTeamGroupMembers = query
+ return _q
+}
+
+// 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.User.Query().
+// GroupBy(user.FieldDeletedAt).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &UserGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = user.Label
+ grbuild.scan = 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// }
+//
+// client.User.Query().
+// Select(user.FieldDeletedAt).
+// Scan(ctx, &v)
+func (_q *UserQuery) Select(fields ...string) *UserSelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &UserSelect{UserQuery: _q}
+ sbuild.label = user.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a UserSelect configured with the given aggregations.
+func (_q *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *UserQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !user.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, error) {
+ var (
+ nodes = []*User{}
+ _spec = _q.querySpec()
+ loadedTypes = [6]bool{
+ _q.withIdentities != nil,
+ _q.withAudits != nil,
+ _q.withTeams != nil,
+ _q.withGroups != nil,
+ _q.withTeamMembers != nil,
+ _q.withTeamGroupMembers != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*User).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &User{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withIdentities; query != nil {
+ if err := _q.loadIdentities(ctx, query, nodes,
+ func(n *User) { n.Edges.Identities = []*UserIdentity{} },
+ func(n *User, e *UserIdentity) { n.Edges.Identities = append(n.Edges.Identities, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withAudits; query != nil {
+ if err := _q.loadAudits(ctx, query, nodes,
+ func(n *User) { n.Edges.Audits = []*Audit{} },
+ func(n *User, e *Audit) { n.Edges.Audits = append(n.Edges.Audits, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeams; query != nil {
+ if err := _q.loadTeams(ctx, query, nodes,
+ func(n *User) { n.Edges.Teams = []*Team{} },
+ func(n *User, e *Team) { n.Edges.Teams = append(n.Edges.Teams, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withGroups; query != nil {
+ if err := _q.loadGroups(ctx, query, nodes,
+ func(n *User) { n.Edges.Groups = []*TeamGroup{} },
+ func(n *User, e *TeamGroup) { n.Edges.Groups = append(n.Edges.Groups, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeamMembers; query != nil {
+ if err := _q.loadTeamMembers(ctx, query, nodes,
+ func(n *User) { n.Edges.TeamMembers = []*TeamMember{} },
+ func(n *User, e *TeamMember) { n.Edges.TeamMembers = append(n.Edges.TeamMembers, e) }); err != nil {
+ return nil, err
+ }
+ }
+ if query := _q.withTeamGroupMembers; query != nil {
+ if err := _q.loadTeamGroupMembers(ctx, query, nodes,
+ func(n *User) { n.Edges.TeamGroupMembers = []*TeamGroupMember{} },
+ func(n *User, e *TeamGroupMember) { n.Edges.TeamGroupMembers = append(n.Edges.TeamGroupMembers, e) }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *UserQuery) loadIdentities(ctx context.Context, query *UserIdentityQuery, nodes []*User, init func(*User), assign func(*User, *UserIdentity)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*User)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(useridentity.FieldUserID)
+ }
+ query.Where(predicate.UserIdentity(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(user.IdentitiesColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.UserID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+func (_q *UserQuery) loadAudits(ctx context.Context, query *AuditQuery, nodes []*User, init func(*User), assign func(*User, *Audit)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*User)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(audit.FieldUserID)
+ }
+ query.Where(predicate.Audit(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(user.AuditsColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.UserID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+func (_q *UserQuery) loadTeams(ctx context.Context, query *TeamQuery, nodes []*User, init func(*User), assign func(*User, *Team)) error {
+ edgeIDs := make([]driver.Value, len(nodes))
+ byID := make(map[uuid.UUID]*User)
+ nids := make(map[uuid.UUID]map[*User]struct{})
+ for i, node := range nodes {
+ edgeIDs[i] = node.ID
+ byID[node.ID] = node
+ if init != nil {
+ init(node)
+ }
+ }
+ query.Where(func(s *sql.Selector) {
+ joinT := sql.Table(user.TeamsTable)
+ s.Join(joinT).On(s.C(team.FieldID), joinT.C(user.TeamsPrimaryKey[1]))
+ s.Where(sql.InValues(joinT.C(user.TeamsPrimaryKey[0]), edgeIDs...))
+ columns := s.SelectedColumns()
+ s.Select(joinT.C(user.TeamsPrimaryKey[0]))
+ s.AppendSelect(columns...)
+ s.SetDistinct(false)
+ })
+ if err := query.prepareQuery(ctx); err != nil {
+ return err
+ }
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
+ }
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*User]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
+ }
+ })
+ })
+ neighbors, err := withInterceptors[[]*Team](ctx, query, qr, query.inters)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected "teams" node returned %v`, n.ID)
+ }
+ for kn := range nodes {
+ assign(kn, n)
+ }
+ }
+ return nil
+}
+func (_q *UserQuery) loadGroups(ctx context.Context, query *TeamGroupQuery, nodes []*User, init func(*User), assign func(*User, *TeamGroup)) error {
+ edgeIDs := make([]driver.Value, len(nodes))
+ byID := make(map[uuid.UUID]*User)
+ nids := make(map[uuid.UUID]map[*User]struct{})
+ for i, node := range nodes {
+ edgeIDs[i] = node.ID
+ byID[node.ID] = node
+ if init != nil {
+ init(node)
+ }
+ }
+ query.Where(func(s *sql.Selector) {
+ joinT := sql.Table(user.GroupsTable)
+ s.Join(joinT).On(s.C(teamgroup.FieldID), joinT.C(user.GroupsPrimaryKey[1]))
+ s.Where(sql.InValues(joinT.C(user.GroupsPrimaryKey[0]), edgeIDs...))
+ columns := s.SelectedColumns()
+ s.Select(joinT.C(user.GroupsPrimaryKey[0]))
+ s.AppendSelect(columns...)
+ s.SetDistinct(false)
+ })
+ if err := query.prepareQuery(ctx); err != nil {
+ return err
+ }
+ qr := QuerierFunc(func(ctx context.Context, q Query) (Value, error) {
+ return query.sqlAll(ctx, func(_ context.Context, spec *sqlgraph.QuerySpec) {
+ assign := spec.Assign
+ values := spec.ScanValues
+ spec.ScanValues = func(columns []string) ([]any, error) {
+ values, err := values(columns[1:])
+ if err != nil {
+ return nil, err
+ }
+ return append([]any{new(uuid.UUID)}, values...), nil
+ }
+ spec.Assign = func(columns []string, values []any) error {
+ outValue := *values[0].(*uuid.UUID)
+ inValue := *values[1].(*uuid.UUID)
+ if nids[inValue] == nil {
+ nids[inValue] = map[*User]struct{}{byID[outValue]: {}}
+ return assign(columns[1:], values[1:])
+ }
+ nids[inValue][byID[outValue]] = struct{}{}
+ return nil
+ }
+ })
+ })
+ neighbors, err := withInterceptors[[]*TeamGroup](ctx, query, qr, query.inters)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected "groups" node returned %v`, n.ID)
+ }
+ for kn := range nodes {
+ assign(kn, n)
+ }
+ }
+ return nil
+}
+func (_q *UserQuery) loadTeamMembers(ctx context.Context, query *TeamMemberQuery, nodes []*User, init func(*User), assign func(*User, *TeamMember)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*User)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(teammember.FieldUserID)
+ }
+ query.Where(predicate.TeamMember(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(user.TeamMembersColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.UserID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+func (_q *UserQuery) loadTeamGroupMembers(ctx context.Context, query *TeamGroupMemberQuery, nodes []*User, init func(*User), assign func(*User, *TeamGroupMember)) error {
+ fks := make([]driver.Value, 0, len(nodes))
+ nodeids := make(map[uuid.UUID]*User)
+ for i := range nodes {
+ fks = append(fks, nodes[i].ID)
+ nodeids[nodes[i].ID] = nodes[i]
+ if init != nil {
+ init(nodes[i])
+ }
+ }
+ if len(query.ctx.Fields) > 0 {
+ query.ctx.AppendFieldOnce(teamgroupmember.FieldUserID)
+ }
+ query.Where(predicate.TeamGroupMember(func(s *sql.Selector) {
+ s.Where(sql.InValues(s.C(user.TeamGroupMembersColumn), fks...))
+ }))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ fk := n.UserID
+ node, ok := nodeids[fk]
+ if !ok {
+ return fmt.Errorf(`unexpected referenced foreign-key "user_id" returned %v for node %v`, fk, n.ID)
+ }
+ assign(node, n)
+ }
+ return nil
+}
+
+func (_q *UserQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *UserQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
+ for i := range fields {
+ if fields[i] != user.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *UserQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(user.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = user.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *UserQuery) ForUpdate(opts ...sql.LockOption) *UserQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *UserQuery) ForShare(opts ...sql.LockOption) *UserQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *UserQuery) Modify(modifiers ...func(s *sql.Selector)) *UserSelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// UserGroupBy is the group-by builder for User entities.
+type UserGroupBy struct {
+ selector
+ build *UserQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *UserGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*UserQuery, *UserGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *UserGroupBy) sqlScan(ctx context.Context, root *UserQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// UserSelect is the builder for selecting fields of User entities.
+type UserSelect struct {
+ *UserQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *UserSelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*UserQuery, *UserSelect](ctx, _s.UserQuery, _s, _s.inters, v)
+}
+
+func (_s *UserSelect) sqlScan(ctx context.Context, root *UserQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *UserSelect) Modify(modifiers ...func(s *sql.Selector)) *UserSelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/user_update.go b/backend/db/user_update.go
new file mode 100644
index 00000000..bd6f755c
--- /dev/null
+++ b/backend/db/user_update.go
@@ -0,0 +1,1708 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/audit"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/team"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroup"
+ "github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
+ "github.com/chaitin/MonkeyCode/backend/db/teammember"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserUpdate is the builder for updating User entities.
+type UserUpdate struct {
+ config
+ hooks []Hook
+ mutation *UserMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the UserUpdate builder.
+func (_u *UserUpdate) Where(ps ...predicate.User) *UserUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *UserUpdate) SetDeletedAt(v time.Time) *UserUpdate {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableDeletedAt(v *time.Time) *UserUpdate {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *UserUpdate) ClearDeletedAt() *UserUpdate {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *UserUpdate) SetName(v string) *UserUpdate {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableName(v *string) *UserUpdate {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetEmail sets the "email" field.
+func (_u *UserUpdate) SetEmail(v string) *UserUpdate {
+ _u.mutation.SetEmail(v)
+ return _u
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableEmail(v *string) *UserUpdate {
+ if v != nil {
+ _u.SetEmail(*v)
+ }
+ return _u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (_u *UserUpdate) ClearEmail() *UserUpdate {
+ _u.mutation.ClearEmail()
+ return _u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_u *UserUpdate) SetAvatarURL(v string) *UserUpdate {
+ _u.mutation.SetAvatarURL(v)
+ return _u
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableAvatarURL(v *string) *UserUpdate {
+ if v != nil {
+ _u.SetAvatarURL(*v)
+ }
+ return _u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (_u *UserUpdate) ClearAvatarURL() *UserUpdate {
+ _u.mutation.ClearAvatarURL()
+ return _u
+}
+
+// SetPassword sets the "password" field.
+func (_u *UserUpdate) SetPassword(v string) *UserUpdate {
+ _u.mutation.SetPassword(v)
+ return _u
+}
+
+// SetNillablePassword sets the "password" field if the given value is not nil.
+func (_u *UserUpdate) SetNillablePassword(v *string) *UserUpdate {
+ if v != nil {
+ _u.SetPassword(*v)
+ }
+ return _u
+}
+
+// ClearPassword clears the value of the "password" field.
+func (_u *UserUpdate) ClearPassword() *UserUpdate {
+ _u.mutation.ClearPassword()
+ return _u
+}
+
+// SetRole sets the "role" field.
+func (_u *UserUpdate) SetRole(v consts.UserRole) *UserUpdate {
+ _u.mutation.SetRole(v)
+ return _u
+}
+
+// SetNillableRole sets the "role" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableRole(v *consts.UserRole) *UserUpdate {
+ if v != nil {
+ _u.SetRole(*v)
+ }
+ return _u
+}
+
+// SetStatus sets the "status" field.
+func (_u *UserUpdate) SetStatus(v consts.UserStatus) *UserUpdate {
+ _u.mutation.SetStatus(v)
+ return _u
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableStatus(v *consts.UserStatus) *UserUpdate {
+ if v != nil {
+ _u.SetStatus(*v)
+ }
+ return _u
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (_u *UserUpdate) SetIsBlocked(v bool) *UserUpdate {
+ _u.mutation.SetIsBlocked(v)
+ return _u
+}
+
+// SetNillableIsBlocked sets the "is_blocked" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableIsBlocked(v *bool) *UserUpdate {
+ if v != nil {
+ _u.SetIsBlocked(*v)
+ }
+ return _u
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (_u *UserUpdate) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserUpdate {
+ _u.mutation.SetDefaultConfigs(v)
+ return _u
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (_u *UserUpdate) ClearDefaultConfigs() *UserUpdate {
+ _u.mutation.ClearDefaultConfigs()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *UserUpdate) SetCreatedAt(v time.Time) *UserUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *UserUpdate) SetNillableCreatedAt(v *time.Time) *UserUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *UserUpdate) SetUpdatedAt(v time.Time) *UserUpdate {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// AddIdentityIDs adds the "identities" edge to the UserIdentity entity by IDs.
+func (_u *UserUpdate) AddIdentityIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddIdentityIDs(ids...)
+ return _u
+}
+
+// AddIdentities adds the "identities" edges to the UserIdentity entity.
+func (_u *UserUpdate) AddIdentities(v ...*UserIdentity) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddIdentityIDs(ids...)
+}
+
+// AddAuditIDs adds the "audits" edge to the Audit entity by IDs.
+func (_u *UserUpdate) AddAuditIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddAuditIDs(ids...)
+ return _u
+}
+
+// AddAudits adds the "audits" edges to the Audit entity.
+func (_u *UserUpdate) AddAudits(v ...*Audit) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddAuditIDs(ids...)
+}
+
+// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
+func (_u *UserUpdate) AddTeamIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddTeamIDs(ids...)
+ return _u
+}
+
+// AddTeams adds the "teams" edges to the Team entity.
+func (_u *UserUpdate) AddTeams(v ...*Team) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamIDs(ids...)
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_u *UserUpdate) AddGroupIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddGroupIDs(ids...)
+ return _u
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_u *UserUpdate) AddGroups(v ...*TeamGroup) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddGroupIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_u *UserUpdate) AddTeamMemberIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddTeamMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_u *UserUpdate) AddTeamMembers(v ...*TeamMember) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamMemberIDs(ids...)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_u *UserUpdate) AddTeamGroupMemberIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.AddTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_u *UserUpdate) AddTeamGroupMembers(v ...*TeamGroupMember) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (_u *UserUpdate) Mutation() *UserMutation {
+ return _u.mutation
+}
+
+// ClearIdentities clears all "identities" edges to the UserIdentity entity.
+func (_u *UserUpdate) ClearIdentities() *UserUpdate {
+ _u.mutation.ClearIdentities()
+ return _u
+}
+
+// RemoveIdentityIDs removes the "identities" edge to UserIdentity entities by IDs.
+func (_u *UserUpdate) RemoveIdentityIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveIdentityIDs(ids...)
+ return _u
+}
+
+// RemoveIdentities removes "identities" edges to UserIdentity entities.
+func (_u *UserUpdate) RemoveIdentities(v ...*UserIdentity) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveIdentityIDs(ids...)
+}
+
+// ClearAudits clears all "audits" edges to the Audit entity.
+func (_u *UserUpdate) ClearAudits() *UserUpdate {
+ _u.mutation.ClearAudits()
+ return _u
+}
+
+// RemoveAuditIDs removes the "audits" edge to Audit entities by IDs.
+func (_u *UserUpdate) RemoveAuditIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveAuditIDs(ids...)
+ return _u
+}
+
+// RemoveAudits removes "audits" edges to Audit entities.
+func (_u *UserUpdate) RemoveAudits(v ...*Audit) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveAuditIDs(ids...)
+}
+
+// ClearTeams clears all "teams" edges to the Team entity.
+func (_u *UserUpdate) ClearTeams() *UserUpdate {
+ _u.mutation.ClearTeams()
+ return _u
+}
+
+// RemoveTeamIDs removes the "teams" edge to Team entities by IDs.
+func (_u *UserUpdate) RemoveTeamIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveTeamIDs(ids...)
+ return _u
+}
+
+// RemoveTeams removes "teams" edges to Team entities.
+func (_u *UserUpdate) RemoveTeams(v ...*Team) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamIDs(ids...)
+}
+
+// ClearGroups clears all "groups" edges to the TeamGroup entity.
+func (_u *UserUpdate) ClearGroups() *UserUpdate {
+ _u.mutation.ClearGroups()
+ return _u
+}
+
+// RemoveGroupIDs removes the "groups" edge to TeamGroup entities by IDs.
+func (_u *UserUpdate) RemoveGroupIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveGroupIDs(ids...)
+ return _u
+}
+
+// RemoveGroups removes "groups" edges to TeamGroup entities.
+func (_u *UserUpdate) RemoveGroups(v ...*TeamGroup) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveGroupIDs(ids...)
+}
+
+// ClearTeamMembers clears all "team_members" edges to the TeamMember entity.
+func (_u *UserUpdate) ClearTeamMembers() *UserUpdate {
+ _u.mutation.ClearTeamMembers()
+ return _u
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to TeamMember entities by IDs.
+func (_u *UserUpdate) RemoveTeamMemberIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveTeamMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamMembers removes "team_members" edges to TeamMember entities.
+func (_u *UserUpdate) RemoveTeamMembers(v ...*TeamMember) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamMemberIDs(ids...)
+}
+
+// ClearTeamGroupMembers clears all "team_group_members" edges to the TeamGroupMember entity.
+func (_u *UserUpdate) ClearTeamGroupMembers() *UserUpdate {
+ _u.mutation.ClearTeamGroupMembers()
+ return _u
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to TeamGroupMember entities by IDs.
+func (_u *UserUpdate) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) *UserUpdate {
+ _u.mutation.RemoveTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamGroupMembers removes "team_group_members" edges to TeamGroupMember entities.
+func (_u *UserUpdate) RemoveTeamGroupMembers(v ...*TeamGroupMember) *UserUpdate {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamGroupMemberIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *UserUpdate) Save(ctx context.Context) (int, error) {
+ if err := _u.defaults(); err != nil {
+ return 0, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *UserUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *UserUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *UserUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *UserUpdate) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok {
+ if user.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized user.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := user.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *UserUpdate) check() error {
+ if v, ok := _u.mutation.Name(); ok {
+ if err := user.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "User.name": %w`, err)}
+ }
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *UserUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *UserUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(user.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(user.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(user.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Email(); ok {
+ _spec.SetField(user.FieldEmail, field.TypeString, value)
+ }
+ if _u.mutation.EmailCleared() {
+ _spec.ClearField(user.FieldEmail, field.TypeString)
+ }
+ if value, ok := _u.mutation.AvatarURL(); ok {
+ _spec.SetField(user.FieldAvatarURL, field.TypeString, value)
+ }
+ if _u.mutation.AvatarURLCleared() {
+ _spec.ClearField(user.FieldAvatarURL, field.TypeString)
+ }
+ if value, ok := _u.mutation.Password(); ok {
+ _spec.SetField(user.FieldPassword, field.TypeString, value)
+ }
+ if _u.mutation.PasswordCleared() {
+ _spec.ClearField(user.FieldPassword, field.TypeString)
+ }
+ if value, ok := _u.mutation.Role(); ok {
+ _spec.SetField(user.FieldRole, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Status(); ok {
+ _spec.SetField(user.FieldStatus, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.IsBlocked(); ok {
+ _spec.SetField(user.FieldIsBlocked, field.TypeBool, value)
+ }
+ if value, ok := _u.mutation.DefaultConfigs(); ok {
+ _spec.SetField(user.FieldDefaultConfigs, field.TypeJSON, value)
+ }
+ if _u.mutation.DefaultConfigsCleared() {
+ _spec.ClearField(user.FieldDefaultConfigs, field.TypeJSON)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(user.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.IdentitiesCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedIdentitiesIDs(); len(nodes) > 0 && !_u.mutation.IdentitiesCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.IdentitiesIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.AuditsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedAuditsIDs(); len(nodes) > 0 && !_u.mutation.AuditsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.AuditsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamsIDs(); len(nodes) > 0 && !_u.mutation.TeamsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedGroupsIDs(); len(nodes) > 0 && !_u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamGroupMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{user.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// UserUpdateOne is the builder for updating a single User entity.
+type UserUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *UserMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *UserUpdateOne) SetDeletedAt(v time.Time) *UserUpdateOne {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableDeletedAt(v *time.Time) *UserUpdateOne {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *UserUpdateOne) ClearDeletedAt() *UserUpdateOne {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetName sets the "name" field.
+func (_u *UserUpdateOne) SetName(v string) *UserUpdateOne {
+ _u.mutation.SetName(v)
+ return _u
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableName(v *string) *UserUpdateOne {
+ if v != nil {
+ _u.SetName(*v)
+ }
+ return _u
+}
+
+// SetEmail sets the "email" field.
+func (_u *UserUpdateOne) SetEmail(v string) *UserUpdateOne {
+ _u.mutation.SetEmail(v)
+ return _u
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableEmail(v *string) *UserUpdateOne {
+ if v != nil {
+ _u.SetEmail(*v)
+ }
+ return _u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (_u *UserUpdateOne) ClearEmail() *UserUpdateOne {
+ _u.mutation.ClearEmail()
+ return _u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_u *UserUpdateOne) SetAvatarURL(v string) *UserUpdateOne {
+ _u.mutation.SetAvatarURL(v)
+ return _u
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableAvatarURL(v *string) *UserUpdateOne {
+ if v != nil {
+ _u.SetAvatarURL(*v)
+ }
+ return _u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (_u *UserUpdateOne) ClearAvatarURL() *UserUpdateOne {
+ _u.mutation.ClearAvatarURL()
+ return _u
+}
+
+// SetPassword sets the "password" field.
+func (_u *UserUpdateOne) SetPassword(v string) *UserUpdateOne {
+ _u.mutation.SetPassword(v)
+ return _u
+}
+
+// SetNillablePassword sets the "password" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillablePassword(v *string) *UserUpdateOne {
+ if v != nil {
+ _u.SetPassword(*v)
+ }
+ return _u
+}
+
+// ClearPassword clears the value of the "password" field.
+func (_u *UserUpdateOne) ClearPassword() *UserUpdateOne {
+ _u.mutation.ClearPassword()
+ return _u
+}
+
+// SetRole sets the "role" field.
+func (_u *UserUpdateOne) SetRole(v consts.UserRole) *UserUpdateOne {
+ _u.mutation.SetRole(v)
+ return _u
+}
+
+// SetNillableRole sets the "role" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableRole(v *consts.UserRole) *UserUpdateOne {
+ if v != nil {
+ _u.SetRole(*v)
+ }
+ return _u
+}
+
+// SetStatus sets the "status" field.
+func (_u *UserUpdateOne) SetStatus(v consts.UserStatus) *UserUpdateOne {
+ _u.mutation.SetStatus(v)
+ return _u
+}
+
+// SetNillableStatus sets the "status" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableStatus(v *consts.UserStatus) *UserUpdateOne {
+ if v != nil {
+ _u.SetStatus(*v)
+ }
+ return _u
+}
+
+// SetIsBlocked sets the "is_blocked" field.
+func (_u *UserUpdateOne) SetIsBlocked(v bool) *UserUpdateOne {
+ _u.mutation.SetIsBlocked(v)
+ return _u
+}
+
+// SetNillableIsBlocked sets the "is_blocked" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableIsBlocked(v *bool) *UserUpdateOne {
+ if v != nil {
+ _u.SetIsBlocked(*v)
+ }
+ return _u
+}
+
+// SetDefaultConfigs sets the "default_configs" field.
+func (_u *UserUpdateOne) SetDefaultConfigs(v map[consts.DefaultConfigType]uuid.UUID) *UserUpdateOne {
+ _u.mutation.SetDefaultConfigs(v)
+ return _u
+}
+
+// ClearDefaultConfigs clears the value of the "default_configs" field.
+func (_u *UserUpdateOne) ClearDefaultConfigs() *UserUpdateOne {
+ _u.mutation.ClearDefaultConfigs()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *UserUpdateOne) SetCreatedAt(v time.Time) *UserUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *UserUpdateOne) SetNillableCreatedAt(v *time.Time) *UserUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *UserUpdateOne) SetUpdatedAt(v time.Time) *UserUpdateOne {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// AddIdentityIDs adds the "identities" edge to the UserIdentity entity by IDs.
+func (_u *UserUpdateOne) AddIdentityIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddIdentityIDs(ids...)
+ return _u
+}
+
+// AddIdentities adds the "identities" edges to the UserIdentity entity.
+func (_u *UserUpdateOne) AddIdentities(v ...*UserIdentity) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddIdentityIDs(ids...)
+}
+
+// AddAuditIDs adds the "audits" edge to the Audit entity by IDs.
+func (_u *UserUpdateOne) AddAuditIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddAuditIDs(ids...)
+ return _u
+}
+
+// AddAudits adds the "audits" edges to the Audit entity.
+func (_u *UserUpdateOne) AddAudits(v ...*Audit) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddAuditIDs(ids...)
+}
+
+// AddTeamIDs adds the "teams" edge to the Team entity by IDs.
+func (_u *UserUpdateOne) AddTeamIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddTeamIDs(ids...)
+ return _u
+}
+
+// AddTeams adds the "teams" edges to the Team entity.
+func (_u *UserUpdateOne) AddTeams(v ...*Team) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamIDs(ids...)
+}
+
+// AddGroupIDs adds the "groups" edge to the TeamGroup entity by IDs.
+func (_u *UserUpdateOne) AddGroupIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddGroupIDs(ids...)
+ return _u
+}
+
+// AddGroups adds the "groups" edges to the TeamGroup entity.
+func (_u *UserUpdateOne) AddGroups(v ...*TeamGroup) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddGroupIDs(ids...)
+}
+
+// AddTeamMemberIDs adds the "team_members" edge to the TeamMember entity by IDs.
+func (_u *UserUpdateOne) AddTeamMemberIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddTeamMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamMembers adds the "team_members" edges to the TeamMember entity.
+func (_u *UserUpdateOne) AddTeamMembers(v ...*TeamMember) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamMemberIDs(ids...)
+}
+
+// AddTeamGroupMemberIDs adds the "team_group_members" edge to the TeamGroupMember entity by IDs.
+func (_u *UserUpdateOne) AddTeamGroupMemberIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.AddTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// AddTeamGroupMembers adds the "team_group_members" edges to the TeamGroupMember entity.
+func (_u *UserUpdateOne) AddTeamGroupMembers(v ...*TeamGroupMember) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.AddTeamGroupMemberIDs(ids...)
+}
+
+// Mutation returns the UserMutation object of the builder.
+func (_u *UserUpdateOne) Mutation() *UserMutation {
+ return _u.mutation
+}
+
+// ClearIdentities clears all "identities" edges to the UserIdentity entity.
+func (_u *UserUpdateOne) ClearIdentities() *UserUpdateOne {
+ _u.mutation.ClearIdentities()
+ return _u
+}
+
+// RemoveIdentityIDs removes the "identities" edge to UserIdentity entities by IDs.
+func (_u *UserUpdateOne) RemoveIdentityIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveIdentityIDs(ids...)
+ return _u
+}
+
+// RemoveIdentities removes "identities" edges to UserIdentity entities.
+func (_u *UserUpdateOne) RemoveIdentities(v ...*UserIdentity) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveIdentityIDs(ids...)
+}
+
+// ClearAudits clears all "audits" edges to the Audit entity.
+func (_u *UserUpdateOne) ClearAudits() *UserUpdateOne {
+ _u.mutation.ClearAudits()
+ return _u
+}
+
+// RemoveAuditIDs removes the "audits" edge to Audit entities by IDs.
+func (_u *UserUpdateOne) RemoveAuditIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveAuditIDs(ids...)
+ return _u
+}
+
+// RemoveAudits removes "audits" edges to Audit entities.
+func (_u *UserUpdateOne) RemoveAudits(v ...*Audit) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveAuditIDs(ids...)
+}
+
+// ClearTeams clears all "teams" edges to the Team entity.
+func (_u *UserUpdateOne) ClearTeams() *UserUpdateOne {
+ _u.mutation.ClearTeams()
+ return _u
+}
+
+// RemoveTeamIDs removes the "teams" edge to Team entities by IDs.
+func (_u *UserUpdateOne) RemoveTeamIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveTeamIDs(ids...)
+ return _u
+}
+
+// RemoveTeams removes "teams" edges to Team entities.
+func (_u *UserUpdateOne) RemoveTeams(v ...*Team) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamIDs(ids...)
+}
+
+// ClearGroups clears all "groups" edges to the TeamGroup entity.
+func (_u *UserUpdateOne) ClearGroups() *UserUpdateOne {
+ _u.mutation.ClearGroups()
+ return _u
+}
+
+// RemoveGroupIDs removes the "groups" edge to TeamGroup entities by IDs.
+func (_u *UserUpdateOne) RemoveGroupIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveGroupIDs(ids...)
+ return _u
+}
+
+// RemoveGroups removes "groups" edges to TeamGroup entities.
+func (_u *UserUpdateOne) RemoveGroups(v ...*TeamGroup) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveGroupIDs(ids...)
+}
+
+// ClearTeamMembers clears all "team_members" edges to the TeamMember entity.
+func (_u *UserUpdateOne) ClearTeamMembers() *UserUpdateOne {
+ _u.mutation.ClearTeamMembers()
+ return _u
+}
+
+// RemoveTeamMemberIDs removes the "team_members" edge to TeamMember entities by IDs.
+func (_u *UserUpdateOne) RemoveTeamMemberIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveTeamMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamMembers removes "team_members" edges to TeamMember entities.
+func (_u *UserUpdateOne) RemoveTeamMembers(v ...*TeamMember) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamMemberIDs(ids...)
+}
+
+// ClearTeamGroupMembers clears all "team_group_members" edges to the TeamGroupMember entity.
+func (_u *UserUpdateOne) ClearTeamGroupMembers() *UserUpdateOne {
+ _u.mutation.ClearTeamGroupMembers()
+ return _u
+}
+
+// RemoveTeamGroupMemberIDs removes the "team_group_members" edge to TeamGroupMember entities by IDs.
+func (_u *UserUpdateOne) RemoveTeamGroupMemberIDs(ids ...uuid.UUID) *UserUpdateOne {
+ _u.mutation.RemoveTeamGroupMemberIDs(ids...)
+ return _u
+}
+
+// RemoveTeamGroupMembers removes "team_group_members" edges to TeamGroupMember entities.
+func (_u *UserUpdateOne) RemoveTeamGroupMembers(v ...*TeamGroupMember) *UserUpdateOne {
+ ids := make([]uuid.UUID, len(v))
+ for i := range v {
+ ids[i] = v[i].ID
+ }
+ return _u.RemoveTeamGroupMemberIDs(ids...)
+}
+
+// Where appends a list predicates to the UserUpdate builder.
+func (_u *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated User entity.
+func (_u *UserUpdateOne) Save(ctx context.Context) (*User, error) {
+ if err := _u.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *UserUpdateOne) SaveX(ctx context.Context) *User {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *UserUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *UserUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *UserUpdateOne) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok {
+ if user.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized user.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := user.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *UserUpdateOne) check() error {
+ if v, ok := _u.mutation.Name(); ok {
+ if err := user.NameValidator(v); err != nil {
+ return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "User.name": %w`, err)}
+ }
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *UserUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(user.Table, user.Columns, sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "User.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, user.FieldID)
+ for _, f := range fields {
+ if !user.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != user.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(user.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(user.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Name(); ok {
+ _spec.SetField(user.FieldName, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Email(); ok {
+ _spec.SetField(user.FieldEmail, field.TypeString, value)
+ }
+ if _u.mutation.EmailCleared() {
+ _spec.ClearField(user.FieldEmail, field.TypeString)
+ }
+ if value, ok := _u.mutation.AvatarURL(); ok {
+ _spec.SetField(user.FieldAvatarURL, field.TypeString, value)
+ }
+ if _u.mutation.AvatarURLCleared() {
+ _spec.ClearField(user.FieldAvatarURL, field.TypeString)
+ }
+ if value, ok := _u.mutation.Password(); ok {
+ _spec.SetField(user.FieldPassword, field.TypeString, value)
+ }
+ if _u.mutation.PasswordCleared() {
+ _spec.ClearField(user.FieldPassword, field.TypeString)
+ }
+ if value, ok := _u.mutation.Role(); ok {
+ _spec.SetField(user.FieldRole, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Status(); ok {
+ _spec.SetField(user.FieldStatus, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.IsBlocked(); ok {
+ _spec.SetField(user.FieldIsBlocked, field.TypeBool, value)
+ }
+ if value, ok := _u.mutation.DefaultConfigs(); ok {
+ _spec.SetField(user.FieldDefaultConfigs, field.TypeJSON, value)
+ }
+ if _u.mutation.DefaultConfigsCleared() {
+ _spec.ClearField(user.FieldDefaultConfigs, field.TypeJSON)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(user.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(user.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.IdentitiesCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedIdentitiesIDs(); len(nodes) > 0 && !_u.mutation.IdentitiesCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.IdentitiesIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.IdentitiesTable,
+ Columns: []string{user.IdentitiesColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.AuditsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedAuditsIDs(); len(nodes) > 0 && !_u.mutation.AuditsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.AuditsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: false,
+ Table: user.AuditsTable,
+ Columns: []string{user.AuditsColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(audit.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamsIDs(); len(nodes) > 0 && !_u.mutation.TeamsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.TeamsTable,
+ Columns: user.TeamsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(team.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamMemberCreate{config: _u.config, mutation: newTeamMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedGroupsIDs(); len(nodes) > 0 && !_u.mutation.GroupsCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.GroupsIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2M,
+ Inverse: false,
+ Table: user.GroupsTable,
+ Columns: user.GroupsPrimaryKey,
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroup.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ createE := &TeamGroupMemberCreate{config: _u.config, mutation: newTeamGroupMemberMutation(_u.config, OpCreate)}
+ createE.defaults()
+ _, specE := createE.createSpec()
+ edge.Target.Fields = specE.Fields
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamMembersTable,
+ Columns: []string{user.TeamMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teammember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ if _u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.RemovedTeamGroupMembersIDs(); len(nodes) > 0 && !_u.mutation.TeamGroupMembersCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.TeamGroupMembersIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.O2M,
+ Inverse: true,
+ Table: user.TeamGroupMembersTable,
+ Columns: []string{user.TeamGroupMembersColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(teamgroupmember.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &User{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{user.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/db/useridentity.go b/backend/db/useridentity.go
new file mode 100644
index 00000000..fafdcc9b
--- /dev/null
+++ b/backend/db/useridentity.go
@@ -0,0 +1,225 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "fmt"
+ "strings"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserIdentity is the model entity for the UserIdentity schema.
+type UserIdentity struct {
+ config `json:"-"`
+ // ID of the ent.
+ ID uuid.UUID `json:"id,omitempty"`
+ // DeletedAt holds the value of the "deleted_at" field.
+ DeletedAt time.Time `json:"deleted_at,omitempty"`
+ // UserID holds the value of the "user_id" field.
+ UserID uuid.UUID `json:"user_id,omitempty"`
+ // Platform holds the value of the "platform" field.
+ Platform consts.UserPlatform `json:"platform,omitempty"`
+ // IdentityID holds the value of the "identity_id" field.
+ IdentityID string `json:"identity_id,omitempty"`
+ // Username holds the value of the "username" field.
+ Username string `json:"username,omitempty"`
+ // Email holds the value of the "email" field.
+ Email string `json:"email,omitempty"`
+ // AvatarURL holds the value of the "avatar_url" field.
+ AvatarURL string `json:"avatar_url,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"`
+ // Edges holds the relations/edges for other nodes in the graph.
+ // The values are being populated by the UserIdentityQuery when eager-loading is set.
+ Edges UserIdentityEdges `json:"edges"`
+ selectValues sql.SelectValues
+}
+
+// UserIdentityEdges holds the relations/edges for other nodes in the graph.
+type UserIdentityEdges struct {
+ // User holds the value of the user edge.
+ User *User `json:"user,omitempty"`
+ // loadedTypes holds the information for reporting if a
+ // type was loaded (or requested) in eager-loading or not.
+ loadedTypes [1]bool
+}
+
+// UserOrErr returns the User value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e UserIdentityEdges) UserOrErr() (*User, error) {
+ if e.User != nil {
+ return e.User, nil
+ } else if e.loadedTypes[0] {
+ return nil, &NotFoundError{label: user.Label}
+ }
+ return nil, &NotLoadedError{edge: "user"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*UserIdentity) scanValues(columns []string) ([]any, error) {
+ values := make([]any, len(columns))
+ for i := range columns {
+ switch columns[i] {
+ case useridentity.FieldPlatform, useridentity.FieldIdentityID, useridentity.FieldUsername, useridentity.FieldEmail, useridentity.FieldAvatarURL:
+ values[i] = new(sql.NullString)
+ case useridentity.FieldDeletedAt, useridentity.FieldCreatedAt, useridentity.FieldUpdatedAt:
+ values[i] = new(sql.NullTime)
+ case useridentity.FieldID, useridentity.FieldUserID:
+ values[i] = new(uuid.UUID)
+ default:
+ values[i] = new(sql.UnknownType)
+ }
+ }
+ return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the UserIdentity fields.
+func (_m *UserIdentity) 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 useridentity.FieldID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field id", values[i])
+ } else if value != nil {
+ _m.ID = *value
+ }
+ case useridentity.FieldDeletedAt:
+ if value, ok := values[i].(*sql.NullTime); !ok {
+ return fmt.Errorf("unexpected type %T for field deleted_at", values[i])
+ } else if value.Valid {
+ _m.DeletedAt = value.Time
+ }
+ case useridentity.FieldUserID:
+ if value, ok := values[i].(*uuid.UUID); !ok {
+ return fmt.Errorf("unexpected type %T for field user_id", values[i])
+ } else if value != nil {
+ _m.UserID = *value
+ }
+ case useridentity.FieldPlatform:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field platform", values[i])
+ } else if value.Valid {
+ _m.Platform = consts.UserPlatform(value.String)
+ }
+ case useridentity.FieldIdentityID:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field identity_id", values[i])
+ } else if value.Valid {
+ _m.IdentityID = value.String
+ }
+ case useridentity.FieldUsername:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field username", values[i])
+ } else if value.Valid {
+ _m.Username = value.String
+ }
+ case useridentity.FieldEmail:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field email", values[i])
+ } else if value.Valid {
+ _m.Email = value.String
+ }
+ case useridentity.FieldAvatarURL:
+ if value, ok := values[i].(*sql.NullString); !ok {
+ return fmt.Errorf("unexpected type %T for field avatar_url", values[i])
+ } else if value.Valid {
+ _m.AvatarURL = value.String
+ }
+ case useridentity.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 {
+ _m.CreatedAt = value.Time
+ }
+ case useridentity.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 {
+ _m.UpdatedAt = value.Time
+ }
+ default:
+ _m.selectValues.Set(columns[i], values[i])
+ }
+ }
+ return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the UserIdentity.
+// This includes values selected through modifiers, order, etc.
+func (_m *UserIdentity) Value(name string) (ent.Value, error) {
+ return _m.selectValues.Get(name)
+}
+
+// QueryUser queries the "user" edge of the UserIdentity entity.
+func (_m *UserIdentity) QueryUser() *UserQuery {
+ return NewUserIdentityClient(_m.config).QueryUser(_m)
+}
+
+// Update returns a builder for updating this UserIdentity.
+// Note that you need to call UserIdentity.Unwrap() before calling this method if this UserIdentity
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (_m *UserIdentity) Update() *UserIdentityUpdateOne {
+ return NewUserIdentityClient(_m.config).UpdateOne(_m)
+}
+
+// Unwrap unwraps the UserIdentity 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 (_m *UserIdentity) Unwrap() *UserIdentity {
+ _tx, ok := _m.config.driver.(*txDriver)
+ if !ok {
+ panic("db: UserIdentity is not a transactional entity")
+ }
+ _m.config.driver = _tx.drv
+ return _m
+}
+
+// String implements the fmt.Stringer.
+func (_m *UserIdentity) String() string {
+ var builder strings.Builder
+ builder.WriteString("UserIdentity(")
+ builder.WriteString(fmt.Sprintf("id=%v, ", _m.ID))
+ builder.WriteString("deleted_at=")
+ builder.WriteString(_m.DeletedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("user_id=")
+ builder.WriteString(fmt.Sprintf("%v", _m.UserID))
+ builder.WriteString(", ")
+ builder.WriteString("platform=")
+ builder.WriteString(fmt.Sprintf("%v", _m.Platform))
+ builder.WriteString(", ")
+ builder.WriteString("identity_id=")
+ builder.WriteString(_m.IdentityID)
+ builder.WriteString(", ")
+ builder.WriteString("username=")
+ builder.WriteString(_m.Username)
+ builder.WriteString(", ")
+ builder.WriteString("email=")
+ builder.WriteString(_m.Email)
+ builder.WriteString(", ")
+ builder.WriteString("avatar_url=")
+ builder.WriteString(_m.AvatarURL)
+ builder.WriteString(", ")
+ builder.WriteString("created_at=")
+ builder.WriteString(_m.CreatedAt.Format(time.ANSIC))
+ builder.WriteString(", ")
+ builder.WriteString("updated_at=")
+ builder.WriteString(_m.UpdatedAt.Format(time.ANSIC))
+ builder.WriteByte(')')
+ return builder.String()
+}
+
+// UserIdentities is a parsable slice of UserIdentity.
+type UserIdentities []*UserIdentity
diff --git a/backend/db/useridentity/useridentity.go b/backend/db/useridentity/useridentity.go
new file mode 100644
index 00000000..b51bfd67
--- /dev/null
+++ b/backend/db/useridentity/useridentity.go
@@ -0,0 +1,158 @@
+// Code generated by ent, DO NOT EDIT.
+
+package useridentity
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+ // Label holds the string label denoting the useridentity type in the database.
+ Label = "user_identity"
+ // FieldID holds the string denoting the id field in the database.
+ FieldID = "id"
+ // FieldDeletedAt holds the string denoting the deleted_at field in the database.
+ FieldDeletedAt = "deleted_at"
+ // FieldUserID holds the string denoting the user_id field in the database.
+ FieldUserID = "user_id"
+ // FieldPlatform holds the string denoting the platform field in the database.
+ FieldPlatform = "platform"
+ // FieldIdentityID holds the string denoting the identity_id field in the database.
+ FieldIdentityID = "identity_id"
+ // FieldUsername holds the string denoting the username field in the database.
+ FieldUsername = "username"
+ // FieldEmail holds the string denoting the email field in the database.
+ FieldEmail = "email"
+ // FieldAvatarURL holds the string denoting the avatar_url field in the database.
+ FieldAvatarURL = "avatar_url"
+ // 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"
+ // EdgeUser holds the string denoting the user edge name in mutations.
+ EdgeUser = "user"
+ // Table holds the table name of the useridentity in the database.
+ Table = "user_identities"
+ // UserTable is the table that holds the user relation/edge.
+ UserTable = "user_identities"
+ // UserInverseTable is the table name for the User entity.
+ // It exists in this package in order to avoid circular dependency with the "user" package.
+ UserInverseTable = "users"
+ // UserColumn is the table column denoting the user relation/edge.
+ UserColumn = "user_id"
+)
+
+// Columns holds all SQL columns for useridentity fields.
+var Columns = []string{
+ FieldID,
+ FieldDeletedAt,
+ FieldUserID,
+ FieldPlatform,
+ FieldIdentityID,
+ FieldUsername,
+ FieldEmail,
+ FieldAvatarURL,
+ FieldCreatedAt,
+ FieldUpdatedAt,
+}
+
+// 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
+ }
+ }
+ return false
+}
+
+// Note that the variables below are initialized by the runtime
+// package on the initialization of the application. Therefore,
+// it should be imported in the main as follows:
+//
+// import _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+var (
+ Hooks [1]ent.Hook
+ Interceptors [1]ent.Interceptor
+ // PlatformValidator is a validator for the "platform" field. It is called by the builders before save.
+ PlatformValidator func(string) error
+ // IdentityIDValidator is a validator for the "identity_id" field. It is called by the builders before save.
+ IdentityIDValidator func(string) error
+ // UsernameValidator is a validator for the "username" field. It is called by the builders before save.
+ UsernameValidator func(string) error
+ // DefaultCreatedAt holds the default value on creation for the "created_at" field.
+ DefaultCreatedAt func() time.Time
+ // UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+ UpdateDefaultUpdatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the UserIdentity queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByDeletedAt orders the results by the deleted_at field.
+func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldDeletedAt, opts...).ToFunc()
+}
+
+// ByUserID orders the results by the user_id field.
+func ByUserID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUserID, opts...).ToFunc()
+}
+
+// ByPlatform orders the results by the platform field.
+func ByPlatform(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldPlatform, opts...).ToFunc()
+}
+
+// ByIdentityID orders the results by the identity_id field.
+func ByIdentityID(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldIdentityID, opts...).ToFunc()
+}
+
+// ByUsername orders the results by the username field.
+func ByUsername(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUsername, opts...).ToFunc()
+}
+
+// ByEmail orders the results by the email field.
+func ByEmail(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldEmail, opts...).ToFunc()
+}
+
+// ByAvatarURL orders the results by the avatar_url field.
+func ByAvatarURL(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldAvatarURL, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+ return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByUserField orders the results by user field.
+func ByUserField(field string, opts ...sql.OrderTermOption) OrderOption {
+ return func(s *sql.Selector) {
+ sqlgraph.OrderByNeighborTerms(s, newUserStep(), sql.OrderByField(field, opts...))
+ }
+}
+func newUserStep() *sqlgraph.Step {
+ return sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.To(UserInverseTable, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+ )
+}
diff --git a/backend/db/useridentity/where.go b/backend/db/useridentity/where.go
new file mode 100644
index 00000000..29c3a733
--- /dev/null
+++ b/backend/db/useridentity/where.go
@@ -0,0 +1,666 @@
+// Code generated by ent, DO NOT EDIT.
+
+package useridentity
+
+import (
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldID, id))
+}
+
+// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
+func DeletedAt(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// UserID applies equality check predicate on the "user_id" field. It's identical to UserIDEQ.
+func UserID(v uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUserID, v))
+}
+
+// Platform applies equality check predicate on the "platform" field. It's identical to PlatformEQ.
+func Platform(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldEQ(FieldPlatform, vc))
+}
+
+// IdentityID applies equality check predicate on the "identity_id" field. It's identical to IdentityIDEQ.
+func IdentityID(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldIdentityID, v))
+}
+
+// Username applies equality check predicate on the "username" field. It's identical to UsernameEQ.
+func Username(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUsername, v))
+}
+
+// Email applies equality check predicate on the "email" field. It's identical to EmailEQ.
+func Email(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldEmail, v))
+}
+
+// AvatarURL applies equality check predicate on the "avatar_url" field. It's identical to AvatarURLEQ.
+func AvatarURL(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldAvatarURL, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
+func DeletedAtEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
+func DeletedAtNEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtIn applies the In predicate on the "deleted_at" field.
+func DeletedAtIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
+func DeletedAtNotIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtGT applies the GT predicate on the "deleted_at" field.
+func DeletedAtGT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldDeletedAt, v))
+}
+
+// DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
+func DeletedAtGTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldDeletedAt, v))
+}
+
+// DeletedAtLT applies the LT predicate on the "deleted_at" field.
+func DeletedAtLT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldDeletedAt, v))
+}
+
+// DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
+func DeletedAtLTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldDeletedAt, v))
+}
+
+// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
+func DeletedAtIsNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIsNull(FieldDeletedAt))
+}
+
+// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
+func DeletedAtNotNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotNull(FieldDeletedAt))
+}
+
+// UserIDEQ applies the EQ predicate on the "user_id" field.
+func UserIDEQ(v uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUserID, v))
+}
+
+// UserIDNEQ applies the NEQ predicate on the "user_id" field.
+func UserIDNEQ(v uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldUserID, v))
+}
+
+// UserIDIn applies the In predicate on the "user_id" field.
+func UserIDIn(vs ...uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldUserID, vs...))
+}
+
+// UserIDNotIn applies the NotIn predicate on the "user_id" field.
+func UserIDNotIn(vs ...uuid.UUID) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldUserID, vs...))
+}
+
+// PlatformEQ applies the EQ predicate on the "platform" field.
+func PlatformEQ(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldEQ(FieldPlatform, vc))
+}
+
+// PlatformNEQ applies the NEQ predicate on the "platform" field.
+func PlatformNEQ(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldNEQ(FieldPlatform, vc))
+}
+
+// PlatformIn applies the In predicate on the "platform" field.
+func PlatformIn(vs ...consts.UserPlatform) predicate.UserIdentity {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.UserIdentity(sql.FieldIn(FieldPlatform, v...))
+}
+
+// PlatformNotIn applies the NotIn predicate on the "platform" field.
+func PlatformNotIn(vs ...consts.UserPlatform) predicate.UserIdentity {
+ v := make([]any, len(vs))
+ for i := range v {
+ v[i] = string(vs[i])
+ }
+ return predicate.UserIdentity(sql.FieldNotIn(FieldPlatform, v...))
+}
+
+// PlatformGT applies the GT predicate on the "platform" field.
+func PlatformGT(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldGT(FieldPlatform, vc))
+}
+
+// PlatformGTE applies the GTE predicate on the "platform" field.
+func PlatformGTE(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldGTE(FieldPlatform, vc))
+}
+
+// PlatformLT applies the LT predicate on the "platform" field.
+func PlatformLT(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldLT(FieldPlatform, vc))
+}
+
+// PlatformLTE applies the LTE predicate on the "platform" field.
+func PlatformLTE(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldLTE(FieldPlatform, vc))
+}
+
+// PlatformContains applies the Contains predicate on the "platform" field.
+func PlatformContains(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldContains(FieldPlatform, vc))
+}
+
+// PlatformHasPrefix applies the HasPrefix predicate on the "platform" field.
+func PlatformHasPrefix(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldHasPrefix(FieldPlatform, vc))
+}
+
+// PlatformHasSuffix applies the HasSuffix predicate on the "platform" field.
+func PlatformHasSuffix(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldHasSuffix(FieldPlatform, vc))
+}
+
+// PlatformEqualFold applies the EqualFold predicate on the "platform" field.
+func PlatformEqualFold(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldEqualFold(FieldPlatform, vc))
+}
+
+// PlatformContainsFold applies the ContainsFold predicate on the "platform" field.
+func PlatformContainsFold(v consts.UserPlatform) predicate.UserIdentity {
+ vc := string(v)
+ return predicate.UserIdentity(sql.FieldContainsFold(FieldPlatform, vc))
+}
+
+// IdentityIDEQ applies the EQ predicate on the "identity_id" field.
+func IdentityIDEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldIdentityID, v))
+}
+
+// IdentityIDNEQ applies the NEQ predicate on the "identity_id" field.
+func IdentityIDNEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldIdentityID, v))
+}
+
+// IdentityIDIn applies the In predicate on the "identity_id" field.
+func IdentityIDIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldIdentityID, vs...))
+}
+
+// IdentityIDNotIn applies the NotIn predicate on the "identity_id" field.
+func IdentityIDNotIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldIdentityID, vs...))
+}
+
+// IdentityIDGT applies the GT predicate on the "identity_id" field.
+func IdentityIDGT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldIdentityID, v))
+}
+
+// IdentityIDGTE applies the GTE predicate on the "identity_id" field.
+func IdentityIDGTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldIdentityID, v))
+}
+
+// IdentityIDLT applies the LT predicate on the "identity_id" field.
+func IdentityIDLT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldIdentityID, v))
+}
+
+// IdentityIDLTE applies the LTE predicate on the "identity_id" field.
+func IdentityIDLTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldIdentityID, v))
+}
+
+// IdentityIDContains applies the Contains predicate on the "identity_id" field.
+func IdentityIDContains(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContains(FieldIdentityID, v))
+}
+
+// IdentityIDHasPrefix applies the HasPrefix predicate on the "identity_id" field.
+func IdentityIDHasPrefix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasPrefix(FieldIdentityID, v))
+}
+
+// IdentityIDHasSuffix applies the HasSuffix predicate on the "identity_id" field.
+func IdentityIDHasSuffix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasSuffix(FieldIdentityID, v))
+}
+
+// IdentityIDEqualFold applies the EqualFold predicate on the "identity_id" field.
+func IdentityIDEqualFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEqualFold(FieldIdentityID, v))
+}
+
+// IdentityIDContainsFold applies the ContainsFold predicate on the "identity_id" field.
+func IdentityIDContainsFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContainsFold(FieldIdentityID, v))
+}
+
+// UsernameEQ applies the EQ predicate on the "username" field.
+func UsernameEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUsername, v))
+}
+
+// UsernameNEQ applies the NEQ predicate on the "username" field.
+func UsernameNEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldUsername, v))
+}
+
+// UsernameIn applies the In predicate on the "username" field.
+func UsernameIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldUsername, vs...))
+}
+
+// UsernameNotIn applies the NotIn predicate on the "username" field.
+func UsernameNotIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldUsername, vs...))
+}
+
+// UsernameGT applies the GT predicate on the "username" field.
+func UsernameGT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldUsername, v))
+}
+
+// UsernameGTE applies the GTE predicate on the "username" field.
+func UsernameGTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldUsername, v))
+}
+
+// UsernameLT applies the LT predicate on the "username" field.
+func UsernameLT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldUsername, v))
+}
+
+// UsernameLTE applies the LTE predicate on the "username" field.
+func UsernameLTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldUsername, v))
+}
+
+// UsernameContains applies the Contains predicate on the "username" field.
+func UsernameContains(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContains(FieldUsername, v))
+}
+
+// UsernameHasPrefix applies the HasPrefix predicate on the "username" field.
+func UsernameHasPrefix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasPrefix(FieldUsername, v))
+}
+
+// UsernameHasSuffix applies the HasSuffix predicate on the "username" field.
+func UsernameHasSuffix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasSuffix(FieldUsername, v))
+}
+
+// UsernameEqualFold applies the EqualFold predicate on the "username" field.
+func UsernameEqualFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEqualFold(FieldUsername, v))
+}
+
+// UsernameContainsFold applies the ContainsFold predicate on the "username" field.
+func UsernameContainsFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContainsFold(FieldUsername, v))
+}
+
+// EmailEQ applies the EQ predicate on the "email" field.
+func EmailEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldEmail, v))
+}
+
+// EmailNEQ applies the NEQ predicate on the "email" field.
+func EmailNEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldEmail, v))
+}
+
+// EmailIn applies the In predicate on the "email" field.
+func EmailIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldEmail, vs...))
+}
+
+// EmailNotIn applies the NotIn predicate on the "email" field.
+func EmailNotIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldEmail, vs...))
+}
+
+// EmailGT applies the GT predicate on the "email" field.
+func EmailGT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldEmail, v))
+}
+
+// EmailGTE applies the GTE predicate on the "email" field.
+func EmailGTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldEmail, v))
+}
+
+// EmailLT applies the LT predicate on the "email" field.
+func EmailLT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldEmail, v))
+}
+
+// EmailLTE applies the LTE predicate on the "email" field.
+func EmailLTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldEmail, v))
+}
+
+// EmailContains applies the Contains predicate on the "email" field.
+func EmailContains(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContains(FieldEmail, v))
+}
+
+// EmailHasPrefix applies the HasPrefix predicate on the "email" field.
+func EmailHasPrefix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasPrefix(FieldEmail, v))
+}
+
+// EmailHasSuffix applies the HasSuffix predicate on the "email" field.
+func EmailHasSuffix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasSuffix(FieldEmail, v))
+}
+
+// EmailIsNil applies the IsNil predicate on the "email" field.
+func EmailIsNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIsNull(FieldEmail))
+}
+
+// EmailNotNil applies the NotNil predicate on the "email" field.
+func EmailNotNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotNull(FieldEmail))
+}
+
+// EmailEqualFold applies the EqualFold predicate on the "email" field.
+func EmailEqualFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEqualFold(FieldEmail, v))
+}
+
+// EmailContainsFold applies the ContainsFold predicate on the "email" field.
+func EmailContainsFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContainsFold(FieldEmail, v))
+}
+
+// AvatarURLEQ applies the EQ predicate on the "avatar_url" field.
+func AvatarURLEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldAvatarURL, v))
+}
+
+// AvatarURLNEQ applies the NEQ predicate on the "avatar_url" field.
+func AvatarURLNEQ(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldAvatarURL, v))
+}
+
+// AvatarURLIn applies the In predicate on the "avatar_url" field.
+func AvatarURLIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldAvatarURL, vs...))
+}
+
+// AvatarURLNotIn applies the NotIn predicate on the "avatar_url" field.
+func AvatarURLNotIn(vs ...string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldAvatarURL, vs...))
+}
+
+// AvatarURLGT applies the GT predicate on the "avatar_url" field.
+func AvatarURLGT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldAvatarURL, v))
+}
+
+// AvatarURLGTE applies the GTE predicate on the "avatar_url" field.
+func AvatarURLGTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldAvatarURL, v))
+}
+
+// AvatarURLLT applies the LT predicate on the "avatar_url" field.
+func AvatarURLLT(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldAvatarURL, v))
+}
+
+// AvatarURLLTE applies the LTE predicate on the "avatar_url" field.
+func AvatarURLLTE(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldAvatarURL, v))
+}
+
+// AvatarURLContains applies the Contains predicate on the "avatar_url" field.
+func AvatarURLContains(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContains(FieldAvatarURL, v))
+}
+
+// AvatarURLHasPrefix applies the HasPrefix predicate on the "avatar_url" field.
+func AvatarURLHasPrefix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasPrefix(FieldAvatarURL, v))
+}
+
+// AvatarURLHasSuffix applies the HasSuffix predicate on the "avatar_url" field.
+func AvatarURLHasSuffix(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldHasSuffix(FieldAvatarURL, v))
+}
+
+// AvatarURLIsNil applies the IsNil predicate on the "avatar_url" field.
+func AvatarURLIsNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIsNull(FieldAvatarURL))
+}
+
+// AvatarURLNotNil applies the NotNil predicate on the "avatar_url" field.
+func AvatarURLNotNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotNull(FieldAvatarURL))
+}
+
+// AvatarURLEqualFold applies the EqualFold predicate on the "avatar_url" field.
+func AvatarURLEqualFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEqualFold(FieldAvatarURL, v))
+}
+
+// AvatarURLContainsFold applies the ContainsFold predicate on the "avatar_url" field.
+func AvatarURLContainsFold(v string) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldContainsFold(FieldAvatarURL, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field.
+func UpdatedAtIsNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldIsNull(FieldUpdatedAt))
+}
+
+// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field.
+func UpdatedAtNotNil() predicate.UserIdentity {
+ return predicate.UserIdentity(sql.FieldNotNull(FieldUpdatedAt))
+}
+
+// HasUser applies the HasEdge predicate on the "user" edge.
+func HasUser() predicate.UserIdentity {
+ return predicate.UserIdentity(func(s *sql.Selector) {
+ step := sqlgraph.NewStep(
+ sqlgraph.From(Table, FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, UserTable, UserColumn),
+ )
+ sqlgraph.HasNeighbors(s, step)
+ })
+}
+
+// HasUserWith applies the HasEdge predicate on the "user" edge with a given conditions (other predicates).
+func HasUserWith(preds ...predicate.User) predicate.UserIdentity {
+ return predicate.UserIdentity(func(s *sql.Selector) {
+ step := newUserStep()
+ 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.UserIdentity) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.UserIdentity) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.UserIdentity) predicate.UserIdentity {
+ return predicate.UserIdentity(sql.NotPredicates(p))
+}
diff --git a/backend/db/useridentity_create.go b/backend/db/useridentity_create.go
new file mode 100644
index 00000000..116b6417
--- /dev/null
+++ b/backend/db/useridentity_create.go
@@ -0,0 +1,1077 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserIdentityCreate is the builder for creating a UserIdentity entity.
+type UserIdentityCreate struct {
+ config
+ mutation *UserIdentityMutation
+ hooks []Hook
+ conflict []sql.ConflictOption
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_c *UserIdentityCreate) SetDeletedAt(v time.Time) *UserIdentityCreate {
+ _c.mutation.SetDeletedAt(v)
+ return _c
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_c *UserIdentityCreate) SetNillableDeletedAt(v *time.Time) *UserIdentityCreate {
+ if v != nil {
+ _c.SetDeletedAt(*v)
+ }
+ return _c
+}
+
+// SetUserID sets the "user_id" field.
+func (_c *UserIdentityCreate) SetUserID(v uuid.UUID) *UserIdentityCreate {
+ _c.mutation.SetUserID(v)
+ return _c
+}
+
+// SetPlatform sets the "platform" field.
+func (_c *UserIdentityCreate) SetPlatform(v consts.UserPlatform) *UserIdentityCreate {
+ _c.mutation.SetPlatform(v)
+ return _c
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (_c *UserIdentityCreate) SetIdentityID(v string) *UserIdentityCreate {
+ _c.mutation.SetIdentityID(v)
+ return _c
+}
+
+// SetUsername sets the "username" field.
+func (_c *UserIdentityCreate) SetUsername(v string) *UserIdentityCreate {
+ _c.mutation.SetUsername(v)
+ return _c
+}
+
+// SetEmail sets the "email" field.
+func (_c *UserIdentityCreate) SetEmail(v string) *UserIdentityCreate {
+ _c.mutation.SetEmail(v)
+ return _c
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_c *UserIdentityCreate) SetNillableEmail(v *string) *UserIdentityCreate {
+ if v != nil {
+ _c.SetEmail(*v)
+ }
+ return _c
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_c *UserIdentityCreate) SetAvatarURL(v string) *UserIdentityCreate {
+ _c.mutation.SetAvatarURL(v)
+ return _c
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_c *UserIdentityCreate) SetNillableAvatarURL(v *string) *UserIdentityCreate {
+ if v != nil {
+ _c.SetAvatarURL(*v)
+ }
+ return _c
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_c *UserIdentityCreate) SetCreatedAt(v time.Time) *UserIdentityCreate {
+ _c.mutation.SetCreatedAt(v)
+ return _c
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_c *UserIdentityCreate) SetNillableCreatedAt(v *time.Time) *UserIdentityCreate {
+ if v != nil {
+ _c.SetCreatedAt(*v)
+ }
+ return _c
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_c *UserIdentityCreate) SetUpdatedAt(v time.Time) *UserIdentityCreate {
+ _c.mutation.SetUpdatedAt(v)
+ return _c
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (_c *UserIdentityCreate) SetNillableUpdatedAt(v *time.Time) *UserIdentityCreate {
+ if v != nil {
+ _c.SetUpdatedAt(*v)
+ }
+ return _c
+}
+
+// SetID sets the "id" field.
+func (_c *UserIdentityCreate) SetID(v uuid.UUID) *UserIdentityCreate {
+ _c.mutation.SetID(v)
+ return _c
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_c *UserIdentityCreate) SetUser(v *User) *UserIdentityCreate {
+ return _c.SetUserID(v.ID)
+}
+
+// Mutation returns the UserIdentityMutation object of the builder.
+func (_c *UserIdentityCreate) Mutation() *UserIdentityMutation {
+ return _c.mutation
+}
+
+// Save creates the UserIdentity in the database.
+func (_c *UserIdentityCreate) Save(ctx context.Context) (*UserIdentity, error) {
+ if err := _c.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _c.sqlSave, _c.mutation, _c.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (_c *UserIdentityCreate) SaveX(ctx context.Context) *UserIdentity {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *UserIdentityCreate) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *UserIdentityCreate) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_c *UserIdentityCreate) defaults() error {
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ if useridentity.DefaultCreatedAt == nil {
+ return fmt.Errorf("db: uninitialized useridentity.DefaultCreatedAt (forgotten import db/runtime?)")
+ }
+ v := useridentity.DefaultCreatedAt()
+ _c.mutation.SetCreatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_c *UserIdentityCreate) check() error {
+ if _, ok := _c.mutation.UserID(); !ok {
+ return &ValidationError{Name: "user_id", err: errors.New(`db: missing required field "UserIdentity.user_id"`)}
+ }
+ if _, ok := _c.mutation.Platform(); !ok {
+ return &ValidationError{Name: "platform", err: errors.New(`db: missing required field "UserIdentity.platform"`)}
+ }
+ if v, ok := _c.mutation.Platform(); ok {
+ if err := useridentity.PlatformValidator(string(v)); err != nil {
+ return &ValidationError{Name: "platform", err: fmt.Errorf(`db: validator failed for field "UserIdentity.platform": %w`, err)}
+ }
+ }
+ if _, ok := _c.mutation.IdentityID(); !ok {
+ return &ValidationError{Name: "identity_id", err: errors.New(`db: missing required field "UserIdentity.identity_id"`)}
+ }
+ if v, ok := _c.mutation.IdentityID(); ok {
+ if err := useridentity.IdentityIDValidator(v); err != nil {
+ return &ValidationError{Name: "identity_id", err: fmt.Errorf(`db: validator failed for field "UserIdentity.identity_id": %w`, err)}
+ }
+ }
+ if _, ok := _c.mutation.Username(); !ok {
+ return &ValidationError{Name: "username", err: errors.New(`db: missing required field "UserIdentity.username"`)}
+ }
+ if v, ok := _c.mutation.Username(); ok {
+ if err := useridentity.UsernameValidator(v); err != nil {
+ return &ValidationError{Name: "username", err: fmt.Errorf(`db: validator failed for field "UserIdentity.username": %w`, err)}
+ }
+ }
+ if _, ok := _c.mutation.CreatedAt(); !ok {
+ return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "UserIdentity.created_at"`)}
+ }
+ if len(_c.mutation.UserIDs()) == 0 {
+ return &ValidationError{Name: "user", err: errors.New(`db: missing required edge "UserIdentity.user"`)}
+ }
+ return nil
+}
+
+func (_c *UserIdentityCreate) sqlSave(ctx context.Context) (*UserIdentity, error) {
+ if err := _c.check(); err != nil {
+ return nil, err
+ }
+ _node, _spec := _c.createSpec()
+ if err := sqlgraph.CreateNode(ctx, _c.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
+ }
+ }
+ _c.mutation.id = &_node.ID
+ _c.mutation.done = true
+ return _node, nil
+}
+
+func (_c *UserIdentityCreate) createSpec() (*UserIdentity, *sqlgraph.CreateSpec) {
+ var (
+ _node = &UserIdentity{config: _c.config}
+ _spec = sqlgraph.NewCreateSpec(useridentity.Table, sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID))
+ )
+ _spec.OnConflict = _c.conflict
+ if id, ok := _c.mutation.ID(); ok {
+ _node.ID = id
+ _spec.ID.Value = &id
+ }
+ if value, ok := _c.mutation.DeletedAt(); ok {
+ _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value)
+ _node.DeletedAt = value
+ }
+ if value, ok := _c.mutation.Platform(); ok {
+ _spec.SetField(useridentity.FieldPlatform, field.TypeString, value)
+ _node.Platform = value
+ }
+ if value, ok := _c.mutation.IdentityID(); ok {
+ _spec.SetField(useridentity.FieldIdentityID, field.TypeString, value)
+ _node.IdentityID = value
+ }
+ if value, ok := _c.mutation.Username(); ok {
+ _spec.SetField(useridentity.FieldUsername, field.TypeString, value)
+ _node.Username = value
+ }
+ if value, ok := _c.mutation.Email(); ok {
+ _spec.SetField(useridentity.FieldEmail, field.TypeString, value)
+ _node.Email = value
+ }
+ if value, ok := _c.mutation.AvatarURL(); ok {
+ _spec.SetField(useridentity.FieldAvatarURL, field.TypeString, value)
+ _node.AvatarURL = value
+ }
+ if value, ok := _c.mutation.CreatedAt(); ok {
+ _spec.SetField(useridentity.FieldCreatedAt, field.TypeTime, value)
+ _node.CreatedAt = value
+ }
+ if value, ok := _c.mutation.UpdatedAt(); ok {
+ _spec.SetField(useridentity.FieldUpdatedAt, field.TypeTime, value)
+ _node.UpdatedAt = value
+ }
+ if nodes := _c.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: useridentity.UserTable,
+ Columns: []string{useridentity.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _node.UserID = nodes[0]
+ _spec.Edges = append(_spec.Edges, edge)
+ }
+ return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.UserIdentity.Create().
+// SetDeletedAt(v).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.UserIdentityUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *UserIdentityCreate) OnConflict(opts ...sql.ConflictOption) *UserIdentityUpsertOne {
+ _c.conflict = opts
+ return &UserIdentityUpsertOne{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *UserIdentityCreate) OnConflictColumns(columns ...string) *UserIdentityUpsertOne {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &UserIdentityUpsertOne{
+ create: _c,
+ }
+}
+
+type (
+ // UserIdentityUpsertOne is the builder for "upsert"-ing
+ // one UserIdentity node.
+ UserIdentityUpsertOne struct {
+ create *UserIdentityCreate
+ }
+
+ // UserIdentityUpsert is the "OnConflict" setter.
+ UserIdentityUpsert struct {
+ *sql.UpdateSet
+ }
+)
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserIdentityUpsert) SetDeletedAt(v time.Time) *UserIdentityUpsert {
+ u.Set(useridentity.FieldDeletedAt, v)
+ return u
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateDeletedAt() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldDeletedAt)
+ return u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserIdentityUpsert) ClearDeletedAt() *UserIdentityUpsert {
+ u.SetNull(useridentity.FieldDeletedAt)
+ return u
+}
+
+// SetUserID sets the "user_id" field.
+func (u *UserIdentityUpsert) SetUserID(v uuid.UUID) *UserIdentityUpsert {
+ u.Set(useridentity.FieldUserID, v)
+ return u
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateUserID() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldUserID)
+ return u
+}
+
+// SetPlatform sets the "platform" field.
+func (u *UserIdentityUpsert) SetPlatform(v consts.UserPlatform) *UserIdentityUpsert {
+ u.Set(useridentity.FieldPlatform, v)
+ return u
+}
+
+// UpdatePlatform sets the "platform" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdatePlatform() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldPlatform)
+ return u
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (u *UserIdentityUpsert) SetIdentityID(v string) *UserIdentityUpsert {
+ u.Set(useridentity.FieldIdentityID, v)
+ return u
+}
+
+// UpdateIdentityID sets the "identity_id" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateIdentityID() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldIdentityID)
+ return u
+}
+
+// SetUsername sets the "username" field.
+func (u *UserIdentityUpsert) SetUsername(v string) *UserIdentityUpsert {
+ u.Set(useridentity.FieldUsername, v)
+ return u
+}
+
+// UpdateUsername sets the "username" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateUsername() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldUsername)
+ return u
+}
+
+// SetEmail sets the "email" field.
+func (u *UserIdentityUpsert) SetEmail(v string) *UserIdentityUpsert {
+ u.Set(useridentity.FieldEmail, v)
+ return u
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateEmail() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldEmail)
+ return u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserIdentityUpsert) ClearEmail() *UserIdentityUpsert {
+ u.SetNull(useridentity.FieldEmail)
+ return u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserIdentityUpsert) SetAvatarURL(v string) *UserIdentityUpsert {
+ u.Set(useridentity.FieldAvatarURL, v)
+ return u
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateAvatarURL() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldAvatarURL)
+ return u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserIdentityUpsert) ClearAvatarURL() *UserIdentityUpsert {
+ u.SetNull(useridentity.FieldAvatarURL)
+ return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserIdentityUpsert) SetCreatedAt(v time.Time) *UserIdentityUpsert {
+ u.Set(useridentity.FieldCreatedAt, v)
+ return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateCreatedAt() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldCreatedAt)
+ return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserIdentityUpsert) SetUpdatedAt(v time.Time) *UserIdentityUpsert {
+ u.Set(useridentity.FieldUpdatedAt, v)
+ return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserIdentityUpsert) UpdateUpdatedAt() *UserIdentityUpsert {
+ u.SetExcluded(useridentity.FieldUpdatedAt)
+ return u
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (u *UserIdentityUpsert) ClearUpdatedAt() *UserIdentityUpsert {
+ u.SetNull(useridentity.FieldUpdatedAt)
+ return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(useridentity.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *UserIdentityUpsertOne) UpdateNewValues() *UserIdentityUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ if _, exists := u.create.mutation.ID(); exists {
+ s.SetIgnore(useridentity.FieldID)
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *UserIdentityUpsertOne) Ignore() *UserIdentityUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *UserIdentityUpsertOne) DoNothing() *UserIdentityUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the UserIdentityCreate.OnConflict
+// documentation for more info.
+func (u *UserIdentityUpsertOne) Update(set func(*UserIdentityUpsert)) *UserIdentityUpsertOne {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&UserIdentityUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserIdentityUpsertOne) SetDeletedAt(v time.Time) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateDeletedAt() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserIdentityUpsertOne) ClearDeletedAt() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *UserIdentityUpsertOne) SetUserID(v uuid.UUID) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateUserID() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetPlatform sets the "platform" field.
+func (u *UserIdentityUpsertOne) SetPlatform(v consts.UserPlatform) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetPlatform(v)
+ })
+}
+
+// UpdatePlatform sets the "platform" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdatePlatform() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdatePlatform()
+ })
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (u *UserIdentityUpsertOne) SetIdentityID(v string) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetIdentityID(v)
+ })
+}
+
+// UpdateIdentityID sets the "identity_id" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateIdentityID() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateIdentityID()
+ })
+}
+
+// SetUsername sets the "username" field.
+func (u *UserIdentityUpsertOne) SetUsername(v string) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUsername(v)
+ })
+}
+
+// UpdateUsername sets the "username" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateUsername() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUsername()
+ })
+}
+
+// SetEmail sets the "email" field.
+func (u *UserIdentityUpsertOne) SetEmail(v string) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetEmail(v)
+ })
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateEmail() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateEmail()
+ })
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserIdentityUpsertOne) ClearEmail() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearEmail()
+ })
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserIdentityUpsertOne) SetAvatarURL(v string) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetAvatarURL(v)
+ })
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateAvatarURL() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateAvatarURL()
+ })
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserIdentityUpsertOne) ClearAvatarURL() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearAvatarURL()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserIdentityUpsertOne) SetCreatedAt(v time.Time) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateCreatedAt() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserIdentityUpsertOne) SetUpdatedAt(v time.Time) *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertOne) UpdateUpdatedAt() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (u *UserIdentityUpsertOne) ClearUpdatedAt() *UserIdentityUpsertOne {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *UserIdentityUpsertOne) Exec(ctx context.Context) error {
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for UserIdentityCreate.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *UserIdentityUpsertOne) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *UserIdentityUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+ if u.create.driver.Dialect() == dialect.MySQL {
+ // In case of "ON CONFLICT", there is no way to get back non-numeric ID
+ // fields from the database since MySQL does not support the RETURNING clause.
+ return id, errors.New("db: UserIdentityUpsertOne.ID is not supported by MySQL driver. Use UserIdentityUpsertOne.Exec instead")
+ }
+ node, err := u.create.Save(ctx)
+ if err != nil {
+ return id, err
+ }
+ return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *UserIdentityUpsertOne) IDX(ctx context.Context) uuid.UUID {
+ id, err := u.ID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// UserIdentityCreateBulk is the builder for creating many UserIdentity entities in bulk.
+type UserIdentityCreateBulk struct {
+ config
+ err error
+ builders []*UserIdentityCreate
+ conflict []sql.ConflictOption
+}
+
+// Save creates the UserIdentity entities in the database.
+func (_c *UserIdentityCreateBulk) Save(ctx context.Context) ([]*UserIdentity, error) {
+ if _c.err != nil {
+ return nil, _c.err
+ }
+ specs := make([]*sqlgraph.CreateSpec, len(_c.builders))
+ nodes := make([]*UserIdentity, len(_c.builders))
+ mutators := make([]Mutator, len(_c.builders))
+ for i := range _c.builders {
+ func(i int, root context.Context) {
+ builder := _c.builders[i]
+ builder.defaults()
+ var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+ mutation, ok := m.(*UserIdentityMutation)
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ if err := builder.check(); err != nil {
+ return nil, err
+ }
+ builder.mutation = mutation
+ var err error
+ nodes[i], specs[i] = builder.createSpec()
+ if i < len(mutators)-1 {
+ _, err = mutators[i+1].Mutate(root, _c.builders[i+1].mutation)
+ } else {
+ spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+ spec.OnConflict = _c.conflict
+ // Invoke the actual operation on the latest mutation in the chain.
+ if err = sqlgraph.BatchCreate(ctx, _c.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, _c.builders[0].mutation); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_c *UserIdentityCreateBulk) SaveX(ctx context.Context) []*UserIdentity {
+ v, err := _c.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return v
+}
+
+// Exec executes the query.
+func (_c *UserIdentityCreateBulk) Exec(ctx context.Context) error {
+ _, err := _c.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_c *UserIdentityCreateBulk) ExecX(ctx context.Context) {
+ if err := _c.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+// client.UserIdentity.CreateBulk(builders...).
+// OnConflict(
+// // Update the row with the new values
+// // the was proposed for insertion.
+// sql.ResolveWithNewValues(),
+// ).
+// // Override some of the fields with custom
+// // update values.
+// Update(func(u *ent.UserIdentityUpsert) {
+// SetDeletedAt(v+v).
+// }).
+// Exec(ctx)
+func (_c *UserIdentityCreateBulk) OnConflict(opts ...sql.ConflictOption) *UserIdentityUpsertBulk {
+ _c.conflict = opts
+ return &UserIdentityUpsertBulk{
+ create: _c,
+ }
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(sql.ConflictColumns(columns...)).
+// Exec(ctx)
+func (_c *UserIdentityCreateBulk) OnConflictColumns(columns ...string) *UserIdentityUpsertBulk {
+ _c.conflict = append(_c.conflict, sql.ConflictColumns(columns...))
+ return &UserIdentityUpsertBulk{
+ create: _c,
+ }
+}
+
+// UserIdentityUpsertBulk is the builder for "upsert"-ing
+// a bulk of UserIdentity nodes.
+type UserIdentityUpsertBulk struct {
+ create *UserIdentityCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(
+// sql.ResolveWithNewValues(),
+// sql.ResolveWith(func(u *sql.UpdateSet) {
+// u.SetIgnore(useridentity.FieldID)
+// }),
+// ).
+// Exec(ctx)
+func (u *UserIdentityUpsertBulk) UpdateNewValues() *UserIdentityUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+ for _, b := range u.create.builders {
+ if _, exists := b.mutation.ID(); exists {
+ s.SetIgnore(useridentity.FieldID)
+ }
+ }
+ }))
+ return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+// client.UserIdentity.Create().
+// OnConflict(sql.ResolveWithIgnore()).
+// Exec(ctx)
+func (u *UserIdentityUpsertBulk) Ignore() *UserIdentityUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+ return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *UserIdentityUpsertBulk) DoNothing() *UserIdentityUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.DoNothing())
+ return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the UserIdentityCreateBulk.OnConflict
+// documentation for more info.
+func (u *UserIdentityUpsertBulk) Update(set func(*UserIdentityUpsert)) *UserIdentityUpsertBulk {
+ u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+ set(&UserIdentityUpsert{UpdateSet: update})
+ }))
+ return u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (u *UserIdentityUpsertBulk) SetDeletedAt(v time.Time) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetDeletedAt(v)
+ })
+}
+
+// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateDeletedAt() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateDeletedAt()
+ })
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (u *UserIdentityUpsertBulk) ClearDeletedAt() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearDeletedAt()
+ })
+}
+
+// SetUserID sets the "user_id" field.
+func (u *UserIdentityUpsertBulk) SetUserID(v uuid.UUID) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUserID(v)
+ })
+}
+
+// UpdateUserID sets the "user_id" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateUserID() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUserID()
+ })
+}
+
+// SetPlatform sets the "platform" field.
+func (u *UserIdentityUpsertBulk) SetPlatform(v consts.UserPlatform) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetPlatform(v)
+ })
+}
+
+// UpdatePlatform sets the "platform" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdatePlatform() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdatePlatform()
+ })
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (u *UserIdentityUpsertBulk) SetIdentityID(v string) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetIdentityID(v)
+ })
+}
+
+// UpdateIdentityID sets the "identity_id" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateIdentityID() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateIdentityID()
+ })
+}
+
+// SetUsername sets the "username" field.
+func (u *UserIdentityUpsertBulk) SetUsername(v string) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUsername(v)
+ })
+}
+
+// UpdateUsername sets the "username" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateUsername() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUsername()
+ })
+}
+
+// SetEmail sets the "email" field.
+func (u *UserIdentityUpsertBulk) SetEmail(v string) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetEmail(v)
+ })
+}
+
+// UpdateEmail sets the "email" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateEmail() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateEmail()
+ })
+}
+
+// ClearEmail clears the value of the "email" field.
+func (u *UserIdentityUpsertBulk) ClearEmail() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearEmail()
+ })
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (u *UserIdentityUpsertBulk) SetAvatarURL(v string) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetAvatarURL(v)
+ })
+}
+
+// UpdateAvatarURL sets the "avatar_url" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateAvatarURL() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateAvatarURL()
+ })
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (u *UserIdentityUpsertBulk) ClearAvatarURL() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearAvatarURL()
+ })
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *UserIdentityUpsertBulk) SetCreatedAt(v time.Time) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetCreatedAt(v)
+ })
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateCreatedAt() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateCreatedAt()
+ })
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *UserIdentityUpsertBulk) SetUpdatedAt(v time.Time) *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.SetUpdatedAt(v)
+ })
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *UserIdentityUpsertBulk) UpdateUpdatedAt() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.UpdateUpdatedAt()
+ })
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (u *UserIdentityUpsertBulk) ClearUpdatedAt() *UserIdentityUpsertBulk {
+ return u.Update(func(s *UserIdentityUpsert) {
+ s.ClearUpdatedAt()
+ })
+}
+
+// Exec executes the query.
+func (u *UserIdentityUpsertBulk) Exec(ctx context.Context) error {
+ if u.create.err != nil {
+ return u.create.err
+ }
+ for i, b := range u.create.builders {
+ if len(b.conflict) != 0 {
+ return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the UserIdentityCreateBulk instead", i)
+ }
+ }
+ if len(u.create.conflict) == 0 {
+ return errors.New("db: missing options for UserIdentityCreateBulk.OnConflict")
+ }
+ return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *UserIdentityUpsertBulk) ExecX(ctx context.Context) {
+ if err := u.create.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/useridentity_delete.go b/backend/db/useridentity_delete.go
new file mode 100644
index 00000000..a3502d01
--- /dev/null
+++ b/backend/db/useridentity_delete.go
@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+)
+
+// UserIdentityDelete is the builder for deleting a UserIdentity entity.
+type UserIdentityDelete struct {
+ config
+ hooks []Hook
+ mutation *UserIdentityMutation
+}
+
+// Where appends a list predicates to the UserIdentityDelete builder.
+func (_d *UserIdentityDelete) Where(ps ...predicate.UserIdentity) *UserIdentityDelete {
+ _d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (_d *UserIdentityDelete) Exec(ctx context.Context) (int, error) {
+ return withHooks(ctx, _d.sqlExec, _d.mutation, _d.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *UserIdentityDelete) ExecX(ctx context.Context) int {
+ n, err := _d.Exec(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return n
+}
+
+func (_d *UserIdentityDelete) sqlExec(ctx context.Context) (int, error) {
+ _spec := sqlgraph.NewDeleteSpec(useridentity.Table, sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID))
+ if ps := _d.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ affected, err := sqlgraph.DeleteNodes(ctx, _d.driver, _spec)
+ if err != nil && sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ _d.mutation.done = true
+ return affected, err
+}
+
+// UserIdentityDeleteOne is the builder for deleting a single UserIdentity entity.
+type UserIdentityDeleteOne struct {
+ _d *UserIdentityDelete
+}
+
+// Where appends a list predicates to the UserIdentityDelete builder.
+func (_d *UserIdentityDeleteOne) Where(ps ...predicate.UserIdentity) *UserIdentityDeleteOne {
+ _d._d.mutation.Where(ps...)
+ return _d
+}
+
+// Exec executes the deletion query.
+func (_d *UserIdentityDeleteOne) Exec(ctx context.Context) error {
+ n, err := _d._d.Exec(ctx)
+ switch {
+ case err != nil:
+ return err
+ case n == 0:
+ return &NotFoundError{useridentity.Label}
+ default:
+ return nil
+ }
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_d *UserIdentityDeleteOne) ExecX(ctx context.Context) {
+ if err := _d.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
diff --git a/backend/db/useridentity_query.go b/backend/db/useridentity_query.go
new file mode 100644
index 00000000..615baa89
--- /dev/null
+++ b/backend/db/useridentity_query.go
@@ -0,0 +1,657 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "fmt"
+ "math"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserIdentityQuery is the builder for querying UserIdentity entities.
+type UserIdentityQuery struct {
+ config
+ ctx *QueryContext
+ order []useridentity.OrderOption
+ inters []Interceptor
+ predicates []predicate.UserIdentity
+ withUser *UserQuery
+ modifiers []func(*sql.Selector)
+ // intermediate query (i.e. traversal path).
+ sql *sql.Selector
+ path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the UserIdentityQuery builder.
+func (_q *UserIdentityQuery) Where(ps ...predicate.UserIdentity) *UserIdentityQuery {
+ _q.predicates = append(_q.predicates, ps...)
+ return _q
+}
+
+// Limit the number of records to be returned by this query.
+func (_q *UserIdentityQuery) Limit(limit int) *UserIdentityQuery {
+ _q.ctx.Limit = &limit
+ return _q
+}
+
+// Offset to start from.
+func (_q *UserIdentityQuery) Offset(offset int) *UserIdentityQuery {
+ _q.ctx.Offset = &offset
+ return _q
+}
+
+// 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 (_q *UserIdentityQuery) Unique(unique bool) *UserIdentityQuery {
+ _q.ctx.Unique = &unique
+ return _q
+}
+
+// Order specifies how the records should be ordered.
+func (_q *UserIdentityQuery) Order(o ...useridentity.OrderOption) *UserIdentityQuery {
+ _q.order = append(_q.order, o...)
+ return _q
+}
+
+// QueryUser chains the current query on the "user" edge.
+func (_q *UserIdentityQuery) QueryUser() *UserQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ selector := _q.sqlQuery(ctx)
+ if err := selector.Err(); err != nil {
+ return nil, err
+ }
+ step := sqlgraph.NewStep(
+ sqlgraph.From(useridentity.Table, useridentity.FieldID, selector),
+ sqlgraph.To(user.Table, user.FieldID),
+ sqlgraph.Edge(sqlgraph.M2O, true, useridentity.UserTable, useridentity.UserColumn),
+ )
+ fromU = sqlgraph.SetNeighbors(_q.driver.Dialect(), step)
+ return fromU, nil
+ }
+ return query
+}
+
+// First returns the first UserIdentity entity from the query.
+// Returns a *NotFoundError when no UserIdentity was found.
+func (_q *UserIdentityQuery) First(ctx context.Context) (*UserIdentity, error) {
+ nodes, err := _q.Limit(1).All(setContextOp(ctx, _q.ctx, ent.OpQueryFirst))
+ if err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nil, &NotFoundError{useridentity.Label}
+ }
+ return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (_q *UserIdentityQuery) FirstX(ctx context.Context) *UserIdentity {
+ node, err := _q.First(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return node
+}
+
+// FirstID returns the first UserIdentity ID from the query.
+// Returns a *NotFoundError when no UserIdentity ID was found.
+func (_q *UserIdentityQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(1).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryFirstID)); err != nil {
+ return
+ }
+ if len(ids) == 0 {
+ err = &NotFoundError{useridentity.Label}
+ return
+ }
+ return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (_q *UserIdentityQuery) FirstIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.FirstID(ctx)
+ if err != nil && !IsNotFound(err) {
+ panic(err)
+ }
+ return id
+}
+
+// Only returns a single UserIdentity entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one UserIdentity entity is found.
+// Returns a *NotFoundError when no UserIdentity entities are found.
+func (_q *UserIdentityQuery) Only(ctx context.Context) (*UserIdentity, error) {
+ nodes, err := _q.Limit(2).All(setContextOp(ctx, _q.ctx, ent.OpQueryOnly))
+ if err != nil {
+ return nil, err
+ }
+ switch len(nodes) {
+ case 1:
+ return nodes[0], nil
+ case 0:
+ return nil, &NotFoundError{useridentity.Label}
+ default:
+ return nil, &NotSingularError{useridentity.Label}
+ }
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (_q *UserIdentityQuery) OnlyX(ctx context.Context) *UserIdentity {
+ node, err := _q.Only(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// OnlyID is like Only, but returns the only UserIdentity ID in the query.
+// Returns a *NotSingularError when more than one UserIdentity ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (_q *UserIdentityQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+ var ids []uuid.UUID
+ if ids, err = _q.Limit(2).IDs(setContextOp(ctx, _q.ctx, ent.OpQueryOnlyID)); err != nil {
+ return
+ }
+ switch len(ids) {
+ case 1:
+ id = ids[0]
+ case 0:
+ err = &NotFoundError{useridentity.Label}
+ default:
+ err = &NotSingularError{useridentity.Label}
+ }
+ return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (_q *UserIdentityQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+ id, err := _q.OnlyID(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return id
+}
+
+// All executes the query and returns a list of UserIdentities.
+func (_q *UserIdentityQuery) All(ctx context.Context) ([]*UserIdentity, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryAll)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return nil, err
+ }
+ qr := querierAll[[]*UserIdentity, *UserIdentityQuery]()
+ return withInterceptors[[]*UserIdentity](ctx, _q, qr, _q.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (_q *UserIdentityQuery) AllX(ctx context.Context) []*UserIdentity {
+ nodes, err := _q.All(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return nodes
+}
+
+// IDs executes the query and returns a list of UserIdentity IDs.
+func (_q *UserIdentityQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+ if _q.ctx.Unique == nil && _q.path != nil {
+ _q.Unique(true)
+ }
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryIDs)
+ if err = _q.Select(useridentity.FieldID).Scan(ctx, &ids); err != nil {
+ return nil, err
+ }
+ return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (_q *UserIdentityQuery) IDsX(ctx context.Context) []uuid.UUID {
+ ids, err := _q.IDs(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return ids
+}
+
+// Count returns the count of the given query.
+func (_q *UserIdentityQuery) Count(ctx context.Context) (int, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryCount)
+ if err := _q.prepareQuery(ctx); err != nil {
+ return 0, err
+ }
+ return withInterceptors[int](ctx, _q, querierCount[*UserIdentityQuery](), _q.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (_q *UserIdentityQuery) CountX(ctx context.Context) int {
+ count, err := _q.Count(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (_q *UserIdentityQuery) Exist(ctx context.Context) (bool, error) {
+ ctx = setContextOp(ctx, _q.ctx, ent.OpQueryExist)
+ switch _, err := _q.FirstID(ctx); {
+ case IsNotFound(err):
+ return false, nil
+ case err != nil:
+ return false, fmt.Errorf("db: check existence: %w", err)
+ default:
+ return true, nil
+ }
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (_q *UserIdentityQuery) ExistX(ctx context.Context) bool {
+ exist, err := _q.Exist(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return exist
+}
+
+// Clone returns a duplicate of the UserIdentityQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (_q *UserIdentityQuery) Clone() *UserIdentityQuery {
+ if _q == nil {
+ return nil
+ }
+ return &UserIdentityQuery{
+ config: _q.config,
+ ctx: _q.ctx.Clone(),
+ order: append([]useridentity.OrderOption{}, _q.order...),
+ inters: append([]Interceptor{}, _q.inters...),
+ predicates: append([]predicate.UserIdentity{}, _q.predicates...),
+ withUser: _q.withUser.Clone(),
+ // clone intermediate query.
+ sql: _q.sql.Clone(),
+ path: _q.path,
+ modifiers: append([]func(*sql.Selector){}, _q.modifiers...),
+ }
+}
+
+// WithUser tells the query-builder to eager-load the nodes that are connected to
+// the "user" edge. The optional arguments are used to configure the query builder of the edge.
+func (_q *UserIdentityQuery) WithUser(opts ...func(*UserQuery)) *UserIdentityQuery {
+ query := (&UserClient{config: _q.config}).Query()
+ for _, opt := range opts {
+ opt(query)
+ }
+ _q.withUser = query
+ return _q
+}
+
+// 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// Count int `json:"count,omitempty"`
+// }
+//
+// client.UserIdentity.Query().
+// GroupBy(useridentity.FieldDeletedAt).
+// Aggregate(db.Count()).
+// Scan(ctx, &v)
+func (_q *UserIdentityQuery) GroupBy(field string, fields ...string) *UserIdentityGroupBy {
+ _q.ctx.Fields = append([]string{field}, fields...)
+ grbuild := &UserIdentityGroupBy{build: _q}
+ grbuild.flds = &_q.ctx.Fields
+ grbuild.label = useridentity.Label
+ grbuild.scan = 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 {
+// DeletedAt time.Time `json:"deleted_at,omitempty"`
+// }
+//
+// client.UserIdentity.Query().
+// Select(useridentity.FieldDeletedAt).
+// Scan(ctx, &v)
+func (_q *UserIdentityQuery) Select(fields ...string) *UserIdentitySelect {
+ _q.ctx.Fields = append(_q.ctx.Fields, fields...)
+ sbuild := &UserIdentitySelect{UserIdentityQuery: _q}
+ sbuild.label = useridentity.Label
+ sbuild.flds, sbuild.scan = &_q.ctx.Fields, sbuild.Scan
+ return sbuild
+}
+
+// Aggregate returns a UserIdentitySelect configured with the given aggregations.
+func (_q *UserIdentityQuery) Aggregate(fns ...AggregateFunc) *UserIdentitySelect {
+ return _q.Select().Aggregate(fns...)
+}
+
+func (_q *UserIdentityQuery) prepareQuery(ctx context.Context) error {
+ for _, inter := range _q.inters {
+ if inter == nil {
+ return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+ }
+ if trv, ok := inter.(Traverser); ok {
+ if err := trv.Traverse(ctx, _q); err != nil {
+ return err
+ }
+ }
+ }
+ for _, f := range _q.ctx.Fields {
+ if !useridentity.ValidColumn(f) {
+ return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ }
+ if _q.path != nil {
+ prev, err := _q.path(ctx)
+ if err != nil {
+ return err
+ }
+ _q.sql = prev
+ }
+ return nil
+}
+
+func (_q *UserIdentityQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*UserIdentity, error) {
+ var (
+ nodes = []*UserIdentity{}
+ _spec = _q.querySpec()
+ loadedTypes = [1]bool{
+ _q.withUser != nil,
+ }
+ )
+ _spec.ScanValues = func(columns []string) ([]any, error) {
+ return (*UserIdentity).scanValues(nil, columns)
+ }
+ _spec.Assign = func(columns []string, values []any) error {
+ node := &UserIdentity{config: _q.config}
+ nodes = append(nodes, node)
+ node.Edges.loadedTypes = loadedTypes
+ return node.assignValues(columns, values)
+ }
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ for i := range hooks {
+ hooks[i](ctx, _spec)
+ }
+ if err := sqlgraph.QueryNodes(ctx, _q.driver, _spec); err != nil {
+ return nil, err
+ }
+ if len(nodes) == 0 {
+ return nodes, nil
+ }
+ if query := _q.withUser; query != nil {
+ if err := _q.loadUser(ctx, query, nodes, nil,
+ func(n *UserIdentity, e *User) { n.Edges.User = e }); err != nil {
+ return nil, err
+ }
+ }
+ return nodes, nil
+}
+
+func (_q *UserIdentityQuery) loadUser(ctx context.Context, query *UserQuery, nodes []*UserIdentity, init func(*UserIdentity), assign func(*UserIdentity, *User)) error {
+ ids := make([]uuid.UUID, 0, len(nodes))
+ nodeids := make(map[uuid.UUID][]*UserIdentity)
+ for i := range nodes {
+ fk := nodes[i].UserID
+ if _, ok := nodeids[fk]; !ok {
+ ids = append(ids, fk)
+ }
+ nodeids[fk] = append(nodeids[fk], nodes[i])
+ }
+ if len(ids) == 0 {
+ return nil
+ }
+ query.Where(user.IDIn(ids...))
+ neighbors, err := query.All(ctx)
+ if err != nil {
+ return err
+ }
+ for _, n := range neighbors {
+ nodes, ok := nodeids[n.ID]
+ if !ok {
+ return fmt.Errorf(`unexpected foreign-key "user_id" returned %v`, n.ID)
+ }
+ for i := range nodes {
+ assign(nodes[i], n)
+ }
+ }
+ return nil
+}
+
+func (_q *UserIdentityQuery) sqlCount(ctx context.Context) (int, error) {
+ _spec := _q.querySpec()
+ if len(_q.modifiers) > 0 {
+ _spec.Modifiers = _q.modifiers
+ }
+ _spec.Node.Columns = _q.ctx.Fields
+ if len(_q.ctx.Fields) > 0 {
+ _spec.Unique = _q.ctx.Unique != nil && *_q.ctx.Unique
+ }
+ return sqlgraph.CountNodes(ctx, _q.driver, _spec)
+}
+
+func (_q *UserIdentityQuery) querySpec() *sqlgraph.QuerySpec {
+ _spec := sqlgraph.NewQuerySpec(useridentity.Table, useridentity.Columns, sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID))
+ _spec.From = _q.sql
+ if unique := _q.ctx.Unique; unique != nil {
+ _spec.Unique = *unique
+ } else if _q.path != nil {
+ _spec.Unique = true
+ }
+ if fields := _q.ctx.Fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, useridentity.FieldID)
+ for i := range fields {
+ if fields[i] != useridentity.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+ }
+ }
+ if _q.withUser != nil {
+ _spec.Node.AddColumnOnce(useridentity.FieldUserID)
+ }
+ }
+ if ps := _q.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ _spec.Limit = *limit
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ _spec.Offset = *offset
+ }
+ if ps := _q.order; len(ps) > 0 {
+ _spec.Order = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ return _spec
+}
+
+func (_q *UserIdentityQuery) sqlQuery(ctx context.Context) *sql.Selector {
+ builder := sql.Dialect(_q.driver.Dialect())
+ t1 := builder.Table(useridentity.Table)
+ columns := _q.ctx.Fields
+ if len(columns) == 0 {
+ columns = useridentity.Columns
+ }
+ selector := builder.Select(t1.Columns(columns...)...).From(t1)
+ if _q.sql != nil {
+ selector = _q.sql
+ selector.Select(selector.Columns(columns...)...)
+ }
+ if _q.ctx.Unique != nil && *_q.ctx.Unique {
+ selector.Distinct()
+ }
+ for _, m := range _q.modifiers {
+ m(selector)
+ }
+ for _, p := range _q.predicates {
+ p(selector)
+ }
+ for _, p := range _q.order {
+ p(selector)
+ }
+ if offset := _q.ctx.Offset; offset != nil {
+ // limit is mandatory for offset clause. We start
+ // with default value, and override it below if needed.
+ selector.Offset(*offset).Limit(math.MaxInt32)
+ }
+ if limit := _q.ctx.Limit; limit != nil {
+ selector.Limit(*limit)
+ }
+ return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (_q *UserIdentityQuery) ForUpdate(opts ...sql.LockOption) *UserIdentityQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForUpdate(opts...)
+ })
+ return _q
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (_q *UserIdentityQuery) ForShare(opts ...sql.LockOption) *UserIdentityQuery {
+ if _q.driver.Dialect() == dialect.Postgres {
+ _q.Unique(false)
+ }
+ _q.modifiers = append(_q.modifiers, func(s *sql.Selector) {
+ s.ForShare(opts...)
+ })
+ return _q
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_q *UserIdentityQuery) Modify(modifiers ...func(s *sql.Selector)) *UserIdentitySelect {
+ _q.modifiers = append(_q.modifiers, modifiers...)
+ return _q.Select()
+}
+
+// UserIdentityGroupBy is the group-by builder for UserIdentity entities.
+type UserIdentityGroupBy struct {
+ selector
+ build *UserIdentityQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (_g *UserIdentityGroupBy) Aggregate(fns ...AggregateFunc) *UserIdentityGroupBy {
+ _g.fns = append(_g.fns, fns...)
+ return _g
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_g *UserIdentityGroupBy) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _g.build.ctx, ent.OpQueryGroupBy)
+ if err := _g.build.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*UserIdentityQuery, *UserIdentityGroupBy](ctx, _g.build, _g, _g.build.inters, v)
+}
+
+func (_g *UserIdentityGroupBy) sqlScan(ctx context.Context, root *UserIdentityQuery, v any) error {
+ selector := root.sqlQuery(ctx).Select()
+ aggregation := make([]string, 0, len(_g.fns))
+ for _, fn := range _g.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ if len(selector.SelectedColumns()) == 0 {
+ columns := make([]string, 0, len(*_g.flds)+len(_g.fns))
+ for _, f := range *_g.flds {
+ columns = append(columns, selector.C(f))
+ }
+ columns = append(columns, aggregation...)
+ selector.Select(columns...)
+ }
+ selector.GroupBy(selector.Columns(*_g.flds...)...)
+ if err := selector.Err(); err != nil {
+ return err
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _g.build.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// UserIdentitySelect is the builder for selecting fields of UserIdentity entities.
+type UserIdentitySelect struct {
+ *UserIdentityQuery
+ selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (_s *UserIdentitySelect) Aggregate(fns ...AggregateFunc) *UserIdentitySelect {
+ _s.fns = append(_s.fns, fns...)
+ return _s
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (_s *UserIdentitySelect) Scan(ctx context.Context, v any) error {
+ ctx = setContextOp(ctx, _s.ctx, ent.OpQuerySelect)
+ if err := _s.prepareQuery(ctx); err != nil {
+ return err
+ }
+ return scanWithInterceptors[*UserIdentityQuery, *UserIdentitySelect](ctx, _s.UserIdentityQuery, _s, _s.inters, v)
+}
+
+func (_s *UserIdentitySelect) sqlScan(ctx context.Context, root *UserIdentityQuery, v any) error {
+ selector := root.sqlQuery(ctx)
+ aggregation := make([]string, 0, len(_s.fns))
+ for _, fn := range _s.fns {
+ aggregation = append(aggregation, fn(selector))
+ }
+ switch n := len(*_s.selector.flds); {
+ case n == 0 && len(aggregation) > 0:
+ selector.Select(aggregation...)
+ case n != 0 && len(aggregation) > 0:
+ selector.AppendSelect(aggregation...)
+ }
+ rows := &sql.Rows{}
+ query, args := selector.Query()
+ if err := _s.driver.Query(ctx, query, args, rows); err != nil {
+ return err
+ }
+ defer rows.Close()
+ return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (_s *UserIdentitySelect) Modify(modifiers ...func(s *sql.Selector)) *UserIdentitySelect {
+ _s.modifiers = append(_s.modifiers, modifiers...)
+ return _s
+}
diff --git a/backend/db/useridentity_update.go b/backend/db/useridentity_update.go
new file mode 100644
index 00000000..bb09df3a
--- /dev/null
+++ b/backend/db/useridentity_update.go
@@ -0,0 +1,713 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/dialect/sql/sqlgraph"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/db/predicate"
+ "github.com/chaitin/MonkeyCode/backend/db/user"
+ "github.com/chaitin/MonkeyCode/backend/db/useridentity"
+ "github.com/google/uuid"
+)
+
+// UserIdentityUpdate is the builder for updating UserIdentity entities.
+type UserIdentityUpdate struct {
+ config
+ hooks []Hook
+ mutation *UserIdentityMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the UserIdentityUpdate builder.
+func (_u *UserIdentityUpdate) Where(ps ...predicate.UserIdentity) *UserIdentityUpdate {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *UserIdentityUpdate) SetDeletedAt(v time.Time) *UserIdentityUpdate {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableDeletedAt(v *time.Time) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *UserIdentityUpdate) ClearDeletedAt() *UserIdentityUpdate {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *UserIdentityUpdate) SetUserID(v uuid.UUID) *UserIdentityUpdate {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableUserID(v *uuid.UUID) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetPlatform sets the "platform" field.
+func (_u *UserIdentityUpdate) SetPlatform(v consts.UserPlatform) *UserIdentityUpdate {
+ _u.mutation.SetPlatform(v)
+ return _u
+}
+
+// SetNillablePlatform sets the "platform" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillablePlatform(v *consts.UserPlatform) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetPlatform(*v)
+ }
+ return _u
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (_u *UserIdentityUpdate) SetIdentityID(v string) *UserIdentityUpdate {
+ _u.mutation.SetIdentityID(v)
+ return _u
+}
+
+// SetNillableIdentityID sets the "identity_id" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableIdentityID(v *string) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetIdentityID(*v)
+ }
+ return _u
+}
+
+// SetUsername sets the "username" field.
+func (_u *UserIdentityUpdate) SetUsername(v string) *UserIdentityUpdate {
+ _u.mutation.SetUsername(v)
+ return _u
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableUsername(v *string) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetUsername(*v)
+ }
+ return _u
+}
+
+// SetEmail sets the "email" field.
+func (_u *UserIdentityUpdate) SetEmail(v string) *UserIdentityUpdate {
+ _u.mutation.SetEmail(v)
+ return _u
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableEmail(v *string) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetEmail(*v)
+ }
+ return _u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (_u *UserIdentityUpdate) ClearEmail() *UserIdentityUpdate {
+ _u.mutation.ClearEmail()
+ return _u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_u *UserIdentityUpdate) SetAvatarURL(v string) *UserIdentityUpdate {
+ _u.mutation.SetAvatarURL(v)
+ return _u
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableAvatarURL(v *string) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetAvatarURL(*v)
+ }
+ return _u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (_u *UserIdentityUpdate) ClearAvatarURL() *UserIdentityUpdate {
+ _u.mutation.ClearAvatarURL()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *UserIdentityUpdate) SetCreatedAt(v time.Time) *UserIdentityUpdate {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *UserIdentityUpdate) SetNillableCreatedAt(v *time.Time) *UserIdentityUpdate {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *UserIdentityUpdate) SetUpdatedAt(v time.Time) *UserIdentityUpdate {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (_u *UserIdentityUpdate) ClearUpdatedAt() *UserIdentityUpdate {
+ _u.mutation.ClearUpdatedAt()
+ return _u
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *UserIdentityUpdate) SetUser(v *User) *UserIdentityUpdate {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the UserIdentityMutation object of the builder.
+func (_u *UserIdentityUpdate) Mutation() *UserIdentityMutation {
+ return _u.mutation
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *UserIdentityUpdate) ClearUser() *UserIdentityUpdate {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (_u *UserIdentityUpdate) Save(ctx context.Context) (int, error) {
+ if err := _u.defaults(); err != nil {
+ return 0, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *UserIdentityUpdate) SaveX(ctx context.Context) int {
+ affected, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return affected
+}
+
+// Exec executes the query.
+func (_u *UserIdentityUpdate) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *UserIdentityUpdate) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *UserIdentityUpdate) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok && !_u.mutation.UpdatedAtCleared() {
+ if useridentity.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized useridentity.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := useridentity.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *UserIdentityUpdate) check() error {
+ if v, ok := _u.mutation.Platform(); ok {
+ if err := useridentity.PlatformValidator(string(v)); err != nil {
+ return &ValidationError{Name: "platform", err: fmt.Errorf(`db: validator failed for field "UserIdentity.platform": %w`, err)}
+ }
+ }
+ if v, ok := _u.mutation.IdentityID(); ok {
+ if err := useridentity.IdentityIDValidator(v); err != nil {
+ return &ValidationError{Name: "identity_id", err: fmt.Errorf(`db: validator failed for field "UserIdentity.identity_id": %w`, err)}
+ }
+ }
+ if v, ok := _u.mutation.Username(); ok {
+ if err := useridentity.UsernameValidator(v); err != nil {
+ return &ValidationError{Name: "username", err: fmt.Errorf(`db: validator failed for field "UserIdentity.username": %w`, err)}
+ }
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "UserIdentity.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *UserIdentityUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserIdentityUpdate {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *UserIdentityUpdate) sqlSave(ctx context.Context) (_node int, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(useridentity.Table, useridentity.Columns, sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID))
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(useridentity.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Platform(); ok {
+ _spec.SetField(useridentity.FieldPlatform, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.IdentityID(); ok {
+ _spec.SetField(useridentity.FieldIdentityID, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Username(); ok {
+ _spec.SetField(useridentity.FieldUsername, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Email(); ok {
+ _spec.SetField(useridentity.FieldEmail, field.TypeString, value)
+ }
+ if _u.mutation.EmailCleared() {
+ _spec.ClearField(useridentity.FieldEmail, field.TypeString)
+ }
+ if value, ok := _u.mutation.AvatarURL(); ok {
+ _spec.SetField(useridentity.FieldAvatarURL, field.TypeString, value)
+ }
+ if _u.mutation.AvatarURLCleared() {
+ _spec.ClearField(useridentity.FieldAvatarURL, field.TypeString)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(useridentity.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(useridentity.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.UpdatedAtCleared() {
+ _spec.ClearField(useridentity.FieldUpdatedAt, field.TypeTime)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: useridentity.UserTable,
+ Columns: []string{useridentity.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: useridentity.UserTable,
+ Columns: []string{useridentity.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ if _node, err = sqlgraph.UpdateNodes(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{useridentity.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return 0, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
+
+// UserIdentityUpdateOne is the builder for updating a single UserIdentity entity.
+type UserIdentityUpdateOne struct {
+ config
+ fields []string
+ hooks []Hook
+ mutation *UserIdentityMutation
+ modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetDeletedAt sets the "deleted_at" field.
+func (_u *UserIdentityUpdateOne) SetDeletedAt(v time.Time) *UserIdentityUpdateOne {
+ _u.mutation.SetDeletedAt(v)
+ return _u
+}
+
+// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableDeletedAt(v *time.Time) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetDeletedAt(*v)
+ }
+ return _u
+}
+
+// ClearDeletedAt clears the value of the "deleted_at" field.
+func (_u *UserIdentityUpdateOne) ClearDeletedAt() *UserIdentityUpdateOne {
+ _u.mutation.ClearDeletedAt()
+ return _u
+}
+
+// SetUserID sets the "user_id" field.
+func (_u *UserIdentityUpdateOne) SetUserID(v uuid.UUID) *UserIdentityUpdateOne {
+ _u.mutation.SetUserID(v)
+ return _u
+}
+
+// SetNillableUserID sets the "user_id" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableUserID(v *uuid.UUID) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetUserID(*v)
+ }
+ return _u
+}
+
+// SetPlatform sets the "platform" field.
+func (_u *UserIdentityUpdateOne) SetPlatform(v consts.UserPlatform) *UserIdentityUpdateOne {
+ _u.mutation.SetPlatform(v)
+ return _u
+}
+
+// SetNillablePlatform sets the "platform" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillablePlatform(v *consts.UserPlatform) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetPlatform(*v)
+ }
+ return _u
+}
+
+// SetIdentityID sets the "identity_id" field.
+func (_u *UserIdentityUpdateOne) SetIdentityID(v string) *UserIdentityUpdateOne {
+ _u.mutation.SetIdentityID(v)
+ return _u
+}
+
+// SetNillableIdentityID sets the "identity_id" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableIdentityID(v *string) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetIdentityID(*v)
+ }
+ return _u
+}
+
+// SetUsername sets the "username" field.
+func (_u *UserIdentityUpdateOne) SetUsername(v string) *UserIdentityUpdateOne {
+ _u.mutation.SetUsername(v)
+ return _u
+}
+
+// SetNillableUsername sets the "username" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableUsername(v *string) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetUsername(*v)
+ }
+ return _u
+}
+
+// SetEmail sets the "email" field.
+func (_u *UserIdentityUpdateOne) SetEmail(v string) *UserIdentityUpdateOne {
+ _u.mutation.SetEmail(v)
+ return _u
+}
+
+// SetNillableEmail sets the "email" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableEmail(v *string) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetEmail(*v)
+ }
+ return _u
+}
+
+// ClearEmail clears the value of the "email" field.
+func (_u *UserIdentityUpdateOne) ClearEmail() *UserIdentityUpdateOne {
+ _u.mutation.ClearEmail()
+ return _u
+}
+
+// SetAvatarURL sets the "avatar_url" field.
+func (_u *UserIdentityUpdateOne) SetAvatarURL(v string) *UserIdentityUpdateOne {
+ _u.mutation.SetAvatarURL(v)
+ return _u
+}
+
+// SetNillableAvatarURL sets the "avatar_url" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableAvatarURL(v *string) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetAvatarURL(*v)
+ }
+ return _u
+}
+
+// ClearAvatarURL clears the value of the "avatar_url" field.
+func (_u *UserIdentityUpdateOne) ClearAvatarURL() *UserIdentityUpdateOne {
+ _u.mutation.ClearAvatarURL()
+ return _u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (_u *UserIdentityUpdateOne) SetCreatedAt(v time.Time) *UserIdentityUpdateOne {
+ _u.mutation.SetCreatedAt(v)
+ return _u
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (_u *UserIdentityUpdateOne) SetNillableCreatedAt(v *time.Time) *UserIdentityUpdateOne {
+ if v != nil {
+ _u.SetCreatedAt(*v)
+ }
+ return _u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (_u *UserIdentityUpdateOne) SetUpdatedAt(v time.Time) *UserIdentityUpdateOne {
+ _u.mutation.SetUpdatedAt(v)
+ return _u
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (_u *UserIdentityUpdateOne) ClearUpdatedAt() *UserIdentityUpdateOne {
+ _u.mutation.ClearUpdatedAt()
+ return _u
+}
+
+// SetUser sets the "user" edge to the User entity.
+func (_u *UserIdentityUpdateOne) SetUser(v *User) *UserIdentityUpdateOne {
+ return _u.SetUserID(v.ID)
+}
+
+// Mutation returns the UserIdentityMutation object of the builder.
+func (_u *UserIdentityUpdateOne) Mutation() *UserIdentityMutation {
+ return _u.mutation
+}
+
+// ClearUser clears the "user" edge to the User entity.
+func (_u *UserIdentityUpdateOne) ClearUser() *UserIdentityUpdateOne {
+ _u.mutation.ClearUser()
+ return _u
+}
+
+// Where appends a list predicates to the UserIdentityUpdate builder.
+func (_u *UserIdentityUpdateOne) Where(ps ...predicate.UserIdentity) *UserIdentityUpdateOne {
+ _u.mutation.Where(ps...)
+ return _u
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (_u *UserIdentityUpdateOne) Select(field string, fields ...string) *UserIdentityUpdateOne {
+ _u.fields = append([]string{field}, fields...)
+ return _u
+}
+
+// Save executes the query and returns the updated UserIdentity entity.
+func (_u *UserIdentityUpdateOne) Save(ctx context.Context) (*UserIdentity, error) {
+ if err := _u.defaults(); err != nil {
+ return nil, err
+ }
+ return withHooks(ctx, _u.sqlSave, _u.mutation, _u.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (_u *UserIdentityUpdateOne) SaveX(ctx context.Context) *UserIdentity {
+ node, err := _u.Save(ctx)
+ if err != nil {
+ panic(err)
+ }
+ return node
+}
+
+// Exec executes the query on the entity.
+func (_u *UserIdentityUpdateOne) Exec(ctx context.Context) error {
+ _, err := _u.Save(ctx)
+ return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (_u *UserIdentityUpdateOne) ExecX(ctx context.Context) {
+ if err := _u.Exec(ctx); err != nil {
+ panic(err)
+ }
+}
+
+// defaults sets the default values of the builder before save.
+func (_u *UserIdentityUpdateOne) defaults() error {
+ if _, ok := _u.mutation.UpdatedAt(); !ok && !_u.mutation.UpdatedAtCleared() {
+ if useridentity.UpdateDefaultUpdatedAt == nil {
+ return fmt.Errorf("db: uninitialized useridentity.UpdateDefaultUpdatedAt (forgotten import db/runtime?)")
+ }
+ v := useridentity.UpdateDefaultUpdatedAt()
+ _u.mutation.SetUpdatedAt(v)
+ }
+ return nil
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (_u *UserIdentityUpdateOne) check() error {
+ if v, ok := _u.mutation.Platform(); ok {
+ if err := useridentity.PlatformValidator(string(v)); err != nil {
+ return &ValidationError{Name: "platform", err: fmt.Errorf(`db: validator failed for field "UserIdentity.platform": %w`, err)}
+ }
+ }
+ if v, ok := _u.mutation.IdentityID(); ok {
+ if err := useridentity.IdentityIDValidator(v); err != nil {
+ return &ValidationError{Name: "identity_id", err: fmt.Errorf(`db: validator failed for field "UserIdentity.identity_id": %w`, err)}
+ }
+ }
+ if v, ok := _u.mutation.Username(); ok {
+ if err := useridentity.UsernameValidator(v); err != nil {
+ return &ValidationError{Name: "username", err: fmt.Errorf(`db: validator failed for field "UserIdentity.username": %w`, err)}
+ }
+ }
+ if _u.mutation.UserCleared() && len(_u.mutation.UserIDs()) > 0 {
+ return errors.New(`db: clearing a required unique edge "UserIdentity.user"`)
+ }
+ return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (_u *UserIdentityUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserIdentityUpdateOne {
+ _u.modifiers = append(_u.modifiers, modifiers...)
+ return _u
+}
+
+func (_u *UserIdentityUpdateOne) sqlSave(ctx context.Context) (_node *UserIdentity, err error) {
+ if err := _u.check(); err != nil {
+ return _node, err
+ }
+ _spec := sqlgraph.NewUpdateSpec(useridentity.Table, useridentity.Columns, sqlgraph.NewFieldSpec(useridentity.FieldID, field.TypeUUID))
+ id, ok := _u.mutation.ID()
+ if !ok {
+ return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "UserIdentity.id" for update`)}
+ }
+ _spec.Node.ID.Value = id
+ if fields := _u.fields; len(fields) > 0 {
+ _spec.Node.Columns = make([]string, 0, len(fields))
+ _spec.Node.Columns = append(_spec.Node.Columns, useridentity.FieldID)
+ for _, f := range fields {
+ if !useridentity.ValidColumn(f) {
+ return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+ }
+ if f != useridentity.FieldID {
+ _spec.Node.Columns = append(_spec.Node.Columns, f)
+ }
+ }
+ }
+ if ps := _u.mutation.predicates; len(ps) > 0 {
+ _spec.Predicate = func(selector *sql.Selector) {
+ for i := range ps {
+ ps[i](selector)
+ }
+ }
+ }
+ if value, ok := _u.mutation.DeletedAt(); ok {
+ _spec.SetField(useridentity.FieldDeletedAt, field.TypeTime, value)
+ }
+ if _u.mutation.DeletedAtCleared() {
+ _spec.ClearField(useridentity.FieldDeletedAt, field.TypeTime)
+ }
+ if value, ok := _u.mutation.Platform(); ok {
+ _spec.SetField(useridentity.FieldPlatform, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.IdentityID(); ok {
+ _spec.SetField(useridentity.FieldIdentityID, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Username(); ok {
+ _spec.SetField(useridentity.FieldUsername, field.TypeString, value)
+ }
+ if value, ok := _u.mutation.Email(); ok {
+ _spec.SetField(useridentity.FieldEmail, field.TypeString, value)
+ }
+ if _u.mutation.EmailCleared() {
+ _spec.ClearField(useridentity.FieldEmail, field.TypeString)
+ }
+ if value, ok := _u.mutation.AvatarURL(); ok {
+ _spec.SetField(useridentity.FieldAvatarURL, field.TypeString, value)
+ }
+ if _u.mutation.AvatarURLCleared() {
+ _spec.ClearField(useridentity.FieldAvatarURL, field.TypeString)
+ }
+ if value, ok := _u.mutation.CreatedAt(); ok {
+ _spec.SetField(useridentity.FieldCreatedAt, field.TypeTime, value)
+ }
+ if value, ok := _u.mutation.UpdatedAt(); ok {
+ _spec.SetField(useridentity.FieldUpdatedAt, field.TypeTime, value)
+ }
+ if _u.mutation.UpdatedAtCleared() {
+ _spec.ClearField(useridentity.FieldUpdatedAt, field.TypeTime)
+ }
+ if _u.mutation.UserCleared() {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: useridentity.UserTable,
+ Columns: []string{useridentity.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ _spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+ }
+ if nodes := _u.mutation.UserIDs(); len(nodes) > 0 {
+ edge := &sqlgraph.EdgeSpec{
+ Rel: sqlgraph.M2O,
+ Inverse: true,
+ Table: useridentity.UserTable,
+ Columns: []string{useridentity.UserColumn},
+ Bidi: false,
+ Target: &sqlgraph.EdgeTarget{
+ IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeUUID),
+ },
+ }
+ for _, k := range nodes {
+ edge.Target.Nodes = append(edge.Target.Nodes, k)
+ }
+ _spec.Edges.Add = append(_spec.Edges.Add, edge)
+ }
+ _spec.AddModifiers(_u.modifiers...)
+ _node = &UserIdentity{config: _u.config}
+ _spec.Assign = _node.assignValues
+ _spec.ScanValues = _node.scanValues
+ if err = sqlgraph.UpdateNode(ctx, _u.driver, _spec); err != nil {
+ if _, ok := err.(*sqlgraph.NotFoundError); ok {
+ err = &NotFoundError{useridentity.Label}
+ } else if sqlgraph.IsConstraintError(err) {
+ err = &ConstraintError{msg: err.Error(), wrap: err}
+ }
+ return nil, err
+ }
+ _u.mutation.done = true
+ return _node, nil
+}
diff --git a/backend/docker-compose.yml b/backend/docker-compose.yml
new file mode 100644
index 00000000..e8b4db2c
--- /dev/null
+++ b/backend/docker-compose.yml
@@ -0,0 +1,21 @@
+version: '3.8'
+
+services:
+ postgres:
+ image: postgres:16-alpine
+ environment:
+ POSTGRES_USER: monkeycode
+ POSTGRES_PASSWORD: monkeycode
+ POSTGRES_DB: monkeycode
+ ports:
+ - "5432:5432"
+ volumes:
+ - pgdata:/var/lib/postgresql/data
+
+ redis:
+ image: redis:7-alpine
+ ports:
+ - "6379:6379"
+
+volumes:
+ pgdata:
diff --git a/backend/domain/audit.go b/backend/domain/audit.go
new file mode 100644
index 00000000..25182452
--- /dev/null
+++ b/backend/domain/audit.go
@@ -0,0 +1,83 @@
+package domain
+
+import (
+ "context"
+ "time"
+
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/pkg/cvt"
+)
+
+// AuditUsecase 审计日志业务逻辑接口
+type AuditUsecase interface {
+ CreateAudit(ctx context.Context, audit *Audit) error
+ ListAudits(ctx context.Context, teamUser *TeamUser, req *ListAuditsRequest) (*ListAuditsResponse, error)
+}
+
+// AuditRepo 审计日志仓库接口
+type AuditRepo interface {
+ CreateAudit(ctx context.Context, audit *Audit) error
+ ListAudits(ctx context.Context, teamUser *TeamUser, req *ListAuditsRequest) ([]*db.Audit, *db.Cursor, error)
+}
+
+// ListAuditsRequest 查询审计日志请求
+type ListAuditsRequest struct {
+ UserID uuid.UUID `query:"user_id" json:"user_id,omitempty"`
+ Operation string `query:"operation" json:"operation,omitempty"`
+ SourceIP string `query:"source_ip" json:"source_ip,omitempty"`
+ UserAgent string `query:"user_agent" json:"user_agent,omitempty"`
+ Request string `query:"request" json:"request,omitempty"`
+ Response string `query:"response" json:"response,omitempty"`
+ CreatedAtStart time.Time `query:"created_at_start" json:"created_at_start"`
+ CreatedAtEnd time.Time `query:"created_at_end" json:"created_at_end"`
+ CursorReq
+}
+
+// ListAuditsResponse 查询审计日志响应
+type ListAuditsResponse struct {
+ Audits []*Audit `json:"audits"`
+ Page *db.Cursor `json:"page"`
+}
+
+// CreateAuditRequest 创建审计日志请求
+type CreateAuditRequest struct {
+ UserID uuid.UUID `json:"user_id" binding:"required"`
+ Operation string `json:"operation" binding:"required"`
+ SourceIP string `json:"source_ip" binding:"required"`
+ UserAgent string `json:"user_agent"`
+ Request string `json:"request"`
+ Response string `json:"response"`
+}
+
+// Audit 审计日志
+type Audit struct {
+ ID uuid.UUID `json:"id"`
+ Operation string `json:"operation"`
+ SourceIP string `json:"source_ip"`
+ UserAgent string `json:"user_agent"`
+ Request string `json:"request"`
+ Response string `json:"response"`
+ CreatedAt time.Time `json:"created_at"`
+ User *User `json:"user"`
+}
+
+// From 从 dbAudit 转换为 domain.Audit
+func (a *Audit) From(src *db.Audit) *Audit {
+ if src == nil {
+ return nil
+ }
+ a.ID = src.ID
+ a.Operation = src.Operation
+ a.SourceIP = src.SourceIP
+ a.UserAgent = src.UserAgent
+ a.Request = src.Request
+ a.Response = src.Response
+ a.CreatedAt = src.CreatedAt
+
+ if src.Edges.User != nil {
+ a.User = cvt.From(src.Edges.User, &User{})
+ }
+ return a
+}
diff --git a/backend/domain/captcha.go b/backend/domain/captcha.go
new file mode 100644
index 00000000..6807038a
--- /dev/null
+++ b/backend/domain/captcha.go
@@ -0,0 +1,6 @@
+package domain
+
+type RedeemCaptchaReq struct {
+ Token string `json:"token"`
+ Solutions []int64 `json:"solutions"`
+}
diff --git a/backend/domain/team.go b/backend/domain/team.go
new file mode 100644
index 00000000..1f769849
--- /dev/null
+++ b/backend/domain/team.go
@@ -0,0 +1,322 @@
+package domain
+
+import (
+ "context"
+ "time"
+
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/pkg/cvt"
+
+ "github.com/chaitin/MonkeyCode/backend/consts"
+)
+
+// TeamGroupUserUsecase 团队分组成员业务逻辑接口
+type TeamGroupUserUsecase interface {
+ List(ctx context.Context, teamUser *TeamUser) (*ListTeamGroupsResp, error)
+ Add(ctx context.Context, teamUser *TeamUser, req *AddTeamGroupReq) (*TeamGroup, error)
+ AddUser(ctx context.Context, teamUser *TeamUser, req *AddTeamUserReq) (*AddTeamUserResp, error)
+ AddAdmin(ctx context.Context, teamUser *TeamUser, req *AddTeamAdminReq) (*AddTeamAdminResp, error)
+ Update(ctx context.Context, req *UpdateTeamGroupReq) (*TeamGroup, error)
+ Delete(ctx context.Context, teamUser *TeamUser, req *DeleteTeamGroupReq) error
+ ListGroups(ctx context.Context, req *ListTeamGroupUsersReq) (*ListTeamGroupUsersResp, error)
+ ModifyGroups(ctx context.Context, req *AddTeamGroupUsersReq) (*AddTeamGroupUsersResp, error)
+ DeleteGroups(ctx context.Context, req *DeleteTeamGroupUserReq) error
+ Login(ctx context.Context, req *TeamLoginReq) (*User, error)
+ MemberList(ctx context.Context, teamUser *TeamUser, req *MemberListReq) (*MemberListResp, error)
+ ChangePassword(ctx context.Context, userID uuid.UUID, req *ChangePasswordReq) error
+ UpdateUser(ctx context.Context, req *UpdateTeamUserReq) (*UpdateTeamUserResp, error)
+}
+
+// TeamGroupUserRepo 团队分组成员数据访问接口
+type TeamGroupUserRepo interface {
+ List(ctx context.Context, teamID uuid.UUID) ([]*db.TeamGroup, error)
+ Get(ctx context.Context, groupID uuid.UUID) (*db.TeamGroup, error)
+ Create(ctx context.Context, teamID uuid.UUID, req *AddTeamGroupReq) (*db.TeamGroup, error)
+ CreateUsers(ctx context.Context, teamID uuid.UUID, req *AddTeamUserReq) ([]*db.User, error)
+ CreateAdmin(ctx context.Context, teamID uuid.UUID, req *AddTeamAdminReq) (*db.User, error)
+ Update(ctx context.Context, req *UpdateTeamGroupReq) (*db.TeamGroup, error)
+ Delete(ctx context.Context, teamID, groupID uuid.UUID) error
+ ListGroupUsers(ctx context.Context, groupID uuid.UUID) ([]*db.TeamGroupMember, error)
+ ModifyGroupUsers(ctx context.Context, groupID uuid.UUID, userIDs []uuid.UUID) ([]*db.TeamGroupMember, error)
+ DeleteGroupUser(ctx context.Context, groupID, userID uuid.UUID) error
+ Login(ctx context.Context, req *TeamLoginReq) (*db.User, error)
+ MemberList(ctx context.Context, teamID uuid.UUID, role consts.TeamMemberRole) ([]*db.TeamMember, error)
+ ChangePassword(ctx context.Context, userID uuid.UUID, currentPassword, newPassword string) error
+ GetTeam(ctx context.Context, teamID uuid.UUID) (*db.Team, error)
+ UpdateUser(ctx context.Context, userID uuid.UUID, req *UpdateTeamUserReq) (*db.User, error)
+ GetMembersByIDs(ctx context.Context, teamID uuid.UUID, userIDs []uuid.UUID) ([]*db.TeamMember, error)
+ GetMember(ctx context.Context, teamID, userID uuid.UUID) (*db.TeamMember, error)
+}
+
+type Team struct {
+ ID uuid.UUID `json:"id"`
+ Name string `json:"name"`
+}
+
+// From 从数据库模型转换为领域模型
+func (t *Team) From(src *db.Team) *Team {
+ if src == nil {
+ return t
+ }
+ t.ID = src.ID
+ t.Name = src.Name
+ return t
+}
+
+// TeamMember 团队成员
+type TeamMember struct {
+ TeamID uuid.UUID `json:"team_id"`
+ UserID uuid.UUID `json:"user_id"`
+ TeamName string `json:"team_name"`
+ TeamRole consts.TeamMemberRole `json:"team_role"`
+}
+
+// From 从数据库模型转换为领域模型
+func (t *TeamMember) From(src *db.TeamMember) *TeamMember {
+ if src == nil {
+ return t
+ }
+ t.TeamID = src.TeamID
+ t.UserID = src.UserID
+ if src.Edges.Team != nil {
+ t.TeamName = src.Edges.Team.Name
+ }
+ t.TeamRole = src.Role
+ return t
+}
+
+// TeamUser 用户团队信息
+type TeamUser struct {
+ User *User `json:"user"`
+ Team *Team `json:"team"`
+}
+
+// From 从数据库模型转换为领域模型
+func (t *TeamUser) From(src *db.User) *TeamUser {
+ if src == nil {
+ return t
+ }
+ t.User = cvt.From(src, &User{})
+ if teams := src.Edges.Teams; len(teams) > 0 {
+ t.Team = cvt.From(teams[0], &Team{})
+ }
+
+ return t
+}
+
+// GetTeamID 获取团队ID
+func (t *TeamUser) GetTeamID() uuid.UUID {
+ if t.Team != nil {
+ return t.Team.ID
+ }
+ return uuid.Nil
+}
+
+// TeamGroup 团队分组信息
+type TeamGroup struct {
+ ID uuid.UUID `json:"id"`
+ Name string `json:"name"`
+ CreatedAt int64 `json:"created_at"`
+ UpdatedAt int64 `json:"updated_at"`
+ Users []*User `json:"users,omitempty"`
+}
+
+// From 从数据库模型转换为领域模型
+func (t *TeamGroup) From(src *db.TeamGroup) *TeamGroup {
+ if src == nil {
+ return t
+ }
+
+ t.ID = src.ID
+ t.Name = src.Name
+ t.CreatedAt = src.CreatedAt.Unix()
+ t.UpdatedAt = src.UpdatedAt.Unix()
+ t.Users = cvt.Iter(src.Edges.Members, func(_ int, member *db.User) *User {
+ return cvt.From(member, &User{})
+ })
+ return t
+}
+
+// ListTeamGroupsReq 获取团队分组列表请求
+type ListTeamGroupsReq struct{}
+
+// ListTeamGroupsResp 获取团队分组列表响应
+type ListTeamGroupsResp struct {
+ Groups []*TeamGroup `json:"groups"`
+}
+
+// AddTeamGroupReq 创建团队分组请求
+type AddTeamGroupReq struct {
+ Name string `json:"name" validate:"required"`
+}
+
+// UpdateTeamGroupReq 更新团队分组请求
+type UpdateTeamGroupReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"`
+ Name string `json:"name" validate:"required"`
+}
+
+// DeleteTeamGroupReq 删除团队分组请求
+type DeleteTeamGroupReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"`
+}
+
+// ListTeamGroupUsersReq 获取团队组成员列表请求
+type ListTeamGroupUsersReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"`
+}
+
+// ListTeamGroupUsersResp 获取团队组成员列表响应
+type ListTeamGroupUsersResp struct {
+ Users []*User `json:"users"`
+}
+
+// AddTeamGroupUsersReq 添加团队组成员请求
+type AddTeamGroupUsersReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"`
+ UserIDs []uuid.UUID `json:"user_ids" validate:"required"`
+}
+
+// AddTeamGroupUsersResp 添加团队组成员响应
+type AddTeamGroupUsersResp struct {
+ Users []*User `json:"users"`
+}
+
+// DeleteTeamGroupUserReq 删除团队组成员请求
+type DeleteTeamGroupUserReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"`
+ UserID uuid.UUID `param:"user_id" validate:"required" json:"-" swaggerignore:"true"`
+}
+
+// JoinGroupReq 用户加入团队分组请求
+type JoinGroupReq struct {
+ InviteCode string `query:"invite_code" validate:"required"` // 邀请码
+}
+
+// JoinGroupResp 用户加入团队分组响应
+type JoinGroupResp struct {
+ Message string `json:"message"`
+ Success bool `json:"success"`
+}
+
+// TeamLoginReq 团队用户登录请求
+type TeamLoginReq struct {
+ Email string `json:"email" validate:"required"` // 用户邮箱
+ Password string `json:"password" validate:"required"` // 用户密码（MD5加密后的值）
+ CaptchaToken string `json:"captcha_token" validate:"required"` // 验证码Token
+}
+
+// TeamLoginResp 团队用户登录响应
+type TeamLoginResp struct {
+ Success bool `json:"success"`
+ Message string `json:"message"`
+ TeamUser
+}
+
+// TeamUserStatusResp 团队用户状态响应
+type TeamUserStatusResp struct {
+ TeamUser
+ Login bool `json:"login"`
+}
+
+// InviteLinkReq 生成邀请链接请求
+type InviteLinkReq struct {
+ GroupID uuid.UUID `param:"group_id" validate:"required" json:"-" swaggerignore:"true"` // 团队组ID
+ ExpireAt *time.Time `json:"expire_at" validate:"omitempty"` // 邀请链接过期时间
+}
+
+// Validate 验证邀请链接请求
+func (i *InviteLinkReq) Validate() error {
+ if i.ExpireAt == nil {
+ expireAt := time.Now().Add(5 * time.Minute)
+ i.ExpireAt = &expireAt
+ }
+ return nil
+}
+
+// TeamInviteLinkResp 团队邀请链接响应
+type TeamInviteLinkResp struct {
+ InviteLink string `json:"invite_link"`
+}
+
+// TeamLogoutResp 团队用户登出响应
+type TeamLogoutResp struct {
+ Message string `json:"message"`
+}
+
+// AddTeamUserReq 创建团队成员请求
+type AddTeamUserReq struct {
+ Emails []string `json:"emails" validate:"required"` // 邮箱列表
+ GroupID uuid.UUID `json:"group_id" validate:"omitempty"` // 团队组ID
+}
+
+// AddTeamUserResp 创建团队成员响应
+type AddTeamUserResp struct {
+ Users []*TeamUser `json:"users"`
+}
+
+// AddTeamAdminReq 创建团队管理员请求
+type AddTeamAdminReq struct {
+ Email string `json:"email" validate:"required,email"` // 邮箱
+ Name string `json:"name" validate:"required"` // 姓名
+}
+
+// AddTeamAdminResp 创建团队管理员响应
+type AddTeamAdminResp struct {
+ User *TeamUser `json:"user"`
+}
+
+// MemberListReq 获取团队成员列表请求
+type MemberListReq struct {
+ Role consts.TeamMemberRole `query:"role" validate:"omitempty"`
+}
+
+// MemberListResp 获取团队成员列表响应
+type MemberListResp struct {
+ Members []*TeamMemberInfo `json:"members"`
+ MemberLimit int `json:"member_limit"`
+}
+
+// TeamMemberInfo 团队成员信息
+type TeamMemberInfo struct {
+ User *User `json:"user"`
+ Role consts.TeamMemberRole `json:"role"`
+ CreatedAt int64 `json:"created_at"`
+ LastActiveAt int64 `json:"last_active_at"`
+}
+
+// ChangePasswordReq 修改密码请求
+type ChangePasswordReq struct {
+ CurrentPassword string `json:"current_password" validate:"omitempty"` // 当前密码
+ NewPassword string `json:"new_password" validate:"required,min=8,max=32"` // 新密码
+}
+
+// ChangePasswordResp 修改密码响应
+type ChangePasswordResp struct {
+ Success bool `json:"success"`
+ Message string `json:"message"`
+}
+
+// UpdateTeamUserReq 更新团队用户信息请求
+type UpdateTeamUserReq struct {
+ UserID uuid.UUID `param:"user_id" validate:"required" json:"-" swaggerignore:"true"`
+ IsBlocked *bool `json:"is_blocked" validate:"omitempty"`
+}
+
+// UpdateTeamUserResp 更新团队用户信息响应
+type UpdateTeamUserResp struct {
+ User *User `json:"user"`
+}
+
+// ResetPasswordReq 重置密码请求
+type ResetPasswordReq struct {
+ UserIDs []uuid.UUID `json:"user_ids" validate:"required"` // 用户ID列表
+}
+
+// InviteLinkToken 邀请链接令牌
+type InviteLinkToken struct {
+ TeamID uuid.UUID `json:"team_id"`
+ GroupID uuid.UUID `json:"group_id"`
+}
diff --git a/backend/domain/user.go b/backend/domain/user.go
new file mode 100644
index 00000000..03f85fd1
--- /dev/null
+++ b/backend/domain/user.go
@@ -0,0 +1,157 @@
+package domain
+
+import (
+ "context"
+
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/pkg/cvt"
+
+ "github.com/chaitin/MonkeyCode/backend/consts"
+)
+
+type UserUsecase interface {
+ Get(ctx context.Context, uid uuid.UUID) (*User, error)
+ Update(ctx context.Context, uid uuid.UUID, avatarURL string, req UpdateUserReq) (*User, error)
+ GetUserWithTeams(ctx context.Context, userID uuid.UUID) (*TeamUserInfo, error)
+ PasswordLogin(ctx context.Context, req *TeamLoginReq) (*User, error)
+ ChangePassword(ctx context.Context, userID uuid.UUID, req *ChangePasswordReq, isReset bool) error
+ SendResetPasswordEmail(ctx context.Context, req *ResetUserPasswordEmailReq) error
+ GetUserByEmail(ctx context.Context, emails []string) ([]*User, error)
+}
+
+type UserRepo interface {
+ Get(ctx context.Context, uid uuid.UUID) (*db.User, error)
+ Update(ctx context.Context, uid uuid.UUID, name, avatarURL string) error
+ GetUserWithTeams(ctx context.Context, uid uuid.UUID) (*db.User, error)
+ PasswordLogin(ctx context.Context, req *TeamLoginReq) (*db.User, error)
+ ChangePassword(ctx context.Context, uid uuid.UUID, currentPassword, newPassword string, isReset bool) error
+ GetUserByEmail(ctx context.Context, emails []string) ([]*db.User, error)
+}
+
+type User struct {
+ ID uuid.UUID `json:"id"`
+ Name string `json:"name"`
+ AvatarURL string `json:"avatar_url"`
+ Email string `json:"email"`
+ Role consts.UserRole `json:"role"`
+ Status consts.UserStatus `json:"status"`
+ IsBlocked bool `json:"is_blocked"`
+ Token string `json:"token,omitempty"`
+ Identities []*UserIdentity `json:"identities"`
+ Team *Team `json:"team,omitempty"`
+}
+
+func (u *User) From(src *db.User) *User {
+ if src == nil {
+ return u
+ }
+
+ u.ID = src.ID
+ u.Name = src.Name
+ u.AvatarURL = src.AvatarURL
+ u.Email = src.Email
+ u.Role = src.Role
+ u.Status = consts.UserStatusActive
+ u.IsBlocked = src.IsBlocked
+ u.Identities = cvt.Iter(src.Edges.Identities, func(_ int, i *db.UserIdentity) *UserIdentity {
+ return cvt.From(i, &UserIdentity{})
+ })
+ if teams := src.Edges.Teams; len(teams) > 0 {
+ u.Team = cvt.From(teams[0], &Team{})
+ }
+ return u
+}
+
+type UserIdentity struct {
+ ID uuid.UUID `json:"id"`
+ AvatarURL string `json:"avatar_url"`
+ Username string `json:"username"`
+ IdentityID string `json:"identity_id"`
+ Platform consts.UserPlatform `json:"platform"`
+ Email string `json:"email"`
+}
+
+func (i *UserIdentity) From(src *db.UserIdentity) *UserIdentity {
+ if src == nil {
+ return i
+ }
+
+ i.ID = src.ID
+ i.AvatarURL = src.AvatarURL
+ i.Username = src.Username
+ i.Platform = src.Platform
+ i.Email = src.Email
+ i.IdentityID = src.IdentityID
+
+ return i
+}
+
+// TeamUserInfo 用户团队信息
+type TeamUserInfo struct {
+ User *User `json:"user"`
+ Teams []*TeamMember `json:"teams"`
+}
+
+// From 从数据库模型转换为领域模型
+func (t *TeamUserInfo) From(src *db.User) *TeamUserInfo {
+ if src == nil {
+ return t
+ }
+ t.User = cvt.From(src, &User{})
+ t.Teams = cvt.Iter(src.Edges.TeamMembers, func(_ int, team *db.TeamMember) *TeamMember {
+ return cvt.From(team, &TeamMember{})
+ })
+ return t
+}
+
+// TeamUserLoginResp 团队用户登录响应
+type TeamUserLoginResp struct {
+ TeamUserInfo
+}
+
+// UpdateUserReq 更新用户信息请求
+type UpdateUserReq struct {
+ Name string `json:"name,omitempty" form:"name"`
+ AvatarURL string `json:"avatar_url,omitempty" form:"avatar_url"`
+}
+
+// UpdateUserResp 更新用户信息响应
+type UpdateUserResp struct {
+ User *User `json:"user"`
+ Message string `json:"message"`
+ Success bool `json:"success"`
+}
+
+// GetAccountInfoReq 通过 token 查询账户信息请求
+type GetAccountInfoReq struct {
+ Token string `param:"token" validate:"required"`
+}
+
+// ResetUserPasswordReq 修改密码请求
+type ResetUserPasswordReq struct {
+ NewPassword string `json:"new_password" validate:"required,min=8,max=32"`
+ Token string `json:"token" validate:"required"`
+}
+
+// ResetUserPasswordEmailReq 发送重置密码邮件请求
+type ResetUserPasswordEmailReq struct {
+ Emails []string `json:"emails" validate:"required"`
+ CaptchaToken string `json:"captcha_token" validate:"required"`
+}
+
+// TeamMembersResp 团队成员列表响应
+type TeamMembersResp []*User
+
+// ActivateReq 激活请求
+type ActivateReq struct {
+ InviteCode string `json:"invite_code" validate:"required"`
+ InviterID string `json:"inviter_id,omitempty"`
+}
+
+// CursorReq 游标分页请求
+type CursorReq struct {
+ Cursor string `query:"cursor"`
+ Limit int `query:"limit"`
+}
diff --git a/backend/ent/entc.go b/backend/ent/entc.go
new file mode 100644
index 00000000..2637801d
--- /dev/null
+++ b/backend/ent/entc.go
@@ -0,0 +1,34 @@
+//go:build ignore
+
+package main
+
+import (
+ "log"
+
+ "entgo.io/ent/entc"
+ "entgo.io/ent/entc/gen"
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+)
+
+func main() {
+ if err := entc.Generate(
+ "./schema",
+ &gen.Config{
+ Target: "../db",
+ Package: "github.com/chaitin/MonkeyCode/backend/db",
+ Features: []gen.Feature{
+ gen.FeatureUpsert,
+ gen.FeatureModifier,
+ gen.FeatureExecQuery,
+ gen.FeatureIntercept,
+ gen.FeatureLock,
+ },
+ },
+ entc.Extensions(
+ &entx.Cursor{},
+ &entx.Page{},
+ ),
+ ); err != nil {
+ log.Fatal("running ent codegen:", err)
+ }
+}
diff --git a/backend/ent/generate.go b/backend/ent/generate.go
new file mode 100644
index 00000000..8232761c
--- /dev/null
+++ b/backend/ent/generate.go
@@ -0,0 +1,3 @@
+package ent
+
+//go:generate go run -mod=mod entc.go
diff --git a/backend/ent/schema/audit.go b/backend/ent/schema/audit.go
new file mode 100644
index 00000000..7a3d0938
--- /dev/null
+++ b/backend/ent/schema/audit.go
@@ -0,0 +1,46 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+ "github.com/google/uuid"
+)
+
+// Audit holds the schema definition for the Audit entity.
+type Audit struct {
+ ent.Schema
+}
+
+func (Audit) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("audits"),
+ entx.NewCursor(entx.CursorKindCreatedAt),
+ }
+}
+
+// Fields of the Audit.
+func (Audit) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}),
+ field.UUID("user_id", uuid.UUID{}),
+ field.String("operation"),
+ field.String("source_ip"),
+ field.String("user_agent"),
+ field.String("request"),
+ field.String("response").Optional(),
+ field.Time("created_at").Default(time.Now),
+ }
+}
+
+// Edges of the Audit.
+func (Audit) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.From("user", User.Type).Ref("audits").Field("user_id").Unique().Required(),
+ }
+}
diff --git a/backend/ent/schema/team.go b/backend/ent/schema/team.go
new file mode 100644
index 00000000..bb9c9f03
--- /dev/null
+++ b/backend/ent/schema/team.go
@@ -0,0 +1,50 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+)
+
+// Team holds the schema definition for the Team entity.
+type Team struct {
+ ent.Schema
+}
+
+func (Team) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("teams"),
+ }
+}
+
+func (Team) Mixin() []ent.Mixin {
+ return []ent.Mixin{
+ entx.SoftDeleteMixin2{},
+ }
+}
+
+// Fields of the Team.
+func (Team) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.String("name").NotEmpty(),
+ field.Int("member_limit"),
+ field.Time("created_at").Default(time.Now),
+ field.Time("updated_at").Default(time.Now),
+ }
+}
+
+// Edges of the Team.
+func (Team) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.To("groups", TeamGroup.Type),
+ edge.From("members", User.Type).Ref("teams").Through("team_members", TeamMember.Type),
+ }
+}
diff --git a/backend/ent/schema/teamgroup.go b/backend/ent/schema/teamgroup.go
new file mode 100644
index 00000000..50a626cf
--- /dev/null
+++ b/backend/ent/schema/teamgroup.go
@@ -0,0 +1,51 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+)
+
+// TeamGroup holds the schema definition for the TeamGroup entity.
+type TeamGroup struct {
+ ent.Schema
+}
+
+func (TeamGroup) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("team_groups"),
+ entx.NewCursor(entx.CursorKindCreatedAt),
+ }
+}
+
+func (TeamGroup) Mixin() []ent.Mixin {
+ return []ent.Mixin{
+ entx.SoftDeleteMixin2{},
+ }
+}
+
+// Fields of the TeamGroup.
+func (TeamGroup) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.UUID("team_id", uuid.UUID{}),
+ field.String("name"),
+ field.Time("created_at").Default(time.Now),
+ field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+ }
+}
+
+// Edges of the TeamGroup.
+func (TeamGroup) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.From("members", User.Type).Ref("groups").Through("team_group_members", TeamGroupMember.Type),
+ edge.From("team", Team.Type).Ref("groups").Field("team_id").Unique().Required(),
+ }
+}
diff --git a/backend/ent/schema/teamgroupmember.go b/backend/ent/schema/teamgroupmember.go
new file mode 100644
index 00000000..23c2cb1d
--- /dev/null
+++ b/backend/ent/schema/teamgroupmember.go
@@ -0,0 +1,41 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+)
+
+// TeamGroupMember holds the schema definition for the TeamGroupMember entity.
+type TeamGroupMember struct {
+ ent.Schema
+}
+
+func (TeamGroupMember) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("team_group_members"),
+ }
+}
+
+// Fields of the TeamGroupMember.
+func (TeamGroupMember) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.UUID("group_id", uuid.UUID{}),
+ field.UUID("user_id", uuid.UUID{}),
+ field.Time("created_at").Default(time.Now),
+ }
+}
+
+// Edges of the TeamGroupMember.
+func (TeamGroupMember) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.To("group", TeamGroup.Type).Field("group_id").Unique().Required(),
+ edge.To("user", User.Type).Field("user_id").Unique().Required(),
+ }
+}
diff --git a/backend/ent/schema/teammember.go b/backend/ent/schema/teammember.go
new file mode 100644
index 00000000..8879efd6
--- /dev/null
+++ b/backend/ent/schema/teammember.go
@@ -0,0 +1,44 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/consts"
+)
+
+// TeamMember holds the schema definition for the TeamMember entity.
+type TeamMember struct {
+ ent.Schema
+}
+
+func (TeamMember) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("team_members"),
+ }
+}
+
+// Fields of the TeamMember.
+func (TeamMember) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.UUID("team_id", uuid.UUID{}),
+ field.UUID("user_id", uuid.UUID{}),
+ field.String("role").GoType(consts.TeamMemberRole("")),
+ field.Time("created_at").Default(time.Now),
+ }
+}
+
+// Edges of the TeamMember.
+func (TeamMember) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.To("team", Team.Type).Field("team_id").Unique().Required(),
+ edge.To("user", User.Type).Field("user_id").Unique().Required(),
+ }
+}
diff --git a/backend/ent/schema/user.go b/backend/ent/schema/user.go
new file mode 100644
index 00000000..af77c9ad
--- /dev/null
+++ b/backend/ent/schema/user.go
@@ -0,0 +1,59 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+)
+
+// User holds the schema definition for the User entity.
+type User struct {
+ ent.Schema
+}
+
+func (User) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("users"),
+ }
+}
+
+func (User) Mixin() []ent.Mixin {
+ return []ent.Mixin{
+ entx.SoftDeleteMixin2{},
+ }
+}
+
+// Fields of the User.
+func (User) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.String("name").NotEmpty(),
+ field.String("email").Optional(),
+ field.String("avatar_url").Optional(),
+ field.String("password").Optional(),
+ field.String("role").GoType(consts.UserRole("")),
+ field.String("status").GoType(consts.UserStatus("")),
+ field.Bool("is_blocked").Default(false),
+ field.JSON("default_configs", map[consts.DefaultConfigType]uuid.UUID{}).Optional(),
+ field.Time("created_at").Default(time.Now),
+ field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+ }
+}
+
+// Edges of the User.
+func (User) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.To("identities", UserIdentity.Type),
+ edge.To("audits", Audit.Type),
+ edge.To("teams", Team.Type).Through("team_members", TeamMember.Type),
+ edge.To("groups", TeamGroup.Type).Through("team_group_members", TeamGroupMember.Type),
+ }
+}
diff --git a/backend/ent/schema/useridentity.go b/backend/ent/schema/useridentity.go
new file mode 100644
index 00000000..6d107c24
--- /dev/null
+++ b/backend/ent/schema/useridentity.go
@@ -0,0 +1,54 @@
+package schema
+
+import (
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/entsql"
+ "entgo.io/ent/schema"
+ "entgo.io/ent/schema/edge"
+ "entgo.io/ent/schema/field"
+ "github.com/google/uuid"
+
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/pkg/entx"
+)
+
+// UserIdentity holds the schema definition for the UserIdentity entity.
+type UserIdentity struct {
+ ent.Schema
+}
+
+func (UserIdentity) Annotations() []schema.Annotation {
+ return []schema.Annotation{
+ entsql.Table("user_identities"),
+ }
+}
+
+func (UserIdentity) Mixin() []ent.Mixin {
+ return []ent.Mixin{
+ entx.SoftDeleteMixin2{},
+ }
+}
+
+// Fields of the UserIdentity.
+func (UserIdentity) Fields() []ent.Field {
+ return []ent.Field{
+ field.UUID("id", uuid.UUID{}).Unique(),
+ field.UUID("user_id", uuid.UUID{}),
+ field.String("platform").GoType(consts.UserPlatform("")).NotEmpty(),
+ field.String("identity_id").NotEmpty(),
+ field.String("username").NotEmpty(),
+ field.String("email").Optional(),
+ field.String("avatar_url").Optional(),
+ field.Time("created_at").Default(time.Now),
+ field.Time("updated_at").UpdateDefault(time.Now).Optional(),
+ }
+}
+
+// Edges of the UserIdentity.
+func (UserIdentity) Edges() []ent.Edge {
+ return []ent.Edge{
+ edge.From("user", User.Type).Ref("identities").Field("user_id").Required().Unique(),
+ }
+}
diff --git a/backend/errcode/errcode.go b/backend/errcode/errcode.go
new file mode 100644
index 00000000..03872746
--- /dev/null
+++ b/backend/errcode/errcode.go
@@ -0,0 +1,106 @@
+// Package errcode 提供统一的错误码定义和国际化支持
+package errcode
+
+import (
+ "embed"
+ "net/http"
+
+ "github.com/GoYoko/web"
+)
+
+// LocalFS 嵌入本地化文件系统
+//
+//go:embed locale.*.toml
+var LocalFS embed.FS
+
+// 框架层面的错误
+var (
+ ErrUnauthorized = web.NewErr(http.StatusUnauthorized, http.StatusUnauthorized, "err-unauthorized")
+ ErrForbidden = web.NewErr(http.StatusForbidden, http.StatusForbidden, "err-forbidden")
+ ErrBadRequest = web.NewErr(http.StatusBadRequest, http.StatusBadRequest, "err-bad-request")
+)
+
+// 业务层面的错误
+var (
+ // 通用的错误
+ ErrInternalServer = web.NewErr(http.StatusOK, 10000, "err-internal-server")
+ ErrPermision = web.NewErr(http.StatusOK, 10001, "err-permision-denied")
+ ErrNotFound = web.NewErr(http.StatusOK, 10002, "err-not-found")
+ ErrDuplicate = web.NewErr(http.StatusOK, 10003, "err-duplicate")
+ ErrDatabaseQuery = web.NewErr(http.StatusOK, 10004, "err-database-query")
+ ErrDatabaseOperation = web.NewErr(http.StatusOK, 10005, "err-database-operation-failed")
+ ErrHTTPRequest = web.NewErr(http.StatusOK, 10006, "err-http-request-failed")
+ ErrHasInvalidEntry = web.NewErr(http.StatusOK, 10007, "err-has-invalid-entry")
+ ErrStreamDisconnect = web.NewErr(http.StatusOK, 10008, "err-stream-disconnect")
+
+ // 业务模块特有的 错误码
+
+ // 文件管理
+ ErrFilePermisionDenied = web.NewErr(http.StatusOK, 10100, "err-file-permision-denied")
+ ErrFileOp = web.NewErr(http.StatusOK, 10101, "err-file-op")
+
+ // 主机管理
+ ErrVMIDRequired = web.NewErr(http.StatusOK, 10200, "err-vm-id-required")
+ ErrVMNotBelongToUser = web.NewErr(http.StatusOK, 10201, "err-vm-not-belong-to-user")
+ ErrPermisionDenied = web.NewErr(http.StatusOK, 10202, "err-permision-denied")
+ ErrInvalidInstallToken = web.NewErr(http.StatusOK, 10203, "err-host-id-required")
+ ErrPublicHostNotFound = web.NewErr(http.StatusOK, 10204, "err-public-host-not-found")
+ ErrHostOffline = web.NewErr(http.StatusOK, 10205, "err-host-offline")
+ ErrVMExpired = web.NewErr(http.StatusOK, 10206, "err-vm-expired")
+ ErrApplyPortFailed = web.NewErr(http.StatusOK, 10207, "err-apply-port-failed")
+ ErrRecyclePortFailed = web.NewErr(http.StatusOK, 10208, "err-recycle-port-failed")
+ ErrPublicHostCannotRenew = web.NewErr(http.StatusOK, 10209, "err-public-host-cannot-renew")
+ ErrPublicHostBeyondLimit = web.NewErr(http.StatusOK, 10230, "err-public-host-beyond-limit")
+ ErrVmRemoved = web.NewErr(http.StatusOK, 10231, "err-vm-removed")
+ ErrVmBeyondExpireTime = web.NewErr(http.StatusOK, 10232, "err-vm-beyond-expire-time")
+
+ // 模型配置管理
+ ErrInvalidAPIKey = web.NewErr(http.StatusOK, 10300, "err-model-id-required")
+ ErrInvalidParameter = web.NewErr(http.StatusOK, 10301, "err-invalid-parameter")
+
+ // 项目管理
+ ErrInvalidPlatform = web.NewErr(http.StatusOK, 10400, "err-invalid-platform")
+ ErrInvalidToken = web.NewErr(http.StatusOK, 10401, "err-invalid-token")
+ ErrInvalidCollaborarator = web.NewErr(http.StatusOK, 10402, "err-invalid-collaborarator")
+ ErrUpdateProjectFailed = web.NewErr(http.StatusOK, 10403, "err-update-project-failed")
+ ErrGitOperation = web.NewErr(http.StatusOK, 10404, "err-git-operation")
+ ErrProjectGitIdentityRequired = web.NewErr(http.StatusOK, 10405, "err-project-git-identity-required")
+ ErrRepoAlreadyLinked = web.NewErr(http.StatusOK, 10406, "err-repo-already-linked")
+ ErrGitIdentityInUseByProject = web.NewErr(http.StatusOK, 10407, "err-git-identity-in-use-by-project")
+ ErrForbiddenBaseURL = web.NewErr(http.StatusOK, 10408, "err-forbidden-base-url")
+
+ // 团队管理
+ ErrTeamMemberLimitExceeded = web.NewErr(http.StatusOK, 10500, "err-team-member-limit-exceeded")
+ ErrInvalidPassword = web.NewErr(http.StatusOK, 10501, "err-invalid-password")
+ ErrSMSFailed = web.NewErr(http.StatusOK, 10502, "err-sms-failed")
+ ErrUserAlreadyExists = web.NewErr(http.StatusOK, 10503, "err-user-already-exists")
+ ErrChangePasswordFailed = web.NewErr(http.StatusOK, 10504, "err-change-password-failed")
+ ErrPasswordHashFailed = web.NewErr(http.StatusOK, 10505, "err-password-hash-failed")
+
+ // 用户管理
+ ErrIdentityAlreadyBound = web.NewErr(http.StatusOK, 10601, "err-identity-already-bound")
+ ErrInvalidState = web.NewErr(http.StatusOK, 10602, "err-invalid-state")
+ ErrNotLoggedIn = web.NewErr(http.StatusOK, 10603, "err-not-logged-in")
+ ErrUserBlocked = web.NewErr(http.StatusOK, 10605, "err-user-blocked")
+ ErrLoginFailed = web.NewErr(http.StatusOK, 10606, "err-login-failed")
+ ErrInvalidCoupon = web.NewErr(http.StatusOK, 10607, "err-invalid-coupon")
+ ErrResetPasswordFailed = web.NewErr(http.StatusOK, 10608, "err-reset-password-failed")
+ ErrWalletInsufficient = web.NewErr(http.StatusOK, 10609, "err-wallet-insufficient")
+ ErrAccountOverdraft = web.NewErr(http.StatusOK, 10610, "err-account-overdraft")
+
+ // captcha 模块
+ ErrCreateCaptchaFailed = web.NewErr(http.StatusOK, 10700, "err-create-captcha-failed")
+ ErrRedeemCaptchaFailed = web.NewErr(http.StatusOK, 10701, "err-redeem-captcha-failed")
+ ErrCaptchaVerifyFailed = web.NewErr(http.StatusOK, 10702, "err-captcha-verify-failed")
+
+ ErrDepositFailed = web.NewErr(http.StatusOK, 10801, "err-deposit-failed")
+
+ // 知识库索引管理
+ ErrKBNilTree = web.NewErr(http.StatusOK, 10900, "err-kb-nil-tree")
+ ErrKBEmptyPath = web.NewErr(http.StatusOK, 10901, "err-kb-empty-path")
+ ErrKBPathNotFound = web.NewErr(http.StatusOK, 10902, "err-kb-path-not-found")
+ ErrKBNotFile = web.NewErr(http.StatusOK, 10903, "err-kb-not-file")
+ ErrKBNotDir = web.NewErr(http.StatusOK, 10904, "err-kb-not-dir")
+ ErrKBDirNotEmpty = web.NewErr(http.StatusOK, 10905, "err-kb-dir-not-empty")
+ ErrKBAlreadyExists = web.NewErr(http.StatusOK, 10906, "err-kb-already-exists")
+)
diff --git a/backend/errcode/locale.en.toml b/backend/errcode/locale.en.toml
new file mode 100644
index 00000000..eea6ed4d
--- /dev/null
+++ b/backend/errcode/locale.en.toml
@@ -0,0 +1,163 @@
+[err-unauthorized]
+other = "Unauthorized"
+
+[err-forbidden]
+other = "Forbidden"
+
+[err-bad-request]
+other = "Bad request"
+
+[err-internal-server]
+other = "Internal server error"
+
+[err-permision-denied]
+other = "Permission denied"
+
+[err-not-found]
+other = "Resource not found"
+
+[err-duplicate]
+other = "Duplicate entry"
+
+[err-database-query]
+other = "Database query failed"
+
+[err-database-operation-failed]
+other = "Database operation failed"
+
+[err-http-request-failed]
+other = "HTTP request failed"
+
+[err-file-permision-denied]
+other = "{{.file}} permission denied"
+
+[err-vm-id-required]
+other = "VM ID is required"
+
+[err-vm-not-belong-to-user]
+other = "VM does not belong to user"
+
+[err-host-id-required]
+other = "Host ID is required"
+
+[err-public-host-cannot-renew]
+other = "Public hosts cannot be renewed"
+
+[err-public-host-beyond-limit]
+other = "Number of public hosts beyond limit"
+
+[err-vm-beyond-expire-time]
+other = "Virtual machine expiration time exceeded"
+
+[err-model-id-required]
+other = "Model ID is required"
+
+[err-invalid-parameter]
+other = "Invalid parameter"
+
+[err-invalid-platform]
+other = "Invalid platform"
+
+[err-invalid-token]
+other = "Invalid token"
+
+[err-invalid-collaborarator]
+other = "Invalid collaborator"
+
+[err-update-project-failed]
+other = "Update project failed"
+
+[err-git-operation]
+other = "Git operation failed"
+
+[err-project-git-identity-required]
+other = "Project must be linked to a Git identity first"
+
+[err-repo-already-linked]
+other = "Repository already linked, duplicate binding not allowed"
+
+[err-git-identity-in-use-by-project]
+other = "This Git identity is in use by project(s), cannot delete"
+
+[err-team-member-limit-exceeded]
+other = "Team member limit exceeded"
+
+[err-invalid-password]
+other = "Invalid password"
+
+[err-sms-failed]
+other = "SMS send failed"
+
+[err-identity-already-bound]
+other = "Identity already bound"
+
+[err-invalid-state]
+other = "Invalid state"
+
+[err-not-logged-in]
+other = "Not logged in"
+
+[err-user-blocked]
+other = "User account is blocked"
+
+[err-not-allow-individual]
+other = "Individual users do not have permission to operate"
+
+[err-login-failed]
+other = "Login failed"
+
+[err-invalid-coupon]
+other = "Invalid coupon"
+
+[err-reset-password-failed]
+other = "Reset password failed"
+[err-create-captcha-failed]
+other = "Failed to create captcha"
+
+[err-redeem-captcha-failed]
+other = "Failed to redeem captcha"
+
+[err-public-host-not-found]
+other = "Public host not found"
+
+[err-host-offline]
+other = "Host is offline"
+
+[err-wallet-insufficient]
+other = "Insufficient wallet balance"
+
+[err-account-overdraft]
+other = "Account overdraft"
+
+[err-deposit-failed]
+other = "Deposit failed"
+
+[err-vm-expired]
+other = "Virtual machine expired"
+
+[err-apply-port-failed]
+other = "Failed to apply port"
+
+[err-recycle-port-failed]
+other = "Failed to recycle port"
+
+[err-kb-nil-tree]
+other = "Tree is nil"
+
+[err-kb-empty-path]
+other = "Path is empty"
+
+[err-kb-path-not-found]
+other = "Path not found"
+
+[err-kb-not-file]
+other = "Path is a directory, not a file"
+
+[err-kb-not-dir]
+other = "Path is a file, not a directory"
+
+[err-kb-dir-not-empty]
+other = "Directory is not empty"
+
+[err-kb-already-exists]
+other = "Path already exists with different type"
\ No newline at end of file
diff --git a/backend/errcode/locale.zh.toml b/backend/errcode/locale.zh.toml
new file mode 100644
index 00000000..cfe32246
--- /dev/null
+++ b/backend/errcode/locale.zh.toml
@@ -0,0 +1,170 @@
+[err-unauthorized]
+other = "未授权"
+
+[err-forbidden]
+other = "禁止访问"
+
+[err-bad-request]
+other = "请求错误"
+
+[err-internal-server]
+other = "内部服务器错误"
+
+[err-permision-denied]
+other = "权限不足"
+
+[err-not-found]
+other = "资源不存在"
+
+[err-duplicate]
+other = "重复条目"
+
+[err-database-query]
+other = "数据库查询失败"
+
+[err-database-operation-failed]
+other = "数据库操作失败"
+
+[err-http-request-failed]
+other = "HTTP请求失败"
+
+[err-file-permision-denied]
+other = "无权操作 {{.file}}"
+
+[err-stream-disconnect]
+other = "与开发环境断开连接， 请稍后再试"
+
+[err-file-op]
+other = "文件操作失败"
+
+[err-vm-id-required]
+other = "开发环境ID必填"
+
+[err-vm-not-belong-to-user]
+other = "开发环境不属于该用户"
+
+[err-vm-removed]
+other = "开发环境已被回收"
+
+[err-host-id-required]
+other = "宿主机ID必填"
+
+[err-public-host-cannot-renew]
+other = "公共宿主机不能续费"
+
+[err-public-host-beyond-limit]
+other = "公共宿主机超过配额"
+
+[err-vm-beyond-expire-time]
+other = "虚拟机过期时间超额"
+
+[err-model-id-required]
+other = "模型ID必填"
+
+[err-invalid-parameter]
+other = "参数无效"
+
+[err-invalid-platform]
+other = "平台无效"
+
+[err-invalid-token]
+other = "令牌无效"
+
+[err-invalid-collaborarator]
+other = "协作者无效"
+
+[err-update-project-failed]
+other = "更新项目失败"
+
+[err-git-operation]
+other = "Git操作失败"
+
+[err-project-git-identity-required]
+other = "项目需要先关联 Git 身份"
+
+[err-repo-already-linked]
+other = "重复绑定仓库"
+
+[err-git-identity-in-use-by-project]
+other = "该 Git 身份已被项目使用，无法删除"
+
+[err-team-member-limit-exceeded]
+other = "团队成员数量超出限制"
+
+[err-invalid-password]
+other = "密码无效"
+
+[err-sms-failed]
+other = "短信发送失败"
+
+[err-identity-already-bound]
+other = "该身份已被绑定"
+
+[err-invalid-state]
+other = "状态无效"
+
+[err-not-logged-in]
+other = "未登录"
+
+[err-user-blocked]
+other = "用户账号已被封禁"
+
+[err-login-failed]
+other = "登录失败"
+
+[err-invalid-coupon]
+other = "兑换码无效"
+
+[err-reset-password-failed]
+other = "重置密码失败"
+
+[err-create-captcha-failed]
+other = "创建验证码失败"
+
+[err-redeem-captcha-failed]
+other = "兑换验证码失败"
+
+[err-public-host-not-found]
+other = "公网宿主机未找到"
+
+[err-host-offline]
+other = "主机不在线"
+
+[err-wallet-insufficient]
+other = "余额不足"
+
+[err-account-overdraft]
+other = "账户超支"
+
+[err-deposit-failed]
+other = "充值失败"
+
+[err-vm-expired]
+other = "开发环境已过期"
+
+[err-apply-port-failed]
+other = "申请端口失败"
+
+[err-recycle-port-failed]
+other = "回收端口失败"
+
+[err-kb-nil-tree]
+other = "树结构为空"
+
+[err-kb-empty-path]
+other = "路径为空"
+
+[err-kb-path-not-found]
+other = "路径不存在"
+
+[err-kb-not-file]
+other = "路径是目录而非文件"
+
+[err-kb-not-dir]
+other = "路径是文件而非目录"
+
+[err-kb-dir-not-empty]
+other = "目录非空"
+
+[err-kb-already-exists]
+other = "路径已存在但类型不同"
diff --git a/backend/go.mod b/backend/go.mod
new file mode 100644
index 00000000..7f385f71
--- /dev/null
+++ b/backend/go.mod
@@ -0,0 +1,73 @@
+module github.com/chaitin/MonkeyCode/backend
+
+go 1.25.0
+
+require (
+ entgo.io/ent v0.14.5
+ github.com/GoYoko/web v1.5.0
+ github.com/ackcoder/go-cap v1.1.3
+ github.com/golang-migrate/migrate/v4 v4.19.0
+ github.com/google/uuid v1.6.0
+ github.com/labstack/echo/v4 v4.13.4
+ github.com/lib/pq v1.10.9
+ github.com/redis/go-redis/v9 v9.18.0
+ github.com/samber/do v1.6.0
+ github.com/samber/lo v1.53.0
+ github.com/spf13/viper v1.21.0
+ golang.org/x/crypto v0.41.0
+)
+
+require (
+ ariga.io/atlas v0.32.1-0.20250325101103-175b25e1c1b9 // indirect
+ github.com/BurntSushi/toml v1.4.0 // indirect
+ github.com/agext/levenshtein v1.2.3 // indirect
+ github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect
+ github.com/bmatcuk/doublestar v1.3.4 // indirect
+ github.com/cespare/xxhash/v2 v2.3.0 // indirect
+ github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+ github.com/fsnotify/fsnotify v1.9.0 // indirect
+ github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+ github.com/go-logr/logr v1.4.3 // indirect
+ github.com/go-logr/stdr v1.2.2 // indirect
+ github.com/go-openapi/inflect v0.19.0 // indirect
+ github.com/go-playground/locales v0.14.1 // indirect
+ github.com/go-playground/universal-translator v0.18.1 // indirect
+ github.com/go-playground/validator/v10 v10.25.0 // indirect
+ github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+ github.com/google/go-cmp v0.7.0 // indirect
+ github.com/hashicorp/errwrap v1.1.0 // indirect
+ github.com/hashicorp/go-multierror v1.1.1 // indirect
+ github.com/hashicorp/hcl/v2 v2.18.1 // indirect
+ github.com/labstack/gommon v0.4.2 // indirect
+ github.com/leodido/go-urn v1.4.0 // indirect
+ github.com/mattn/go-colorable v0.1.14 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/mitchellh/go-wordwrap v1.0.1 // indirect
+ github.com/nicksnyder/go-i18n/v2 v2.5.1 // indirect
+ github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+ github.com/sagikazarmark/locafero v0.11.0 // indirect
+ github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
+ github.com/spf13/afero v1.15.0 // indirect
+ github.com/spf13/cast v1.10.0 // indirect
+ github.com/spf13/pflag v1.0.10 // indirect
+ github.com/subosito/gotenv v1.6.0 // indirect
+ github.com/valyala/bytebufferpool v1.0.0 // indirect
+ github.com/valyala/fasttemplate v1.2.2 // indirect
+ github.com/zclconf/go-cty v1.14.4 // indirect
+ github.com/zclconf/go-cty-yaml v1.1.0 // indirect
+ go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+ go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho v0.63.0 // indirect
+ go.opentelemetry.io/otel v1.38.0 // indirect
+ go.opentelemetry.io/otel/metric v1.38.0 // indirect
+ go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+ go.opentelemetry.io/otel/trace v1.38.0 // indirect
+ go.uber.org/atomic v1.11.0 // indirect
+ go.yaml.in/yaml/v3 v3.0.4 // indirect
+ golang.org/x/mod v0.27.0 // indirect
+ golang.org/x/net v0.43.0 // indirect
+ golang.org/x/sync v0.17.0 // indirect
+ golang.org/x/sys v0.35.0 // indirect
+ golang.org/x/text v0.29.0 // indirect
+ golang.org/x/time v0.12.0 // indirect
+ golang.org/x/tools v0.36.0 // indirect
+)
diff --git a/backend/go.sum b/backend/go.sum
new file mode 100644
index 00000000..d71428af
--- /dev/null
+++ b/backend/go.sum
@@ -0,0 +1,212 @@
+ariga.io/atlas v0.32.1-0.20250325101103-175b25e1c1b9 h1:E0wvcUXTkgyN4wy4LGtNzMNGMytJN8afmIWXJVMi4cc=
+ariga.io/atlas v0.32.1-0.20250325101103-175b25e1c1b9/go.mod h1:Oe1xWPuu5q9LzyrWfbZmEZxFYeu4BHTyzfjeW2aZp/w=
+entgo.io/ent v0.14.5 h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=
+entgo.io/ent v0.14.5/go.mod h1:zTzLmWtPvGpmSwtkaayM2cm5m819NdM7z7tYPq3vN0U=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
+github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
+github.com/DATA-DOG/go-sqlmock v1.5.0/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM=
+github.com/GoYoko/web v1.5.0 h1:hrCBGq2ubT+Un4Bp1W4v05EOdwhuEdp3W8Zo70kWmYo=
+github.com/GoYoko/web v1.5.0/go.mod h1:MNOw+4KjmtRzUabIMqWK3t59yibnO1sDCp3EcLCmJVc=
+github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
+github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
+github.com/ackcoder/go-cap v1.1.3 h1:rHIZEmyOM/KlXJQxGoy3UHpzpeUhw+V8qa/OoEaJR7A=
+github.com/ackcoder/go-cap v1.1.3/go.mod h1:NRffl9i4+VPdgAgMT4G62cXakEyCyZtXg9ZMX3/RsDA=
+github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
+github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
+github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY=
+github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4=
+github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQrS0=
+github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI=
+github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M=
+github.com/containerd/errdefs/pkg v0.3.0 h1:9IKJ06FvyNlexW690DXuQNx2KA2cUJXx151Xdx3ZPPE=
+github.com/containerd/errdefs/pkg v0.3.0/go.mod h1:NJw6s9HwNuRhnjJhM7pylWwMyAkmCQvQ4GpJHEqRLVk=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/dhui/dktest v0.4.6 h1:+DPKyScKSEp3VLtbMDHcUq6V5Lm5zfZZVb0Sk7Ahom4=
+github.com/dhui/dktest v0.4.6/go.mod h1:JHTSYDtKkvFNFHJKqCzVzqXecyv+tKt8EzceOmQOgbU=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/docker v28.3.3+incompatible h1:Dypm25kh4rmk49v1eiVbsAtpAsYURjYkaKubwuBdxEI=
+github.com/docker/docker v28.3.3+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
+github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.25.0 h1:5Dh7cjvzR7BRZadnsVOzPhWsrwUr0nmsZJxEAnFLNO8=
+github.com/go-playground/validator/v10 v10.25.0/go.mod h1:GGzBIJMuE98Ic/kJsBXbz1x/7cByt++cQ+YOuDM5wus=
+github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
+github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
+github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang-migrate/migrate/v4 v4.19.0 h1:RcjOnCGz3Or6HQYEJ/EEVLfWnmw9KnoigPSjzhCuaSE=
+github.com/golang-migrate/migrate/v4 v4.19.0/go.mod h1:9dyEcu+hO+G9hPSw8AIg50yg622pXJsoHItQnDGZkI0=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/hashicorp/hcl/v2 v2.18.1 h1:6nxnOJFku1EuSawSD81fuviYUV8DxFr3fp2dUi3ZYSo=
+github.com/hashicorp/hcl/v2 v2.18.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE=
+github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo/v4 v4.13.4 h1:oTZZW+T3s9gAu5L8vmzihV7/lkXGZuITzTQkTEhcXEA=
+github.com/labstack/echo/v4 v4.13.4/go.mod h1:g63b33BZ5vZzcIUF8AtRH40DrTlXnx4UMC8rBdndmjQ=
+github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
+github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
+github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
+github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
+github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
+github.com/nicksnyder/go-i18n/v2 v2.5.1 h1:IxtPxYsR9Gp60cGXjfuR/llTqV8aYMsC472zD0D1vHk=
+github.com/nicksnyder/go-i18n/v2 v2.5.1/go.mod h1:DrhgsSDZxoAfvVrBVLXoxZn/pN5TXqaDbq7ju94viiQ=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
+github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs=
+github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
+github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
+github.com/samber/do v1.6.0 h1:Jy/N++BXINDB6lAx5wBlbpHlUdl0FKpLWgGEV9YWqaU=
+github.com/samber/do v1.6.0/go.mod h1:DWqBvumy8dyb2vEnYZE7D7zaVEB64J45B0NjTlY/M4k=
+github.com/samber/lo v1.53.0 h1:t975lj2py4kJPQ6haz1QMgtId2gtmfktACxIXArw3HM=
+github.com/samber/lo v1.53.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
+github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
+github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
+github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
+github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
+github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
+github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
+github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
+github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
+github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
+github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
+github.com/zclconf/go-cty v1.14.4 h1:uXXczd9QDGsgu0i/QFR/hzI5NYCHLf6NQw/atrbnhq8=
+github.com/zclconf/go-cty v1.14.4/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE=
+github.com/zclconf/go-cty-yaml v1.1.0 h1:nP+jp0qPHv2IhUVqmQSzjvqAWcObN0KBkUl2rWBdig0=
+github.com/zclconf/go-cty-yaml v1.1.0/go.mod h1:9YLUH4g7lOhVWqUbctnVlZ5KLpg7JAprQNgxSZ1Gyxs=
+github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
+github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho v0.63.0 h1:6YeICKmGrvgJ5th4+OMNpcuoB6q/Xs8gt0YCO7MUv1k=
+go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho v0.63.0/go.mod h1:ZEA7j2B35siNV0T00aapacNzjz4tvOlNoHp0ncCfwNQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
+go.opentelemetry.io/contrib/propagators/b3 v1.38.0 h1:uHsCCOSKl0kLrV2dLkFK+8Ywk9iKa/fptkytc6aFFEo=
+go.opentelemetry.io/contrib/propagators/b3 v1.38.0/go.mod h1:wMRSZJZcY8ya9mApLLhwIMjqmApy2o/Ml+62lhvxyHU=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/backend/middleware/audit.go b/backend/middleware/audit.go
new file mode 100644
index 00000000..97b528d8
--- /dev/null
+++ b/backend/middleware/audit.go
@@ -0,0 +1,163 @@
+package middleware
+
+import (
+ "bytes"
+ "encoding/json"
+ "io"
+ "log/slog"
+ "net/http"
+
+ "github.com/labstack/echo/v4"
+
+ "github.com/chaitin/MonkeyCode/backend/domain"
+)
+
+// responseWriter 包装 http.ResponseWriter 以捕获响应内容
+type responseWriter struct {
+ http.ResponseWriter
+ body *bytes.Buffer
+}
+
+func (w *responseWriter) Write(data []byte) (int, error) {
+ w.body.Write(data)
+ return w.ResponseWriter.Write(data)
+}
+
+// AuditMiddleware 审计中间件
+type AuditMiddleware struct {
+ logger *slog.Logger
+ usecase domain.AuditUsecase
+ userUsecase domain.UserUsecase
+}
+
+// NewAuditMiddleware 创建审计中间件
+func NewAuditMiddleware(
+ logger *slog.Logger,
+ usecase domain.AuditUsecase,
+ userUsecase domain.UserUsecase,
+) *AuditMiddleware {
+ return &AuditMiddleware{
+ logger: logger.With("module", "AuditMiddleware"),
+ usecase: usecase,
+ userUsecase: userUsecase,
+ }
+}
+
+// Audit 审计中间件
+func (a *AuditMiddleware) Audit(operation string) echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ ctx := c.Request().Context()
+ teamUser := GetTeamUser(c)
+
+ // 请求体
+ bodyBytes, err := io.ReadAll(c.Request().Body)
+ if err != nil {
+ a.logger.ErrorContext(ctx, "failed to read request body", "error", err)
+ return next(c)
+ }
+ c.Request().Body = io.NopCloser(bytes.NewReader(bodyBytes))
+ requestBody := string(bodyBytes)
+
+ // 响应体
+ respWriter := &responseWriter{ResponseWriter: c.Response().Writer, body: &bytes.Buffer{}}
+ c.Response().Writer = respWriter
+
+ err = next(c)
+ if err != nil {
+ return err
+ }
+
+ // 响应内容
+ responseBody := respWriter.body.String()
+
+ if operation == "team_user_login" {
+ req := &domain.TeamLoginReq{}
+ err = json.Unmarshal(bodyBytes, req)
+ if err != nil {
+ a.logger.ErrorContext(ctx, "failed to unmarshal login response body", "error", err)
+ return nil
+ }
+ users, err := a.userUsecase.GetUserByEmail(ctx, []string{req.Email})
+ if err != nil {
+ a.logger.ErrorContext(ctx, "failed to get user by email", "error", err)
+ return nil
+ }
+ teamUser = &domain.TeamUser{
+ User: &domain.User{},
+ }
+ if len(users) > 0 {
+ teamUser = &domain.TeamUser{
+ User: users[0],
+ Team: users[0].Team,
+ }
+ }
+ }
+
+ // 构建审计记录，需要检查 teamUser 和 teamUser.User 是否为 nil
+ audit := &domain.Audit{
+ SourceIP: c.RealIP(),
+ UserAgent: c.Request().UserAgent(),
+ Request: requestBody,
+ Response: responseBody,
+ Operation: operation,
+ User: teamUser.User,
+ }
+ reqBody, respBody, err := maskSensitiveData(operation, requestBody, responseBody)
+ if err != nil {
+ a.logger.ErrorContext(ctx, "failed to mask sensitive data", "error", err)
+ return nil
+ }
+ audit.Request = reqBody
+ audit.Response = respBody
+ err = a.usecase.CreateAudit(ctx, audit)
+ if err != nil {
+ a.logger.ErrorContext(ctx, "failed to create audit", "error", err)
+ }
+ return nil
+ }
+ }
+}
+
+// maskJSON 通用的 JSON 脱敏处理函数
+// maskFunc 是一个函数，接收解析后的对象并对其进行脱敏处理
+func maskJSON[T any](body string, maskFunc func(*T)) (string, error) {
+ if body == "" {
+ return body, nil
+ }
+ var obj T
+ if err := json.Unmarshal([]byte(body), &obj); err != nil {
+ return body, nil // 如果解析失败，返回原始内容（不报错，避免影响审计流程）
+ }
+ maskFunc(&obj)
+ bytes, err := json.Marshal(obj)
+ if err != nil {
+ return body, err
+ }
+ return string(bytes), nil
+}
+
+// maskSensitiveData 数据脱敏处理
+func maskSensitiveData(operation, reqBody, respBody string) (string, string, error) {
+ var err error
+
+ switch operation {
+ case "team_user_login":
+ reqBody, err = maskJSON(reqBody, func(req *domain.TeamLoginReq) {
+ req.Password = "********"
+ })
+ if err != nil {
+ return "", "", err
+ }
+ case "change_team_user_password":
+ reqBody, err = maskJSON(reqBody, func(req *domain.ChangePasswordReq) {
+ req.CurrentPassword = "********"
+ req.NewPassword = "********"
+ })
+ if err != nil {
+ return "", "", err
+ }
+ }
+
+ return reqBody, respBody, nil
+}
diff --git a/backend/middleware/auth.go b/backend/middleware/auth.go
new file mode 100644
index 00000000..a2966233
--- /dev/null
+++ b/backend/middleware/auth.go
@@ -0,0 +1,339 @@
+package middleware
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "log/slog"
+ "net/http"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/labstack/echo/v4"
+ "github.com/redis/go-redis/v9"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/consts"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/pkg/crypto"
+)
+
+const (
+ // UserContextKey 用户上下文键
+ UserContextKey = "user"
+ UserSessionKey = "monkeycode_ai_user:%s"
+ // TeamUserContextKey 团队用户上下文键
+ TeamUserContextKey = "team_user"
+ TeamUserSessionKey = "monkeycode_ai_team_user:%s"
+)
+
+type Field struct {
+ UID string `json:"uid"`
+ RandomString uuid.UUID `json:"random_string"`
+}
+
+// GetUser 从上下文中获取用户信息
+func GetUser(ctx echo.Context) *domain.User {
+ user, ok := ctx.Get(UserContextKey).(*domain.User)
+ if !ok {
+ return nil
+ }
+ return user
+}
+
+// SetUser 设置用户信息到上下文
+func SetUser(ctx echo.Context, user *domain.User) {
+ ctx.Set(UserContextKey, user)
+}
+
+// GetTeamUser 从上下文中获取团队用户信息
+func GetTeamUser(ctx echo.Context) *domain.TeamUser {
+ user, ok := ctx.Get(TeamUserContextKey).(*domain.TeamUser)
+ if !ok {
+ return nil
+ }
+ return user
+}
+
+// SetTeamUser 设置团队用户信息到上下文
+func SetTeamUser(ctx echo.Context, user *domain.TeamUser) {
+ ctx.Set(TeamUserContextKey, user)
+}
+
+// TeamAdminAuth 团队管理员权限中间件，必须在 TeamAuth 之后使用
+func TeamAdminAuth(isAdmin func(ctx context.Context, teamID, userID uuid.UUID) bool) echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ teamUser := GetTeamUser(c)
+ if teamUser == nil || teamUser.User == nil || teamUser.Team == nil {
+ return c.String(http.StatusForbidden, "Forbidden")
+ }
+
+ if !isAdmin(c.Request().Context(), teamUser.GetTeamID(), teamUser.User.ID) {
+ return c.String(http.StatusForbidden, "Forbidden")
+ }
+
+ return next(c)
+ }
+ }
+}
+
+// AuthMiddleware 认证中间件管理器
+type AuthMiddleware struct {
+ cfg *config.Config
+ usecase domain.UserUsecase
+ logger *slog.Logger
+ redis *redis.Client
+}
+
+// NewAuthMiddleware 创建认证中间件管理器
+func NewAuthMiddleware(
+ cfg *config.Config,
+ usecase domain.UserUsecase,
+ logger *slog.Logger,
+ redisClient *redis.Client,
+) *AuthMiddleware {
+ return &AuthMiddleware{
+ cfg: cfg,
+ usecase: usecase,
+ logger: logger.With("module", "AuthMiddleware"),
+ redis: redisClient,
+ }
+}
+
+// Auth 强制要求认证
+func (a *AuthMiddleware) Auth() echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ ctx := c.Request().Context()
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAISession)
+ if err != nil {
+ a.logger.DebugContext(ctx, "no cookie found, skipping auth")
+ return c.String(http.StatusUnauthorized, "No Cookie Found")
+ }
+
+ user, err := a.GetUserFromRedis(ctx, UserSessionKey, cookie.Value)
+ if err != nil {
+ a.logger.DebugContext(ctx, "get user from redis failed", "error", err)
+ return c.String(http.StatusUnauthorized, "Invalid Cookie")
+ }
+
+ if user == nil {
+ a.logger.DebugContext(ctx, "no user found, skipping auth")
+ return c.String(http.StatusUnauthorized, "Invalid Cookie")
+ }
+
+ user.Token = cookie.Value
+ SetUser(c, user)
+ return next(c)
+ }
+ }
+}
+
+// Check 检查用户是否已认证（不强制要求认证）
+func (a *AuthMiddleware) Check() echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ ctx := c.Request().Context()
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAISession)
+ if err != nil {
+ a.logger.DebugContext(ctx, "no cookie found, skipping auth")
+ return next(c)
+ }
+
+ user, err := a.GetUserFromRedis(ctx, UserSessionKey, cookie.Value)
+ if err != nil {
+ a.logger.DebugContext(ctx, "get user from redis failed", "error", err)
+ return next(c)
+ }
+
+ if user == nil {
+ a.logger.DebugContext(ctx, "no user found, skipping auth")
+ return next(c)
+ }
+
+ SetUser(c, user)
+ return next(c)
+ }
+ }
+}
+
+// TeamAuth 团队认证中间件
+func (a *AuthMiddleware) TeamAuth() echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ ctx := c.Request().Context()
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAITeamSession)
+ if err != nil {
+ a.logger.DebugContext(ctx, "no cookie found, skipping auth")
+ return c.String(http.StatusUnauthorized, "No Cookie Found")
+ }
+
+ user, err := a.GetUserFromRedis(ctx, TeamUserSessionKey, cookie.Value)
+ if err != nil {
+ a.logger.DebugContext(ctx, "get user from redis failed", "error", err)
+ return c.String(http.StatusUnauthorized, "No Cookie Found")
+ }
+
+ if user == nil {
+ return c.String(http.StatusUnauthorized, "No Cookie Found")
+ }
+
+ if user.Team == nil {
+ return c.String(http.StatusUnauthorized, "User has no team")
+ }
+
+ SetTeamUser(c, &domain.TeamUser{
+ User: user,
+ Team: user.Team,
+ })
+ return next(c)
+ }
+ }
+}
+
+// TeamAuthCheck 团队认证中间件
+func (a *AuthMiddleware) TeamAuthCheck() echo.MiddlewareFunc {
+ return func(next echo.HandlerFunc) echo.HandlerFunc {
+ return func(c echo.Context) error {
+ ctx := c.Request().Context()
+
+ cookie, err := c.Cookie(consts.MonkeyCodeAITeamSession)
+ if err != nil {
+ a.logger.DebugContext(ctx, "no cookie found, skipping auth")
+ return c.String(http.StatusUnauthorized, "cookie not found")
+ }
+
+ user, err := a.GetUserFromRedis(ctx, TeamUserSessionKey, cookie.Value)
+ if err != nil {
+ a.logger.DebugContext(ctx, "get user from redis failed", "error", err)
+ return c.String(http.StatusUnauthorized, "session not found")
+ }
+
+ a.logger.InfoContext(ctx, "get team user from redis", "user", user)
+
+ if user == nil {
+ return c.String(http.StatusUnauthorized, "session not found")
+ }
+
+ if user.Team == nil {
+ return c.String(http.StatusUnauthorized, "User has no team")
+ }
+
+ SetTeamUser(c, &domain.TeamUser{
+ User: user,
+ Team: user.Team,
+ })
+ return next(c)
+ }
+ }
+}
+
+// SetUserCookieIntoRedis 设置用户的 Redis Cookie
+func (a *AuthMiddleware) SetUserCookieIntoRedis(ctx context.Context, cookie, prefix string, user *domain.User) error {
+ b, err := json.Marshal(user)
+ if err != nil {
+ return err
+ }
+
+ key := fmt.Sprintf(prefix, user.ID.String())
+ err = a.redis.HSet(ctx, key, cookie, b).Err()
+ if err != nil {
+ return err
+ }
+ err = a.redis.Expire(ctx, key, time.Duration(a.cfg.Session.Expire)*time.Second).Err()
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// GetUserFromRedis 从 Redis 中获取用户信息
+func (a *AuthMiddleware) GetUserFromRedis(ctx context.Context, prefix, cookie string) (*domain.User, error) {
+ cryptor, err := crypto.NewAESEncryptorFromString(a.cfg.Session.Secret)
+ if err != nil {
+ a.logger.DebugContext(ctx, "new aes encryptor failed", "error", err)
+ }
+ field, err := cryptor.DecryptString(cookie)
+ if err != nil {
+ a.logger.DebugContext(ctx, "decrypt token failed", "error", err)
+ }
+ fieldData := &Field{}
+ if err := json.Unmarshal([]byte(field), fieldData); err != nil {
+ a.logger.DebugContext(ctx, "unmarshal field failed", "error", err)
+ return nil, err
+ }
+ key := fmt.Sprintf(prefix, fieldData.UID)
+ userBytes, err := a.redis.HGet(ctx, key, cookie).Result()
+ if err != nil {
+ a.logger.DebugContext(ctx, "get user from redis failed", "error", err)
+ return nil, err
+ }
+ var user domain.User
+ if err := json.Unmarshal([]byte(userBytes), &user); err != nil {
+ a.logger.DebugContext(ctx, "unmarshal user failed", "error", err)
+ return nil, err
+ }
+ return &user, nil
+}
+
+// GenerateCookieByUID 根据 id 生成 Cookie
+func (a *AuthMiddleware) GenerateCookieByUID(ctx context.Context, uid uuid.UUID) (string, error) {
+ fieldData := &Field{
+ UID: uid.String(),
+ RandomString: uuid.New(),
+ }
+ field, err := json.Marshal(fieldData)
+ if err != nil {
+ return "", err
+ }
+ cryptor, err := crypto.NewAESEncryptorFromString(a.cfg.Session.Secret)
+ if err != nil {
+ return "", err
+ }
+ encryptedField, err := cryptor.EncryptString(string(field))
+ if err != nil {
+ return "", err
+ }
+ return encryptedField, nil
+}
+
+// DeleteUserCookieFromRedis 删除用户 Cookie 从 Redis
+func (a *AuthMiddleware) DeleteUserCookieFromRedis(ctx context.Context, prefix string, uid uuid.UUID) error {
+ key := fmt.Sprintf(prefix, uid.String())
+ err := a.redis.Del(ctx, key).Err()
+ if err != nil {
+ a.logger.DebugContext(ctx, "delete user cookie from redis failed", "error", err)
+ return err
+ }
+ a.logger.DebugContext(ctx, "delete user cookie from redis success", "key", key)
+ return nil
+}
+
+// FlushRedisUserInfo 刷新用户信息到 Cookie
+func (a *AuthMiddleware) FlushRedisUserInfo(ctx context.Context, uid uuid.UUID, user *domain.User) error {
+ userBytes, err := json.Marshal(user)
+ if err != nil {
+ return err
+ }
+ key := fmt.Sprintf(UserSessionKey, uid.String())
+
+ cookieMap, err := a.redis.HGetAll(ctx, key).Result()
+ if err != nil {
+ a.logger.DebugContext(ctx, "get cookie map from redis failed", "error", err)
+ return err
+ }
+
+ // 遍历 hashmap 并更新每个 cookie 对应的用户信息
+ for cookie := range cookieMap {
+ err = a.redis.HSet(ctx, key, cookie, userBytes).Err()
+ if err != nil {
+ a.logger.DebugContext(ctx, "update user info in redis failed", "error", err, "cookie", cookie)
+ return err
+ }
+ }
+ return nil
+}
diff --git a/backend/migration/000001_init.down.sql b/backend/migration/000001_init.down.sql
new file mode 100644
index 00000000..83788b39
--- /dev/null
+++ b/backend/migration/000001_init.down.sql
@@ -0,0 +1,7 @@
+DROP TABLE IF EXISTS audits CASCADE;
+DROP TABLE IF EXISTS team_group_members CASCADE;
+DROP TABLE IF EXISTS team_groups CASCADE;
+DROP TABLE IF EXISTS team_members CASCADE;
+DROP TABLE IF EXISTS teams CASCADE;
+DROP TABLE IF EXISTS user_identities CASCADE;
+DROP TABLE IF EXISTS users CASCADE;
\ No newline at end of file
diff --git a/backend/migration/000001_init.up.sql b/backend/migration/000001_init.up.sql
new file mode 100644
index 00000000..41d6f553
--- /dev/null
+++ b/backend/migration/000001_init.up.sql
@@ -0,0 +1,87 @@
+CREATE TABLE IF NOT EXISTS users (
+ id UUID PRIMARY KEY,
+ name VARCHAR(255) NOT NULL,
+ email VARCHAR(255),
+ avatar_url VARCHAR(512),
+ password VARCHAR(255),
+ role VARCHAR(50),
+ status VARCHAR(50),
+ is_blocked BOOLEAN DEFAULT FALSE,
+ default_configs JSONB,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ deleted_at TIMESTAMP WITH TIME ZONE
+);
+
+CREATE TABLE IF NOT EXISTS user_identities (
+ id UUID PRIMARY KEY,
+ user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ platform VARCHAR(50) NOT NULL,
+ identity_id VARCHAR(255) NOT NULL,
+ username VARCHAR(255) NOT NULL,
+ email VARCHAR(255),
+ avatar_url VARCHAR(512),
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE,
+ deleted_at TIMESTAMP WITH TIME ZONE,
+ UNIQUE(user_id, platform)
+);
+
+CREATE TABLE IF NOT EXISTS teams (
+ id UUID PRIMARY KEY,
+ name VARCHAR(255) NOT NULL,
+ member_limit INTEGER,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ deleted_at TIMESTAMP WITH TIME ZONE
+);
+
+CREATE TABLE IF NOT EXISTS team_members (
+ id UUID PRIMARY KEY,
+ team_id UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+ user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ role VARCHAR(50),
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ UNIQUE(team_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS team_groups (
+ id UUID PRIMARY KEY,
+ team_id UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
+ name VARCHAR(255) NOT NULL,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ deleted_at TIMESTAMP WITH TIME ZONE
+);
+
+CREATE TABLE IF NOT EXISTS team_group_members (
+ id UUID PRIMARY KEY,
+ group_id UUID NOT NULL REFERENCES team_groups(id) ON DELETE CASCADE,
+ user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+ UNIQUE(group_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS audits (
+ id UUID PRIMARY KEY,
+ user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+ operation VARCHAR(100) NOT NULL,
+ source_ip VARCHAR(50),
+ user_agent VARCHAR(512),
+ request TEXT,
+ response TEXT,
+ created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE INDEX IF NOT EXISTS idx_users_deleted_at ON users(deleted_at);
+CREATE INDEX IF NOT EXISTS idx_user_identities_user_id ON user_identities(user_id);
+CREATE INDEX IF NOT EXISTS idx_teams_deleted_at ON teams(deleted_at);
+CREATE INDEX IF NOT EXISTS idx_team_members_team_id ON team_members(team_id);
+CREATE INDEX IF NOT EXISTS idx_team_members_user_id ON team_members(user_id);
+CREATE INDEX IF NOT EXISTS idx_team_groups_team_id ON team_groups(team_id);
+CREATE INDEX IF NOT EXISTS idx_team_groups_deleted_at ON team_groups(deleted_at);
+CREATE INDEX IF NOT EXISTS idx_team_group_members_group_id ON team_group_members(group_id);
+CREATE INDEX IF NOT EXISTS idx_team_group_members_user_id ON team_group_members(user_id);
+CREATE INDEX IF NOT EXISTS idx_audits_user_id ON audits(user_id);
+CREATE INDEX IF NOT EXISTS idx_audits_created_at ON audits(created_at);
\ No newline at end of file
diff --git a/backend/pkg/captcha/captcha.go b/backend/pkg/captcha/captcha.go
new file mode 100644
index 00000000..31d67d4a
--- /dev/null
+++ b/backend/pkg/captcha/captcha.go
@@ -0,0 +1,30 @@
+package captcha
+
+import (
+ "context"
+
+ gocap "github.com/ackcoder/go-cap"
+)
+
+type Captcha struct {
+ *gocap.Cap
+}
+
+func NewCaptcha() *Captcha {
+ return &Captcha{
+ Cap: gocap.New(
+ gocap.WithChallenge(50, 32, 3),
+ gocap.WithChallengeExpires(60*2),
+ gocap.WithTokenExpires(60*5),
+ ),
+ }
+}
+
+// Verify 验证验证码 token
+func (c *Captcha) Verify(token string, solutions []int64) (bool, error) {
+ _, err := c.Cap.RedeemChallenge(context.Background(), token, solutions)
+ if err != nil {
+ return false, err
+ }
+ return true, nil
+}
diff --git a/backend/pkg/crypto/aes.go b/backend/pkg/crypto/aes.go
new file mode 100644
index 00000000..32ac0f83
--- /dev/null
+++ b/backend/pkg/crypto/aes.go
@@ -0,0 +1,183 @@
+package crypto
+
+import (
+ "crypto/aes"
+ "crypto/cipher"
+ "crypto/rand"
+ "encoding/base64"
+ "fmt"
+ "io"
+)
+
+// AESEncryptor AES 加密器
+type AESEncryptor struct {
+ key []byte
+}
+
+// NewAESEncryptor 创建 AES 加密器
+// key 必须是 16, 24 或 32 字节，分别对应 AES-128, AES-192 或 AES-256
+func NewAESEncryptor(key []byte) (*AESEncryptor, error) {
+ if len(key) != 16 && len(key) != 24 && len(key) != 32 {
+ return nil, fmt.Errorf("invalid key size: must be 16, 24 or 32 bytes")
+ }
+ return &AESEncryptor{key: key}, nil
+}
+
+// NewAESEncryptorFromString 从字符串创建 AES 加密器
+// 会自动将字符串转换为合适的密钥长度（32字节 = AES-256）
+func NewAESEncryptorFromString(keyString string) (*AESEncryptor, error) {
+ key := []byte(keyString)
+
+ // 如果密钥长度不是标准长度，则填充或截断到 32 字节
+ if len(key) < 32 {
+ // 填充到 32 字节
+ paddedKey := make([]byte, 32)
+ copy(paddedKey, key)
+ key = paddedKey
+ } else if len(key) > 32 {
+ // 截断到 32 字节
+ key = key[:32]
+ }
+
+ return NewAESEncryptor(key)
+}
+
+// Encrypt 使用 AES-GCM 加密数据
+// 返回 base64 编码的加密数据（包含 nonce）
+func (e *AESEncryptor) Encrypt(plaintext []byte) (string, error) {
+ block, err := aes.NewCipher(e.key)
+ if err != nil {
+ return "", fmt.Errorf("create cipher: %w", err)
+ }
+
+ // 使用 GCM 模式
+ aesGCM, err := cipher.NewGCM(block)
+ if err != nil {
+ return "", fmt.Errorf("create GCM: %w", err)
+ }
+
+ // 生成随机 nonce
+ nonce := make([]byte, aesGCM.NonceSize())
+ if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+ return "", fmt.Errorf("generate nonce: %w", err)
+ }
+
+ // 加密数据，nonce 会被附加到密文前面
+ ciphertext := aesGCM.Seal(nonce, nonce, plaintext, nil)
+
+ // 返回 base64 编码的结果
+ return base64.StdEncoding.EncodeToString(ciphertext), nil
+}
+
+// EncryptString 加密字符串
+func (e *AESEncryptor) EncryptString(plaintext string) (string, error) {
+ return e.Encrypt([]byte(plaintext))
+}
+
+// Decrypt 使用 AES-GCM 解密数据
+// 输入应该是 base64 编码的密文
+func (e *AESEncryptor) Decrypt(ciphertext string) ([]byte, error) {
+ // 解码 base64
+ data, err := base64.StdEncoding.DecodeString(ciphertext)
+ if err != nil {
+ return nil, fmt.Errorf("decode base64: %w", err)
+ }
+
+ block, err := aes.NewCipher(e.key)
+ if err != nil {
+ return nil, fmt.Errorf("create cipher: %w", err)
+ }
+
+ aesGCM, err := cipher.NewGCM(block)
+ if err != nil {
+ return nil, fmt.Errorf("create GCM: %w", err)
+ }
+
+ nonceSize := aesGCM.NonceSize()
+ if len(data) < nonceSize {
+ return nil, fmt.Errorf("ciphertext too short")
+ }
+
+ // 提取 nonce 和密文
+ nonce, ciphertextBytes := data[:nonceSize], data[nonceSize:]
+
+ // 解密
+ plaintext, err := aesGCM.Open(nil, nonce, ciphertextBytes, nil)
+ if err != nil {
+ return nil, fmt.Errorf("decrypt: %w", err)
+ }
+
+ return plaintext, nil
+}
+
+// DecryptString 解密为字符串
+func (e *AESEncryptor) DecryptString(ciphertext string) (string, error) {
+ plaintext, err := e.Decrypt(ciphertext)
+ if err != nil {
+ return "", err
+ }
+ return string(plaintext), nil
+}
+
+// EncryptToBytes 加密并返回原始字节（不进行 base64 编码）
+func (e *AESEncryptor) EncryptToBytes(plaintext []byte) ([]byte, error) {
+ block, err := aes.NewCipher(e.key)
+ if err != nil {
+ return nil, fmt.Errorf("create cipher: %w", err)
+ }
+
+ aesGCM, err := cipher.NewGCM(block)
+ if err != nil {
+ return nil, fmt.Errorf("create GCM: %w", err)
+ }
+
+ nonce := make([]byte, aesGCM.NonceSize())
+ if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+ return nil, fmt.Errorf("generate nonce: %w", err)
+ }
+
+ ciphertext := aesGCM.Seal(nonce, nonce, plaintext, nil)
+ return ciphertext, nil
+}
+
+// DecryptFromBytes 从原始字节解密（不进行 base64 解码）
+func (e *AESEncryptor) DecryptFromBytes(ciphertext []byte) ([]byte, error) {
+ block, err := aes.NewCipher(e.key)
+ if err != nil {
+ return nil, fmt.Errorf("create cipher: %w", err)
+ }
+
+ aesGCM, err := cipher.NewGCM(block)
+ if err != nil {
+ return nil, fmt.Errorf("create GCM: %w", err)
+ }
+
+ nonceSize := aesGCM.NonceSize()
+ if len(ciphertext) < nonceSize {
+ return nil, fmt.Errorf("ciphertext too short")
+ }
+
+ nonce, ciphertextBytes := ciphertext[:nonceSize], ciphertext[nonceSize:]
+
+ plaintext, err := aesGCM.Open(nil, nonce, ciphertextBytes, nil)
+ if err != nil {
+ return nil, fmt.Errorf("decrypt: %w", err)
+ }
+
+ return plaintext, nil
+}
+
+// GenerateAESKey 生成随机的 AES 密钥
+// size 必须是 16, 24 或 32，分别对应 AES-128, AES-192 或 AES-256
+func GenerateAESKey(size int) ([]byte, error) {
+ if size != 16 && size != 24 && size != 32 {
+ return nil, fmt.Errorf("invalid key size: must be 16, 24 or 32 bytes")
+ }
+
+ key := make([]byte, size)
+ if _, err := io.ReadFull(rand.Reader, key); err != nil {
+ return nil, fmt.Errorf("generate key: %w", err)
+ }
+
+ return key, nil
+}
diff --git a/backend/pkg/crypto/bcrypt.go b/backend/pkg/crypto/bcrypt.go
new file mode 100644
index 00000000..fc731e1d
--- /dev/null
+++ b/backend/pkg/crypto/bcrypt.go
@@ -0,0 +1,24 @@
+package crypto
+
+import (
+ "errors"
+
+ "golang.org/x/crypto/bcrypt"
+)
+
+// HashPassword 使用 bcrypt 加密密码
+func HashPassword(password string) (string, error) {
+ if len(password) > 32 {
+ return "", errors.New("password must be less than 32 characters")
+ }
+ hashedBytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+ if err != nil {
+ return "", err
+ }
+ return string(hashedBytes), nil
+}
+
+// VerifyPassword 验证密码
+func VerifyPassword(dbPassword, password string) error {
+ return bcrypt.CompareHashAndPassword([]byte(dbPassword), []byte(password))
+}
diff --git a/backend/pkg/crypto/token.go b/backend/pkg/crypto/token.go
new file mode 100644
index 00000000..a28aff26
--- /dev/null
+++ b/backend/pkg/crypto/token.go
@@ -0,0 +1,58 @@
+package crypto
+
+import (
+ "crypto/rand"
+ "encoding/base32"
+ "encoding/binary"
+ "errors"
+ "time"
+)
+
+var (
+ ErrGenerateToken = errors.New("failed to generate token")
+ ErrInvalidToken = errors.New("invalid token")
+ ErrExpiredToken = errors.New("token has expired")
+ ErrInvalidLength = errors.New("invalid token length")
+)
+
+func Simple(content string, expiredAt time.Time) (string, error) {
+ contentBytes := []byte(content)
+ contentLen := uint16(len(contentBytes))
+
+ // 5 bytes random + 2 bytes length + content + 8 bytes timestamp
+ dataLen := 5 + 2 + len(contentBytes) + 8
+ data := make([]byte, dataLen)
+ if _, err := rand.Read(data[:5]); err != nil {
+ return "", ErrGenerateToken
+ }
+
+ binary.BigEndian.PutUint16(data[5:7], contentLen)
+ copy(data[7:7+len(contentBytes)], contentBytes)
+ t := expiredAt.UnixNano()
+ binary.BigEndian.PutUint64(data[7+len(contentBytes):], uint64(t))
+ token := base32.StdEncoding.EncodeToString(data)
+ return token, nil
+}
+
+func ValidateSimple(token string) (string, error) {
+ data, err := base32.StdEncoding.DecodeString(token)
+ if err != nil {
+ return "", errors.Join(ErrInvalidToken, err)
+ }
+ if len(data) < 5+2+8 { // minimum length: 5 random + 2 length + 0 content + 8 timestamp
+ return "", ErrInvalidLength
+ }
+
+ contentLen := binary.BigEndian.Uint16(data[5:7])
+ expectedLen := 5 + 2 + int(contentLen) + 8
+ if len(data) != expectedLen {
+ return "", ErrInvalidLength
+ }
+
+ content := string(data[7 : 7+int(contentLen)])
+ t := int64(binary.BigEndian.Uint64(data[7+int(contentLen):]))
+ if time.Now().UnixNano() > t {
+ return "", ErrExpiredToken
+ }
+ return content, nil
+}
diff --git a/backend/pkg/crypto/uuidmap.go b/backend/pkg/crypto/uuidmap.go
new file mode 100644
index 00000000..1b75f49e
--- /dev/null
+++ b/backend/pkg/crypto/uuidmap.go
@@ -0,0 +1,67 @@
+package crypto
+
+import (
+ "crypto/aes"
+ "crypto/sha256"
+ "encoding/hex"
+ "strings"
+)
+
+func uuidToBytes(uuid string) ([]byte, error) {
+ s := strings.ReplaceAll(uuid, "-", "")
+ return hex.DecodeString(s)
+}
+
+func bytesToUUID(b []byte) string {
+ hexStr := hex.EncodeToString(b)
+ return hexStr[0:8] + "-" +
+ hexStr[8:12] + "-" +
+ hexStr[12:16] + "-" +
+ hexStr[16:20] + "-" +
+ hexStr[20:32]
+}
+
+func deriveKey(secret string) []byte {
+ sum := sha256.Sum256([]byte(secret))
+ return sum[:16] // AES-128
+}
+
+// MapUUID 正向映射 UUID
+func MapUUID(uuid string, secret string) (string, error) {
+ data, err := uuidToBytes(uuid)
+ if err != nil {
+ return "", err
+ }
+
+ key := deriveKey(secret)
+
+ block, err := aes.NewCipher(key)
+ if err != nil {
+ return "", err
+ }
+
+ out := make([]byte, 16)
+ block.Encrypt(out, data)
+
+ return bytesToUUID(out), nil
+}
+
+// UnmapUUID 反向映射 UUID
+func UnmapUUID(uuid string, secret string) (string, error) {
+ data, err := uuidToBytes(uuid)
+ if err != nil {
+ return "", err
+ }
+
+ key := deriveKey(secret)
+
+ block, err := aes.NewCipher(key)
+ if err != nil {
+ return "", err
+ }
+
+ out := make([]byte, 16)
+ block.Decrypt(out, data)
+
+ return bytesToUUID(out), nil
+}
diff --git a/backend/pkg/cvt/cvt.go b/backend/pkg/cvt/cvt.go
new file mode 100644
index 00000000..9a905aee
--- /dev/null
+++ b/backend/pkg/cvt/cvt.go
@@ -0,0 +1,256 @@
+package cvt
+
+import (
+ "slices"
+)
+
+// Iter 用来迭代类型T的列表, 然后返回类型为R的列表
+func Iter[T any, R any](ts []T, fn func(int, T) R) []R {
+ r := make([]R, len(ts))
+ for i, v := range ts {
+ r[i] = fn(i, v)
+ }
+ return r
+}
+
+// IterToMap 迭代类型T的列表, 然后转换成一个 map[K]V.
+// K: 可以是任何可比较的值
+// V: 是任务类型
+func IterToMap[T any, K comparable, V any](ts []T, fn func(int, T) (K, V)) map[K]V {
+ m := make(map[K]V)
+ for i, v := range ts {
+ k, v := fn(i, v)
+ m[k] = v
+ }
+ return m
+}
+
+// ForEach 简单的迭代
+func ForEach[T any](ts []T, fn func(int, T)) {
+ for i, t := range ts {
+ fn(i, t)
+ }
+}
+
+// Filter 过滤迭代
+func Filter[T any, R any](ts []T, fn func(int, T) (R, bool)) []R {
+ r := make([]R, 0)
+ for i, v := range ts {
+ if res, ok := fn(i, v); ok {
+ r = append(r, res)
+ }
+ }
+ return r
+}
+
+// Unique 去重
+func Unique[T comparable](ts []T) []T {
+ m := make(map[T]struct{})
+ news := make([]T, 0)
+ for _, v := range ts {
+ if _, ok := m[v]; ok {
+ continue
+ }
+
+ m[v] = struct{}{}
+ news = append(news, v)
+ }
+ return news
+}
+
+// UniqueFn 根据fn去重
+func UniqueFn[T any, K comparable](ts []T, fn func(T) K) []T {
+ m := make(map[K]struct{})
+ news := make([]T, 0)
+ for _, v := range ts {
+ k := fn(v)
+ if _, ok := m[k]; ok {
+ continue
+ }
+
+ m[k] = struct{}{}
+ news = append(news, v)
+ }
+ return news
+}
+
+// Union 并集
+func Union[T comparable](a, b []T) []T {
+ return Unique(append(a, b...))
+}
+
+// Intersection 交集
+func Intersection[T comparable](a, b []T) []T {
+ return Filter(a, func(i int, t T) (T, bool) {
+ return t, slices.Contains(b, t)
+ })
+}
+
+// Difference 差集
+func Difference[T comparable](a, b []T) []T {
+ return Filter(a, func(i int, t T) (T, bool) {
+ return t, !slices.Contains(b, t)
+ })
+}
+
+// GroupBy 分组
+func GroupBy[T any, K comparable, V any](collection []T, fn func(item T) (K, V)) map[K][]V {
+ result := map[K][]V{}
+
+ for _, item := range collection {
+ k, v := fn(item)
+
+ result[k] = append(result[k], v)
+ }
+
+ return result
+}
+
+// SumBy 求和
+func SumBy[K comparable, T any](ts []T, fn func(item T) K) map[K]int64 {
+ result := map[K]int64{}
+ for _, item := range ts {
+ k := fn(item)
+ result[k]++
+ }
+ return result
+}
+
+// MapToList map 转成 slice
+func MapToList[K comparable, V any, R any](m map[K]V, fn func(K, V) R) []R {
+ r := make([]R, 0)
+ for k, v := range m {
+ r = append(r, fn(k, v))
+ }
+ return r
+}
+
+// NilWithZero t不为nil则执行fn. 否则返回类型为R的空值
+func NilWithZero[T any, R any](t *T, fn func(*T) R) R {
+ if t != nil {
+ return fn(t)
+ }
+ var b R
+ return b
+}
+
+// ZeroWithDefault 给t一个默认值def
+func ZeroWithDefault[T comparable](t T, def T) T {
+ var zero T
+ if t == zero {
+ return def
+ }
+ return t
+}
+
+// NilWithDefault 给空指针t一个默认值def
+func NilWithDefault[T any](t, def *T) *T {
+ if t != nil {
+ return t
+ }
+ return def
+}
+
+// Contains 列表包含
+func Contains[T any](ts []T, fn func(T) bool) bool {
+ return slices.ContainsFunc(ts, fn)
+}
+
+// GetN 安全获取slice的索引值. 没有返回空值
+func GetN[T any](ts []T, i int) T {
+ if len(ts) > i {
+ return ts[i]
+ }
+ var t T
+ return t
+}
+
+// RangeByStep 步进ts
+func RangeByStep[T any](ts []T, step int, fn func([]T)) {
+ for len(ts) > 0 {
+ if len(ts) < step {
+ fn(ts)
+ ts = nil
+ } else {
+ fn(ts[:step])
+ ts = ts[step:]
+ }
+ }
+}
+
+// EqualIfNotZero 当b不为空时, 进行比较操作
+func EqualIfNotZero[T comparable](a, b T) bool {
+ var zero T
+ if b == zero {
+ return true
+ }
+
+ return a == b
+}
+
+// CanditionVar 条件变量
+func CanditionVar[T any](fn ...func() (T, bool)) T {
+ var t T
+ for _, f := range fn {
+ if v, ok := f(); ok {
+ return v
+ }
+ }
+ return t
+}
+
+type Identifier interface {
+ GetID() string
+}
+
+// TopN 根据ID获取出现次数最多的前n个
+func TopN[T Identifier](ts []T, n int) []T {
+ all := make(map[string]T)
+ counter := make(map[string]int)
+ for _, t := range ts {
+ counter[t.GetID()]++
+ all[t.GetID()] = t
+ }
+
+ res := make([]T, 0)
+ for range n {
+ maxID := ""
+ maxC := 0
+ for k, c := range counter {
+ if c > maxC {
+ maxC = c
+ maxID = k
+ }
+ }
+ if maxID == "" {
+ break
+ }
+ res = append(res, all[maxID])
+ delete(counter, maxID)
+ }
+ return res
+}
+
+// Assert 段言a的类型是否为T, 如何不是返回类型为T的空值
+func Assert[T any](a any) T {
+ if t, ok := a.(T); ok {
+ return t
+ }
+ var t T
+ return t
+}
+
+type Fromer[A, B any] interface {
+ From(a A) B
+}
+
+// From 从A对象转换为B对象
+func From[A, B any](a A, f Fromer[A, B]) B {
+ return f.From(a)
+}
+
+// Zero 返回类型为T的空值
+func Zero[T any]() *T {
+ var zero T
+ return &zero
+}
diff --git a/backend/pkg/email/smtp.go b/backend/pkg/email/smtp.go
new file mode 100644
index 00000000..b9126070
--- /dev/null
+++ b/backend/pkg/email/smtp.go
@@ -0,0 +1,127 @@
+package email
+
+import (
+ "bytes"
+ "fmt"
+ "html/template"
+ "net/smtp"
+)
+
+type SMTPConfig struct {
+ Host string
+ Port int
+ Username string
+ Password string
+ From string
+}
+
+type SMTPClient struct {
+ Host string
+ Port int
+ Username string
+ Password string
+ From string
+}
+
+func NewSMTPClient(cfg SMTPConfig) *SMTPClient {
+ return &SMTPClient{
+ Host: cfg.Host,
+ Port: cfg.Port,
+ Username: cfg.Username,
+ Password: cfg.Password,
+ From: cfg.From,
+ }
+}
+
+const resetPasswordTpl = `
+
+
+
+Password Reset
+Hi {{.Username}},
+Click the link below to reset your password:
+{{.ResetURL}}
+This link will expire in 30 minutes.
+If you did not request this, please ignore this email.
+
+`
+
+const inviteTpl = `
+
+
+
+Team Invitation
+Hi,
+You have been invited to join team {{.TeamName}}.
+Click the link below to accept:
+{{.InviteURL}}
+
+`
+
+const verifyCodeTpl = `
+
+
+
+Verification Code
+Hi {{.Username}},
+Your verification code is: {{.Code}}
+This code will expire in {{.ExpireMinutes}} minutes.
+
+`
+
+func (c *SMTPClient) send(to, subject, body string) error {
+ addr := fmt.Sprintf("%s:%d", c.Host, c.Port)
+ auth := smtp.PlainAuth("", c.Username, c.Password, c.Host)
+
+ mime := "MIME-version: 1.0;\nContent-Type: text/html; charset=\"UTF-8\";\n\n"
+ msg := fmt.Appendf(nil, "From: %s\r\nTo: %s\r\nSubject: %s\r\n%s\r\n%s",
+ c.From, to, subject, mime, body)
+
+ return smtp.SendMail(addr, auth, c.From, []string{to}, msg)
+}
+
+func (c *SMTPClient) SendResetPasswordEmail(to, username, resetURL string) error {
+ tmpl, err := template.New("reset").Parse(resetPasswordTpl)
+ if err != nil {
+ return err
+ }
+ var buf bytes.Buffer
+ if err := tmpl.Execute(&buf, map[string]string{
+ "Username": username,
+ "ResetURL": resetURL,
+ }); err != nil {
+ return err
+ }
+ return c.send(to, "Reset Your Password", buf.String())
+}
+
+func (c *SMTPClient) SendInviteEmail(to, teamName, inviteURL string) error {
+ tmpl, err := template.New("invite").Parse(inviteTpl)
+ if err != nil {
+ return err
+ }
+ var buf bytes.Buffer
+ if err := tmpl.Execute(&buf, map[string]string{
+ "TeamName": teamName,
+ "InviteURL": inviteURL,
+ }); err != nil {
+ return err
+ }
+ return c.send(to, "Team Invitation", buf.String())
+}
+
+func (c *SMTPClient) SendVerifyCodeEmail(to, username, code string, expireMinutes int) error {
+ tmpl, err := template.New("verify").Parse(verifyCodeTpl)
+ if err != nil {
+ return err
+ }
+ var buf bytes.Buffer
+ if err := tmpl.Execute(&buf, map[string]any{
+ "Username": username,
+ "Code": code,
+ "ExpireMinutes": expireMinutes,
+ }); err != nil {
+ return err
+ }
+ return c.send(to, "Verification Code", buf.String())
+}
diff --git a/backend/pkg/entx/cursor.go b/backend/pkg/entx/cursor.go
new file mode 100644
index 00000000..8d6575b0
--- /dev/null
+++ b/backend/pkg/entx/cursor.go
@@ -0,0 +1,31 @@
+package entx
+
+import (
+ "entgo.io/ent/schema"
+)
+
+type CursorKind string
+
+const (
+ CursorKindCreatedAt CursorKind = "created_at"
+ CursorKindUpdatedAt CursorKind = "updated_at"
+)
+
+// CursorPagination 标记该 Schema 需要生成游标分页
+// Cursor 目前实现了基于 created_at, id; updated_at, id 的游标分页逻辑
+// kind: 指定游标类型，目前支持 created_at 和 updated_at
+type CursorPagination struct {
+ Kind CursorKind `json:"kind"`
+}
+
+var _ schema.Annotation = (*CursorPagination)(nil)
+
+func NewCursor(kind CursorKind) CursorPagination {
+ return CursorPagination{
+ Kind: kind,
+ }
+}
+
+func (CursorPagination) Name() string {
+ return "CursorPagination"
+}
diff --git a/backend/pkg/entx/entx.go b/backend/pkg/entx/entx.go
new file mode 100644
index 00000000..aa70e6f9
--- /dev/null
+++ b/backend/pkg/entx/entx.go
@@ -0,0 +1,29 @@
+package entx
+
+import (
+ "entgo.io/ent/entc"
+ "entgo.io/ent/entc/gen"
+)
+
+type Page struct {
+ entc.DefaultExtension
+}
+
+func (*Page) Templates() []*gen.Template {
+ return []*gen.Template{
+ gen.MustParse(gen.NewTemplate("page").
+ ParseFiles("../templates/page.tmpl")),
+ }
+}
+
+type Cursor struct {
+ entc.DefaultExtension
+}
+
+func (*Cursor) Templates() []*gen.Template {
+ return []*gen.Template{
+ gen.MustParse(gen.NewTemplate("cursor").
+ Funcs(gen.Funcs).
+ ParseFiles("../templates/cursor.tmpl")),
+ }
+}
diff --git a/backend/pkg/entx/softdelete2.go b/backend/pkg/entx/softdelete2.go
new file mode 100644
index 00000000..da13228d
--- /dev/null
+++ b/backend/pkg/entx/softdelete2.go
@@ -0,0 +1,87 @@
+package entx
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect/sql"
+ "entgo.io/ent/schema/field"
+ "entgo.io/ent/schema/mixin"
+
+ gen "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/db/hook"
+ "github.com/chaitin/MonkeyCode/backend/db/intercept"
+)
+
+// SoftDeleteMixin implements the soft delete pattern for schemas.
+type SoftDeleteMixin2 struct {
+ mixin.Schema
+}
+
+type softDeleteKey struct{}
+
+// SkipSoftDelete returns a new context that skips the soft-delete interceptor/mutators.
+func SkipSoftDelete(parent context.Context) context.Context {
+ return context.WithValue(parent, softDeleteKey{}, true)
+}
+
+// Fields of the SoftDeleteMixin.
+func (SoftDeleteMixin2) Fields() []ent.Field {
+ return []ent.Field{
+ field.Time("deleted_at").
+ Optional(),
+ }
+}
+
+// Interceptors of the SoftDeleteMixin.
+func (d SoftDeleteMixin2) Interceptors() []ent.Interceptor {
+ return []ent.Interceptor{
+ intercept.TraverseFunc(func(ctx context.Context, q intercept.Query) error {
+ // Skip soft-delete, means include soft-deleted entities.
+ if skip, _ := ctx.Value(softDeleteKey{}).(bool); skip {
+ return nil
+ }
+ d.P(q)
+ return nil
+ }),
+ }
+}
+
+// Hooks of the SoftDeleteMixin.
+func (d SoftDeleteMixin2) Hooks() []ent.Hook {
+ return []ent.Hook{
+ hook.On(
+ func(next ent.Mutator) ent.Mutator {
+ return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+ // Skip soft-delete, means delete the entity permanently.
+ if skip, _ := ctx.Value(softDeleteKey{}).(bool); skip {
+ return next.Mutate(ctx, m)
+ }
+ mx, ok := m.(interface {
+ SetOp(ent.Op)
+ Client() *gen.Client
+ SetDeletedAt(time.Time)
+ WhereP(...func(*sql.Selector))
+ })
+ if !ok {
+ return nil, fmt.Errorf("unexpected mutation type %T", m)
+ }
+ d.P(mx)
+ mx.SetOp(ent.OpUpdate)
+ mx.SetDeletedAt(time.Now())
+ return mx.Client().Mutate(ctx, m)
+ })
+ },
+ ent.OpDeleteOne|ent.OpDelete,
+ ),
+ }
+}
+
+// P adds a storage-level predicate to the queries and mutations.
+func (d SoftDeleteMixin2) P(w interface{ WhereP(...func(*sql.Selector)) }) {
+ w.WhereP(
+ sql.FieldIsNull(d.Fields()[0].Descriptor().Name),
+ )
+}
diff --git a/backend/pkg/entx/tx.go b/backend/pkg/entx/tx.go
new file mode 100644
index 00000000..51e039d9
--- /dev/null
+++ b/backend/pkg/entx/tx.go
@@ -0,0 +1,31 @@
+package entx
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/chaitin/MonkeyCode/backend/db"
+)
+
+func WithTx2(ctx context.Context, client *db.Client, fn func(tx *db.Tx) error) error {
+ tx, err := client.Tx(ctx)
+ if err != nil {
+ return err
+ }
+ defer func() {
+ if v := recover(); v != nil {
+ tx.Rollback()
+ panic(v)
+ }
+ }()
+ if err := fn(tx); err != nil {
+ if rerr := tx.Rollback(); rerr != nil {
+ err = fmt.Errorf("%w: rolling back transaction: %v", err, rerr)
+ }
+ return err
+ }
+ if err := tx.Commit(); err != nil {
+ return fmt.Errorf("committing transaction: %w", err)
+ }
+ return nil
+}
diff --git a/backend/pkg/logger/context.go b/backend/pkg/logger/context.go
new file mode 100644
index 00000000..871047a4
--- /dev/null
+++ b/backend/pkg/logger/context.go
@@ -0,0 +1,43 @@
+package logger
+
+import (
+ "context"
+ "log/slog"
+)
+
+type contextKey string
+
+const (
+ RequestIDKey contextKey = "request_id"
+ UserIDKey contextKey = "user_id"
+)
+
+type ContextLogger struct {
+ slog.Handler
+}
+
+func (c *ContextLogger) Enabled(ctx context.Context, level slog.Level) bool {
+ return c.Handler.Enabled(ctx, level)
+}
+
+func (c *ContextLogger) WithAttrs(attrs []slog.Attr) slog.Handler {
+ return &ContextLogger{Handler: c.Handler.WithAttrs(attrs)}
+}
+
+func (c *ContextLogger) WithGroup(name string) slog.Handler {
+ return &ContextLogger{Handler: c.Handler.WithGroup(name)}
+}
+
+func (c *ContextLogger) Handle(ctx context.Context, r slog.Record) error {
+ newRecord := r.Clone()
+
+ if i, ok := ctx.Value(RequestIDKey).(string); ok {
+ newRecord.AddAttrs(slog.String("request_id", i))
+ }
+
+ if i, ok := ctx.Value(UserIDKey).(string); ok {
+ newRecord.AddAttrs(slog.String("user_id", i))
+ }
+
+ return c.Handler.Handle(ctx, newRecord)
+}
diff --git a/backend/pkg/logger/logger.go b/backend/pkg/logger/logger.go
new file mode 100644
index 00000000..bf4d4d74
--- /dev/null
+++ b/backend/pkg/logger/logger.go
@@ -0,0 +1,51 @@
+package logger
+
+import (
+ "log/slog"
+ "os"
+)
+
+type Config struct {
+ Level string
+}
+
+var level = new(slog.LevelVar)
+
+func NewLogger(cfg *Config) *slog.Logger {
+ switch cfg.Level {
+ case "debug":
+ level.Set(slog.LevelDebug)
+ case "info":
+ level.Set(slog.LevelInfo)
+ case "warn":
+ level.Set(slog.LevelWarn)
+ case "error":
+ level.Set(slog.LevelError)
+ default:
+ level.Set(slog.LevelWarn)
+ }
+ base := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+ Level: level,
+ })
+ handler := &ContextLogger{Handler: base}
+ return slog.New(handler)
+}
+
+func SetLevel(lv string) {
+ switch lv {
+ case "debug":
+ level.Set(slog.LevelDebug)
+ case "info":
+ level.Set(slog.LevelInfo)
+ case "warn":
+ level.Set(slog.LevelWarn)
+ case "error":
+ level.Set(slog.LevelError)
+ default:
+ level.Set(slog.LevelWarn)
+ }
+}
+
+func Level() string {
+ return level.String()
+}
diff --git a/backend/pkg/register.go b/backend/pkg/register.go
new file mode 100644
index 00000000..e4312da1
--- /dev/null
+++ b/backend/pkg/register.go
@@ -0,0 +1,80 @@
+package pkg
+
+import (
+ "log/slog"
+
+ "github.com/GoYoko/web"
+ "github.com/redis/go-redis/v9"
+ "github.com/samber/do"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ "github.com/chaitin/MonkeyCode/backend/domain"
+ "github.com/chaitin/MonkeyCode/backend/middleware"
+ "github.com/chaitin/MonkeyCode/backend/pkg/captcha"
+ "github.com/chaitin/MonkeyCode/backend/pkg/email"
+ "github.com/chaitin/MonkeyCode/backend/pkg/logger"
+ "github.com/chaitin/MonkeyCode/backend/pkg/store"
+)
+
+// RegisterInfra 注册基础设施依赖
+func RegisterInfra(i *do.Injector) error {
+ // Logger
+ do.Provide(i, func(i *do.Injector) (*slog.Logger, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ return logger.NewLogger(cfg.Logger), nil
+ })
+
+ // Redis
+ do.Provide(i, func(i *do.Injector) (*redis.Client, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ return store.NewRedisCli(cfg), nil
+ })
+
+ // Ent DB
+ do.Provide(i, func(i *do.Injector) (*db.Client, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ l := do.MustInvoke[*slog.Logger](i)
+ return store.NewEntDBV2(cfg, l)
+ })
+
+ // Web
+ do.Provide(i, func(i *do.Injector) (*web.Web, error) {
+ return web.New(), nil
+ })
+
+ // Captcha
+ do.Provide(i, func(i *do.Injector) (*captcha.Captcha, error) {
+ return captcha.NewCaptcha(), nil
+ })
+
+ // Email SMTP Client
+ do.Provide(i, func(i *do.Injector) (*email.SMTPClient, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ return email.NewSMTPClient(email.SMTPConfig{
+ Host: cfg.SMTP.Host,
+ Port: cfg.SMTP.Port,
+ Username: cfg.SMTP.Username,
+ Password: cfg.SMTP.Password,
+ From: cfg.SMTP.From,
+ }), nil
+ })
+
+ // Auth Middleware - 简化版本，避免循环依赖
+ do.Provide(i, func(i *do.Injector) (*middleware.AuthMiddleware, error) {
+ cfg := do.MustInvoke[*config.Config](i)
+ l := do.MustInvoke[*slog.Logger](i)
+ redisCli := do.MustInvoke[*redis.Client](i)
+ return middleware.NewAuthMiddleware(cfg, nil, l, redisCli), nil
+ })
+
+ // Audit Middleware
+ do.Provide(i, func(i *do.Injector) (*middleware.AuditMiddleware, error) {
+ l := do.MustInvoke[*slog.Logger](i)
+ auditUc := do.MustInvoke[domain.AuditUsecase](i)
+ userUc := do.MustInvoke[domain.UserUsecase](i)
+ return middleware.NewAuditMiddleware(l, auditUc, userUc), nil
+ })
+
+ return nil
+}
diff --git a/backend/pkg/service/pprof.go b/backend/pkg/service/pprof.go
new file mode 100644
index 00000000..65a3d5d8
--- /dev/null
+++ b/backend/pkg/service/pprof.go
@@ -0,0 +1,21 @@
+package service
+
+import (
+ "net/http"
+ _ "net/http/pprof"
+)
+
+type pprofSvc struct {
+}
+
+func (p *pprofSvc) Name() string {
+ return "Pprof Server"
+}
+
+func (p *pprofSvc) Start() error {
+ return http.ListenAndServe(":6060", nil)
+}
+
+func (p *pprofSvc) Stop() error {
+ return nil
+}
diff --git a/backend/pkg/service/service.go b/backend/pkg/service/service.go
new file mode 100644
index 00000000..a044e86f
--- /dev/null
+++ b/backend/pkg/service/service.go
@@ -0,0 +1,109 @@
+package service
+
+import (
+ "context"
+ "fmt"
+ "log/slog"
+ "os"
+ "os/signal"
+ "sync"
+ "syscall"
+ "time"
+)
+
+type Option func(sv *Service)
+
+func WithPprof() Option {
+ return func(sv *Service) {
+ sv.Add(&pprofSvc{})
+ }
+}
+
+type Servicer interface {
+ Name() string
+ // Start never returns
+ Start() error
+ Stop() error
+}
+
+type Service struct {
+ svs []Servicer
+ logger *slog.Logger
+ stopDone chan struct{}
+}
+
+func NewService(opts ...Option) *Service {
+ sv := &Service{
+ svs: make([]Servicer, 0),
+ logger: slog.Default(),
+ stopDone: make(chan struct{}),
+ }
+ for _, opt := range opts {
+ opt(sv)
+ }
+ return sv
+}
+
+func (s *Service) Run() error {
+ ech := s.start()
+ sig := make(chan os.Signal, 1)
+ signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+
+ select {
+ case <-sig:
+ s.logger.Info("Received signal to stop")
+ case err := <-ech:
+ s.logger.Error("Received error from service start", "error", err)
+ }
+
+ timeout, cancel2 := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel2()
+
+ go func() {
+ if err := s.stop(); err != nil {
+ s.logger.Error("Service stop failed", "error", err)
+ }
+ }()
+
+ select {
+ case <-timeout.Done():
+ s.logger.Info("Service stop timeout")
+ case <-s.stopDone:
+ s.logger.Info("Service stop done")
+ }
+ return nil
+}
+
+func (s *Service) Add(sv Servicer) {
+ s.svs = append(s.svs, sv)
+}
+
+func (s *Service) start() chan error {
+ ech := make(chan error, len(s.svs))
+ for _, sv := range s.svs {
+ go func(sv Servicer) {
+ s.logger.Info("Starting service", "name", sv.Name())
+ err := sv.Start()
+ ech <- fmt.Errorf("[%s] Service shutdown: %w", sv.Name(), err)
+ }(sv)
+ }
+ return ech
+}
+
+func (s *Service) stop() error {
+ wg := sync.WaitGroup{}
+ for i := len(s.svs) - 1; i >= 0; i-- {
+ wg.Add(1)
+ go func(sv Servicer) {
+ defer wg.Done()
+ s.logger.Info("Stopping service", "name", sv.Name())
+ if err := sv.Stop(); err != nil {
+ s.logger.Error("Service stop failed", "name", sv.Name(), "error", err)
+ }
+ }(s.svs[i])
+ }
+ wg.Wait()
+
+ close(s.stopDone)
+ return nil
+}
diff --git a/backend/pkg/store/client.go b/backend/pkg/store/client.go
new file mode 100644
index 00000000..fe873d22
--- /dev/null
+++ b/backend/pkg/store/client.go
@@ -0,0 +1,47 @@
+// Package store 提供数据库存储和迁移功能
+package store
+
+import (
+ "context"
+ "database/sql"
+ "log/slog"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+)
+
+// Client 数据库客户端
+type Client struct {
+ db *sql.DB
+}
+
+// NewClient 创建新的数据库客户端
+func NewClient(cfg *config.Config, logger *slog.Logger) (*Client, error) {
+ db, err := sql.Open("postgres", cfg.Database.Master)
+ if err != nil {
+ return nil, err
+ }
+
+ // 测试连接
+ if err := db.Ping(); err != nil {
+ return nil, err
+ }
+
+ logger.With("component", "db").Info("database connection established")
+
+ return &Client{db: db}, nil
+}
+
+// QueryContext 执行查询
+func (c *Client) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
+ return c.db.QueryContext(ctx, query, args...)
+}
+
+// ExecContext 执行SQL语句
+func (c *Client) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
+ return c.db.ExecContext(ctx, query, args...)
+}
+
+// Close 关闭数据库连接
+func (c *Client) Close() error {
+ return c.db.Close()
+}
diff --git a/backend/pkg/store/driver.go b/backend/pkg/store/driver.go
new file mode 100644
index 00000000..cacd41ff
--- /dev/null
+++ b/backend/pkg/store/driver.go
@@ -0,0 +1,79 @@
+package store
+
+import (
+ "context"
+ "database/sql"
+ "log/slog"
+ "strings"
+
+ "entgo.io/ent"
+ "entgo.io/ent/dialect"
+ esql "entgo.io/ent/dialect/sql"
+)
+
+type multiDriver struct {
+ r, w dialect.Driver
+ logger *slog.Logger
+}
+
+func NewMultiDriver(r, w dialect.Driver, logger *slog.Logger) dialect.Driver {
+ return &multiDriver{r: r, w: w, logger: logger}
+}
+
+var _ dialect.Driver = (*multiDriver)(nil)
+
+func (d *multiDriver) Query(ctx context.Context, query string, args, v any) error {
+ e := d.r
+ if ent.QueryFromContext(ctx) == nil {
+ e = d.w
+ }
+ if err := e.Query(ctx, query, args, v); err != nil {
+ d.logger.Error("query error", "query", strings.ReplaceAll(query, `"`, ""), "args", args)
+ return err
+ }
+ return nil
+}
+
+func (d *multiDriver) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
+ v := &esql.Rows{}
+ err := d.r.Query(ctx, query, args, v)
+ if err != nil {
+ d.logger.Error("query error", "query", strings.ReplaceAll(query, `"`, ""), "args", args)
+ return nil, err
+ }
+ return v.ColumnScanner.(*sql.Rows), nil
+}
+
+func (d *multiDriver) Exec(ctx context.Context, query string, args, v any) error {
+ if err := d.w.Exec(ctx, query, args, v); err != nil {
+ d.logger.Error("exec error", "query", strings.ReplaceAll(query, `"`, ""), "args", args)
+ return err
+ }
+ return nil
+}
+
+func (d *multiDriver) Tx(ctx context.Context) (dialect.Tx, error) {
+ return d.w.Tx(ctx)
+}
+
+func (d *multiDriver) BeginTx(ctx context.Context, opts *sql.TxOptions) (dialect.Tx, error) {
+ return d.w.(interface {
+ BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
+ }).BeginTx(ctx, opts)
+}
+
+func (d *multiDriver) Close() error {
+ rerr := d.r.Close()
+ werr := d.w.Close()
+ if rerr != nil {
+ return rerr
+ }
+ if werr != nil {
+ return werr
+ }
+ return nil
+}
+
+func (d *multiDriver) Dialect() string {
+ return d.r.Dialect()
+}
diff --git a/backend/pkg/store/entdb.go b/backend/pkg/store/entdb.go
new file mode 100644
index 00000000..e86aa2cd
--- /dev/null
+++ b/backend/pkg/store/entdb.go
@@ -0,0 +1,69 @@
+package store
+
+import (
+ dql "database/sql"
+ "log/slog"
+ "time"
+
+ "entgo.io/ent/dialect"
+ "entgo.io/ent/dialect/sql"
+ "github.com/golang-migrate/migrate/v4"
+ "github.com/golang-migrate/migrate/v4/database/postgres"
+ _ "github.com/golang-migrate/migrate/v4/source/file"
+ _ "github.com/lib/pq"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+ "github.com/chaitin/MonkeyCode/backend/db"
+ _ "github.com/chaitin/MonkeyCode/backend/db/runtime"
+)
+
+func NewEntDBV2(cfg *config.Config, logger *slog.Logger) (*db.Client, error) {
+ w, err := sql.Open(dialect.Postgres, cfg.Database.Master)
+ if err != nil {
+ return nil, err
+ }
+ w.DB().SetMaxOpenConns(cfg.Database.MaxOpenConns)
+ w.DB().SetMaxIdleConns(cfg.Database.MaxIdleConns)
+ w.DB().SetConnMaxLifetime(time.Duration(cfg.Database.ConnMaxLifetime) * time.Minute)
+ // 如果 slave 为空，使用 master 连接字符串
+ slaveConnStr := cfg.Database.Slave
+ if slaveConnStr == "" {
+ slaveConnStr = cfg.Database.Master
+ }
+ r, err := sql.Open(dialect.Postgres, slaveConnStr)
+ if err != nil {
+ return nil, err
+ }
+
+ r.DB().SetMaxOpenConns(cfg.Database.MaxOpenConns)
+ r.DB().SetMaxIdleConns(cfg.Database.MaxIdleConns)
+ r.DB().SetConnMaxLifetime(time.Duration(cfg.Database.ConnMaxLifetime) * time.Minute)
+ c := db.NewClient(db.Driver(NewMultiDriver(r, w, logger)))
+ if cfg.Debug {
+ c = c.Debug()
+ }
+
+ return c, nil
+}
+
+func MigrateSQL(cfg *config.Config, logger *slog.Logger) error {
+ db, err := dql.Open("postgres", cfg.Database.Master)
+ if err != nil {
+ return err
+ }
+ driver, err := postgres.WithInstance(db, &postgres.Config{})
+ if err != nil {
+ return err
+ }
+ m, err := migrate.NewWithDatabaseInstance(
+ "file://migration",
+ "postgres", driver)
+ if err != nil {
+ return err
+ }
+ if err := m.Up(); err != nil {
+ logger.With("component", "db").With("err", err).Warn("migrate db failed")
+ }
+
+ return nil
+}
diff --git a/backend/pkg/store/redis.go b/backend/pkg/store/redis.go
new file mode 100644
index 00000000..8af90c4b
--- /dev/null
+++ b/backend/pkg/store/redis.go
@@ -0,0 +1,21 @@
+package store
+
+import (
+ "fmt"
+ "net"
+
+ "github.com/redis/go-redis/v9"
+
+ "github.com/chaitin/MonkeyCode/backend/config"
+)
+
+func NewRedisCli(cfg *config.Config) *redis.Client {
+ addr := net.JoinHostPort(cfg.Redis.Host, fmt.Sprintf("%d", cfg.Redis.Port))
+ rdb := redis.NewClient(&redis.Options{
+ Addr: addr,
+ Password: cfg.Redis.Pass,
+ DB: cfg.Redis.DB,
+ MaxIdleConns: 3,
+ })
+ return rdb
+}
diff --git a/backend/templates/claude.tmpl b/backend/templates/claude.tmpl
new file mode 100644
index 00000000..403a41b2
--- /dev/null
+++ b/backend/templates/claude.tmpl
@@ -0,0 +1,12 @@
+{
+ "env": {
+ "ANTHROPIC_BASE_URL": "{{.base_url}}",
+ "ANTHROPIC_AUTH_TOKEN": "{{.api_key}}",
+ "ANTHROPIC_DEFAULT_SONNET_MODEL": "{{.model}}",
+ "API_TIMEOUT_MS": "600000",
+ "CLAUDE_CODE_ENABLE_TELEMETRY": "0",
+ "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
+ },
+ "model": "{{.model}}",
+ "language": "chinese"
+}
\ No newline at end of file
diff --git a/backend/templates/codex.tmpl b/backend/templates/codex.tmpl
new file mode 100644
index 00000000..56022e26
--- /dev/null
+++ b/backend/templates/codex.tmpl
@@ -0,0 +1,18 @@
+model = "{{.model}}"
+model_provider = "ct"
+preferred_auth_method = "apikey"
+approval_policy = "untrusted"
+sandbox_mode = "danger-full-access"
+
+[model_providers.ct]
+name = "Azure"
+base_url = "{{.base_url}}"
+env_key = "OPENAI_API_KEY"
+
+[projects."/workspace"]
+trust_level = "trusted"
+
+{{- with .mcpserver}}
+[mcp_servers.gittask]
+url = "{{.}}"
+{{end}}
\ No newline at end of file
diff --git a/backend/templates/cursor.tmpl b/backend/templates/cursor.tmpl
new file mode 100644
index 00000000..6b5381cf
--- /dev/null
+++ b/backend/templates/cursor.tmpl
@@ -0,0 +1,234 @@
+{{ define "cursor" }}
+
+{{/* 头部引用 */}}
+{{ $pkg := base $.Config.Package }}
+{{ template "header" $ }}
+
+// Extra imports required by this file.
+import (
+ "encoding/base64"
+ "encoding/json"
+ "fmt"
+ "entgo.io/ent/dialect/sql"
+ "github.com/google/uuid"
+)
+
+type Cursor struct {
+ Cursor string `json:"cursor,omitempty"` // 游标
+ HasNextPage bool `json:"has_next_page"` // 是否有下一页
+}
+
+type createdAtCursor struct {
+ ID any `json:"id"`
+ CreatedAt time.Time `json:"created_at"`
+}
+
+func (i *createdAtCursor) marshal() (string, error) {
+ if i == nil {
+ return "", nil
+ }
+
+ milli := i.CreatedAt.UnixMilli()
+ b36 := strconv.FormatInt(milli, 36)
+
+ switch ii := i.ID.(type) {
+ case string:
+ return fmt.Sprintf("s.%s.%s", b36, ii), nil
+
+ case uuid.UUID:
+ bb, err := ii.MarshalBinary()
+ if err != nil {
+ return "", err
+ }
+ is := base64.RawURLEncoding.EncodeToString(bb)
+ return fmt.Sprintf("u.%s.%s", b36, is), nil
+ default:
+ return "", fmt.Errorf("unsupported ID type")
+ }
+}
+
+func unmarshalCreatedAt(s string) (*createdAtCursor, error) {
+ if s == "" {
+ return nil, nil
+ }
+ parts := strings.Split(s, ".")
+ if len(parts) != 3 {
+ return nil, fmt.Errorf("invalid cursor format")
+ }
+ milli, err := strconv.ParseInt(parts[1], 36, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parts[0] {
+ case "s":
+ return &createdAtCursor{
+ CreatedAt: time.UnixMilli(milli),
+ ID: parts[2],
+ }, nil
+
+ case "u":
+ id, err := base64.RawURLEncoding.DecodeString(parts[2])
+ if err != nil {
+ return nil, err
+ }
+ uuid, err := uuid.FromBytes(id)
+ if err != nil {
+ return nil, err
+ }
+ return &createdAtCursor{
+ CreatedAt: time.UnixMilli(milli),
+ ID: uuid,
+ }, nil
+ default:
+ return nil, fmt.Errorf("invalid cursor prefix")
+ }
+}
+
+type updateAtCursor struct {
+ ID any `json:"id"`
+ UpdatedAt time.Time `json:"updated_at"`
+}
+
+func (i *updateAtCursor) marshal() (string, error) {
+ if i == nil {
+ return "", nil
+ }
+
+ milli := i.UpdatedAt.UnixMilli()
+ b36 := strconv.FormatInt(milli, 36)
+
+ switch ii := i.ID.(type) {
+ case string:
+ return fmt.Sprintf("s.%s.%s", b36, ii), nil
+
+ case uuid.UUID:
+ bb, err := ii.MarshalBinary()
+ if err != nil {
+ return "", err
+ }
+ is := base64.RawURLEncoding.EncodeToString(bb)
+ return fmt.Sprintf("u.%s.%s", b36, is), nil
+ default:
+ return "", fmt.Errorf("unsupported ID type")
+ }
+}
+
+func unmarshalUpdatedAt(s string) (*updateAtCursor, error) {
+ if s == "" {
+ return nil, nil
+ }
+ parts := strings.Split(s, ".")
+ if len(parts) != 3 {
+ return nil, fmt.Errorf("invalid cursor format")
+ }
+ milli, err := strconv.ParseInt(parts[1], 36, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ switch parts[0] {
+ case "s":
+ return &updateAtCursor{
+ UpdatedAt: time.UnixMilli(milli),
+ ID: parts[2],
+ }, nil
+
+ case "u":
+ id, err := base64.RawURLEncoding.DecodeString(parts[2])
+ if err != nil {
+ return nil, err
+ }
+ uuid, err := uuid.FromBytes(id)
+ if err != nil {
+ return nil, err
+ }
+ return &updateAtCursor{
+ UpdatedAt: time.UnixMilli(milli),
+ ID: uuid,
+ }, nil
+ default:
+ return nil, fmt.Errorf("invalid cursor prefix")
+ }
+}
+
+
+{{ range $n := $.Nodes }}
+ {{/* 检查 Annotation（使用内置模板函数） */}}
+ {{- with $cur := $n.Annotations.CursorPagination -}}
+ func (q *{{ $n.QueryName }}) After(ctx context.Context, cursor string, limit int) ([]*{{ $n.Name }}, *Cursor, error) {
+ {{- if eq $cur.kind "updated_at" }}
+ i, err := unmarshalUpdatedAt(cursor)
+ if err != nil {
+ return nil, nil, err
+ }
+ q.Order({{ $n.Package }}.ByUpdatedAt(sql.OrderDesc()), {{ $n.Package }}.ByID(sql.OrderDesc()))
+ {{- else }}
+ i, err := unmarshalCreatedAt(cursor)
+ if err != nil {
+ return nil, nil, err
+ }
+ q.Order({{ $n.Package }}.ByCreatedAt(sql.OrderDesc()), {{ $n.Package }}.ByID(sql.OrderDesc()))
+ {{- end }}
+ q.Limit(limit + 1)
+
+ if i != nil {
+ q.Where(func(s *sql.Selector) {
+ s.Where(sql.Or(
+ {{- if eq $cur.kind "updated_at" }}
+ sql.LT(s.C("updated_at"), i.UpdatedAt),
+ sql.And(
+ sql.EQ(s.C("updated_at"), i.UpdatedAt),
+ sql.LT(s.C("id"), i.ID),
+ ),
+ {{- else }}
+ sql.LT(s.C("created_at"), i.CreatedAt),
+ sql.And(
+ sql.EQ(s.C("created_at"), i.CreatedAt),
+ sql.LT(s.C("id"), i.ID),
+ ),
+ {{- end }}
+ ))
+ })
+ }
+ nodes, err := q.All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ res := &Cursor{}
+ if len(nodes) > limit {
+ res.HasNextPage = true
+ nodes = nodes[:limit]
+ }
+
+ if len(nodes) > 0 {
+ last := nodes[len(nodes)-1]
+ {{- if eq $cur.kind "updated_at" }}
+ i := &updateAtCursor{
+ UpdatedAt: last.UpdatedAt,
+ ID: last.ID,
+ }
+ cursor, err := i.marshal()
+ if err != nil {
+ return nil, nil, err
+ }
+ res.Cursor = cursor
+ {{- else }}
+ i := &createdAtCursor{
+ CreatedAt: last.CreatedAt,
+ ID: last.ID,
+ }
+ cursor, err := i.marshal()
+ if err != nil {
+ return nil, nil, err
+ }
+ res.Cursor = cursor
+ {{- end }}
+ }
+ return nodes, res, nil
+ }
+ {{ end }}
+{{ end }}
+
+{{ end }}
\ No newline at end of file
diff --git a/backend/templates/install.sh.tmpl b/backend/templates/install.sh.tmpl
new file mode 100644
index 00000000..96adb689
--- /dev/null
+++ b/backend/templates/install.sh.tmpl
@@ -0,0 +1,81 @@
+#!/bin/bash
+
+# 设置颜色输出
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# 设置错误处理
+set -e
+trap 'handle_error $? $LINENO' ERR
+
+# 错误处理函数
+handle_error() {
+ local exit_code=$1
+ local line_number=$2
+ echo -e "${RED}Error occurred in script at line $line_number with exit code $exit_code${NC}"
+ cleanup
+ exit $exit_code
+}
+
+# 清理函数
+cleanup() {
+ echo -e "${YELLOW}Cleaning up temporary files...${NC}"
+ rm -f "$FILE_NAME"
+}
+
+# 检查系统架构
+ARCH=$(uname -m)
+case "$ARCH" in
+ "x86_64"|"amd64")
+ ARCH="x86_64"
+ ;;
+ "aarch64"|"arm64"|"armv8l")
+ ARCH="aarch64"
+ ;;
+ *)
+ echo -e "${RED}This installer only supports amd64 (x86_64) and arm64 (aarch64) architectures${NC}"
+ echo -e "${RED}Current architecture: $ARCH${NC}"
+ exit 1
+ ;;
+esac
+
+# 检查root权限
+if [[ $EUID -ne 0 ]]; then
+ echo -e "${RED}This script must be run as root${NC}"
+ exit 1
+fi
+
+echo -e "${GREEN}Architecture: $ARCH${NC}"
+URL="https://release.baizhi.cloud/monkeycode/runner/$ARCH/installer"
+FILE_NAME="/tmp/monkeycode-runner-installer"
+
+echo -e "${GREEN}Starting MonkeyCode Runner Installer${NC}"
+echo -e "${YELLOW}Downloading installer...${NC}"
+
+# 下载安装程序
+if ! curl -4sSLk -o "$FILE_NAME" "$URL"; then
+ echo -e "${RED}Failed to download installer${NC}"
+ exit 1
+fi
+
+echo -e "${GREEN}Download completed${NC}"
+echo -e "${YELLOW}Setting up installer...${NC}"
+
+# 设置执行权限
+chmod +x "$FILE_NAME"
+
+echo -e "${GREEN}Starting installation...${NC}"
+
+# 执行安装程序
+$FILE_NAME --env TOKEN={{.token}} --env GRPC_HOST={{.grpc_host}} --env GRPC_PORT={{.grpc_port}} --env GRPC_URL={{.grpc_url}}
+
+if [[ $? -ne 0 ]]; then
+ echo -e "${RED}Installation failed${NC}"
+ exit 1
+fi
+
+echo -e "${GREEN}Installation completed successfully${NC}"
+cleanup
+exit 0
\ No newline at end of file
diff --git a/backend/templates/opencode.tmpl b/backend/templates/opencode.tmpl
new file mode 100644
index 00000000..d511f65c
--- /dev/null
+++ b/backend/templates/opencode.tmpl
@@ -0,0 +1,18 @@
+{
+ "provider": {
+ "monkeycode-ai": {
+ "npm": "@ai-sdk/openai-compatible",
+ "name": "monkeycode-ai",
+ "options": {
+ "baseURL": "{{.base_url}}"
+ },
+ "models": {
+ "{{.model}}": {
+ "name": "{{.model}}"
+ }
+ }
+ }
+ },
+ "model": "monkeycode-ai/{{.model}}",
+ "instructions": ["/tmp/codingmatrix-project-tpl/.ai-ready/rules/*.md"]
+}
\ No newline at end of file
diff --git a/backend/templates/opencodeauth.tmpl b/backend/templates/opencodeauth.tmpl
new file mode 100644
index 00000000..06830fc2
--- /dev/null
+++ b/backend/templates/opencodeauth.tmpl
@@ -0,0 +1,6 @@
+{
+ "monkeycode-ai": {
+ "type": "api",
+ "key": "{{.api_key}}"
+ }
+}
\ No newline at end of file
diff --git a/backend/templates/page.tmpl b/backend/templates/page.tmpl
new file mode 100644
index 00000000..5aa61ed7
--- /dev/null
+++ b/backend/templates/page.tmpl
@@ -0,0 +1,32 @@
+{{ define "page" }}
+
+{{/* Add the base header for the generated file */}}
+{{ $pkg := base $.Config.Package }}
+{{ template "header" $ }}
+
+// PageInfo 分页信息
+type PageInfo struct {
+ NextToken string `json:"next_token,omitempty"`
+ HasNextPage bool `json:"has_next_page"`
+ TotalCount int64 `json:"total_count"`
+}
+
+{{/* Loop over all nodes and add the Greet method */}}
+{{ range $n := $.Nodes }}
+ {{ $receiver := $n.Receiver }}
+ func ({{ $receiver }} *{{ $n.QueryName }}) Page(ctx context.Context, page, size int) ([]*{{ $n.Name }}, *PageInfo, error) {
+ cnt, err := {{ $receiver }}.Count(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ offset := size * (page - 1)
+ rs, err := {{ $receiver }}.Offset(offset).Limit(size).All(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+ has := (page * size) < cnt
+ return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+ }
+{{ end }}
+
+{{ end }}
\ No newline at end of file
diff --git a/backend/templates/temp.go b/backend/templates/temp.go
new file mode 100644
index 00000000..8ac07e96
--- /dev/null
+++ b/backend/templates/temp.go
@@ -0,0 +1,20 @@
+package templates
+
+import (
+ _ "embed"
+)
+
+//go:embed install.sh.tmpl
+var InstallTmpl []byte
+
+//go:embed codex.tmpl
+var Codex []byte
+
+//go:embed claude.tmpl
+var Claude []byte
+
+//go:embed opencode.tmpl
+var OpenCode []byte
+
+//go:embed opencodeauth.tmpl
+var OpenCodeAuth []byte