Files

8281 lines
311 KiB
Go

// 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/gitbot"
"github.com/chaitin/MonkeyCode/backend/db/gitbottask"
"github.com/chaitin/MonkeyCode/backend/db/gitbotuser"
"github.com/chaitin/MonkeyCode/backend/db/gitidentity"
"github.com/chaitin/MonkeyCode/backend/db/gittask"
"github.com/chaitin/MonkeyCode/backend/db/host"
"github.com/chaitin/MonkeyCode/backend/db/image"
"github.com/chaitin/MonkeyCode/backend/db/mcptool"
"github.com/chaitin/MonkeyCode/backend/db/mcpupstream"
"github.com/chaitin/MonkeyCode/backend/db/mcpusertoolsetting"
"github.com/chaitin/MonkeyCode/backend/db/model"
"github.com/chaitin/MonkeyCode/backend/db/modelapikey"
"github.com/chaitin/MonkeyCode/backend/db/modelpricing"
"github.com/chaitin/MonkeyCode/backend/db/notifychannel"
"github.com/chaitin/MonkeyCode/backend/db/notifysendlog"
"github.com/chaitin/MonkeyCode/backend/db/notifysubscription"
"github.com/chaitin/MonkeyCode/backend/db/project"
"github.com/chaitin/MonkeyCode/backend/db/projectcollaborator"
"github.com/chaitin/MonkeyCode/backend/db/projectgitbot"
"github.com/chaitin/MonkeyCode/backend/db/projectissue"
"github.com/chaitin/MonkeyCode/backend/db/projectissuecomment"
"github.com/chaitin/MonkeyCode/backend/db/projecttask"
"github.com/chaitin/MonkeyCode/backend/db/task"
"github.com/chaitin/MonkeyCode/backend/db/taskmodelswitch"
"github.com/chaitin/MonkeyCode/backend/db/taskusagestat"
"github.com/chaitin/MonkeyCode/backend/db/taskvirtualmachine"
"github.com/chaitin/MonkeyCode/backend/db/team"
"github.com/chaitin/MonkeyCode/backend/db/teamgroup"
"github.com/chaitin/MonkeyCode/backend/db/teamgrouphost"
"github.com/chaitin/MonkeyCode/backend/db/teamgroupimage"
"github.com/chaitin/MonkeyCode/backend/db/teamgroupmember"
"github.com/chaitin/MonkeyCode/backend/db/teamgroupmodel"
"github.com/chaitin/MonkeyCode/backend/db/teamhost"
"github.com/chaitin/MonkeyCode/backend/db/teamimage"
"github.com/chaitin/MonkeyCode/backend/db/teammember"
"github.com/chaitin/MonkeyCode/backend/db/teammodel"
"github.com/chaitin/MonkeyCode/backend/db/user"
"github.com/chaitin/MonkeyCode/backend/db/useridentity"
"github.com/chaitin/MonkeyCode/backend/db/virtualmachine"
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
// GitBot is the client for interacting with the GitBot builders.
GitBot *GitBotClient
// GitBotTask is the client for interacting with the GitBotTask builders.
GitBotTask *GitBotTaskClient
// GitBotUser is the client for interacting with the GitBotUser builders.
GitBotUser *GitBotUserClient
// GitIdentity is the client for interacting with the GitIdentity builders.
GitIdentity *GitIdentityClient
// GitTask is the client for interacting with the GitTask builders.
GitTask *GitTaskClient
// Host is the client for interacting with the Host builders.
Host *HostClient
// Image is the client for interacting with the Image builders.
Image *ImageClient
// MCPTool is the client for interacting with the MCPTool builders.
MCPTool *MCPToolClient
// MCPUpstream is the client for interacting with the MCPUpstream builders.
MCPUpstream *MCPUpstreamClient
// MCPUserToolSetting is the client for interacting with the MCPUserToolSetting builders.
MCPUserToolSetting *MCPUserToolSettingClient
// Model is the client for interacting with the Model builders.
Model *ModelClient
// ModelApiKey is the client for interacting with the ModelApiKey builders.
ModelApiKey *ModelApiKeyClient
// ModelPricing is the client for interacting with the ModelPricing builders.
ModelPricing *ModelPricingClient
// NotifyChannel is the client for interacting with the NotifyChannel builders.
NotifyChannel *NotifyChannelClient
// NotifySendLog is the client for interacting with the NotifySendLog builders.
NotifySendLog *NotifySendLogClient
// NotifySubscription is the client for interacting with the NotifySubscription builders.
NotifySubscription *NotifySubscriptionClient
// Project is the client for interacting with the Project builders.
Project *ProjectClient
// ProjectCollaborator is the client for interacting with the ProjectCollaborator builders.
ProjectCollaborator *ProjectCollaboratorClient
// ProjectGitBot is the client for interacting with the ProjectGitBot builders.
ProjectGitBot *ProjectGitBotClient
// ProjectIssue is the client for interacting with the ProjectIssue builders.
ProjectIssue *ProjectIssueClient
// ProjectIssueComment is the client for interacting with the ProjectIssueComment builders.
ProjectIssueComment *ProjectIssueCommentClient
// ProjectTask is the client for interacting with the ProjectTask builders.
ProjectTask *ProjectTaskClient
// Task is the client for interacting with the Task builders.
Task *TaskClient
// TaskModelSwitch is the client for interacting with the TaskModelSwitch builders.
TaskModelSwitch *TaskModelSwitchClient
// TaskUsageStat is the client for interacting with the TaskUsageStat builders.
TaskUsageStat *TaskUsageStatClient
// TaskVirtualMachine is the client for interacting with the TaskVirtualMachine builders.
TaskVirtualMachine *TaskVirtualMachineClient
// Team is the client for interacting with the Team builders.
Team *TeamClient
// TeamGroup is the client for interacting with the TeamGroup builders.
TeamGroup *TeamGroupClient
// TeamGroupHost is the client for interacting with the TeamGroupHost builders.
TeamGroupHost *TeamGroupHostClient
// TeamGroupImage is the client for interacting with the TeamGroupImage builders.
TeamGroupImage *TeamGroupImageClient
// TeamGroupMember is the client for interacting with the TeamGroupMember builders.
TeamGroupMember *TeamGroupMemberClient
// TeamGroupModel is the client for interacting with the TeamGroupModel builders.
TeamGroupModel *TeamGroupModelClient
// TeamHost is the client for interacting with the TeamHost builders.
TeamHost *TeamHostClient
// TeamImage is the client for interacting with the TeamImage builders.
TeamImage *TeamImageClient
// TeamMember is the client for interacting with the TeamMember builders.
TeamMember *TeamMemberClient
// TeamModel is the client for interacting with the TeamModel builders.
TeamModel *TeamModelClient
// User is the client for interacting with the User builders.
User *UserClient
// UserIdentity is the client for interacting with the UserIdentity builders.
UserIdentity *UserIdentityClient
// VirtualMachine is the client for interacting with the VirtualMachine builders.
VirtualMachine *VirtualMachineClient
}
// 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.GitBot = NewGitBotClient(c.config)
c.GitBotTask = NewGitBotTaskClient(c.config)
c.GitBotUser = NewGitBotUserClient(c.config)
c.GitIdentity = NewGitIdentityClient(c.config)
c.GitTask = NewGitTaskClient(c.config)
c.Host = NewHostClient(c.config)
c.Image = NewImageClient(c.config)
c.MCPTool = NewMCPToolClient(c.config)
c.MCPUpstream = NewMCPUpstreamClient(c.config)
c.MCPUserToolSetting = NewMCPUserToolSettingClient(c.config)
c.Model = NewModelClient(c.config)
c.ModelApiKey = NewModelApiKeyClient(c.config)
c.ModelPricing = NewModelPricingClient(c.config)
c.NotifyChannel = NewNotifyChannelClient(c.config)
c.NotifySendLog = NewNotifySendLogClient(c.config)
c.NotifySubscription = NewNotifySubscriptionClient(c.config)
c.Project = NewProjectClient(c.config)
c.ProjectCollaborator = NewProjectCollaboratorClient(c.config)
c.ProjectGitBot = NewProjectGitBotClient(c.config)
c.ProjectIssue = NewProjectIssueClient(c.config)
c.ProjectIssueComment = NewProjectIssueCommentClient(c.config)
c.ProjectTask = NewProjectTaskClient(c.config)
c.Task = NewTaskClient(c.config)
c.TaskModelSwitch = NewTaskModelSwitchClient(c.config)
c.TaskUsageStat = NewTaskUsageStatClient(c.config)
c.TaskVirtualMachine = NewTaskVirtualMachineClient(c.config)
c.Team = NewTeamClient(c.config)
c.TeamGroup = NewTeamGroupClient(c.config)
c.TeamGroupHost = NewTeamGroupHostClient(c.config)
c.TeamGroupImage = NewTeamGroupImageClient(c.config)
c.TeamGroupMember = NewTeamGroupMemberClient(c.config)
c.TeamGroupModel = NewTeamGroupModelClient(c.config)
c.TeamHost = NewTeamHostClient(c.config)
c.TeamImage = NewTeamImageClient(c.config)
c.TeamMember = NewTeamMemberClient(c.config)
c.TeamModel = NewTeamModelClient(c.config)
c.User = NewUserClient(c.config)
c.UserIdentity = NewUserIdentityClient(c.config)
c.VirtualMachine = NewVirtualMachineClient(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),
GitBot: NewGitBotClient(cfg),
GitBotTask: NewGitBotTaskClient(cfg),
GitBotUser: NewGitBotUserClient(cfg),
GitIdentity: NewGitIdentityClient(cfg),
GitTask: NewGitTaskClient(cfg),
Host: NewHostClient(cfg),
Image: NewImageClient(cfg),
MCPTool: NewMCPToolClient(cfg),
MCPUpstream: NewMCPUpstreamClient(cfg),
MCPUserToolSetting: NewMCPUserToolSettingClient(cfg),
Model: NewModelClient(cfg),
ModelApiKey: NewModelApiKeyClient(cfg),
ModelPricing: NewModelPricingClient(cfg),
NotifyChannel: NewNotifyChannelClient(cfg),
NotifySendLog: NewNotifySendLogClient(cfg),
NotifySubscription: NewNotifySubscriptionClient(cfg),
Project: NewProjectClient(cfg),
ProjectCollaborator: NewProjectCollaboratorClient(cfg),
ProjectGitBot: NewProjectGitBotClient(cfg),
ProjectIssue: NewProjectIssueClient(cfg),
ProjectIssueComment: NewProjectIssueCommentClient(cfg),
ProjectTask: NewProjectTaskClient(cfg),
Task: NewTaskClient(cfg),
TaskModelSwitch: NewTaskModelSwitchClient(cfg),
TaskUsageStat: NewTaskUsageStatClient(cfg),
TaskVirtualMachine: NewTaskVirtualMachineClient(cfg),
Team: NewTeamClient(cfg),
TeamGroup: NewTeamGroupClient(cfg),
TeamGroupHost: NewTeamGroupHostClient(cfg),
TeamGroupImage: NewTeamGroupImageClient(cfg),
TeamGroupMember: NewTeamGroupMemberClient(cfg),
TeamGroupModel: NewTeamGroupModelClient(cfg),
TeamHost: NewTeamHostClient(cfg),
TeamImage: NewTeamImageClient(cfg),
TeamMember: NewTeamMemberClient(cfg),
TeamModel: NewTeamModelClient(cfg),
User: NewUserClient(cfg),
UserIdentity: NewUserIdentityClient(cfg),
VirtualMachine: NewVirtualMachineClient(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),
GitBot: NewGitBotClient(cfg),
GitBotTask: NewGitBotTaskClient(cfg),
GitBotUser: NewGitBotUserClient(cfg),
GitIdentity: NewGitIdentityClient(cfg),
GitTask: NewGitTaskClient(cfg),
Host: NewHostClient(cfg),
Image: NewImageClient(cfg),
MCPTool: NewMCPToolClient(cfg),
MCPUpstream: NewMCPUpstreamClient(cfg),
MCPUserToolSetting: NewMCPUserToolSettingClient(cfg),
Model: NewModelClient(cfg),
ModelApiKey: NewModelApiKeyClient(cfg),
ModelPricing: NewModelPricingClient(cfg),
NotifyChannel: NewNotifyChannelClient(cfg),
NotifySendLog: NewNotifySendLogClient(cfg),
NotifySubscription: NewNotifySubscriptionClient(cfg),
Project: NewProjectClient(cfg),
ProjectCollaborator: NewProjectCollaboratorClient(cfg),
ProjectGitBot: NewProjectGitBotClient(cfg),
ProjectIssue: NewProjectIssueClient(cfg),
ProjectIssueComment: NewProjectIssueCommentClient(cfg),
ProjectTask: NewProjectTaskClient(cfg),
Task: NewTaskClient(cfg),
TaskModelSwitch: NewTaskModelSwitchClient(cfg),
TaskUsageStat: NewTaskUsageStatClient(cfg),
TaskVirtualMachine: NewTaskVirtualMachineClient(cfg),
Team: NewTeamClient(cfg),
TeamGroup: NewTeamGroupClient(cfg),
TeamGroupHost: NewTeamGroupHostClient(cfg),
TeamGroupImage: NewTeamGroupImageClient(cfg),
TeamGroupMember: NewTeamGroupMemberClient(cfg),
TeamGroupModel: NewTeamGroupModelClient(cfg),
TeamHost: NewTeamHostClient(cfg),
TeamImage: NewTeamImageClient(cfg),
TeamMember: NewTeamMemberClient(cfg),
TeamModel: NewTeamModelClient(cfg),
User: NewUserClient(cfg),
UserIdentity: NewUserIdentityClient(cfg),
VirtualMachine: NewVirtualMachineClient(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.GitBot, c.GitBotTask, c.GitBotUser, c.GitIdentity, c.GitTask, c.Host,
c.Image, c.MCPTool, c.MCPUpstream, c.MCPUserToolSetting, c.Model,
c.ModelApiKey, c.ModelPricing, c.NotifyChannel, c.NotifySendLog,
c.NotifySubscription, c.Project, c.ProjectCollaborator, c.ProjectGitBot,
c.ProjectIssue, c.ProjectIssueComment, c.ProjectTask, c.Task,
c.TaskModelSwitch, c.TaskUsageStat, c.TaskVirtualMachine, c.Team, c.TeamGroup,
c.TeamGroupHost, c.TeamGroupImage, c.TeamGroupMember, c.TeamGroupModel,
c.TeamHost, c.TeamImage, c.TeamMember, c.TeamModel, c.User, c.UserIdentity,
c.VirtualMachine,
} {
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.GitBot, c.GitBotTask, c.GitBotUser, c.GitIdentity, c.GitTask, c.Host,
c.Image, c.MCPTool, c.MCPUpstream, c.MCPUserToolSetting, c.Model,
c.ModelApiKey, c.ModelPricing, c.NotifyChannel, c.NotifySendLog,
c.NotifySubscription, c.Project, c.ProjectCollaborator, c.ProjectGitBot,
c.ProjectIssue, c.ProjectIssueComment, c.ProjectTask, c.Task,
c.TaskModelSwitch, c.TaskUsageStat, c.TaskVirtualMachine, c.Team, c.TeamGroup,
c.TeamGroupHost, c.TeamGroupImage, c.TeamGroupMember, c.TeamGroupModel,
c.TeamHost, c.TeamImage, c.TeamMember, c.TeamModel, c.User, c.UserIdentity,
c.VirtualMachine,
} {
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 *GitBotMutation:
return c.GitBot.mutate(ctx, m)
case *GitBotTaskMutation:
return c.GitBotTask.mutate(ctx, m)
case *GitBotUserMutation:
return c.GitBotUser.mutate(ctx, m)
case *GitIdentityMutation:
return c.GitIdentity.mutate(ctx, m)
case *GitTaskMutation:
return c.GitTask.mutate(ctx, m)
case *HostMutation:
return c.Host.mutate(ctx, m)
case *ImageMutation:
return c.Image.mutate(ctx, m)
case *MCPToolMutation:
return c.MCPTool.mutate(ctx, m)
case *MCPUpstreamMutation:
return c.MCPUpstream.mutate(ctx, m)
case *MCPUserToolSettingMutation:
return c.MCPUserToolSetting.mutate(ctx, m)
case *ModelMutation:
return c.Model.mutate(ctx, m)
case *ModelApiKeyMutation:
return c.ModelApiKey.mutate(ctx, m)
case *ModelPricingMutation:
return c.ModelPricing.mutate(ctx, m)
case *NotifyChannelMutation:
return c.NotifyChannel.mutate(ctx, m)
case *NotifySendLogMutation:
return c.NotifySendLog.mutate(ctx, m)
case *NotifySubscriptionMutation:
return c.NotifySubscription.mutate(ctx, m)
case *ProjectMutation:
return c.Project.mutate(ctx, m)
case *ProjectCollaboratorMutation:
return c.ProjectCollaborator.mutate(ctx, m)
case *ProjectGitBotMutation:
return c.ProjectGitBot.mutate(ctx, m)
case *ProjectIssueMutation:
return c.ProjectIssue.mutate(ctx, m)
case *ProjectIssueCommentMutation:
return c.ProjectIssueComment.mutate(ctx, m)
case *ProjectTaskMutation:
return c.ProjectTask.mutate(ctx, m)
case *TaskMutation:
return c.Task.mutate(ctx, m)
case *TaskModelSwitchMutation:
return c.TaskModelSwitch.mutate(ctx, m)
case *TaskUsageStatMutation:
return c.TaskUsageStat.mutate(ctx, m)
case *TaskVirtualMachineMutation:
return c.TaskVirtualMachine.mutate(ctx, m)
case *TeamMutation:
return c.Team.mutate(ctx, m)
case *TeamGroupMutation:
return c.TeamGroup.mutate(ctx, m)
case *TeamGroupHostMutation:
return c.TeamGroupHost.mutate(ctx, m)
case *TeamGroupImageMutation:
return c.TeamGroupImage.mutate(ctx, m)
case *TeamGroupMemberMutation:
return c.TeamGroupMember.mutate(ctx, m)
case *TeamGroupModelMutation:
return c.TeamGroupModel.mutate(ctx, m)
case *TeamHostMutation:
return c.TeamHost.mutate(ctx, m)
case *TeamImageMutation:
return c.TeamImage.mutate(ctx, m)
case *TeamMemberMutation:
return c.TeamMember.mutate(ctx, m)
case *TeamModelMutation:
return c.TeamModel.mutate(ctx, m)
case *UserMutation:
return c.User.mutate(ctx, m)
case *UserIdentityMutation:
return c.UserIdentity.mutate(ctx, m)
case *VirtualMachineMutation:
return c.VirtualMachine.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())
}
}
// GitBotClient is a client for the GitBot schema.
type GitBotClient struct {
config
}
// NewGitBotClient returns a client for the GitBot from the given config.
func NewGitBotClient(c config) *GitBotClient {
return &GitBotClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `gitbot.Hooks(f(g(h())))`.
func (c *GitBotClient) Use(hooks ...Hook) {
c.hooks.GitBot = append(c.hooks.GitBot, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `gitbot.Intercept(f(g(h())))`.
func (c *GitBotClient) Intercept(interceptors ...Interceptor) {
c.inters.GitBot = append(c.inters.GitBot, interceptors...)
}
// Create returns a builder for creating a GitBot entity.
func (c *GitBotClient) Create() *GitBotCreate {
mutation := newGitBotMutation(c.config, OpCreate)
return &GitBotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of GitBot entities.
func (c *GitBotClient) CreateBulk(builders ...*GitBotCreate) *GitBotCreateBulk {
return &GitBotCreateBulk{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 *GitBotClient) MapCreateBulk(slice any, setFunc func(*GitBotCreate, int)) *GitBotCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &GitBotCreateBulk{err: fmt.Errorf("calling to GitBotClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*GitBotCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &GitBotCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for GitBot.
func (c *GitBotClient) Update() *GitBotUpdate {
mutation := newGitBotMutation(c.config, OpUpdate)
return &GitBotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *GitBotClient) UpdateOne(_m *GitBot) *GitBotUpdateOne {
mutation := newGitBotMutation(c.config, OpUpdateOne, withGitBot(_m))
return &GitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *GitBotClient) UpdateOneID(id uuid.UUID) *GitBotUpdateOne {
mutation := newGitBotMutation(c.config, OpUpdateOne, withGitBotID(id))
return &GitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for GitBot.
func (c *GitBotClient) Delete() *GitBotDelete {
mutation := newGitBotMutation(c.config, OpDelete)
return &GitBotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *GitBotClient) DeleteOne(_m *GitBot) *GitBotDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GitBotClient) DeleteOneID(id uuid.UUID) *GitBotDeleteOne {
builder := c.Delete().Where(gitbot.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &GitBotDeleteOne{builder}
}
// Query returns a query builder for GitBot.
func (c *GitBotClient) Query() *GitBotQuery {
return &GitBotQuery{
config: c.config,
ctx: &QueryContext{Type: TypeGitBot},
inters: c.Interceptors(),
}
}
// Get returns a GitBot entity by its id.
func (c *GitBotClient) Get(ctx context.Context, id uuid.UUID) (*GitBot, error) {
return c.Query().Where(gitbot.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *GitBotClient) GetX(ctx context.Context, id uuid.UUID) *GitBot {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryGitBotTasks queries the git_bot_tasks edge of a GitBot.
func (c *GitBotClient) QueryGitBotTasks(_m *GitBot) *GitBotTaskQuery {
query := (&GitBotTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(gitbottask.Table, gitbottask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, gitbot.GitBotTasksTable, gitbot.GitBotTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryHost queries the host edge of a GitBot.
func (c *GitBotClient) QueryHost(_m *GitBot) *HostQuery {
query := (&HostClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, gitbot.HostTable, gitbot.HostColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUsers queries the users edge of a GitBot.
func (c *GitBotClient) QueryUsers(_m *GitBot) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, gitbot.UsersTable, gitbot.UsersPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjects queries the projects edge of a GitBot.
func (c *GitBotClient) QueryProjects(_m *GitBot) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, gitbot.ProjectsTable, gitbot.ProjectsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBotUsers queries the git_bot_users edge of a GitBot.
func (c *GitBotClient) QueryGitBotUsers(_m *GitBot) *GitBotUserQuery {
query := (&GitBotUserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(gitbotuser.Table, gitbotuser.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, gitbot.GitBotUsersTable, gitbot.GitBotUsersColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectGitBots queries the project_git_bots edge of a GitBot.
func (c *GitBotClient) QueryProjectGitBots(_m *GitBot) *ProjectGitBotQuery {
query := (&ProjectGitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbot.Table, gitbot.FieldID, id),
sqlgraph.To(projectgitbot.Table, projectgitbot.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, gitbot.ProjectGitBotsTable, gitbot.ProjectGitBotsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *GitBotClient) Hooks() []Hook {
hooks := c.hooks.GitBot
return append(hooks[:len(hooks):len(hooks)], gitbot.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *GitBotClient) Interceptors() []Interceptor {
inters := c.inters.GitBot
return append(inters[:len(inters):len(inters)], gitbot.Interceptors[:]...)
}
func (c *GitBotClient) mutate(ctx context.Context, m *GitBotMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&GitBotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&GitBotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&GitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&GitBotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown GitBot mutation op: %q", m.Op())
}
}
// GitBotTaskClient is a client for the GitBotTask schema.
type GitBotTaskClient struct {
config
}
// NewGitBotTaskClient returns a client for the GitBotTask from the given config.
func NewGitBotTaskClient(c config) *GitBotTaskClient {
return &GitBotTaskClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `gitbottask.Hooks(f(g(h())))`.
func (c *GitBotTaskClient) Use(hooks ...Hook) {
c.hooks.GitBotTask = append(c.hooks.GitBotTask, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `gitbottask.Intercept(f(g(h())))`.
func (c *GitBotTaskClient) Intercept(interceptors ...Interceptor) {
c.inters.GitBotTask = append(c.inters.GitBotTask, interceptors...)
}
// Create returns a builder for creating a GitBotTask entity.
func (c *GitBotTaskClient) Create() *GitBotTaskCreate {
mutation := newGitBotTaskMutation(c.config, OpCreate)
return &GitBotTaskCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of GitBotTask entities.
func (c *GitBotTaskClient) CreateBulk(builders ...*GitBotTaskCreate) *GitBotTaskCreateBulk {
return &GitBotTaskCreateBulk{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 *GitBotTaskClient) MapCreateBulk(slice any, setFunc func(*GitBotTaskCreate, int)) *GitBotTaskCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &GitBotTaskCreateBulk{err: fmt.Errorf("calling to GitBotTaskClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*GitBotTaskCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &GitBotTaskCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for GitBotTask.
func (c *GitBotTaskClient) Update() *GitBotTaskUpdate {
mutation := newGitBotTaskMutation(c.config, OpUpdate)
return &GitBotTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *GitBotTaskClient) UpdateOne(_m *GitBotTask) *GitBotTaskUpdateOne {
mutation := newGitBotTaskMutation(c.config, OpUpdateOne, withGitBotTask(_m))
return &GitBotTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *GitBotTaskClient) UpdateOneID(id uuid.UUID) *GitBotTaskUpdateOne {
mutation := newGitBotTaskMutation(c.config, OpUpdateOne, withGitBotTaskID(id))
return &GitBotTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for GitBotTask.
func (c *GitBotTaskClient) Delete() *GitBotTaskDelete {
mutation := newGitBotTaskMutation(c.config, OpDelete)
return &GitBotTaskDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *GitBotTaskClient) DeleteOne(_m *GitBotTask) *GitBotTaskDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GitBotTaskClient) DeleteOneID(id uuid.UUID) *GitBotTaskDeleteOne {
builder := c.Delete().Where(gitbottask.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &GitBotTaskDeleteOne{builder}
}
// Query returns a query builder for GitBotTask.
func (c *GitBotTaskClient) Query() *GitBotTaskQuery {
return &GitBotTaskQuery{
config: c.config,
ctx: &QueryContext{Type: TypeGitBotTask},
inters: c.Interceptors(),
}
}
// Get returns a GitBotTask entity by its id.
func (c *GitBotTaskClient) Get(ctx context.Context, id uuid.UUID) (*GitBotTask, error) {
return c.Query().Where(gitbottask.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *GitBotTaskClient) GetX(ctx context.Context, id uuid.UUID) *GitBotTask {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTask queries the task edge of a GitBotTask.
func (c *GitBotTaskClient) QueryTask(_m *GitBotTask) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbottask.Table, gitbottask.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, gitbottask.TaskTable, gitbottask.TaskColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBot queries the git_bot edge of a GitBotTask.
func (c *GitBotTaskClient) QueryGitBot(_m *GitBotTask) *GitBotQuery {
query := (&GitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbottask.Table, gitbottask.FieldID, id),
sqlgraph.To(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, gitbottask.GitBotTable, gitbottask.GitBotColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *GitBotTaskClient) Hooks() []Hook {
return c.hooks.GitBotTask
}
// Interceptors returns the client interceptors.
func (c *GitBotTaskClient) Interceptors() []Interceptor {
return c.inters.GitBotTask
}
func (c *GitBotTaskClient) mutate(ctx context.Context, m *GitBotTaskMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&GitBotTaskCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&GitBotTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&GitBotTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&GitBotTaskDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown GitBotTask mutation op: %q", m.Op())
}
}
// GitBotUserClient is a client for the GitBotUser schema.
type GitBotUserClient struct {
config
}
// NewGitBotUserClient returns a client for the GitBotUser from the given config.
func NewGitBotUserClient(c config) *GitBotUserClient {
return &GitBotUserClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `gitbotuser.Hooks(f(g(h())))`.
func (c *GitBotUserClient) Use(hooks ...Hook) {
c.hooks.GitBotUser = append(c.hooks.GitBotUser, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `gitbotuser.Intercept(f(g(h())))`.
func (c *GitBotUserClient) Intercept(interceptors ...Interceptor) {
c.inters.GitBotUser = append(c.inters.GitBotUser, interceptors...)
}
// Create returns a builder for creating a GitBotUser entity.
func (c *GitBotUserClient) Create() *GitBotUserCreate {
mutation := newGitBotUserMutation(c.config, OpCreate)
return &GitBotUserCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of GitBotUser entities.
func (c *GitBotUserClient) CreateBulk(builders ...*GitBotUserCreate) *GitBotUserCreateBulk {
return &GitBotUserCreateBulk{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 *GitBotUserClient) MapCreateBulk(slice any, setFunc func(*GitBotUserCreate, int)) *GitBotUserCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &GitBotUserCreateBulk{err: fmt.Errorf("calling to GitBotUserClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*GitBotUserCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &GitBotUserCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for GitBotUser.
func (c *GitBotUserClient) Update() *GitBotUserUpdate {
mutation := newGitBotUserMutation(c.config, OpUpdate)
return &GitBotUserUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *GitBotUserClient) UpdateOne(_m *GitBotUser) *GitBotUserUpdateOne {
mutation := newGitBotUserMutation(c.config, OpUpdateOne, withGitBotUser(_m))
return &GitBotUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *GitBotUserClient) UpdateOneID(id uuid.UUID) *GitBotUserUpdateOne {
mutation := newGitBotUserMutation(c.config, OpUpdateOne, withGitBotUserID(id))
return &GitBotUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for GitBotUser.
func (c *GitBotUserClient) Delete() *GitBotUserDelete {
mutation := newGitBotUserMutation(c.config, OpDelete)
return &GitBotUserDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *GitBotUserClient) DeleteOne(_m *GitBotUser) *GitBotUserDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GitBotUserClient) DeleteOneID(id uuid.UUID) *GitBotUserDeleteOne {
builder := c.Delete().Where(gitbotuser.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &GitBotUserDeleteOne{builder}
}
// Query returns a query builder for GitBotUser.
func (c *GitBotUserClient) Query() *GitBotUserQuery {
return &GitBotUserQuery{
config: c.config,
ctx: &QueryContext{Type: TypeGitBotUser},
inters: c.Interceptors(),
}
}
// Get returns a GitBotUser entity by its id.
func (c *GitBotUserClient) Get(ctx context.Context, id uuid.UUID) (*GitBotUser, error) {
return c.Query().Where(gitbotuser.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *GitBotUserClient) GetX(ctx context.Context, id uuid.UUID) *GitBotUser {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryGitBot queries the git_bot edge of a GitBotUser.
func (c *GitBotUserClient) QueryGitBot(_m *GitBotUser) *GitBotQuery {
query := (&GitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbotuser.Table, gitbotuser.FieldID, id),
sqlgraph.To(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, gitbotuser.GitBotTable, gitbotuser.GitBotColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a GitBotUser.
func (c *GitBotUserClient) QueryUser(_m *GitBotUser) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitbotuser.Table, gitbotuser.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, gitbotuser.UserTable, gitbotuser.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *GitBotUserClient) Hooks() []Hook {
return c.hooks.GitBotUser
}
// Interceptors returns the client interceptors.
func (c *GitBotUserClient) Interceptors() []Interceptor {
return c.inters.GitBotUser
}
func (c *GitBotUserClient) mutate(ctx context.Context, m *GitBotUserMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&GitBotUserCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&GitBotUserUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&GitBotUserUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&GitBotUserDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown GitBotUser mutation op: %q", m.Op())
}
}
// GitIdentityClient is a client for the GitIdentity schema.
type GitIdentityClient struct {
config
}
// NewGitIdentityClient returns a client for the GitIdentity from the given config.
func NewGitIdentityClient(c config) *GitIdentityClient {
return &GitIdentityClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `gitidentity.Hooks(f(g(h())))`.
func (c *GitIdentityClient) Use(hooks ...Hook) {
c.hooks.GitIdentity = append(c.hooks.GitIdentity, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `gitidentity.Intercept(f(g(h())))`.
func (c *GitIdentityClient) Intercept(interceptors ...Interceptor) {
c.inters.GitIdentity = append(c.inters.GitIdentity, interceptors...)
}
// Create returns a builder for creating a GitIdentity entity.
func (c *GitIdentityClient) Create() *GitIdentityCreate {
mutation := newGitIdentityMutation(c.config, OpCreate)
return &GitIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of GitIdentity entities.
func (c *GitIdentityClient) CreateBulk(builders ...*GitIdentityCreate) *GitIdentityCreateBulk {
return &GitIdentityCreateBulk{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 *GitIdentityClient) MapCreateBulk(slice any, setFunc func(*GitIdentityCreate, int)) *GitIdentityCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &GitIdentityCreateBulk{err: fmt.Errorf("calling to GitIdentityClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*GitIdentityCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &GitIdentityCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for GitIdentity.
func (c *GitIdentityClient) Update() *GitIdentityUpdate {
mutation := newGitIdentityMutation(c.config, OpUpdate)
return &GitIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *GitIdentityClient) UpdateOne(_m *GitIdentity) *GitIdentityUpdateOne {
mutation := newGitIdentityMutation(c.config, OpUpdateOne, withGitIdentity(_m))
return &GitIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *GitIdentityClient) UpdateOneID(id uuid.UUID) *GitIdentityUpdateOne {
mutation := newGitIdentityMutation(c.config, OpUpdateOne, withGitIdentityID(id))
return &GitIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for GitIdentity.
func (c *GitIdentityClient) Delete() *GitIdentityDelete {
mutation := newGitIdentityMutation(c.config, OpDelete)
return &GitIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *GitIdentityClient) DeleteOne(_m *GitIdentity) *GitIdentityDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GitIdentityClient) DeleteOneID(id uuid.UUID) *GitIdentityDeleteOne {
builder := c.Delete().Where(gitidentity.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &GitIdentityDeleteOne{builder}
}
// Query returns a query builder for GitIdentity.
func (c *GitIdentityClient) Query() *GitIdentityQuery {
return &GitIdentityQuery{
config: c.config,
ctx: &QueryContext{Type: TypeGitIdentity},
inters: c.Interceptors(),
}
}
// Get returns a GitIdentity entity by its id.
func (c *GitIdentityClient) Get(ctx context.Context, id uuid.UUID) (*GitIdentity, error) {
return c.Query().Where(gitidentity.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *GitIdentityClient) GetX(ctx context.Context, id uuid.UUID) *GitIdentity {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a GitIdentity.
func (c *GitIdentityClient) QueryUser(_m *GitIdentity) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitidentity.Table, gitidentity.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, gitidentity.UserTable, gitidentity.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjects queries the projects edge of a GitIdentity.
func (c *GitIdentityClient) QueryProjects(_m *GitIdentity) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitidentity.Table, gitidentity.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, gitidentity.ProjectsTable, gitidentity.ProjectsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectTasks queries the project_tasks edge of a GitIdentity.
func (c *GitIdentityClient) QueryProjectTasks(_m *GitIdentity) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitidentity.Table, gitidentity.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, gitidentity.ProjectTasksTable, gitidentity.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVms queries the vms edge of a GitIdentity.
func (c *GitIdentityClient) QueryVms(_m *GitIdentity) *VirtualMachineQuery {
query := (&VirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gitidentity.Table, gitidentity.FieldID, id),
sqlgraph.To(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, gitidentity.VmsTable, gitidentity.VmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *GitIdentityClient) Hooks() []Hook {
hooks := c.hooks.GitIdentity
return append(hooks[:len(hooks):len(hooks)], gitidentity.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *GitIdentityClient) Interceptors() []Interceptor {
inters := c.inters.GitIdentity
return append(inters[:len(inters):len(inters)], gitidentity.Interceptors[:]...)
}
func (c *GitIdentityClient) mutate(ctx context.Context, m *GitIdentityMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&GitIdentityCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&GitIdentityUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&GitIdentityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&GitIdentityDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown GitIdentity mutation op: %q", m.Op())
}
}
// GitTaskClient is a client for the GitTask schema.
type GitTaskClient struct {
config
}
// NewGitTaskClient returns a client for the GitTask from the given config.
func NewGitTaskClient(c config) *GitTaskClient {
return &GitTaskClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `gittask.Hooks(f(g(h())))`.
func (c *GitTaskClient) Use(hooks ...Hook) {
c.hooks.GitTask = append(c.hooks.GitTask, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `gittask.Intercept(f(g(h())))`.
func (c *GitTaskClient) Intercept(interceptors ...Interceptor) {
c.inters.GitTask = append(c.inters.GitTask, interceptors...)
}
// Create returns a builder for creating a GitTask entity.
func (c *GitTaskClient) Create() *GitTaskCreate {
mutation := newGitTaskMutation(c.config, OpCreate)
return &GitTaskCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of GitTask entities.
func (c *GitTaskClient) CreateBulk(builders ...*GitTaskCreate) *GitTaskCreateBulk {
return &GitTaskCreateBulk{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 *GitTaskClient) MapCreateBulk(slice any, setFunc func(*GitTaskCreate, int)) *GitTaskCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &GitTaskCreateBulk{err: fmt.Errorf("calling to GitTaskClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*GitTaskCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &GitTaskCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for GitTask.
func (c *GitTaskClient) Update() *GitTaskUpdate {
mutation := newGitTaskMutation(c.config, OpUpdate)
return &GitTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *GitTaskClient) UpdateOne(_m *GitTask) *GitTaskUpdateOne {
mutation := newGitTaskMutation(c.config, OpUpdateOne, withGitTask(_m))
return &GitTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *GitTaskClient) UpdateOneID(id uuid.UUID) *GitTaskUpdateOne {
mutation := newGitTaskMutation(c.config, OpUpdateOne, withGitTaskID(id))
return &GitTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for GitTask.
func (c *GitTaskClient) Delete() *GitTaskDelete {
mutation := newGitTaskMutation(c.config, OpDelete)
return &GitTaskDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *GitTaskClient) DeleteOne(_m *GitTask) *GitTaskDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *GitTaskClient) DeleteOneID(id uuid.UUID) *GitTaskDeleteOne {
builder := c.Delete().Where(gittask.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &GitTaskDeleteOne{builder}
}
// Query returns a query builder for GitTask.
func (c *GitTaskClient) Query() *GitTaskQuery {
return &GitTaskQuery{
config: c.config,
ctx: &QueryContext{Type: TypeGitTask},
inters: c.Interceptors(),
}
}
// Get returns a GitTask entity by its id.
func (c *GitTaskClient) Get(ctx context.Context, id uuid.UUID) (*GitTask, error) {
return c.Query().Where(gittask.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *GitTaskClient) GetX(ctx context.Context, id uuid.UUID) *GitTask {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTask queries the task edge of a GitTask.
func (c *GitTaskClient) QueryTask(_m *GitTask) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(gittask.Table, gittask.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.O2O, true, gittask.TaskTable, gittask.TaskColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *GitTaskClient) Hooks() []Hook {
return c.hooks.GitTask
}
// Interceptors returns the client interceptors.
func (c *GitTaskClient) Interceptors() []Interceptor {
return c.inters.GitTask
}
func (c *GitTaskClient) mutate(ctx context.Context, m *GitTaskMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&GitTaskCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&GitTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&GitTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&GitTaskDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown GitTask mutation op: %q", m.Op())
}
}
// HostClient is a client for the Host schema.
type HostClient struct {
config
}
// NewHostClient returns a client for the Host from the given config.
func NewHostClient(c config) *HostClient {
return &HostClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `host.Hooks(f(g(h())))`.
func (c *HostClient) Use(hooks ...Hook) {
c.hooks.Host = append(c.hooks.Host, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `host.Intercept(f(g(h())))`.
func (c *HostClient) Intercept(interceptors ...Interceptor) {
c.inters.Host = append(c.inters.Host, interceptors...)
}
// Create returns a builder for creating a Host entity.
func (c *HostClient) Create() *HostCreate {
mutation := newHostMutation(c.config, OpCreate)
return &HostCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Host entities.
func (c *HostClient) CreateBulk(builders ...*HostCreate) *HostCreateBulk {
return &HostCreateBulk{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 *HostClient) MapCreateBulk(slice any, setFunc func(*HostCreate, int)) *HostCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &HostCreateBulk{err: fmt.Errorf("calling to HostClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*HostCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &HostCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Host.
func (c *HostClient) Update() *HostUpdate {
mutation := newHostMutation(c.config, OpUpdate)
return &HostUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *HostClient) UpdateOne(_m *Host) *HostUpdateOne {
mutation := newHostMutation(c.config, OpUpdateOne, withHost(_m))
return &HostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *HostClient) UpdateOneID(id string) *HostUpdateOne {
mutation := newHostMutation(c.config, OpUpdateOne, withHostID(id))
return &HostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Host.
func (c *HostClient) Delete() *HostDelete {
mutation := newHostMutation(c.config, OpDelete)
return &HostDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *HostClient) DeleteOne(_m *Host) *HostDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *HostClient) DeleteOneID(id string) *HostDeleteOne {
builder := c.Delete().Where(host.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &HostDeleteOne{builder}
}
// Query returns a query builder for Host.
func (c *HostClient) Query() *HostQuery {
return &HostQuery{
config: c.config,
ctx: &QueryContext{Type: TypeHost},
inters: c.Interceptors(),
}
}
// Get returns a Host entity by its id.
func (c *HostClient) Get(ctx context.Context, id string) (*Host, error) {
return c.Query().Where(host.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *HostClient) GetX(ctx context.Context, id string) *Host {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryVms queries the vms edge of a Host.
func (c *HostClient) QueryVms(_m *Host) *VirtualMachineQuery {
query := (&VirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(host.Table, host.FieldID, id),
sqlgraph.To(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, host.VmsTable, host.VmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a Host.
func (c *HostClient) QueryUser(_m *Host) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(host.Table, host.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, host.UserTable, host.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGroups queries the groups edge of a Host.
func (c *HostClient) QueryGroups(_m *Host) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(host.Table, host.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, host.GroupsTable, host.GroupsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBots queries the git_bots edge of a Host.
func (c *HostClient) QueryGitBots(_m *Host) *GitBotQuery {
query := (&GitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(host.Table, host.FieldID, id),
sqlgraph.To(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, host.GitBotsTable, host.GitBotsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamGroupHosts queries the team_group_hosts edge of a Host.
func (c *HostClient) QueryTeamGroupHosts(_m *Host) *TeamGroupHostQuery {
query := (&TeamGroupHostClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(host.Table, host.FieldID, id),
sqlgraph.To(teamgrouphost.Table, teamgrouphost.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, host.TeamGroupHostsTable, host.TeamGroupHostsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *HostClient) Hooks() []Hook {
hooks := c.hooks.Host
return append(hooks[:len(hooks):len(hooks)], host.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *HostClient) Interceptors() []Interceptor {
inters := c.inters.Host
return append(inters[:len(inters):len(inters)], host.Interceptors[:]...)
}
func (c *HostClient) mutate(ctx context.Context, m *HostMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&HostCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&HostUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&HostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&HostDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown Host mutation op: %q", m.Op())
}
}
// ImageClient is a client for the Image schema.
type ImageClient struct {
config
}
// NewImageClient returns a client for the Image from the given config.
func NewImageClient(c config) *ImageClient {
return &ImageClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `image.Hooks(f(g(h())))`.
func (c *ImageClient) Use(hooks ...Hook) {
c.hooks.Image = append(c.hooks.Image, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `image.Intercept(f(g(h())))`.
func (c *ImageClient) Intercept(interceptors ...Interceptor) {
c.inters.Image = append(c.inters.Image, interceptors...)
}
// Create returns a builder for creating a Image entity.
func (c *ImageClient) Create() *ImageCreate {
mutation := newImageMutation(c.config, OpCreate)
return &ImageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Image entities.
func (c *ImageClient) CreateBulk(builders ...*ImageCreate) *ImageCreateBulk {
return &ImageCreateBulk{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 *ImageClient) MapCreateBulk(slice any, setFunc func(*ImageCreate, int)) *ImageCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ImageCreateBulk{err: fmt.Errorf("calling to ImageClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ImageCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ImageCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Image.
func (c *ImageClient) Update() *ImageUpdate {
mutation := newImageMutation(c.config, OpUpdate)
return &ImageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ImageClient) UpdateOne(_m *Image) *ImageUpdateOne {
mutation := newImageMutation(c.config, OpUpdateOne, withImage(_m))
return &ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ImageClient) UpdateOneID(id uuid.UUID) *ImageUpdateOne {
mutation := newImageMutation(c.config, OpUpdateOne, withImageID(id))
return &ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Image.
func (c *ImageClient) Delete() *ImageDelete {
mutation := newImageMutation(c.config, OpDelete)
return &ImageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ImageClient) DeleteOne(_m *Image) *ImageDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ImageClient) DeleteOneID(id uuid.UUID) *ImageDeleteOne {
builder := c.Delete().Where(image.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ImageDeleteOne{builder}
}
// Query returns a query builder for Image.
func (c *ImageClient) Query() *ImageQuery {
return &ImageQuery{
config: c.config,
ctx: &QueryContext{Type: TypeImage},
inters: c.Interceptors(),
}
}
// Get returns a Image entity by its id.
func (c *ImageClient) Get(ctx context.Context, id uuid.UUID) (*Image, error) {
return c.Query().Where(image.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ImageClient) GetX(ctx context.Context, id uuid.UUID) *Image {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a Image.
func (c *ImageClient) QueryUser(_m *Image) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, image.UserTable, image.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeams queries the teams edge of a Image.
func (c *ImageClient) QueryTeams(_m *Image) *TeamQuery {
query := (&TeamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(team.Table, team.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, image.TeamsTable, image.TeamsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGroups queries the groups edge of a Image.
func (c *ImageClient) QueryGroups(_m *Image) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, image.GroupsTable, image.GroupsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectTasks queries the project_tasks edge of a Image.
func (c *ImageClient) QueryProjectTasks(_m *Image) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, image.ProjectTasksTable, image.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjects queries the projects edge of a Image.
func (c *ImageClient) QueryProjects(_m *Image) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, image.ProjectsTable, image.ProjectsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamImages queries the team_images edge of a Image.
func (c *ImageClient) QueryTeamImages(_m *Image) *TeamImageQuery {
query := (&TeamImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(teamimage.Table, teamimage.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, image.TeamImagesTable, image.TeamImagesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamGroupImages queries the team_group_images edge of a Image.
func (c *ImageClient) QueryTeamGroupImages(_m *Image) *TeamGroupImageQuery {
query := (&TeamGroupImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(image.Table, image.FieldID, id),
sqlgraph.To(teamgroupimage.Table, teamgroupimage.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, image.TeamGroupImagesTable, image.TeamGroupImagesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ImageClient) Hooks() []Hook {
hooks := c.hooks.Image
return append(hooks[:len(hooks):len(hooks)], image.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ImageClient) Interceptors() []Interceptor {
inters := c.inters.Image
return append(inters[:len(inters):len(inters)], image.Interceptors[:]...)
}
func (c *ImageClient) mutate(ctx context.Context, m *ImageMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ImageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ImageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ImageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown Image mutation op: %q", m.Op())
}
}
// MCPToolClient is a client for the MCPTool schema.
type MCPToolClient struct {
config
}
// NewMCPToolClient returns a client for the MCPTool from the given config.
func NewMCPToolClient(c config) *MCPToolClient {
return &MCPToolClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `mcptool.Hooks(f(g(h())))`.
func (c *MCPToolClient) Use(hooks ...Hook) {
c.hooks.MCPTool = append(c.hooks.MCPTool, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `mcptool.Intercept(f(g(h())))`.
func (c *MCPToolClient) Intercept(interceptors ...Interceptor) {
c.inters.MCPTool = append(c.inters.MCPTool, interceptors...)
}
// Create returns a builder for creating a MCPTool entity.
func (c *MCPToolClient) Create() *MCPToolCreate {
mutation := newMCPToolMutation(c.config, OpCreate)
return &MCPToolCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of MCPTool entities.
func (c *MCPToolClient) CreateBulk(builders ...*MCPToolCreate) *MCPToolCreateBulk {
return &MCPToolCreateBulk{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 *MCPToolClient) MapCreateBulk(slice any, setFunc func(*MCPToolCreate, int)) *MCPToolCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &MCPToolCreateBulk{err: fmt.Errorf("calling to MCPToolClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*MCPToolCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &MCPToolCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for MCPTool.
func (c *MCPToolClient) Update() *MCPToolUpdate {
mutation := newMCPToolMutation(c.config, OpUpdate)
return &MCPToolUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *MCPToolClient) UpdateOne(_m *MCPTool) *MCPToolUpdateOne {
mutation := newMCPToolMutation(c.config, OpUpdateOne, withMCPTool(_m))
return &MCPToolUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *MCPToolClient) UpdateOneID(id uuid.UUID) *MCPToolUpdateOne {
mutation := newMCPToolMutation(c.config, OpUpdateOne, withMCPToolID(id))
return &MCPToolUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for MCPTool.
func (c *MCPToolClient) Delete() *MCPToolDelete {
mutation := newMCPToolMutation(c.config, OpDelete)
return &MCPToolDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *MCPToolClient) DeleteOne(_m *MCPTool) *MCPToolDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *MCPToolClient) DeleteOneID(id uuid.UUID) *MCPToolDeleteOne {
builder := c.Delete().Where(mcptool.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &MCPToolDeleteOne{builder}
}
// Query returns a query builder for MCPTool.
func (c *MCPToolClient) Query() *MCPToolQuery {
return &MCPToolQuery{
config: c.config,
ctx: &QueryContext{Type: TypeMCPTool},
inters: c.Interceptors(),
}
}
// Get returns a MCPTool entity by its id.
func (c *MCPToolClient) Get(ctx context.Context, id uuid.UUID) (*MCPTool, error) {
return c.Query().Where(mcptool.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *MCPToolClient) GetX(ctx context.Context, id uuid.UUID) *MCPTool {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUpstream queries the upstream edge of a MCPTool.
func (c *MCPToolClient) QueryUpstream(_m *MCPTool) *MCPUpstreamQuery {
query := (&MCPUpstreamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(mcptool.Table, mcptool.FieldID, id),
sqlgraph.To(mcpupstream.Table, mcpupstream.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, mcptool.UpstreamTable, mcptool.UpstreamColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *MCPToolClient) Hooks() []Hook {
hooks := c.hooks.MCPTool
return append(hooks[:len(hooks):len(hooks)], mcptool.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *MCPToolClient) Interceptors() []Interceptor {
inters := c.inters.MCPTool
return append(inters[:len(inters):len(inters)], mcptool.Interceptors[:]...)
}
func (c *MCPToolClient) mutate(ctx context.Context, m *MCPToolMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&MCPToolCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&MCPToolUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&MCPToolUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&MCPToolDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown MCPTool mutation op: %q", m.Op())
}
}
// MCPUpstreamClient is a client for the MCPUpstream schema.
type MCPUpstreamClient struct {
config
}
// NewMCPUpstreamClient returns a client for the MCPUpstream from the given config.
func NewMCPUpstreamClient(c config) *MCPUpstreamClient {
return &MCPUpstreamClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `mcpupstream.Hooks(f(g(h())))`.
func (c *MCPUpstreamClient) Use(hooks ...Hook) {
c.hooks.MCPUpstream = append(c.hooks.MCPUpstream, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `mcpupstream.Intercept(f(g(h())))`.
func (c *MCPUpstreamClient) Intercept(interceptors ...Interceptor) {
c.inters.MCPUpstream = append(c.inters.MCPUpstream, interceptors...)
}
// Create returns a builder for creating a MCPUpstream entity.
func (c *MCPUpstreamClient) Create() *MCPUpstreamCreate {
mutation := newMCPUpstreamMutation(c.config, OpCreate)
return &MCPUpstreamCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of MCPUpstream entities.
func (c *MCPUpstreamClient) CreateBulk(builders ...*MCPUpstreamCreate) *MCPUpstreamCreateBulk {
return &MCPUpstreamCreateBulk{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 *MCPUpstreamClient) MapCreateBulk(slice any, setFunc func(*MCPUpstreamCreate, int)) *MCPUpstreamCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &MCPUpstreamCreateBulk{err: fmt.Errorf("calling to MCPUpstreamClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*MCPUpstreamCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &MCPUpstreamCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for MCPUpstream.
func (c *MCPUpstreamClient) Update() *MCPUpstreamUpdate {
mutation := newMCPUpstreamMutation(c.config, OpUpdate)
return &MCPUpstreamUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *MCPUpstreamClient) UpdateOne(_m *MCPUpstream) *MCPUpstreamUpdateOne {
mutation := newMCPUpstreamMutation(c.config, OpUpdateOne, withMCPUpstream(_m))
return &MCPUpstreamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *MCPUpstreamClient) UpdateOneID(id uuid.UUID) *MCPUpstreamUpdateOne {
mutation := newMCPUpstreamMutation(c.config, OpUpdateOne, withMCPUpstreamID(id))
return &MCPUpstreamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for MCPUpstream.
func (c *MCPUpstreamClient) Delete() *MCPUpstreamDelete {
mutation := newMCPUpstreamMutation(c.config, OpDelete)
return &MCPUpstreamDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *MCPUpstreamClient) DeleteOne(_m *MCPUpstream) *MCPUpstreamDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *MCPUpstreamClient) DeleteOneID(id uuid.UUID) *MCPUpstreamDeleteOne {
builder := c.Delete().Where(mcpupstream.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &MCPUpstreamDeleteOne{builder}
}
// Query returns a query builder for MCPUpstream.
func (c *MCPUpstreamClient) Query() *MCPUpstreamQuery {
return &MCPUpstreamQuery{
config: c.config,
ctx: &QueryContext{Type: TypeMCPUpstream},
inters: c.Interceptors(),
}
}
// Get returns a MCPUpstream entity by its id.
func (c *MCPUpstreamClient) Get(ctx context.Context, id uuid.UUID) (*MCPUpstream, error) {
return c.Query().Where(mcpupstream.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *MCPUpstreamClient) GetX(ctx context.Context, id uuid.UUID) *MCPUpstream {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTools queries the tools edge of a MCPUpstream.
func (c *MCPUpstreamClient) QueryTools(_m *MCPUpstream) *MCPToolQuery {
query := (&MCPToolClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(mcpupstream.Table, mcpupstream.FieldID, id),
sqlgraph.To(mcptool.Table, mcptool.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, mcpupstream.ToolsTable, mcpupstream.ToolsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a MCPUpstream.
func (c *MCPUpstreamClient) QueryUser(_m *MCPUpstream) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(mcpupstream.Table, mcpupstream.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, mcpupstream.UserTable, mcpupstream.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *MCPUpstreamClient) Hooks() []Hook {
hooks := c.hooks.MCPUpstream
return append(hooks[:len(hooks):len(hooks)], mcpupstream.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *MCPUpstreamClient) Interceptors() []Interceptor {
inters := c.inters.MCPUpstream
return append(inters[:len(inters):len(inters)], mcpupstream.Interceptors[:]...)
}
func (c *MCPUpstreamClient) mutate(ctx context.Context, m *MCPUpstreamMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&MCPUpstreamCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&MCPUpstreamUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&MCPUpstreamUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&MCPUpstreamDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown MCPUpstream mutation op: %q", m.Op())
}
}
// MCPUserToolSettingClient is a client for the MCPUserToolSetting schema.
type MCPUserToolSettingClient struct {
config
}
// NewMCPUserToolSettingClient returns a client for the MCPUserToolSetting from the given config.
func NewMCPUserToolSettingClient(c config) *MCPUserToolSettingClient {
return &MCPUserToolSettingClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `mcpusertoolsetting.Hooks(f(g(h())))`.
func (c *MCPUserToolSettingClient) Use(hooks ...Hook) {
c.hooks.MCPUserToolSetting = append(c.hooks.MCPUserToolSetting, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `mcpusertoolsetting.Intercept(f(g(h())))`.
func (c *MCPUserToolSettingClient) Intercept(interceptors ...Interceptor) {
c.inters.MCPUserToolSetting = append(c.inters.MCPUserToolSetting, interceptors...)
}
// Create returns a builder for creating a MCPUserToolSetting entity.
func (c *MCPUserToolSettingClient) Create() *MCPUserToolSettingCreate {
mutation := newMCPUserToolSettingMutation(c.config, OpCreate)
return &MCPUserToolSettingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of MCPUserToolSetting entities.
func (c *MCPUserToolSettingClient) CreateBulk(builders ...*MCPUserToolSettingCreate) *MCPUserToolSettingCreateBulk {
return &MCPUserToolSettingCreateBulk{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 *MCPUserToolSettingClient) MapCreateBulk(slice any, setFunc func(*MCPUserToolSettingCreate, int)) *MCPUserToolSettingCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &MCPUserToolSettingCreateBulk{err: fmt.Errorf("calling to MCPUserToolSettingClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*MCPUserToolSettingCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &MCPUserToolSettingCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for MCPUserToolSetting.
func (c *MCPUserToolSettingClient) Update() *MCPUserToolSettingUpdate {
mutation := newMCPUserToolSettingMutation(c.config, OpUpdate)
return &MCPUserToolSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *MCPUserToolSettingClient) UpdateOne(_m *MCPUserToolSetting) *MCPUserToolSettingUpdateOne {
mutation := newMCPUserToolSettingMutation(c.config, OpUpdateOne, withMCPUserToolSetting(_m))
return &MCPUserToolSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *MCPUserToolSettingClient) UpdateOneID(id uuid.UUID) *MCPUserToolSettingUpdateOne {
mutation := newMCPUserToolSettingMutation(c.config, OpUpdateOne, withMCPUserToolSettingID(id))
return &MCPUserToolSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for MCPUserToolSetting.
func (c *MCPUserToolSettingClient) Delete() *MCPUserToolSettingDelete {
mutation := newMCPUserToolSettingMutation(c.config, OpDelete)
return &MCPUserToolSettingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *MCPUserToolSettingClient) DeleteOne(_m *MCPUserToolSetting) *MCPUserToolSettingDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *MCPUserToolSettingClient) DeleteOneID(id uuid.UUID) *MCPUserToolSettingDeleteOne {
builder := c.Delete().Where(mcpusertoolsetting.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &MCPUserToolSettingDeleteOne{builder}
}
// Query returns a query builder for MCPUserToolSetting.
func (c *MCPUserToolSettingClient) Query() *MCPUserToolSettingQuery {
return &MCPUserToolSettingQuery{
config: c.config,
ctx: &QueryContext{Type: TypeMCPUserToolSetting},
inters: c.Interceptors(),
}
}
// Get returns a MCPUserToolSetting entity by its id.
func (c *MCPUserToolSettingClient) Get(ctx context.Context, id uuid.UUID) (*MCPUserToolSetting, error) {
return c.Query().Where(mcpusertoolsetting.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *MCPUserToolSettingClient) GetX(ctx context.Context, id uuid.UUID) *MCPUserToolSetting {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// Hooks returns the client hooks.
func (c *MCPUserToolSettingClient) Hooks() []Hook {
return c.hooks.MCPUserToolSetting
}
// Interceptors returns the client interceptors.
func (c *MCPUserToolSettingClient) Interceptors() []Interceptor {
return c.inters.MCPUserToolSetting
}
func (c *MCPUserToolSettingClient) mutate(ctx context.Context, m *MCPUserToolSettingMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&MCPUserToolSettingCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&MCPUserToolSettingUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&MCPUserToolSettingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&MCPUserToolSettingDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown MCPUserToolSetting mutation op: %q", m.Op())
}
}
// ModelClient is a client for the Model schema.
type ModelClient struct {
config
}
// NewModelClient returns a client for the Model from the given config.
func NewModelClient(c config) *ModelClient {
return &ModelClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `model.Hooks(f(g(h())))`.
func (c *ModelClient) Use(hooks ...Hook) {
c.hooks.Model = append(c.hooks.Model, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `model.Intercept(f(g(h())))`.
func (c *ModelClient) Intercept(interceptors ...Interceptor) {
c.inters.Model = append(c.inters.Model, interceptors...)
}
// Create returns a builder for creating a Model entity.
func (c *ModelClient) Create() *ModelCreate {
mutation := newModelMutation(c.config, OpCreate)
return &ModelCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Model entities.
func (c *ModelClient) CreateBulk(builders ...*ModelCreate) *ModelCreateBulk {
return &ModelCreateBulk{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 *ModelClient) MapCreateBulk(slice any, setFunc func(*ModelCreate, int)) *ModelCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ModelCreateBulk{err: fmt.Errorf("calling to ModelClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ModelCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ModelCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Model.
func (c *ModelClient) Update() *ModelUpdate {
mutation := newModelMutation(c.config, OpUpdate)
return &ModelUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ModelClient) UpdateOne(_m *Model) *ModelUpdateOne {
mutation := newModelMutation(c.config, OpUpdateOne, withModel(_m))
return &ModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ModelClient) UpdateOneID(id uuid.UUID) *ModelUpdateOne {
mutation := newModelMutation(c.config, OpUpdateOne, withModelID(id))
return &ModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Model.
func (c *ModelClient) Delete() *ModelDelete {
mutation := newModelMutation(c.config, OpDelete)
return &ModelDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ModelClient) DeleteOne(_m *Model) *ModelDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ModelClient) DeleteOneID(id uuid.UUID) *ModelDeleteOne {
builder := c.Delete().Where(model.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ModelDeleteOne{builder}
}
// Query returns a query builder for Model.
func (c *ModelClient) Query() *ModelQuery {
return &ModelQuery{
config: c.config,
ctx: &QueryContext{Type: TypeModel},
inters: c.Interceptors(),
}
}
// Get returns a Model entity by its id.
func (c *ModelClient) Get(ctx context.Context, id uuid.UUID) (*Model, error) {
return c.Query().Where(model.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ModelClient) GetX(ctx context.Context, id uuid.UUID) *Model {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a Model.
func (c *ModelClient) QueryUser(_m *Model) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, model.UserTable, model.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeams queries the teams edge of a Model.
func (c *ModelClient) QueryTeams(_m *Model) *TeamQuery {
query := (&TeamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(team.Table, team.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, model.TeamsTable, model.TeamsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGroups queries the groups edge of a Model.
func (c *ModelClient) QueryGroups(_m *Model) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, model.GroupsTable, model.GroupsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVms queries the vms edge of a Model.
func (c *ModelClient) QueryVms(_m *Model) *VirtualMachineQuery {
query := (&VirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, model.VmsTable, model.VmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectTasks queries the project_tasks edge of a Model.
func (c *ModelClient) QueryProjectTasks(_m *Model) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, model.ProjectTasksTable, model.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryPricing queries the pricing edge of a Model.
func (c *ModelClient) QueryPricing(_m *Model) *ModelPricingQuery {
query := (&ModelPricingClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(modelpricing.Table, modelpricing.FieldID),
sqlgraph.Edge(sqlgraph.O2O, false, model.PricingTable, model.PricingColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryApikeys queries the apikeys edge of a Model.
func (c *ModelClient) QueryApikeys(_m *Model) *ModelApiKeyQuery {
query := (&ModelApiKeyClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(modelapikey.Table, modelapikey.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, model.ApikeysTable, model.ApikeysColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QuerySwitchesFrom queries the switches_from edge of a Model.
func (c *ModelClient) QuerySwitchesFrom(_m *Model) *TaskModelSwitchQuery {
query := (&TaskModelSwitchClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(taskmodelswitch.Table, taskmodelswitch.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, model.SwitchesFromTable, model.SwitchesFromColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QuerySwitchesTo queries the switches_to edge of a Model.
func (c *ModelClient) QuerySwitchesTo(_m *Model) *TaskModelSwitchQuery {
query := (&TaskModelSwitchClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(taskmodelswitch.Table, taskmodelswitch.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, model.SwitchesToTable, model.SwitchesToColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamModels queries the team_models edge of a Model.
func (c *ModelClient) QueryTeamModels(_m *Model) *TeamModelQuery {
query := (&TeamModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(teammodel.Table, teammodel.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, model.TeamModelsTable, model.TeamModelsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamGroupModels queries the team_group_models edge of a Model.
func (c *ModelClient) QueryTeamGroupModels(_m *Model) *TeamGroupModelQuery {
query := (&TeamGroupModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(model.Table, model.FieldID, id),
sqlgraph.To(teamgroupmodel.Table, teamgroupmodel.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, model.TeamGroupModelsTable, model.TeamGroupModelsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ModelClient) Hooks() []Hook {
hooks := c.hooks.Model
return append(hooks[:len(hooks):len(hooks)], model.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ModelClient) Interceptors() []Interceptor {
inters := c.inters.Model
return append(inters[:len(inters):len(inters)], model.Interceptors[:]...)
}
func (c *ModelClient) mutate(ctx context.Context, m *ModelMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ModelCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ModelUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ModelDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown Model mutation op: %q", m.Op())
}
}
// ModelApiKeyClient is a client for the ModelApiKey schema.
type ModelApiKeyClient struct {
config
}
// NewModelApiKeyClient returns a client for the ModelApiKey from the given config.
func NewModelApiKeyClient(c config) *ModelApiKeyClient {
return &ModelApiKeyClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `modelapikey.Hooks(f(g(h())))`.
func (c *ModelApiKeyClient) Use(hooks ...Hook) {
c.hooks.ModelApiKey = append(c.hooks.ModelApiKey, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `modelapikey.Intercept(f(g(h())))`.
func (c *ModelApiKeyClient) Intercept(interceptors ...Interceptor) {
c.inters.ModelApiKey = append(c.inters.ModelApiKey, interceptors...)
}
// Create returns a builder for creating a ModelApiKey entity.
func (c *ModelApiKeyClient) Create() *ModelApiKeyCreate {
mutation := newModelApiKeyMutation(c.config, OpCreate)
return &ModelApiKeyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ModelApiKey entities.
func (c *ModelApiKeyClient) CreateBulk(builders ...*ModelApiKeyCreate) *ModelApiKeyCreateBulk {
return &ModelApiKeyCreateBulk{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 *ModelApiKeyClient) MapCreateBulk(slice any, setFunc func(*ModelApiKeyCreate, int)) *ModelApiKeyCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ModelApiKeyCreateBulk{err: fmt.Errorf("calling to ModelApiKeyClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ModelApiKeyCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ModelApiKeyCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ModelApiKey.
func (c *ModelApiKeyClient) Update() *ModelApiKeyUpdate {
mutation := newModelApiKeyMutation(c.config, OpUpdate)
return &ModelApiKeyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ModelApiKeyClient) UpdateOne(_m *ModelApiKey) *ModelApiKeyUpdateOne {
mutation := newModelApiKeyMutation(c.config, OpUpdateOne, withModelApiKey(_m))
return &ModelApiKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ModelApiKeyClient) UpdateOneID(id uuid.UUID) *ModelApiKeyUpdateOne {
mutation := newModelApiKeyMutation(c.config, OpUpdateOne, withModelApiKeyID(id))
return &ModelApiKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ModelApiKey.
func (c *ModelApiKeyClient) Delete() *ModelApiKeyDelete {
mutation := newModelApiKeyMutation(c.config, OpDelete)
return &ModelApiKeyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ModelApiKeyClient) DeleteOne(_m *ModelApiKey) *ModelApiKeyDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ModelApiKeyClient) DeleteOneID(id uuid.UUID) *ModelApiKeyDeleteOne {
builder := c.Delete().Where(modelapikey.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ModelApiKeyDeleteOne{builder}
}
// Query returns a query builder for ModelApiKey.
func (c *ModelApiKeyClient) Query() *ModelApiKeyQuery {
return &ModelApiKeyQuery{
config: c.config,
ctx: &QueryContext{Type: TypeModelApiKey},
inters: c.Interceptors(),
}
}
// Get returns a ModelApiKey entity by its id.
func (c *ModelApiKeyClient) Get(ctx context.Context, id uuid.UUID) (*ModelApiKey, error) {
return c.Query().Where(modelapikey.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ModelApiKeyClient) GetX(ctx context.Context, id uuid.UUID) *ModelApiKey {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryModel queries the model edge of a ModelApiKey.
func (c *ModelApiKeyClient) QueryModel(_m *ModelApiKey) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(modelapikey.Table, modelapikey.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, modelapikey.ModelTable, modelapikey.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ModelApiKeyClient) Hooks() []Hook {
hooks := c.hooks.ModelApiKey
return append(hooks[:len(hooks):len(hooks)], modelapikey.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ModelApiKeyClient) Interceptors() []Interceptor {
inters := c.inters.ModelApiKey
return append(inters[:len(inters):len(inters)], modelapikey.Interceptors[:]...)
}
func (c *ModelApiKeyClient) mutate(ctx context.Context, m *ModelApiKeyMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ModelApiKeyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ModelApiKeyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ModelApiKeyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ModelApiKeyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ModelApiKey mutation op: %q", m.Op())
}
}
// ModelPricingClient is a client for the ModelPricing schema.
type ModelPricingClient struct {
config
}
// NewModelPricingClient returns a client for the ModelPricing from the given config.
func NewModelPricingClient(c config) *ModelPricingClient {
return &ModelPricingClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `modelpricing.Hooks(f(g(h())))`.
func (c *ModelPricingClient) Use(hooks ...Hook) {
c.hooks.ModelPricing = append(c.hooks.ModelPricing, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `modelpricing.Intercept(f(g(h())))`.
func (c *ModelPricingClient) Intercept(interceptors ...Interceptor) {
c.inters.ModelPricing = append(c.inters.ModelPricing, interceptors...)
}
// Create returns a builder for creating a ModelPricing entity.
func (c *ModelPricingClient) Create() *ModelPricingCreate {
mutation := newModelPricingMutation(c.config, OpCreate)
return &ModelPricingCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ModelPricing entities.
func (c *ModelPricingClient) CreateBulk(builders ...*ModelPricingCreate) *ModelPricingCreateBulk {
return &ModelPricingCreateBulk{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 *ModelPricingClient) MapCreateBulk(slice any, setFunc func(*ModelPricingCreate, int)) *ModelPricingCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ModelPricingCreateBulk{err: fmt.Errorf("calling to ModelPricingClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ModelPricingCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ModelPricingCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ModelPricing.
func (c *ModelPricingClient) Update() *ModelPricingUpdate {
mutation := newModelPricingMutation(c.config, OpUpdate)
return &ModelPricingUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ModelPricingClient) UpdateOne(_m *ModelPricing) *ModelPricingUpdateOne {
mutation := newModelPricingMutation(c.config, OpUpdateOne, withModelPricing(_m))
return &ModelPricingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ModelPricingClient) UpdateOneID(id uuid.UUID) *ModelPricingUpdateOne {
mutation := newModelPricingMutation(c.config, OpUpdateOne, withModelPricingID(id))
return &ModelPricingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ModelPricing.
func (c *ModelPricingClient) Delete() *ModelPricingDelete {
mutation := newModelPricingMutation(c.config, OpDelete)
return &ModelPricingDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ModelPricingClient) DeleteOne(_m *ModelPricing) *ModelPricingDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ModelPricingClient) DeleteOneID(id uuid.UUID) *ModelPricingDeleteOne {
builder := c.Delete().Where(modelpricing.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ModelPricingDeleteOne{builder}
}
// Query returns a query builder for ModelPricing.
func (c *ModelPricingClient) Query() *ModelPricingQuery {
return &ModelPricingQuery{
config: c.config,
ctx: &QueryContext{Type: TypeModelPricing},
inters: c.Interceptors(),
}
}
// Get returns a ModelPricing entity by its id.
func (c *ModelPricingClient) Get(ctx context.Context, id uuid.UUID) (*ModelPricing, error) {
return c.Query().Where(modelpricing.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ModelPricingClient) GetX(ctx context.Context, id uuid.UUID) *ModelPricing {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryModel queries the model edge of a ModelPricing.
func (c *ModelPricingClient) QueryModel(_m *ModelPricing) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(modelpricing.Table, modelpricing.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.O2O, true, modelpricing.ModelTable, modelpricing.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ModelPricingClient) Hooks() []Hook {
return c.hooks.ModelPricing
}
// Interceptors returns the client interceptors.
func (c *ModelPricingClient) Interceptors() []Interceptor {
return c.inters.ModelPricing
}
func (c *ModelPricingClient) mutate(ctx context.Context, m *ModelPricingMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ModelPricingCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ModelPricingUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ModelPricingUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ModelPricingDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ModelPricing mutation op: %q", m.Op())
}
}
// NotifyChannelClient is a client for the NotifyChannel schema.
type NotifyChannelClient struct {
config
}
// NewNotifyChannelClient returns a client for the NotifyChannel from the given config.
func NewNotifyChannelClient(c config) *NotifyChannelClient {
return &NotifyChannelClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `notifychannel.Hooks(f(g(h())))`.
func (c *NotifyChannelClient) Use(hooks ...Hook) {
c.hooks.NotifyChannel = append(c.hooks.NotifyChannel, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `notifychannel.Intercept(f(g(h())))`.
func (c *NotifyChannelClient) Intercept(interceptors ...Interceptor) {
c.inters.NotifyChannel = append(c.inters.NotifyChannel, interceptors...)
}
// Create returns a builder for creating a NotifyChannel entity.
func (c *NotifyChannelClient) Create() *NotifyChannelCreate {
mutation := newNotifyChannelMutation(c.config, OpCreate)
return &NotifyChannelCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of NotifyChannel entities.
func (c *NotifyChannelClient) CreateBulk(builders ...*NotifyChannelCreate) *NotifyChannelCreateBulk {
return &NotifyChannelCreateBulk{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 *NotifyChannelClient) MapCreateBulk(slice any, setFunc func(*NotifyChannelCreate, int)) *NotifyChannelCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &NotifyChannelCreateBulk{err: fmt.Errorf("calling to NotifyChannelClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*NotifyChannelCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &NotifyChannelCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for NotifyChannel.
func (c *NotifyChannelClient) Update() *NotifyChannelUpdate {
mutation := newNotifyChannelMutation(c.config, OpUpdate)
return &NotifyChannelUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *NotifyChannelClient) UpdateOne(_m *NotifyChannel) *NotifyChannelUpdateOne {
mutation := newNotifyChannelMutation(c.config, OpUpdateOne, withNotifyChannel(_m))
return &NotifyChannelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *NotifyChannelClient) UpdateOneID(id uuid.UUID) *NotifyChannelUpdateOne {
mutation := newNotifyChannelMutation(c.config, OpUpdateOne, withNotifyChannelID(id))
return &NotifyChannelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for NotifyChannel.
func (c *NotifyChannelClient) Delete() *NotifyChannelDelete {
mutation := newNotifyChannelMutation(c.config, OpDelete)
return &NotifyChannelDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *NotifyChannelClient) DeleteOne(_m *NotifyChannel) *NotifyChannelDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *NotifyChannelClient) DeleteOneID(id uuid.UUID) *NotifyChannelDeleteOne {
builder := c.Delete().Where(notifychannel.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &NotifyChannelDeleteOne{builder}
}
// Query returns a query builder for NotifyChannel.
func (c *NotifyChannelClient) Query() *NotifyChannelQuery {
return &NotifyChannelQuery{
config: c.config,
ctx: &QueryContext{Type: TypeNotifyChannel},
inters: c.Interceptors(),
}
}
// Get returns a NotifyChannel entity by its id.
func (c *NotifyChannelClient) Get(ctx context.Context, id uuid.UUID) (*NotifyChannel, error) {
return c.Query().Where(notifychannel.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *NotifyChannelClient) GetX(ctx context.Context, id uuid.UUID) *NotifyChannel {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QuerySubscriptions queries the subscriptions edge of a NotifyChannel.
func (c *NotifyChannelClient) QuerySubscriptions(_m *NotifyChannel) *NotifySubscriptionQuery {
query := (&NotifySubscriptionClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(notifychannel.Table, notifychannel.FieldID, id),
sqlgraph.To(notifysubscription.Table, notifysubscription.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, notifychannel.SubscriptionsTable, notifychannel.SubscriptionsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *NotifyChannelClient) Hooks() []Hook {
hooks := c.hooks.NotifyChannel
return append(hooks[:len(hooks):len(hooks)], notifychannel.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *NotifyChannelClient) Interceptors() []Interceptor {
inters := c.inters.NotifyChannel
return append(inters[:len(inters):len(inters)], notifychannel.Interceptors[:]...)
}
func (c *NotifyChannelClient) mutate(ctx context.Context, m *NotifyChannelMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&NotifyChannelCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&NotifyChannelUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&NotifyChannelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&NotifyChannelDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown NotifyChannel mutation op: %q", m.Op())
}
}
// NotifySendLogClient is a client for the NotifySendLog schema.
type NotifySendLogClient struct {
config
}
// NewNotifySendLogClient returns a client for the NotifySendLog from the given config.
func NewNotifySendLogClient(c config) *NotifySendLogClient {
return &NotifySendLogClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `notifysendlog.Hooks(f(g(h())))`.
func (c *NotifySendLogClient) Use(hooks ...Hook) {
c.hooks.NotifySendLog = append(c.hooks.NotifySendLog, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `notifysendlog.Intercept(f(g(h())))`.
func (c *NotifySendLogClient) Intercept(interceptors ...Interceptor) {
c.inters.NotifySendLog = append(c.inters.NotifySendLog, interceptors...)
}
// Create returns a builder for creating a NotifySendLog entity.
func (c *NotifySendLogClient) Create() *NotifySendLogCreate {
mutation := newNotifySendLogMutation(c.config, OpCreate)
return &NotifySendLogCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of NotifySendLog entities.
func (c *NotifySendLogClient) CreateBulk(builders ...*NotifySendLogCreate) *NotifySendLogCreateBulk {
return &NotifySendLogCreateBulk{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 *NotifySendLogClient) MapCreateBulk(slice any, setFunc func(*NotifySendLogCreate, int)) *NotifySendLogCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &NotifySendLogCreateBulk{err: fmt.Errorf("calling to NotifySendLogClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*NotifySendLogCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &NotifySendLogCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for NotifySendLog.
func (c *NotifySendLogClient) Update() *NotifySendLogUpdate {
mutation := newNotifySendLogMutation(c.config, OpUpdate)
return &NotifySendLogUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *NotifySendLogClient) UpdateOne(_m *NotifySendLog) *NotifySendLogUpdateOne {
mutation := newNotifySendLogMutation(c.config, OpUpdateOne, withNotifySendLog(_m))
return &NotifySendLogUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *NotifySendLogClient) UpdateOneID(id uuid.UUID) *NotifySendLogUpdateOne {
mutation := newNotifySendLogMutation(c.config, OpUpdateOne, withNotifySendLogID(id))
return &NotifySendLogUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for NotifySendLog.
func (c *NotifySendLogClient) Delete() *NotifySendLogDelete {
mutation := newNotifySendLogMutation(c.config, OpDelete)
return &NotifySendLogDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *NotifySendLogClient) DeleteOne(_m *NotifySendLog) *NotifySendLogDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *NotifySendLogClient) DeleteOneID(id uuid.UUID) *NotifySendLogDeleteOne {
builder := c.Delete().Where(notifysendlog.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &NotifySendLogDeleteOne{builder}
}
// Query returns a query builder for NotifySendLog.
func (c *NotifySendLogClient) Query() *NotifySendLogQuery {
return &NotifySendLogQuery{
config: c.config,
ctx: &QueryContext{Type: TypeNotifySendLog},
inters: c.Interceptors(),
}
}
// Get returns a NotifySendLog entity by its id.
func (c *NotifySendLogClient) Get(ctx context.Context, id uuid.UUID) (*NotifySendLog, error) {
return c.Query().Where(notifysendlog.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *NotifySendLogClient) GetX(ctx context.Context, id uuid.UUID) *NotifySendLog {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// Hooks returns the client hooks.
func (c *NotifySendLogClient) Hooks() []Hook {
return c.hooks.NotifySendLog
}
// Interceptors returns the client interceptors.
func (c *NotifySendLogClient) Interceptors() []Interceptor {
return c.inters.NotifySendLog
}
func (c *NotifySendLogClient) mutate(ctx context.Context, m *NotifySendLogMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&NotifySendLogCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&NotifySendLogUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&NotifySendLogUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&NotifySendLogDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown NotifySendLog mutation op: %q", m.Op())
}
}
// NotifySubscriptionClient is a client for the NotifySubscription schema.
type NotifySubscriptionClient struct {
config
}
// NewNotifySubscriptionClient returns a client for the NotifySubscription from the given config.
func NewNotifySubscriptionClient(c config) *NotifySubscriptionClient {
return &NotifySubscriptionClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `notifysubscription.Hooks(f(g(h())))`.
func (c *NotifySubscriptionClient) Use(hooks ...Hook) {
c.hooks.NotifySubscription = append(c.hooks.NotifySubscription, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `notifysubscription.Intercept(f(g(h())))`.
func (c *NotifySubscriptionClient) Intercept(interceptors ...Interceptor) {
c.inters.NotifySubscription = append(c.inters.NotifySubscription, interceptors...)
}
// Create returns a builder for creating a NotifySubscription entity.
func (c *NotifySubscriptionClient) Create() *NotifySubscriptionCreate {
mutation := newNotifySubscriptionMutation(c.config, OpCreate)
return &NotifySubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of NotifySubscription entities.
func (c *NotifySubscriptionClient) CreateBulk(builders ...*NotifySubscriptionCreate) *NotifySubscriptionCreateBulk {
return &NotifySubscriptionCreateBulk{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 *NotifySubscriptionClient) MapCreateBulk(slice any, setFunc func(*NotifySubscriptionCreate, int)) *NotifySubscriptionCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &NotifySubscriptionCreateBulk{err: fmt.Errorf("calling to NotifySubscriptionClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*NotifySubscriptionCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &NotifySubscriptionCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for NotifySubscription.
func (c *NotifySubscriptionClient) Update() *NotifySubscriptionUpdate {
mutation := newNotifySubscriptionMutation(c.config, OpUpdate)
return &NotifySubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *NotifySubscriptionClient) UpdateOne(_m *NotifySubscription) *NotifySubscriptionUpdateOne {
mutation := newNotifySubscriptionMutation(c.config, OpUpdateOne, withNotifySubscription(_m))
return &NotifySubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *NotifySubscriptionClient) UpdateOneID(id uuid.UUID) *NotifySubscriptionUpdateOne {
mutation := newNotifySubscriptionMutation(c.config, OpUpdateOne, withNotifySubscriptionID(id))
return &NotifySubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for NotifySubscription.
func (c *NotifySubscriptionClient) Delete() *NotifySubscriptionDelete {
mutation := newNotifySubscriptionMutation(c.config, OpDelete)
return &NotifySubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *NotifySubscriptionClient) DeleteOne(_m *NotifySubscription) *NotifySubscriptionDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *NotifySubscriptionClient) DeleteOneID(id uuid.UUID) *NotifySubscriptionDeleteOne {
builder := c.Delete().Where(notifysubscription.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &NotifySubscriptionDeleteOne{builder}
}
// Query returns a query builder for NotifySubscription.
func (c *NotifySubscriptionClient) Query() *NotifySubscriptionQuery {
return &NotifySubscriptionQuery{
config: c.config,
ctx: &QueryContext{Type: TypeNotifySubscription},
inters: c.Interceptors(),
}
}
// Get returns a NotifySubscription entity by its id.
func (c *NotifySubscriptionClient) Get(ctx context.Context, id uuid.UUID) (*NotifySubscription, error) {
return c.Query().Where(notifysubscription.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *NotifySubscriptionClient) GetX(ctx context.Context, id uuid.UUID) *NotifySubscription {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryChannel queries the channel edge of a NotifySubscription.
func (c *NotifySubscriptionClient) QueryChannel(_m *NotifySubscription) *NotifyChannelQuery {
query := (&NotifyChannelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(notifysubscription.Table, notifysubscription.FieldID, id),
sqlgraph.To(notifychannel.Table, notifychannel.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, notifysubscription.ChannelTable, notifysubscription.ChannelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *NotifySubscriptionClient) Hooks() []Hook {
hooks := c.hooks.NotifySubscription
return append(hooks[:len(hooks):len(hooks)], notifysubscription.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *NotifySubscriptionClient) Interceptors() []Interceptor {
inters := c.inters.NotifySubscription
return append(inters[:len(inters):len(inters)], notifysubscription.Interceptors[:]...)
}
func (c *NotifySubscriptionClient) mutate(ctx context.Context, m *NotifySubscriptionMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&NotifySubscriptionCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&NotifySubscriptionUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&NotifySubscriptionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&NotifySubscriptionDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown NotifySubscription mutation op: %q", m.Op())
}
}
// ProjectClient is a client for the Project schema.
type ProjectClient struct {
config
}
// NewProjectClient returns a client for the Project from the given config.
func NewProjectClient(c config) *ProjectClient {
return &ProjectClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `project.Hooks(f(g(h())))`.
func (c *ProjectClient) Use(hooks ...Hook) {
c.hooks.Project = append(c.hooks.Project, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `project.Intercept(f(g(h())))`.
func (c *ProjectClient) Intercept(interceptors ...Interceptor) {
c.inters.Project = append(c.inters.Project, interceptors...)
}
// Create returns a builder for creating a Project entity.
func (c *ProjectClient) Create() *ProjectCreate {
mutation := newProjectMutation(c.config, OpCreate)
return &ProjectCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Project entities.
func (c *ProjectClient) CreateBulk(builders ...*ProjectCreate) *ProjectCreateBulk {
return &ProjectCreateBulk{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 *ProjectClient) MapCreateBulk(slice any, setFunc func(*ProjectCreate, int)) *ProjectCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectCreateBulk{err: fmt.Errorf("calling to ProjectClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Project.
func (c *ProjectClient) Update() *ProjectUpdate {
mutation := newProjectMutation(c.config, OpUpdate)
return &ProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectClient) UpdateOne(_m *Project) *ProjectUpdateOne {
mutation := newProjectMutation(c.config, OpUpdateOne, withProject(_m))
return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectClient) UpdateOneID(id uuid.UUID) *ProjectUpdateOne {
mutation := newProjectMutation(c.config, OpUpdateOne, withProjectID(id))
return &ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Project.
func (c *ProjectClient) Delete() *ProjectDelete {
mutation := newProjectMutation(c.config, OpDelete)
return &ProjectDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectClient) DeleteOne(_m *Project) *ProjectDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectClient) DeleteOneID(id uuid.UUID) *ProjectDeleteOne {
builder := c.Delete().Where(project.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectDeleteOne{builder}
}
// Query returns a query builder for Project.
func (c *ProjectClient) Query() *ProjectQuery {
return &ProjectQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProject},
inters: c.Interceptors(),
}
}
// Get returns a Project entity by its id.
func (c *ProjectClient) Get(ctx context.Context, id uuid.UUID) (*Project, error) {
return c.Query().Where(project.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectClient) GetX(ctx context.Context, id uuid.UUID) *Project {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a Project.
func (c *ProjectClient) QueryUser(_m *Project) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, project.UserTable, project.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitIdentity queries the git_identity edge of a Project.
func (c *ProjectClient) QueryGitIdentity(_m *Project) *GitIdentityQuery {
query := (&GitIdentityClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(gitidentity.Table, gitidentity.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, project.GitIdentityTable, project.GitIdentityColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImage queries the image edge of a Project.
func (c *ProjectClient) QueryImage(_m *Project) *ImageQuery {
query := (&ImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, project.ImageTable, project.ImageColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryIssues queries the issues edge of a Project.
func (c *ProjectClient) QueryIssues(_m *Project) *ProjectIssueQuery {
query := (&ProjectIssueClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(projectissue.Table, projectissue.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, project.IssuesTable, project.IssuesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryCollaborators queries the collaborators edge of a Project.
func (c *ProjectClient) QueryCollaborators(_m *Project) *ProjectCollaboratorQuery {
query := (&ProjectCollaboratorClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(projectcollaborator.Table, projectcollaborator.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, project.CollaboratorsTable, project.CollaboratorsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectTasks queries the project_tasks edge of a Project.
func (c *ProjectClient) QueryProjectTasks(_m *Project) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, project.ProjectTasksTable, project.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBots queries the git_bots edge of a Project.
func (c *ProjectClient) QueryGitBots(_m *Project) *GitBotQuery {
query := (&GitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, project.GitBotsTable, project.GitBotsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectGitBots queries the project_git_bots edge of a Project.
func (c *ProjectClient) QueryProjectGitBots(_m *Project) *ProjectGitBotQuery {
query := (&ProjectGitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(project.Table, project.FieldID, id),
sqlgraph.To(projectgitbot.Table, projectgitbot.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, project.ProjectGitBotsTable, project.ProjectGitBotsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectClient) Hooks() []Hook {
hooks := c.hooks.Project
return append(hooks[:len(hooks):len(hooks)], project.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ProjectClient) Interceptors() []Interceptor {
inters := c.inters.Project
return append(inters[:len(inters):len(inters)], project.Interceptors[:]...)
}
func (c *ProjectClient) mutate(ctx context.Context, m *ProjectMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown Project mutation op: %q", m.Op())
}
}
// ProjectCollaboratorClient is a client for the ProjectCollaborator schema.
type ProjectCollaboratorClient struct {
config
}
// NewProjectCollaboratorClient returns a client for the ProjectCollaborator from the given config.
func NewProjectCollaboratorClient(c config) *ProjectCollaboratorClient {
return &ProjectCollaboratorClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectcollaborator.Hooks(f(g(h())))`.
func (c *ProjectCollaboratorClient) Use(hooks ...Hook) {
c.hooks.ProjectCollaborator = append(c.hooks.ProjectCollaborator, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `projectcollaborator.Intercept(f(g(h())))`.
func (c *ProjectCollaboratorClient) Intercept(interceptors ...Interceptor) {
c.inters.ProjectCollaborator = append(c.inters.ProjectCollaborator, interceptors...)
}
// Create returns a builder for creating a ProjectCollaborator entity.
func (c *ProjectCollaboratorClient) Create() *ProjectCollaboratorCreate {
mutation := newProjectCollaboratorMutation(c.config, OpCreate)
return &ProjectCollaboratorCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ProjectCollaborator entities.
func (c *ProjectCollaboratorClient) CreateBulk(builders ...*ProjectCollaboratorCreate) *ProjectCollaboratorCreateBulk {
return &ProjectCollaboratorCreateBulk{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 *ProjectCollaboratorClient) MapCreateBulk(slice any, setFunc func(*ProjectCollaboratorCreate, int)) *ProjectCollaboratorCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectCollaboratorCreateBulk{err: fmt.Errorf("calling to ProjectCollaboratorClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectCollaboratorCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectCollaboratorCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ProjectCollaborator.
func (c *ProjectCollaboratorClient) Update() *ProjectCollaboratorUpdate {
mutation := newProjectCollaboratorMutation(c.config, OpUpdate)
return &ProjectCollaboratorUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectCollaboratorClient) UpdateOne(_m *ProjectCollaborator) *ProjectCollaboratorUpdateOne {
mutation := newProjectCollaboratorMutation(c.config, OpUpdateOne, withProjectCollaborator(_m))
return &ProjectCollaboratorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectCollaboratorClient) UpdateOneID(id uuid.UUID) *ProjectCollaboratorUpdateOne {
mutation := newProjectCollaboratorMutation(c.config, OpUpdateOne, withProjectCollaboratorID(id))
return &ProjectCollaboratorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ProjectCollaborator.
func (c *ProjectCollaboratorClient) Delete() *ProjectCollaboratorDelete {
mutation := newProjectCollaboratorMutation(c.config, OpDelete)
return &ProjectCollaboratorDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectCollaboratorClient) DeleteOne(_m *ProjectCollaborator) *ProjectCollaboratorDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectCollaboratorClient) DeleteOneID(id uuid.UUID) *ProjectCollaboratorDeleteOne {
builder := c.Delete().Where(projectcollaborator.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectCollaboratorDeleteOne{builder}
}
// Query returns a query builder for ProjectCollaborator.
func (c *ProjectCollaboratorClient) Query() *ProjectCollaboratorQuery {
return &ProjectCollaboratorQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProjectCollaborator},
inters: c.Interceptors(),
}
}
// Get returns a ProjectCollaborator entity by its id.
func (c *ProjectCollaboratorClient) Get(ctx context.Context, id uuid.UUID) (*ProjectCollaborator, error) {
return c.Query().Where(projectcollaborator.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectCollaboratorClient) GetX(ctx context.Context, id uuid.UUID) *ProjectCollaborator {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a ProjectCollaborator.
func (c *ProjectCollaboratorClient) QueryUser(_m *ProjectCollaborator) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectcollaborator.Table, projectcollaborator.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectcollaborator.UserTable, projectcollaborator.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProject queries the project edge of a ProjectCollaborator.
func (c *ProjectCollaboratorClient) QueryProject(_m *ProjectCollaborator) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectcollaborator.Table, projectcollaborator.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectcollaborator.ProjectTable, projectcollaborator.ProjectColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectCollaboratorClient) Hooks() []Hook {
hooks := c.hooks.ProjectCollaborator
return append(hooks[:len(hooks):len(hooks)], projectcollaborator.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ProjectCollaboratorClient) Interceptors() []Interceptor {
inters := c.inters.ProjectCollaborator
return append(inters[:len(inters):len(inters)], projectcollaborator.Interceptors[:]...)
}
func (c *ProjectCollaboratorClient) mutate(ctx context.Context, m *ProjectCollaboratorMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectCollaboratorCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectCollaboratorUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectCollaboratorUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectCollaboratorDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ProjectCollaborator mutation op: %q", m.Op())
}
}
// ProjectGitBotClient is a client for the ProjectGitBot schema.
type ProjectGitBotClient struct {
config
}
// NewProjectGitBotClient returns a client for the ProjectGitBot from the given config.
func NewProjectGitBotClient(c config) *ProjectGitBotClient {
return &ProjectGitBotClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectgitbot.Hooks(f(g(h())))`.
func (c *ProjectGitBotClient) Use(hooks ...Hook) {
c.hooks.ProjectGitBot = append(c.hooks.ProjectGitBot, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `projectgitbot.Intercept(f(g(h())))`.
func (c *ProjectGitBotClient) Intercept(interceptors ...Interceptor) {
c.inters.ProjectGitBot = append(c.inters.ProjectGitBot, interceptors...)
}
// Create returns a builder for creating a ProjectGitBot entity.
func (c *ProjectGitBotClient) Create() *ProjectGitBotCreate {
mutation := newProjectGitBotMutation(c.config, OpCreate)
return &ProjectGitBotCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ProjectGitBot entities.
func (c *ProjectGitBotClient) CreateBulk(builders ...*ProjectGitBotCreate) *ProjectGitBotCreateBulk {
return &ProjectGitBotCreateBulk{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 *ProjectGitBotClient) MapCreateBulk(slice any, setFunc func(*ProjectGitBotCreate, int)) *ProjectGitBotCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectGitBotCreateBulk{err: fmt.Errorf("calling to ProjectGitBotClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectGitBotCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectGitBotCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ProjectGitBot.
func (c *ProjectGitBotClient) Update() *ProjectGitBotUpdate {
mutation := newProjectGitBotMutation(c.config, OpUpdate)
return &ProjectGitBotUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectGitBotClient) UpdateOne(_m *ProjectGitBot) *ProjectGitBotUpdateOne {
mutation := newProjectGitBotMutation(c.config, OpUpdateOne, withProjectGitBot(_m))
return &ProjectGitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectGitBotClient) UpdateOneID(id uuid.UUID) *ProjectGitBotUpdateOne {
mutation := newProjectGitBotMutation(c.config, OpUpdateOne, withProjectGitBotID(id))
return &ProjectGitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ProjectGitBot.
func (c *ProjectGitBotClient) Delete() *ProjectGitBotDelete {
mutation := newProjectGitBotMutation(c.config, OpDelete)
return &ProjectGitBotDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectGitBotClient) DeleteOne(_m *ProjectGitBot) *ProjectGitBotDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectGitBotClient) DeleteOneID(id uuid.UUID) *ProjectGitBotDeleteOne {
builder := c.Delete().Where(projectgitbot.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectGitBotDeleteOne{builder}
}
// Query returns a query builder for ProjectGitBot.
func (c *ProjectGitBotClient) Query() *ProjectGitBotQuery {
return &ProjectGitBotQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProjectGitBot},
inters: c.Interceptors(),
}
}
// Get returns a ProjectGitBot entity by its id.
func (c *ProjectGitBotClient) Get(ctx context.Context, id uuid.UUID) (*ProjectGitBot, error) {
return c.Query().Where(projectgitbot.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectGitBotClient) GetX(ctx context.Context, id uuid.UUID) *ProjectGitBot {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryProject queries the project edge of a ProjectGitBot.
func (c *ProjectGitBotClient) QueryProject(_m *ProjectGitBot) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectgitbot.Table, projectgitbot.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, projectgitbot.ProjectTable, projectgitbot.ProjectColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBot queries the git_bot edge of a ProjectGitBot.
func (c *ProjectGitBotClient) QueryGitBot(_m *ProjectGitBot) *GitBotQuery {
query := (&GitBotClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectgitbot.Table, projectgitbot.FieldID, id),
sqlgraph.To(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, projectgitbot.GitBotTable, projectgitbot.GitBotColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectGitBotClient) Hooks() []Hook {
return c.hooks.ProjectGitBot
}
// Interceptors returns the client interceptors.
func (c *ProjectGitBotClient) Interceptors() []Interceptor {
return c.inters.ProjectGitBot
}
func (c *ProjectGitBotClient) mutate(ctx context.Context, m *ProjectGitBotMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectGitBotCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectGitBotUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectGitBotUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectGitBotDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ProjectGitBot mutation op: %q", m.Op())
}
}
// ProjectIssueClient is a client for the ProjectIssue schema.
type ProjectIssueClient struct {
config
}
// NewProjectIssueClient returns a client for the ProjectIssue from the given config.
func NewProjectIssueClient(c config) *ProjectIssueClient {
return &ProjectIssueClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectissue.Hooks(f(g(h())))`.
func (c *ProjectIssueClient) Use(hooks ...Hook) {
c.hooks.ProjectIssue = append(c.hooks.ProjectIssue, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `projectissue.Intercept(f(g(h())))`.
func (c *ProjectIssueClient) Intercept(interceptors ...Interceptor) {
c.inters.ProjectIssue = append(c.inters.ProjectIssue, interceptors...)
}
// Create returns a builder for creating a ProjectIssue entity.
func (c *ProjectIssueClient) Create() *ProjectIssueCreate {
mutation := newProjectIssueMutation(c.config, OpCreate)
return &ProjectIssueCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ProjectIssue entities.
func (c *ProjectIssueClient) CreateBulk(builders ...*ProjectIssueCreate) *ProjectIssueCreateBulk {
return &ProjectIssueCreateBulk{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 *ProjectIssueClient) MapCreateBulk(slice any, setFunc func(*ProjectIssueCreate, int)) *ProjectIssueCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectIssueCreateBulk{err: fmt.Errorf("calling to ProjectIssueClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectIssueCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectIssueCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ProjectIssue.
func (c *ProjectIssueClient) Update() *ProjectIssueUpdate {
mutation := newProjectIssueMutation(c.config, OpUpdate)
return &ProjectIssueUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectIssueClient) UpdateOne(_m *ProjectIssue) *ProjectIssueUpdateOne {
mutation := newProjectIssueMutation(c.config, OpUpdateOne, withProjectIssue(_m))
return &ProjectIssueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectIssueClient) UpdateOneID(id uuid.UUID) *ProjectIssueUpdateOne {
mutation := newProjectIssueMutation(c.config, OpUpdateOne, withProjectIssueID(id))
return &ProjectIssueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ProjectIssue.
func (c *ProjectIssueClient) Delete() *ProjectIssueDelete {
mutation := newProjectIssueMutation(c.config, OpDelete)
return &ProjectIssueDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectIssueClient) DeleteOne(_m *ProjectIssue) *ProjectIssueDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectIssueClient) DeleteOneID(id uuid.UUID) *ProjectIssueDeleteOne {
builder := c.Delete().Where(projectissue.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectIssueDeleteOne{builder}
}
// Query returns a query builder for ProjectIssue.
func (c *ProjectIssueClient) Query() *ProjectIssueQuery {
return &ProjectIssueQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProjectIssue},
inters: c.Interceptors(),
}
}
// Get returns a ProjectIssue entity by its id.
func (c *ProjectIssueClient) Get(ctx context.Context, id uuid.UUID) (*ProjectIssue, error) {
return c.Query().Where(projectissue.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectIssueClient) GetX(ctx context.Context, id uuid.UUID) *ProjectIssue {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a ProjectIssue.
func (c *ProjectIssueClient) QueryUser(_m *ProjectIssue) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissue.Table, projectissue.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissue.UserTable, projectissue.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryAssignee queries the assignee edge of a ProjectIssue.
func (c *ProjectIssueClient) QueryAssignee(_m *ProjectIssue) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissue.Table, projectissue.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissue.AssigneeTable, projectissue.AssigneeColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProject queries the project edge of a ProjectIssue.
func (c *ProjectIssueClient) QueryProject(_m *ProjectIssue) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissue.Table, projectissue.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissue.ProjectTable, projectissue.ProjectColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryComments queries the comments edge of a ProjectIssue.
func (c *ProjectIssueClient) QueryComments(_m *ProjectIssue) *ProjectIssueCommentQuery {
query := (&ProjectIssueCommentClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissue.Table, projectissue.FieldID, id),
sqlgraph.To(projectissuecomment.Table, projectissuecomment.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, projectissue.CommentsTable, projectissue.CommentsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectTasks queries the project_tasks edge of a ProjectIssue.
func (c *ProjectIssueClient) QueryProjectTasks(_m *ProjectIssue) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissue.Table, projectissue.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, projectissue.ProjectTasksTable, projectissue.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectIssueClient) Hooks() []Hook {
hooks := c.hooks.ProjectIssue
return append(hooks[:len(hooks):len(hooks)], projectissue.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ProjectIssueClient) Interceptors() []Interceptor {
inters := c.inters.ProjectIssue
return append(inters[:len(inters):len(inters)], projectissue.Interceptors[:]...)
}
func (c *ProjectIssueClient) mutate(ctx context.Context, m *ProjectIssueMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectIssueCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectIssueUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectIssueUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectIssueDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ProjectIssue mutation op: %q", m.Op())
}
}
// ProjectIssueCommentClient is a client for the ProjectIssueComment schema.
type ProjectIssueCommentClient struct {
config
}
// NewProjectIssueCommentClient returns a client for the ProjectIssueComment from the given config.
func NewProjectIssueCommentClient(c config) *ProjectIssueCommentClient {
return &ProjectIssueCommentClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projectissuecomment.Hooks(f(g(h())))`.
func (c *ProjectIssueCommentClient) Use(hooks ...Hook) {
c.hooks.ProjectIssueComment = append(c.hooks.ProjectIssueComment, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `projectissuecomment.Intercept(f(g(h())))`.
func (c *ProjectIssueCommentClient) Intercept(interceptors ...Interceptor) {
c.inters.ProjectIssueComment = append(c.inters.ProjectIssueComment, interceptors...)
}
// Create returns a builder for creating a ProjectIssueComment entity.
func (c *ProjectIssueCommentClient) Create() *ProjectIssueCommentCreate {
mutation := newProjectIssueCommentMutation(c.config, OpCreate)
return &ProjectIssueCommentCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ProjectIssueComment entities.
func (c *ProjectIssueCommentClient) CreateBulk(builders ...*ProjectIssueCommentCreate) *ProjectIssueCommentCreateBulk {
return &ProjectIssueCommentCreateBulk{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 *ProjectIssueCommentClient) MapCreateBulk(slice any, setFunc func(*ProjectIssueCommentCreate, int)) *ProjectIssueCommentCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectIssueCommentCreateBulk{err: fmt.Errorf("calling to ProjectIssueCommentClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectIssueCommentCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectIssueCommentCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ProjectIssueComment.
func (c *ProjectIssueCommentClient) Update() *ProjectIssueCommentUpdate {
mutation := newProjectIssueCommentMutation(c.config, OpUpdate)
return &ProjectIssueCommentUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectIssueCommentClient) UpdateOne(_m *ProjectIssueComment) *ProjectIssueCommentUpdateOne {
mutation := newProjectIssueCommentMutation(c.config, OpUpdateOne, withProjectIssueComment(_m))
return &ProjectIssueCommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectIssueCommentClient) UpdateOneID(id uuid.UUID) *ProjectIssueCommentUpdateOne {
mutation := newProjectIssueCommentMutation(c.config, OpUpdateOne, withProjectIssueCommentID(id))
return &ProjectIssueCommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ProjectIssueComment.
func (c *ProjectIssueCommentClient) Delete() *ProjectIssueCommentDelete {
mutation := newProjectIssueCommentMutation(c.config, OpDelete)
return &ProjectIssueCommentDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectIssueCommentClient) DeleteOne(_m *ProjectIssueComment) *ProjectIssueCommentDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectIssueCommentClient) DeleteOneID(id uuid.UUID) *ProjectIssueCommentDeleteOne {
builder := c.Delete().Where(projectissuecomment.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectIssueCommentDeleteOne{builder}
}
// Query returns a query builder for ProjectIssueComment.
func (c *ProjectIssueCommentClient) Query() *ProjectIssueCommentQuery {
return &ProjectIssueCommentQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProjectIssueComment},
inters: c.Interceptors(),
}
}
// Get returns a ProjectIssueComment entity by its id.
func (c *ProjectIssueCommentClient) Get(ctx context.Context, id uuid.UUID) (*ProjectIssueComment, error) {
return c.Query().Where(projectissuecomment.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectIssueCommentClient) GetX(ctx context.Context, id uuid.UUID) *ProjectIssueComment {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUser queries the user edge of a ProjectIssueComment.
func (c *ProjectIssueCommentClient) QueryUser(_m *ProjectIssueComment) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissuecomment.Table, projectissuecomment.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissuecomment.UserTable, projectissuecomment.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryIssue queries the issue edge of a ProjectIssueComment.
func (c *ProjectIssueCommentClient) QueryIssue(_m *ProjectIssueComment) *ProjectIssueQuery {
query := (&ProjectIssueClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissuecomment.Table, projectissuecomment.FieldID, id),
sqlgraph.To(projectissue.Table, projectissue.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissuecomment.IssueTable, projectissuecomment.IssueColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryParent queries the parent edge of a ProjectIssueComment.
func (c *ProjectIssueCommentClient) QueryParent(_m *ProjectIssueComment) *ProjectIssueCommentQuery {
query := (&ProjectIssueCommentClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissuecomment.Table, projectissuecomment.FieldID, id),
sqlgraph.To(projectissuecomment.Table, projectissuecomment.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projectissuecomment.ParentTable, projectissuecomment.ParentColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryReplies queries the replies edge of a ProjectIssueComment.
func (c *ProjectIssueCommentClient) QueryReplies(_m *ProjectIssueComment) *ProjectIssueCommentQuery {
query := (&ProjectIssueCommentClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projectissuecomment.Table, projectissuecomment.FieldID, id),
sqlgraph.To(projectissuecomment.Table, projectissuecomment.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, projectissuecomment.RepliesTable, projectissuecomment.RepliesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectIssueCommentClient) Hooks() []Hook {
hooks := c.hooks.ProjectIssueComment
return append(hooks[:len(hooks):len(hooks)], projectissuecomment.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *ProjectIssueCommentClient) Interceptors() []Interceptor {
inters := c.inters.ProjectIssueComment
return append(inters[:len(inters):len(inters)], projectissuecomment.Interceptors[:]...)
}
func (c *ProjectIssueCommentClient) mutate(ctx context.Context, m *ProjectIssueCommentMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectIssueCommentCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectIssueCommentUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectIssueCommentUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectIssueCommentDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ProjectIssueComment mutation op: %q", m.Op())
}
}
// ProjectTaskClient is a client for the ProjectTask schema.
type ProjectTaskClient struct {
config
}
// NewProjectTaskClient returns a client for the ProjectTask from the given config.
func NewProjectTaskClient(c config) *ProjectTaskClient {
return &ProjectTaskClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `projecttask.Hooks(f(g(h())))`.
func (c *ProjectTaskClient) Use(hooks ...Hook) {
c.hooks.ProjectTask = append(c.hooks.ProjectTask, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `projecttask.Intercept(f(g(h())))`.
func (c *ProjectTaskClient) Intercept(interceptors ...Interceptor) {
c.inters.ProjectTask = append(c.inters.ProjectTask, interceptors...)
}
// Create returns a builder for creating a ProjectTask entity.
func (c *ProjectTaskClient) Create() *ProjectTaskCreate {
mutation := newProjectTaskMutation(c.config, OpCreate)
return &ProjectTaskCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ProjectTask entities.
func (c *ProjectTaskClient) CreateBulk(builders ...*ProjectTaskCreate) *ProjectTaskCreateBulk {
return &ProjectTaskCreateBulk{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 *ProjectTaskClient) MapCreateBulk(slice any, setFunc func(*ProjectTaskCreate, int)) *ProjectTaskCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ProjectTaskCreateBulk{err: fmt.Errorf("calling to ProjectTaskClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ProjectTaskCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ProjectTaskCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ProjectTask.
func (c *ProjectTaskClient) Update() *ProjectTaskUpdate {
mutation := newProjectTaskMutation(c.config, OpUpdate)
return &ProjectTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ProjectTaskClient) UpdateOne(_m *ProjectTask) *ProjectTaskUpdateOne {
mutation := newProjectTaskMutation(c.config, OpUpdateOne, withProjectTask(_m))
return &ProjectTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ProjectTaskClient) UpdateOneID(id uuid.UUID) *ProjectTaskUpdateOne {
mutation := newProjectTaskMutation(c.config, OpUpdateOne, withProjectTaskID(id))
return &ProjectTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ProjectTask.
func (c *ProjectTaskClient) Delete() *ProjectTaskDelete {
mutation := newProjectTaskMutation(c.config, OpDelete)
return &ProjectTaskDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ProjectTaskClient) DeleteOne(_m *ProjectTask) *ProjectTaskDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ProjectTaskClient) DeleteOneID(id uuid.UUID) *ProjectTaskDeleteOne {
builder := c.Delete().Where(projecttask.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ProjectTaskDeleteOne{builder}
}
// Query returns a query builder for ProjectTask.
func (c *ProjectTaskClient) Query() *ProjectTaskQuery {
return &ProjectTaskQuery{
config: c.config,
ctx: &QueryContext{Type: TypeProjectTask},
inters: c.Interceptors(),
}
}
// Get returns a ProjectTask entity by its id.
func (c *ProjectTaskClient) Get(ctx context.Context, id uuid.UUID) (*ProjectTask, error) {
return c.Query().Where(projecttask.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ProjectTaskClient) GetX(ctx context.Context, id uuid.UUID) *ProjectTask {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTask queries the task edge of a ProjectTask.
func (c *ProjectTaskClient) QueryTask(_m *ProjectTask) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.TaskTable, projecttask.TaskColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryModel queries the model edge of a ProjectTask.
func (c *ProjectTaskClient) QueryModel(_m *ProjectTask) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.ModelTable, projecttask.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImage queries the image edge of a ProjectTask.
func (c *ProjectTaskClient) QueryImage(_m *ProjectTask) *ImageQuery {
query := (&ImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.ImageTable, projecttask.ImageColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitIdentity queries the git_identity edge of a ProjectTask.
func (c *ProjectTaskClient) QueryGitIdentity(_m *ProjectTask) *GitIdentityQuery {
query := (&GitIdentityClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(gitidentity.Table, gitidentity.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.GitIdentityTable, projecttask.GitIdentityColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProject queries the project edge of a ProjectTask.
func (c *ProjectTaskClient) QueryProject(_m *ProjectTask) *ProjectQuery {
query := (&ProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.ProjectTable, projecttask.ProjectColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryIssue queries the issue edge of a ProjectTask.
func (c *ProjectTaskClient) QueryIssue(_m *ProjectTask) *ProjectIssueQuery {
query := (&ProjectIssueClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(projecttask.Table, projecttask.FieldID, id),
sqlgraph.To(projectissue.Table, projectissue.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, projecttask.IssueTable, projecttask.IssueColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ProjectTaskClient) Hooks() []Hook {
return c.hooks.ProjectTask
}
// Interceptors returns the client interceptors.
func (c *ProjectTaskClient) Interceptors() []Interceptor {
return c.inters.ProjectTask
}
func (c *ProjectTaskClient) mutate(ctx context.Context, m *ProjectTaskMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ProjectTaskCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ProjectTaskUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ProjectTaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ProjectTaskDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown ProjectTask mutation op: %q", m.Op())
}
}
// TaskClient is a client for the Task schema.
type TaskClient struct {
config
}
// NewTaskClient returns a client for the Task from the given config.
func NewTaskClient(c config) *TaskClient {
return &TaskClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `task.Hooks(f(g(h())))`.
func (c *TaskClient) Use(hooks ...Hook) {
c.hooks.Task = append(c.hooks.Task, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `task.Intercept(f(g(h())))`.
func (c *TaskClient) Intercept(interceptors ...Interceptor) {
c.inters.Task = append(c.inters.Task, interceptors...)
}
// Create returns a builder for creating a Task entity.
func (c *TaskClient) Create() *TaskCreate {
mutation := newTaskMutation(c.config, OpCreate)
return &TaskCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Task entities.
func (c *TaskClient) CreateBulk(builders ...*TaskCreate) *TaskCreateBulk {
return &TaskCreateBulk{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 *TaskClient) MapCreateBulk(slice any, setFunc func(*TaskCreate, int)) *TaskCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TaskCreateBulk{err: fmt.Errorf("calling to TaskClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TaskCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TaskCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Task.
func (c *TaskClient) Update() *TaskUpdate {
mutation := newTaskMutation(c.config, OpUpdate)
return &TaskUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TaskClient) UpdateOne(_m *Task) *TaskUpdateOne {
mutation := newTaskMutation(c.config, OpUpdateOne, withTask(_m))
return &TaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TaskClient) UpdateOneID(id uuid.UUID) *TaskUpdateOne {
mutation := newTaskMutation(c.config, OpUpdateOne, withTaskID(id))
return &TaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Task.
func (c *TaskClient) Delete() *TaskDelete {
mutation := newTaskMutation(c.config, OpDelete)
return &TaskDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TaskClient) DeleteOne(_m *Task) *TaskDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TaskClient) DeleteOneID(id uuid.UUID) *TaskDeleteOne {
builder := c.Delete().Where(task.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TaskDeleteOne{builder}
}
// Query returns a query builder for Task.
func (c *TaskClient) Query() *TaskQuery {
return &TaskQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTask},
inters: c.Interceptors(),
}
}
// Get returns a Task entity by its id.
func (c *TaskClient) Get(ctx context.Context, id uuid.UUID) (*Task, error) {
return c.Query().Where(task.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TaskClient) GetX(ctx context.Context, id uuid.UUID) *Task {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryProjectTasks queries the project_tasks edge of a Task.
func (c *TaskClient) QueryProjectTasks(_m *Task) *ProjectTaskQuery {
query := (&ProjectTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(projecttask.Table, projecttask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, task.ProjectTasksTable, task.ProjectTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitTasks queries the git_tasks edge of a Task.
func (c *TaskClient) QueryGitTasks(_m *Task) *GitTaskQuery {
query := (&GitTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(gittask.Table, gittask.FieldID),
sqlgraph.Edge(sqlgraph.O2O, false, task.GitTasksTable, task.GitTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a Task.
func (c *TaskClient) QueryUser(_m *Task) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, task.UserTable, task.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVms queries the vms edge of a Task.
func (c *TaskClient) QueryVms(_m *Task) *VirtualMachineQuery {
query := (&VirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, task.VmsTable, task.VmsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBotTasks queries the git_bot_tasks edge of a Task.
func (c *TaskClient) QueryGitBotTasks(_m *Task) *GitBotTaskQuery {
query := (&GitBotTaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(gitbottask.Table, gitbottask.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, task.GitBotTasksTable, task.GitBotTasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryModelSwitches queries the model_switches edge of a Task.
func (c *TaskClient) QueryModelSwitches(_m *Task) *TaskModelSwitchQuery {
query := (&TaskModelSwitchClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(taskmodelswitch.Table, taskmodelswitch.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, task.ModelSwitchesTable, task.ModelSwitchesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTaskVms queries the task_vms edge of a Task.
func (c *TaskClient) QueryTaskVms(_m *Task) *TaskVirtualMachineQuery {
query := (&TaskVirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(task.Table, task.FieldID, id),
sqlgraph.To(taskvirtualmachine.Table, taskvirtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, task.TaskVmsTable, task.TaskVmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TaskClient) Hooks() []Hook {
hooks := c.hooks.Task
return append(hooks[:len(hooks):len(hooks)], task.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *TaskClient) Interceptors() []Interceptor {
inters := c.inters.Task
return append(inters[:len(inters):len(inters)], task.Interceptors[:]...)
}
func (c *TaskClient) mutate(ctx context.Context, m *TaskMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TaskCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TaskUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TaskUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TaskDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown Task mutation op: %q", m.Op())
}
}
// TaskModelSwitchClient is a client for the TaskModelSwitch schema.
type TaskModelSwitchClient struct {
config
}
// NewTaskModelSwitchClient returns a client for the TaskModelSwitch from the given config.
func NewTaskModelSwitchClient(c config) *TaskModelSwitchClient {
return &TaskModelSwitchClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `taskmodelswitch.Hooks(f(g(h())))`.
func (c *TaskModelSwitchClient) Use(hooks ...Hook) {
c.hooks.TaskModelSwitch = append(c.hooks.TaskModelSwitch, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `taskmodelswitch.Intercept(f(g(h())))`.
func (c *TaskModelSwitchClient) Intercept(interceptors ...Interceptor) {
c.inters.TaskModelSwitch = append(c.inters.TaskModelSwitch, interceptors...)
}
// Create returns a builder for creating a TaskModelSwitch entity.
func (c *TaskModelSwitchClient) Create() *TaskModelSwitchCreate {
mutation := newTaskModelSwitchMutation(c.config, OpCreate)
return &TaskModelSwitchCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TaskModelSwitch entities.
func (c *TaskModelSwitchClient) CreateBulk(builders ...*TaskModelSwitchCreate) *TaskModelSwitchCreateBulk {
return &TaskModelSwitchCreateBulk{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 *TaskModelSwitchClient) MapCreateBulk(slice any, setFunc func(*TaskModelSwitchCreate, int)) *TaskModelSwitchCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TaskModelSwitchCreateBulk{err: fmt.Errorf("calling to TaskModelSwitchClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TaskModelSwitchCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TaskModelSwitchCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TaskModelSwitch.
func (c *TaskModelSwitchClient) Update() *TaskModelSwitchUpdate {
mutation := newTaskModelSwitchMutation(c.config, OpUpdate)
return &TaskModelSwitchUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TaskModelSwitchClient) UpdateOne(_m *TaskModelSwitch) *TaskModelSwitchUpdateOne {
mutation := newTaskModelSwitchMutation(c.config, OpUpdateOne, withTaskModelSwitch(_m))
return &TaskModelSwitchUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TaskModelSwitchClient) UpdateOneID(id uuid.UUID) *TaskModelSwitchUpdateOne {
mutation := newTaskModelSwitchMutation(c.config, OpUpdateOne, withTaskModelSwitchID(id))
return &TaskModelSwitchUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TaskModelSwitch.
func (c *TaskModelSwitchClient) Delete() *TaskModelSwitchDelete {
mutation := newTaskModelSwitchMutation(c.config, OpDelete)
return &TaskModelSwitchDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TaskModelSwitchClient) DeleteOne(_m *TaskModelSwitch) *TaskModelSwitchDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TaskModelSwitchClient) DeleteOneID(id uuid.UUID) *TaskModelSwitchDeleteOne {
builder := c.Delete().Where(taskmodelswitch.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TaskModelSwitchDeleteOne{builder}
}
// Query returns a query builder for TaskModelSwitch.
func (c *TaskModelSwitchClient) Query() *TaskModelSwitchQuery {
return &TaskModelSwitchQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTaskModelSwitch},
inters: c.Interceptors(),
}
}
// Get returns a TaskModelSwitch entity by its id.
func (c *TaskModelSwitchClient) Get(ctx context.Context, id uuid.UUID) (*TaskModelSwitch, error) {
return c.Query().Where(taskmodelswitch.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TaskModelSwitchClient) GetX(ctx context.Context, id uuid.UUID) *TaskModelSwitch {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTask queries the task edge of a TaskModelSwitch.
func (c *TaskModelSwitchClient) QueryTask(_m *TaskModelSwitch) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskmodelswitch.Table, taskmodelswitch.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, taskmodelswitch.TaskTable, taskmodelswitch.TaskColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a TaskModelSwitch.
func (c *TaskModelSwitchClient) QueryUser(_m *TaskModelSwitch) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskmodelswitch.Table, taskmodelswitch.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, taskmodelswitch.UserTable, taskmodelswitch.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryFromModel queries the from_model edge of a TaskModelSwitch.
func (c *TaskModelSwitchClient) QueryFromModel(_m *TaskModelSwitch) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskmodelswitch.Table, taskmodelswitch.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, taskmodelswitch.FromModelTable, taskmodelswitch.FromModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryToModel queries the to_model edge of a TaskModelSwitch.
func (c *TaskModelSwitchClient) QueryToModel(_m *TaskModelSwitch) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskmodelswitch.Table, taskmodelswitch.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, taskmodelswitch.ToModelTable, taskmodelswitch.ToModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TaskModelSwitchClient) Hooks() []Hook {
return c.hooks.TaskModelSwitch
}
// Interceptors returns the client interceptors.
func (c *TaskModelSwitchClient) Interceptors() []Interceptor {
return c.inters.TaskModelSwitch
}
func (c *TaskModelSwitchClient) mutate(ctx context.Context, m *TaskModelSwitchMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TaskModelSwitchCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TaskModelSwitchUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TaskModelSwitchUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TaskModelSwitchDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TaskModelSwitch mutation op: %q", m.Op())
}
}
// TaskUsageStatClient is a client for the TaskUsageStat schema.
type TaskUsageStatClient struct {
config
}
// NewTaskUsageStatClient returns a client for the TaskUsageStat from the given config.
func NewTaskUsageStatClient(c config) *TaskUsageStatClient {
return &TaskUsageStatClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `taskusagestat.Hooks(f(g(h())))`.
func (c *TaskUsageStatClient) Use(hooks ...Hook) {
c.hooks.TaskUsageStat = append(c.hooks.TaskUsageStat, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `taskusagestat.Intercept(f(g(h())))`.
func (c *TaskUsageStatClient) Intercept(interceptors ...Interceptor) {
c.inters.TaskUsageStat = append(c.inters.TaskUsageStat, interceptors...)
}
// Create returns a builder for creating a TaskUsageStat entity.
func (c *TaskUsageStatClient) Create() *TaskUsageStatCreate {
mutation := newTaskUsageStatMutation(c.config, OpCreate)
return &TaskUsageStatCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TaskUsageStat entities.
func (c *TaskUsageStatClient) CreateBulk(builders ...*TaskUsageStatCreate) *TaskUsageStatCreateBulk {
return &TaskUsageStatCreateBulk{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 *TaskUsageStatClient) MapCreateBulk(slice any, setFunc func(*TaskUsageStatCreate, int)) *TaskUsageStatCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TaskUsageStatCreateBulk{err: fmt.Errorf("calling to TaskUsageStatClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TaskUsageStatCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TaskUsageStatCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TaskUsageStat.
func (c *TaskUsageStatClient) Update() *TaskUsageStatUpdate {
mutation := newTaskUsageStatMutation(c.config, OpUpdate)
return &TaskUsageStatUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TaskUsageStatClient) UpdateOne(_m *TaskUsageStat) *TaskUsageStatUpdateOne {
mutation := newTaskUsageStatMutation(c.config, OpUpdateOne, withTaskUsageStat(_m))
return &TaskUsageStatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TaskUsageStatClient) UpdateOneID(id uuid.UUID) *TaskUsageStatUpdateOne {
mutation := newTaskUsageStatMutation(c.config, OpUpdateOne, withTaskUsageStatID(id))
return &TaskUsageStatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TaskUsageStat.
func (c *TaskUsageStatClient) Delete() *TaskUsageStatDelete {
mutation := newTaskUsageStatMutation(c.config, OpDelete)
return &TaskUsageStatDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TaskUsageStatClient) DeleteOne(_m *TaskUsageStat) *TaskUsageStatDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TaskUsageStatClient) DeleteOneID(id uuid.UUID) *TaskUsageStatDeleteOne {
builder := c.Delete().Where(taskusagestat.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TaskUsageStatDeleteOne{builder}
}
// Query returns a query builder for TaskUsageStat.
func (c *TaskUsageStatClient) Query() *TaskUsageStatQuery {
return &TaskUsageStatQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTaskUsageStat},
inters: c.Interceptors(),
}
}
// Get returns a TaskUsageStat entity by its id.
func (c *TaskUsageStatClient) Get(ctx context.Context, id uuid.UUID) (*TaskUsageStat, error) {
return c.Query().Where(taskusagestat.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TaskUsageStatClient) GetX(ctx context.Context, id uuid.UUID) *TaskUsageStat {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// Hooks returns the client hooks.
func (c *TaskUsageStatClient) Hooks() []Hook {
return c.hooks.TaskUsageStat
}
// Interceptors returns the client interceptors.
func (c *TaskUsageStatClient) Interceptors() []Interceptor {
return c.inters.TaskUsageStat
}
func (c *TaskUsageStatClient) mutate(ctx context.Context, m *TaskUsageStatMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TaskUsageStatCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TaskUsageStatUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TaskUsageStatUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TaskUsageStatDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TaskUsageStat mutation op: %q", m.Op())
}
}
// TaskVirtualMachineClient is a client for the TaskVirtualMachine schema.
type TaskVirtualMachineClient struct {
config
}
// NewTaskVirtualMachineClient returns a client for the TaskVirtualMachine from the given config.
func NewTaskVirtualMachineClient(c config) *TaskVirtualMachineClient {
return &TaskVirtualMachineClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `taskvirtualmachine.Hooks(f(g(h())))`.
func (c *TaskVirtualMachineClient) Use(hooks ...Hook) {
c.hooks.TaskVirtualMachine = append(c.hooks.TaskVirtualMachine, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `taskvirtualmachine.Intercept(f(g(h())))`.
func (c *TaskVirtualMachineClient) Intercept(interceptors ...Interceptor) {
c.inters.TaskVirtualMachine = append(c.inters.TaskVirtualMachine, interceptors...)
}
// Create returns a builder for creating a TaskVirtualMachine entity.
func (c *TaskVirtualMachineClient) Create() *TaskVirtualMachineCreate {
mutation := newTaskVirtualMachineMutation(c.config, OpCreate)
return &TaskVirtualMachineCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TaskVirtualMachine entities.
func (c *TaskVirtualMachineClient) CreateBulk(builders ...*TaskVirtualMachineCreate) *TaskVirtualMachineCreateBulk {
return &TaskVirtualMachineCreateBulk{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 *TaskVirtualMachineClient) MapCreateBulk(slice any, setFunc func(*TaskVirtualMachineCreate, int)) *TaskVirtualMachineCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TaskVirtualMachineCreateBulk{err: fmt.Errorf("calling to TaskVirtualMachineClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TaskVirtualMachineCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TaskVirtualMachineCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TaskVirtualMachine.
func (c *TaskVirtualMachineClient) Update() *TaskVirtualMachineUpdate {
mutation := newTaskVirtualMachineMutation(c.config, OpUpdate)
return &TaskVirtualMachineUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TaskVirtualMachineClient) UpdateOne(_m *TaskVirtualMachine) *TaskVirtualMachineUpdateOne {
mutation := newTaskVirtualMachineMutation(c.config, OpUpdateOne, withTaskVirtualMachine(_m))
return &TaskVirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TaskVirtualMachineClient) UpdateOneID(id uuid.UUID) *TaskVirtualMachineUpdateOne {
mutation := newTaskVirtualMachineMutation(c.config, OpUpdateOne, withTaskVirtualMachineID(id))
return &TaskVirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TaskVirtualMachine.
func (c *TaskVirtualMachineClient) Delete() *TaskVirtualMachineDelete {
mutation := newTaskVirtualMachineMutation(c.config, OpDelete)
return &TaskVirtualMachineDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TaskVirtualMachineClient) DeleteOne(_m *TaskVirtualMachine) *TaskVirtualMachineDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TaskVirtualMachineClient) DeleteOneID(id uuid.UUID) *TaskVirtualMachineDeleteOne {
builder := c.Delete().Where(taskvirtualmachine.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TaskVirtualMachineDeleteOne{builder}
}
// Query returns a query builder for TaskVirtualMachine.
func (c *TaskVirtualMachineClient) Query() *TaskVirtualMachineQuery {
return &TaskVirtualMachineQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTaskVirtualMachine},
inters: c.Interceptors(),
}
}
// Get returns a TaskVirtualMachine entity by its id.
func (c *TaskVirtualMachineClient) Get(ctx context.Context, id uuid.UUID) (*TaskVirtualMachine, error) {
return c.Query().Where(taskvirtualmachine.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TaskVirtualMachineClient) GetX(ctx context.Context, id uuid.UUID) *TaskVirtualMachine {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTask queries the task edge of a TaskVirtualMachine.
func (c *TaskVirtualMachineClient) QueryTask(_m *TaskVirtualMachine) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskvirtualmachine.Table, taskvirtualmachine.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, taskvirtualmachine.TaskTable, taskvirtualmachine.TaskColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVirtualmachine queries the virtualmachine edge of a TaskVirtualMachine.
func (c *TaskVirtualMachineClient) QueryVirtualmachine(_m *TaskVirtualMachine) *VirtualMachineQuery {
query := (&VirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(taskvirtualmachine.Table, taskvirtualmachine.FieldID, id),
sqlgraph.To(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, taskvirtualmachine.VirtualmachineTable, taskvirtualmachine.VirtualmachineColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TaskVirtualMachineClient) Hooks() []Hook {
return c.hooks.TaskVirtualMachine
}
// Interceptors returns the client interceptors.
func (c *TaskVirtualMachineClient) Interceptors() []Interceptor {
return c.inters.TaskVirtualMachine
}
func (c *TaskVirtualMachineClient) mutate(ctx context.Context, m *TaskVirtualMachineMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TaskVirtualMachineCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TaskVirtualMachineUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TaskVirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TaskVirtualMachineDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TaskVirtualMachine 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
}
// QueryModels queries the models edge of a Team.
func (c *TeamClient) QueryModels(_m *Team) *ModelQuery {
query := (&ModelClient{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(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, team.ModelsTable, team.ModelsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImages queries the images edge of a Team.
func (c *TeamClient) QueryImages(_m *Team) *ImageQuery {
query := (&ImageClient{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(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, team.ImagesTable, team.ImagesPrimaryKey...),
)
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
}
// QueryTeamModels queries the team_models edge of a Team.
func (c *TeamClient) QueryTeamModels(_m *Team) *TeamModelQuery {
query := (&TeamModelClient{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(teammodel.Table, teammodel.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, team.TeamModelsTable, team.TeamModelsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamImages queries the team_images edge of a Team.
func (c *TeamClient) QueryTeamImages(_m *Team) *TeamImageQuery {
query := (&TeamImageClient{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(teamimage.Table, teamimage.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, team.TeamImagesTable, team.TeamImagesColumn),
)
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
}
// QueryModels queries the models edge of a TeamGroup.
func (c *TeamGroupClient) QueryModels(_m *TeamGroup) *ModelQuery {
query := (&ModelClient{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(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, teamgroup.ModelsTable, teamgroup.ModelsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImages queries the images edge of a TeamGroup.
func (c *TeamGroupClient) QueryImages(_m *TeamGroup) *ImageQuery {
query := (&ImageClient{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(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, teamgroup.ImagesTable, teamgroup.ImagesPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryHosts queries the hosts edge of a TeamGroup.
func (c *TeamGroupClient) QueryHosts(_m *TeamGroup) *HostQuery {
query := (&HostClient{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(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, teamgroup.HostsTable, teamgroup.HostsPrimaryKey...),
)
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
}
// QueryTeamGroupModels queries the team_group_models edge of a TeamGroup.
func (c *TeamGroupClient) QueryTeamGroupModels(_m *TeamGroup) *TeamGroupModelQuery {
query := (&TeamGroupModelClient{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(teamgroupmodel.Table, teamgroupmodel.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, teamgroup.TeamGroupModelsTable, teamgroup.TeamGroupModelsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamGroupImages queries the team_group_images edge of a TeamGroup.
func (c *TeamGroupClient) QueryTeamGroupImages(_m *TeamGroup) *TeamGroupImageQuery {
query := (&TeamGroupImageClient{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(teamgroupimage.Table, teamgroupimage.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, teamgroup.TeamGroupImagesTable, teamgroup.TeamGroupImagesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTeamGroupHosts queries the team_group_hosts edge of a TeamGroup.
func (c *TeamGroupClient) QueryTeamGroupHosts(_m *TeamGroup) *TeamGroupHostQuery {
query := (&TeamGroupHostClient{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(teamgrouphost.Table, teamgrouphost.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, teamgroup.TeamGroupHostsTable, teamgroup.TeamGroupHostsColumn),
)
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())
}
}
// TeamGroupHostClient is a client for the TeamGroupHost schema.
type TeamGroupHostClient struct {
config
}
// NewTeamGroupHostClient returns a client for the TeamGroupHost from the given config.
func NewTeamGroupHostClient(c config) *TeamGroupHostClient {
return &TeamGroupHostClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teamgrouphost.Hooks(f(g(h())))`.
func (c *TeamGroupHostClient) Use(hooks ...Hook) {
c.hooks.TeamGroupHost = append(c.hooks.TeamGroupHost, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teamgrouphost.Intercept(f(g(h())))`.
func (c *TeamGroupHostClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamGroupHost = append(c.inters.TeamGroupHost, interceptors...)
}
// Create returns a builder for creating a TeamGroupHost entity.
func (c *TeamGroupHostClient) Create() *TeamGroupHostCreate {
mutation := newTeamGroupHostMutation(c.config, OpCreate)
return &TeamGroupHostCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamGroupHost entities.
func (c *TeamGroupHostClient) CreateBulk(builders ...*TeamGroupHostCreate) *TeamGroupHostCreateBulk {
return &TeamGroupHostCreateBulk{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 *TeamGroupHostClient) MapCreateBulk(slice any, setFunc func(*TeamGroupHostCreate, int)) *TeamGroupHostCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamGroupHostCreateBulk{err: fmt.Errorf("calling to TeamGroupHostClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamGroupHostCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamGroupHostCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamGroupHost.
func (c *TeamGroupHostClient) Update() *TeamGroupHostUpdate {
mutation := newTeamGroupHostMutation(c.config, OpUpdate)
return &TeamGroupHostUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamGroupHostClient) UpdateOne(_m *TeamGroupHost) *TeamGroupHostUpdateOne {
mutation := newTeamGroupHostMutation(c.config, OpUpdateOne, withTeamGroupHost(_m))
return &TeamGroupHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamGroupHostClient) UpdateOneID(id uuid.UUID) *TeamGroupHostUpdateOne {
mutation := newTeamGroupHostMutation(c.config, OpUpdateOne, withTeamGroupHostID(id))
return &TeamGroupHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamGroupHost.
func (c *TeamGroupHostClient) Delete() *TeamGroupHostDelete {
mutation := newTeamGroupHostMutation(c.config, OpDelete)
return &TeamGroupHostDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamGroupHostClient) DeleteOne(_m *TeamGroupHost) *TeamGroupHostDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamGroupHostClient) DeleteOneID(id uuid.UUID) *TeamGroupHostDeleteOne {
builder := c.Delete().Where(teamgrouphost.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamGroupHostDeleteOne{builder}
}
// Query returns a query builder for TeamGroupHost.
func (c *TeamGroupHostClient) Query() *TeamGroupHostQuery {
return &TeamGroupHostQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamGroupHost},
inters: c.Interceptors(),
}
}
// Get returns a TeamGroupHost entity by its id.
func (c *TeamGroupHostClient) Get(ctx context.Context, id uuid.UUID) (*TeamGroupHost, error) {
return c.Query().Where(teamgrouphost.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamGroupHostClient) GetX(ctx context.Context, id uuid.UUID) *TeamGroupHost {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryGroup queries the group edge of a TeamGroupHost.
func (c *TeamGroupHostClient) QueryGroup(_m *TeamGroupHost) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgrouphost.Table, teamgrouphost.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgrouphost.GroupTable, teamgrouphost.GroupColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryHost queries the host edge of a TeamGroupHost.
func (c *TeamGroupHostClient) QueryHost(_m *TeamGroupHost) *HostQuery {
query := (&HostClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgrouphost.Table, teamgrouphost.FieldID, id),
sqlgraph.To(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgrouphost.HostTable, teamgrouphost.HostColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamGroupHostClient) Hooks() []Hook {
return c.hooks.TeamGroupHost
}
// Interceptors returns the client interceptors.
func (c *TeamGroupHostClient) Interceptors() []Interceptor {
return c.inters.TeamGroupHost
}
func (c *TeamGroupHostClient) mutate(ctx context.Context, m *TeamGroupHostMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamGroupHostCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamGroupHostUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamGroupHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamGroupHostDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamGroupHost mutation op: %q", m.Op())
}
}
// TeamGroupImageClient is a client for the TeamGroupImage schema.
type TeamGroupImageClient struct {
config
}
// NewTeamGroupImageClient returns a client for the TeamGroupImage from the given config.
func NewTeamGroupImageClient(c config) *TeamGroupImageClient {
return &TeamGroupImageClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teamgroupimage.Hooks(f(g(h())))`.
func (c *TeamGroupImageClient) Use(hooks ...Hook) {
c.hooks.TeamGroupImage = append(c.hooks.TeamGroupImage, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teamgroupimage.Intercept(f(g(h())))`.
func (c *TeamGroupImageClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamGroupImage = append(c.inters.TeamGroupImage, interceptors...)
}
// Create returns a builder for creating a TeamGroupImage entity.
func (c *TeamGroupImageClient) Create() *TeamGroupImageCreate {
mutation := newTeamGroupImageMutation(c.config, OpCreate)
return &TeamGroupImageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamGroupImage entities.
func (c *TeamGroupImageClient) CreateBulk(builders ...*TeamGroupImageCreate) *TeamGroupImageCreateBulk {
return &TeamGroupImageCreateBulk{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 *TeamGroupImageClient) MapCreateBulk(slice any, setFunc func(*TeamGroupImageCreate, int)) *TeamGroupImageCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamGroupImageCreateBulk{err: fmt.Errorf("calling to TeamGroupImageClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamGroupImageCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamGroupImageCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamGroupImage.
func (c *TeamGroupImageClient) Update() *TeamGroupImageUpdate {
mutation := newTeamGroupImageMutation(c.config, OpUpdate)
return &TeamGroupImageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamGroupImageClient) UpdateOne(_m *TeamGroupImage) *TeamGroupImageUpdateOne {
mutation := newTeamGroupImageMutation(c.config, OpUpdateOne, withTeamGroupImage(_m))
return &TeamGroupImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamGroupImageClient) UpdateOneID(id uuid.UUID) *TeamGroupImageUpdateOne {
mutation := newTeamGroupImageMutation(c.config, OpUpdateOne, withTeamGroupImageID(id))
return &TeamGroupImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamGroupImage.
func (c *TeamGroupImageClient) Delete() *TeamGroupImageDelete {
mutation := newTeamGroupImageMutation(c.config, OpDelete)
return &TeamGroupImageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamGroupImageClient) DeleteOne(_m *TeamGroupImage) *TeamGroupImageDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamGroupImageClient) DeleteOneID(id uuid.UUID) *TeamGroupImageDeleteOne {
builder := c.Delete().Where(teamgroupimage.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamGroupImageDeleteOne{builder}
}
// Query returns a query builder for TeamGroupImage.
func (c *TeamGroupImageClient) Query() *TeamGroupImageQuery {
return &TeamGroupImageQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamGroupImage},
inters: c.Interceptors(),
}
}
// Get returns a TeamGroupImage entity by its id.
func (c *TeamGroupImageClient) Get(ctx context.Context, id uuid.UUID) (*TeamGroupImage, error) {
return c.Query().Where(teamgroupimage.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamGroupImageClient) GetX(ctx context.Context, id uuid.UUID) *TeamGroupImage {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryGroup queries the group edge of a TeamGroupImage.
func (c *TeamGroupImageClient) QueryGroup(_m *TeamGroupImage) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgroupimage.Table, teamgroupimage.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgroupimage.GroupTable, teamgroupimage.GroupColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImage queries the image edge of a TeamGroupImage.
func (c *TeamGroupImageClient) QueryImage(_m *TeamGroupImage) *ImageQuery {
query := (&ImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgroupimage.Table, teamgroupimage.FieldID, id),
sqlgraph.To(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgroupimage.ImageTable, teamgroupimage.ImageColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamGroupImageClient) Hooks() []Hook {
return c.hooks.TeamGroupImage
}
// Interceptors returns the client interceptors.
func (c *TeamGroupImageClient) Interceptors() []Interceptor {
return c.inters.TeamGroupImage
}
func (c *TeamGroupImageClient) mutate(ctx context.Context, m *TeamGroupImageMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamGroupImageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamGroupImageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamGroupImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamGroupImageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamGroupImage 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())
}
}
// TeamGroupModelClient is a client for the TeamGroupModel schema.
type TeamGroupModelClient struct {
config
}
// NewTeamGroupModelClient returns a client for the TeamGroupModel from the given config.
func NewTeamGroupModelClient(c config) *TeamGroupModelClient {
return &TeamGroupModelClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teamgroupmodel.Hooks(f(g(h())))`.
func (c *TeamGroupModelClient) Use(hooks ...Hook) {
c.hooks.TeamGroupModel = append(c.hooks.TeamGroupModel, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teamgroupmodel.Intercept(f(g(h())))`.
func (c *TeamGroupModelClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamGroupModel = append(c.inters.TeamGroupModel, interceptors...)
}
// Create returns a builder for creating a TeamGroupModel entity.
func (c *TeamGroupModelClient) Create() *TeamGroupModelCreate {
mutation := newTeamGroupModelMutation(c.config, OpCreate)
return &TeamGroupModelCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamGroupModel entities.
func (c *TeamGroupModelClient) CreateBulk(builders ...*TeamGroupModelCreate) *TeamGroupModelCreateBulk {
return &TeamGroupModelCreateBulk{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 *TeamGroupModelClient) MapCreateBulk(slice any, setFunc func(*TeamGroupModelCreate, int)) *TeamGroupModelCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamGroupModelCreateBulk{err: fmt.Errorf("calling to TeamGroupModelClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamGroupModelCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamGroupModelCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamGroupModel.
func (c *TeamGroupModelClient) Update() *TeamGroupModelUpdate {
mutation := newTeamGroupModelMutation(c.config, OpUpdate)
return &TeamGroupModelUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamGroupModelClient) UpdateOne(_m *TeamGroupModel) *TeamGroupModelUpdateOne {
mutation := newTeamGroupModelMutation(c.config, OpUpdateOne, withTeamGroupModel(_m))
return &TeamGroupModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamGroupModelClient) UpdateOneID(id uuid.UUID) *TeamGroupModelUpdateOne {
mutation := newTeamGroupModelMutation(c.config, OpUpdateOne, withTeamGroupModelID(id))
return &TeamGroupModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamGroupModel.
func (c *TeamGroupModelClient) Delete() *TeamGroupModelDelete {
mutation := newTeamGroupModelMutation(c.config, OpDelete)
return &TeamGroupModelDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamGroupModelClient) DeleteOne(_m *TeamGroupModel) *TeamGroupModelDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamGroupModelClient) DeleteOneID(id uuid.UUID) *TeamGroupModelDeleteOne {
builder := c.Delete().Where(teamgroupmodel.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamGroupModelDeleteOne{builder}
}
// Query returns a query builder for TeamGroupModel.
func (c *TeamGroupModelClient) Query() *TeamGroupModelQuery {
return &TeamGroupModelQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamGroupModel},
inters: c.Interceptors(),
}
}
// Get returns a TeamGroupModel entity by its id.
func (c *TeamGroupModelClient) Get(ctx context.Context, id uuid.UUID) (*TeamGroupModel, error) {
return c.Query().Where(teamgroupmodel.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamGroupModelClient) GetX(ctx context.Context, id uuid.UUID) *TeamGroupModel {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryGroup queries the group edge of a TeamGroupModel.
func (c *TeamGroupModelClient) QueryGroup(_m *TeamGroupModel) *TeamGroupQuery {
query := (&TeamGroupClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgroupmodel.Table, teamgroupmodel.FieldID, id),
sqlgraph.To(teamgroup.Table, teamgroup.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmodel.GroupTable, teamgroupmodel.GroupColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryModel queries the model edge of a TeamGroupModel.
func (c *TeamGroupModelClient) QueryModel(_m *TeamGroupModel) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamgroupmodel.Table, teamgroupmodel.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamgroupmodel.ModelTable, teamgroupmodel.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamGroupModelClient) Hooks() []Hook {
return c.hooks.TeamGroupModel
}
// Interceptors returns the client interceptors.
func (c *TeamGroupModelClient) Interceptors() []Interceptor {
return c.inters.TeamGroupModel
}
func (c *TeamGroupModelClient) mutate(ctx context.Context, m *TeamGroupModelMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamGroupModelCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamGroupModelUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamGroupModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamGroupModelDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamGroupModel mutation op: %q", m.Op())
}
}
// TeamHostClient is a client for the TeamHost schema.
type TeamHostClient struct {
config
}
// NewTeamHostClient returns a client for the TeamHost from the given config.
func NewTeamHostClient(c config) *TeamHostClient {
return &TeamHostClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teamhost.Hooks(f(g(h())))`.
func (c *TeamHostClient) Use(hooks ...Hook) {
c.hooks.TeamHost = append(c.hooks.TeamHost, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teamhost.Intercept(f(g(h())))`.
func (c *TeamHostClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamHost = append(c.inters.TeamHost, interceptors...)
}
// Create returns a builder for creating a TeamHost entity.
func (c *TeamHostClient) Create() *TeamHostCreate {
mutation := newTeamHostMutation(c.config, OpCreate)
return &TeamHostCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamHost entities.
func (c *TeamHostClient) CreateBulk(builders ...*TeamHostCreate) *TeamHostCreateBulk {
return &TeamHostCreateBulk{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 *TeamHostClient) MapCreateBulk(slice any, setFunc func(*TeamHostCreate, int)) *TeamHostCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamHostCreateBulk{err: fmt.Errorf("calling to TeamHostClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamHostCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamHostCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamHost.
func (c *TeamHostClient) Update() *TeamHostUpdate {
mutation := newTeamHostMutation(c.config, OpUpdate)
return &TeamHostUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamHostClient) UpdateOne(_m *TeamHost) *TeamHostUpdateOne {
mutation := newTeamHostMutation(c.config, OpUpdateOne, withTeamHost(_m))
return &TeamHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamHostClient) UpdateOneID(id uuid.UUID) *TeamHostUpdateOne {
mutation := newTeamHostMutation(c.config, OpUpdateOne, withTeamHostID(id))
return &TeamHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamHost.
func (c *TeamHostClient) Delete() *TeamHostDelete {
mutation := newTeamHostMutation(c.config, OpDelete)
return &TeamHostDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamHostClient) DeleteOne(_m *TeamHost) *TeamHostDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamHostClient) DeleteOneID(id uuid.UUID) *TeamHostDeleteOne {
builder := c.Delete().Where(teamhost.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamHostDeleteOne{builder}
}
// Query returns a query builder for TeamHost.
func (c *TeamHostClient) Query() *TeamHostQuery {
return &TeamHostQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamHost},
inters: c.Interceptors(),
}
}
// Get returns a TeamHost entity by its id.
func (c *TeamHostClient) Get(ctx context.Context, id uuid.UUID) (*TeamHost, error) {
return c.Query().Where(teamhost.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamHostClient) GetX(ctx context.Context, id uuid.UUID) *TeamHost {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTeam queries the team edge of a TeamHost.
func (c *TeamHostClient) QueryTeam(_m *TeamHost) *TeamQuery {
query := (&TeamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamhost.Table, teamhost.FieldID, id),
sqlgraph.To(team.Table, team.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamhost.TeamTable, teamhost.TeamColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryHost queries the host edge of a TeamHost.
func (c *TeamHostClient) QueryHost(_m *TeamHost) *HostQuery {
query := (&HostClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamhost.Table, teamhost.FieldID, id),
sqlgraph.To(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamhost.HostTable, teamhost.HostColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamHostClient) Hooks() []Hook {
return c.hooks.TeamHost
}
// Interceptors returns the client interceptors.
func (c *TeamHostClient) Interceptors() []Interceptor {
return c.inters.TeamHost
}
func (c *TeamHostClient) mutate(ctx context.Context, m *TeamHostMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamHostCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamHostUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamHostUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamHostDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamHost mutation op: %q", m.Op())
}
}
// TeamImageClient is a client for the TeamImage schema.
type TeamImageClient struct {
config
}
// NewTeamImageClient returns a client for the TeamImage from the given config.
func NewTeamImageClient(c config) *TeamImageClient {
return &TeamImageClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teamimage.Hooks(f(g(h())))`.
func (c *TeamImageClient) Use(hooks ...Hook) {
c.hooks.TeamImage = append(c.hooks.TeamImage, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teamimage.Intercept(f(g(h())))`.
func (c *TeamImageClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamImage = append(c.inters.TeamImage, interceptors...)
}
// Create returns a builder for creating a TeamImage entity.
func (c *TeamImageClient) Create() *TeamImageCreate {
mutation := newTeamImageMutation(c.config, OpCreate)
return &TeamImageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamImage entities.
func (c *TeamImageClient) CreateBulk(builders ...*TeamImageCreate) *TeamImageCreateBulk {
return &TeamImageCreateBulk{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 *TeamImageClient) MapCreateBulk(slice any, setFunc func(*TeamImageCreate, int)) *TeamImageCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamImageCreateBulk{err: fmt.Errorf("calling to TeamImageClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamImageCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamImageCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamImage.
func (c *TeamImageClient) Update() *TeamImageUpdate {
mutation := newTeamImageMutation(c.config, OpUpdate)
return &TeamImageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamImageClient) UpdateOne(_m *TeamImage) *TeamImageUpdateOne {
mutation := newTeamImageMutation(c.config, OpUpdateOne, withTeamImage(_m))
return &TeamImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamImageClient) UpdateOneID(id uuid.UUID) *TeamImageUpdateOne {
mutation := newTeamImageMutation(c.config, OpUpdateOne, withTeamImageID(id))
return &TeamImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamImage.
func (c *TeamImageClient) Delete() *TeamImageDelete {
mutation := newTeamImageMutation(c.config, OpDelete)
return &TeamImageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamImageClient) DeleteOne(_m *TeamImage) *TeamImageDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamImageClient) DeleteOneID(id uuid.UUID) *TeamImageDeleteOne {
builder := c.Delete().Where(teamimage.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamImageDeleteOne{builder}
}
// Query returns a query builder for TeamImage.
func (c *TeamImageClient) Query() *TeamImageQuery {
return &TeamImageQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamImage},
inters: c.Interceptors(),
}
}
// Get returns a TeamImage entity by its id.
func (c *TeamImageClient) Get(ctx context.Context, id uuid.UUID) (*TeamImage, error) {
return c.Query().Where(teamimage.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamImageClient) GetX(ctx context.Context, id uuid.UUID) *TeamImage {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTeam queries the team edge of a TeamImage.
func (c *TeamImageClient) QueryTeam(_m *TeamImage) *TeamQuery {
query := (&TeamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamimage.Table, teamimage.FieldID, id),
sqlgraph.To(team.Table, team.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamimage.TeamTable, teamimage.TeamColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImage queries the image edge of a TeamImage.
func (c *TeamImageClient) QueryImage(_m *TeamImage) *ImageQuery {
query := (&ImageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teamimage.Table, teamimage.FieldID, id),
sqlgraph.To(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teamimage.ImageTable, teamimage.ImageColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamImageClient) Hooks() []Hook {
return c.hooks.TeamImage
}
// Interceptors returns the client interceptors.
func (c *TeamImageClient) Interceptors() []Interceptor {
return c.inters.TeamImage
}
func (c *TeamImageClient) mutate(ctx context.Context, m *TeamImageMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamImageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamImageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamImageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamImageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamImage 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())
}
}
// TeamModelClient is a client for the TeamModel schema.
type TeamModelClient struct {
config
}
// NewTeamModelClient returns a client for the TeamModel from the given config.
func NewTeamModelClient(c config) *TeamModelClient {
return &TeamModelClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `teammodel.Hooks(f(g(h())))`.
func (c *TeamModelClient) Use(hooks ...Hook) {
c.hooks.TeamModel = append(c.hooks.TeamModel, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `teammodel.Intercept(f(g(h())))`.
func (c *TeamModelClient) Intercept(interceptors ...Interceptor) {
c.inters.TeamModel = append(c.inters.TeamModel, interceptors...)
}
// Create returns a builder for creating a TeamModel entity.
func (c *TeamModelClient) Create() *TeamModelCreate {
mutation := newTeamModelMutation(c.config, OpCreate)
return &TeamModelCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of TeamModel entities.
func (c *TeamModelClient) CreateBulk(builders ...*TeamModelCreate) *TeamModelCreateBulk {
return &TeamModelCreateBulk{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 *TeamModelClient) MapCreateBulk(slice any, setFunc func(*TeamModelCreate, int)) *TeamModelCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &TeamModelCreateBulk{err: fmt.Errorf("calling to TeamModelClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*TeamModelCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &TeamModelCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for TeamModel.
func (c *TeamModelClient) Update() *TeamModelUpdate {
mutation := newTeamModelMutation(c.config, OpUpdate)
return &TeamModelUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *TeamModelClient) UpdateOne(_m *TeamModel) *TeamModelUpdateOne {
mutation := newTeamModelMutation(c.config, OpUpdateOne, withTeamModel(_m))
return &TeamModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *TeamModelClient) UpdateOneID(id uuid.UUID) *TeamModelUpdateOne {
mutation := newTeamModelMutation(c.config, OpUpdateOne, withTeamModelID(id))
return &TeamModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for TeamModel.
func (c *TeamModelClient) Delete() *TeamModelDelete {
mutation := newTeamModelMutation(c.config, OpDelete)
return &TeamModelDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *TeamModelClient) DeleteOne(_m *TeamModel) *TeamModelDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *TeamModelClient) DeleteOneID(id uuid.UUID) *TeamModelDeleteOne {
builder := c.Delete().Where(teammodel.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &TeamModelDeleteOne{builder}
}
// Query returns a query builder for TeamModel.
func (c *TeamModelClient) Query() *TeamModelQuery {
return &TeamModelQuery{
config: c.config,
ctx: &QueryContext{Type: TypeTeamModel},
inters: c.Interceptors(),
}
}
// Get returns a TeamModel entity by its id.
func (c *TeamModelClient) Get(ctx context.Context, id uuid.UUID) (*TeamModel, error) {
return c.Query().Where(teammodel.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *TeamModelClient) GetX(ctx context.Context, id uuid.UUID) *TeamModel {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryTeam queries the team edge of a TeamModel.
func (c *TeamModelClient) QueryTeam(_m *TeamModel) *TeamQuery {
query := (&TeamClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teammodel.Table, teammodel.FieldID, id),
sqlgraph.To(team.Table, team.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teammodel.TeamTable, teammodel.TeamColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryModel queries the model edge of a TeamModel.
func (c *TeamModelClient) QueryModel(_m *TeamModel) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(teammodel.Table, teammodel.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, teammodel.ModelTable, teammodel.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *TeamModelClient) Hooks() []Hook {
return c.hooks.TeamModel
}
// Interceptors returns the client interceptors.
func (c *TeamModelClient) Interceptors() []Interceptor {
return c.inters.TeamModel
}
func (c *TeamModelClient) mutate(ctx context.Context, m *TeamModelMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&TeamModelCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&TeamModelUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&TeamModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&TeamModelDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown TeamModel 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
}
// QueryModels queries the models edge of a User.
func (c *UserClient) QueryModels(_m *User) *ModelQuery {
query := (&ModelClient{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(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ModelsTable, user.ModelsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryImages queries the images edge of a User.
func (c *UserClient) QueryImages(_m *User) *ImageQuery {
query := (&ImageClient{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(image.Table, image.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ImagesTable, user.ImagesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryHosts queries the hosts edge of a User.
func (c *UserClient) QueryHosts(_m *User) *HostQuery {
query := (&HostClient{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(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.HostsTable, user.HostsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVms queries the vms edge of a User.
func (c *UserClient) QueryVms(_m *User) *VirtualMachineQuery {
query := (&VirtualMachineClient{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(virtualmachine.Table, virtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.VmsTable, user.VmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTasks queries the tasks edge of a User.
func (c *UserClient) QueryTasks(_m *User) *TaskQuery {
query := (&TaskClient{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(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.TasksTable, user.TasksColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTaskModelSwitches queries the task_model_switches edge of a User.
func (c *UserClient) QueryTaskModelSwitches(_m *User) *TaskModelSwitchQuery {
query := (&TaskModelSwitchClient{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(taskmodelswitch.Table, taskmodelswitch.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.TaskModelSwitchesTable, user.TaskModelSwitchesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitIdentities queries the git_identities edge of a User.
func (c *UserClient) QueryGitIdentities(_m *User) *GitIdentityQuery {
query := (&GitIdentityClient{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(gitidentity.Table, gitidentity.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.GitIdentitiesTable, user.GitIdentitiesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjects queries the projects edge of a User.
func (c *UserClient) QueryProjects(_m *User) *ProjectQuery {
query := (&ProjectClient{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(project.Table, project.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ProjectsTable, user.ProjectsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectIssues queries the project_issues edge of a User.
func (c *UserClient) QueryProjectIssues(_m *User) *ProjectIssueQuery {
query := (&ProjectIssueClient{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(projectissue.Table, projectissue.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ProjectIssuesTable, user.ProjectIssuesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryAssignedIssues queries the assigned_issues edge of a User.
func (c *UserClient) QueryAssignedIssues(_m *User) *ProjectIssueQuery {
query := (&ProjectIssueClient{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(projectissue.Table, projectissue.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.AssignedIssuesTable, user.AssignedIssuesColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectCollaborators queries the project_collaborators edge of a User.
func (c *UserClient) QueryProjectCollaborators(_m *User) *ProjectCollaboratorQuery {
query := (&ProjectCollaboratorClient{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(projectcollaborator.Table, projectcollaborator.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ProjectCollaboratorsTable, user.ProjectCollaboratorsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjectIssueComments queries the project_issue_comments edge of a User.
func (c *UserClient) QueryProjectIssueComments(_m *User) *ProjectIssueCommentQuery {
query := (&ProjectIssueCommentClient{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(projectissuecomment.Table, projectissuecomment.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.ProjectIssueCommentsTable, user.ProjectIssueCommentsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitBots queries the git_bots edge of a User.
func (c *UserClient) QueryGitBots(_m *User) *GitBotQuery {
query := (&GitBotClient{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(gitbot.Table, gitbot.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, user.GitBotsTable, user.GitBotsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryMcpUpstreams queries the mcp_upstreams edge of a User.
func (c *UserClient) QueryMcpUpstreams(_m *User) *MCPUpstreamQuery {
query := (&MCPUpstreamClient{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(mcpupstream.Table, mcpupstream.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, user.McpUpstreamsTable, user.McpUpstreamsColumn),
)
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
}
// QueryGitBotUsers queries the git_bot_users edge of a User.
func (c *UserClient) QueryGitBotUsers(_m *User) *GitBotUserQuery {
query := (&GitBotUserClient{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(gitbotuser.Table, gitbotuser.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, user.GitBotUsersTable, user.GitBotUsersColumn),
)
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())
}
}
// VirtualMachineClient is a client for the VirtualMachine schema.
type VirtualMachineClient struct {
config
}
// NewVirtualMachineClient returns a client for the VirtualMachine from the given config.
func NewVirtualMachineClient(c config) *VirtualMachineClient {
return &VirtualMachineClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `virtualmachine.Hooks(f(g(h())))`.
func (c *VirtualMachineClient) Use(hooks ...Hook) {
c.hooks.VirtualMachine = append(c.hooks.VirtualMachine, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `virtualmachine.Intercept(f(g(h())))`.
func (c *VirtualMachineClient) Intercept(interceptors ...Interceptor) {
c.inters.VirtualMachine = append(c.inters.VirtualMachine, interceptors...)
}
// Create returns a builder for creating a VirtualMachine entity.
func (c *VirtualMachineClient) Create() *VirtualMachineCreate {
mutation := newVirtualMachineMutation(c.config, OpCreate)
return &VirtualMachineCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of VirtualMachine entities.
func (c *VirtualMachineClient) CreateBulk(builders ...*VirtualMachineCreate) *VirtualMachineCreateBulk {
return &VirtualMachineCreateBulk{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 *VirtualMachineClient) MapCreateBulk(slice any, setFunc func(*VirtualMachineCreate, int)) *VirtualMachineCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &VirtualMachineCreateBulk{err: fmt.Errorf("calling to VirtualMachineClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*VirtualMachineCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &VirtualMachineCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for VirtualMachine.
func (c *VirtualMachineClient) Update() *VirtualMachineUpdate {
mutation := newVirtualMachineMutation(c.config, OpUpdate)
return &VirtualMachineUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *VirtualMachineClient) UpdateOne(_m *VirtualMachine) *VirtualMachineUpdateOne {
mutation := newVirtualMachineMutation(c.config, OpUpdateOne, withVirtualMachine(_m))
return &VirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *VirtualMachineClient) UpdateOneID(id string) *VirtualMachineUpdateOne {
mutation := newVirtualMachineMutation(c.config, OpUpdateOne, withVirtualMachineID(id))
return &VirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for VirtualMachine.
func (c *VirtualMachineClient) Delete() *VirtualMachineDelete {
mutation := newVirtualMachineMutation(c.config, OpDelete)
return &VirtualMachineDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *VirtualMachineClient) DeleteOne(_m *VirtualMachine) *VirtualMachineDeleteOne {
return c.DeleteOneID(_m.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *VirtualMachineClient) DeleteOneID(id string) *VirtualMachineDeleteOne {
builder := c.Delete().Where(virtualmachine.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &VirtualMachineDeleteOne{builder}
}
// Query returns a query builder for VirtualMachine.
func (c *VirtualMachineClient) Query() *VirtualMachineQuery {
return &VirtualMachineQuery{
config: c.config,
ctx: &QueryContext{Type: TypeVirtualMachine},
inters: c.Interceptors(),
}
}
// Get returns a VirtualMachine entity by its id.
func (c *VirtualMachineClient) Get(ctx context.Context, id string) (*VirtualMachine, error) {
return c.Query().Where(virtualmachine.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *VirtualMachineClient) GetX(ctx context.Context, id string) *VirtualMachine {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryHost queries the host edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryHost(_m *VirtualMachine) *HostQuery {
query := (&HostClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(host.Table, host.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, virtualmachine.HostTable, virtualmachine.HostColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryModel queries the model edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryModel(_m *VirtualMachine) *ModelQuery {
query := (&ModelClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(model.Table, model.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, virtualmachine.ModelTable, virtualmachine.ModelColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryUser queries the user edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryUser(_m *VirtualMachine) *UserQuery {
query := (&UserClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(user.Table, user.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, virtualmachine.UserTable, virtualmachine.UserColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryGitIdentity queries the git_identity edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryGitIdentity(_m *VirtualMachine) *GitIdentityQuery {
query := (&GitIdentityClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(gitidentity.Table, gitidentity.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, virtualmachine.GitIdentityTable, virtualmachine.GitIdentityColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTasks queries the tasks edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryTasks(_m *VirtualMachine) *TaskQuery {
query := (&TaskClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(task.Table, task.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, virtualmachine.TasksTable, virtualmachine.TasksPrimaryKey...),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryTaskVms queries the task_vms edge of a VirtualMachine.
func (c *VirtualMachineClient) QueryTaskVms(_m *VirtualMachine) *TaskVirtualMachineQuery {
query := (&TaskVirtualMachineClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := _m.ID
step := sqlgraph.NewStep(
sqlgraph.From(virtualmachine.Table, virtualmachine.FieldID, id),
sqlgraph.To(taskvirtualmachine.Table, taskvirtualmachine.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, virtualmachine.TaskVmsTable, virtualmachine.TaskVmsColumn),
)
fromV = sqlgraph.Neighbors(_m.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *VirtualMachineClient) Hooks() []Hook {
hooks := c.hooks.VirtualMachine
return append(hooks[:len(hooks):len(hooks)], virtualmachine.Hooks[:]...)
}
// Interceptors returns the client interceptors.
func (c *VirtualMachineClient) Interceptors() []Interceptor {
inters := c.inters.VirtualMachine
return append(inters[:len(inters):len(inters)], virtualmachine.Interceptors[:]...)
}
func (c *VirtualMachineClient) mutate(ctx context.Context, m *VirtualMachineMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&VirtualMachineCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&VirtualMachineUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&VirtualMachineUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&VirtualMachineDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("db: unknown VirtualMachine mutation op: %q", m.Op())
}
}
// hooks and interceptors per client, for fast access.
type (
hooks struct {
Audit, GitBot, GitBotTask, GitBotUser, GitIdentity, GitTask, Host, Image,
MCPTool, MCPUpstream, MCPUserToolSetting, Model, ModelApiKey, ModelPricing,
NotifyChannel, NotifySendLog, NotifySubscription, Project, ProjectCollaborator,
ProjectGitBot, ProjectIssue, ProjectIssueComment, ProjectTask, Task,
TaskModelSwitch, TaskUsageStat, TaskVirtualMachine, Team, TeamGroup,
TeamGroupHost, TeamGroupImage, TeamGroupMember, TeamGroupModel, TeamHost,
TeamImage, TeamMember, TeamModel, User, UserIdentity, VirtualMachine []ent.Hook
}
inters struct {
Audit, GitBot, GitBotTask, GitBotUser, GitIdentity, GitTask, Host, Image,
MCPTool, MCPUpstream, MCPUserToolSetting, Model, ModelApiKey, ModelPricing,
NotifyChannel, NotifySendLog, NotifySubscription, Project, ProjectCollaborator,
ProjectGitBot, ProjectIssue, ProjectIssueComment, ProjectTask, Task,
TaskModelSwitch, TaskUsageStat, TaskVirtualMachine, Team, TeamGroup,
TeamGroupHost, TeamGroupImage, TeamGroupMember, TeamGroupModel, TeamHost,
TeamImage, TeamMember, TeamModel, User, UserIdentity,
VirtualMachine []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...)
}