// Code generated by ent, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"log"
"reflect"
"github.com/safedep/vet/ent/migrate"
"entgo.io/ent"
"entgo.io/ent/dialect"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"github.com/safedep/vet/ent/codesourcefile"
"github.com/safedep/vet/ent/depsusageevidence"
"github.com/safedep/vet/ent/reportdependency"
"github.com/safedep/vet/ent/reportdependencygraph"
"github.com/safedep/vet/ent/reportlicense"
"github.com/safedep/vet/ent/reportmalware"
"github.com/safedep/vet/ent/reportpackage"
"github.com/safedep/vet/ent/reportpackagemanifest"
"github.com/safedep/vet/ent/reportproject"
"github.com/safedep/vet/ent/reportscorecard"
"github.com/safedep/vet/ent/reportscorecardcheck"
"github.com/safedep/vet/ent/reportslsaprovenance"
"github.com/safedep/vet/ent/reportvulnerability"
)
// 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
// CodeSourceFile is the client for interacting with the CodeSourceFile builders.
CodeSourceFile *CodeSourceFileClient
// DepsUsageEvidence is the client for interacting with the DepsUsageEvidence builders.
DepsUsageEvidence *DepsUsageEvidenceClient
// ReportDependency is the client for interacting with the ReportDependency builders.
ReportDependency *ReportDependencyClient
// ReportDependencyGraph is the client for interacting with the ReportDependencyGraph builders.
ReportDependencyGraph *ReportDependencyGraphClient
// ReportLicense is the client for interacting with the ReportLicense builders.
ReportLicense *ReportLicenseClient
// ReportMalware is the client for interacting with the ReportMalware builders.
ReportMalware *ReportMalwareClient
// ReportPackage is the client for interacting with the ReportPackage builders.
ReportPackage *ReportPackageClient
// ReportPackageManifest is the client for interacting with the ReportPackageManifest builders.
ReportPackageManifest *ReportPackageManifestClient
// ReportProject is the client for interacting with the ReportProject builders.
ReportProject *ReportProjectClient
// ReportScorecard is the client for interacting with the ReportScorecard builders.
ReportScorecard *ReportScorecardClient
// ReportScorecardCheck is the client for interacting with the ReportScorecardCheck builders.
ReportScorecardCheck *ReportScorecardCheckClient
// ReportSlsaProvenance is the client for interacting with the ReportSlsaProvenance builders.
ReportSlsaProvenance *ReportSlsaProvenanceClient
// ReportVulnerability is the client for interacting with the ReportVulnerability builders.
ReportVulnerability *ReportVulnerabilityClient
}
// 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.CodeSourceFile = NewCodeSourceFileClient(c.config)
c.DepsUsageEvidence = NewDepsUsageEvidenceClient(c.config)
c.ReportDependency = NewReportDependencyClient(c.config)
c.ReportDependencyGraph = NewReportDependencyGraphClient(c.config)
c.ReportLicense = NewReportLicenseClient(c.config)
c.ReportMalware = NewReportMalwareClient(c.config)
c.ReportPackage = NewReportPackageClient(c.config)
c.ReportPackageManifest = NewReportPackageManifestClient(c.config)
c.ReportProject = NewReportProjectClient(c.config)
c.ReportScorecard = NewReportScorecardClient(c.config)
c.ReportScorecardCheck = NewReportScorecardCheckClient(c.config)
c.ReportSlsaProvenance = NewReportSlsaProvenanceClient(c.config)
c.ReportVulnerability = NewReportVulnerabilityClient(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("ent: cannot start a transaction within a transaction")
// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
if _, ok := c.driver.(*txDriver); ok {
return nil, ErrTxStarted
}
tx, err := newTx(ctx, c.driver)
if err != nil {
return nil, fmt.Errorf("ent: starting a transaction: %w", err)
}
cfg := c.config
cfg.driver = tx
return &Tx{
ctx: ctx,
config: cfg,
CodeSourceFile: NewCodeSourceFileClient(cfg),
DepsUsageEvidence: NewDepsUsageEvidenceClient(cfg),
ReportDependency: NewReportDependencyClient(cfg),
ReportDependencyGraph: NewReportDependencyGraphClient(cfg),
ReportLicense: NewReportLicenseClient(cfg),
ReportMalware: NewReportMalwareClient(cfg),
ReportPackage: NewReportPackageClient(cfg),
ReportPackageManifest: NewReportPackageManifestClient(cfg),
ReportProject: NewReportProjectClient(cfg),
ReportScorecard: NewReportScorecardClient(cfg),
ReportScorecardCheck: NewReportScorecardCheckClient(cfg),
ReportSlsaProvenance: NewReportSlsaProvenanceClient(cfg),
ReportVulnerability: NewReportVulnerabilityClient(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,
CodeSourceFile: NewCodeSourceFileClient(cfg),
DepsUsageEvidence: NewDepsUsageEvidenceClient(cfg),
ReportDependency: NewReportDependencyClient(cfg),
ReportDependencyGraph: NewReportDependencyGraphClient(cfg),
ReportLicense: NewReportLicenseClient(cfg),
ReportMalware: NewReportMalwareClient(cfg),
ReportPackage: NewReportPackageClient(cfg),
ReportPackageManifest: NewReportPackageManifestClient(cfg),
ReportProject: NewReportProjectClient(cfg),
ReportScorecard: NewReportScorecardClient(cfg),
ReportScorecardCheck: NewReportScorecardCheckClient(cfg),
ReportSlsaProvenance: NewReportSlsaProvenanceClient(cfg),
ReportVulnerability: NewReportVulnerabilityClient(cfg),
}, nil
}
// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
// client.Debug().
// CodeSourceFile.
// 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.CodeSourceFile, c.DepsUsageEvidence, c.ReportDependency,
c.ReportDependencyGraph, c.ReportLicense, c.ReportMalware, c.ReportPackage,
c.ReportPackageManifest, c.ReportProject, c.ReportScorecard,
c.ReportScorecardCheck, c.ReportSlsaProvenance, c.ReportVulnerability,
} {
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.CodeSourceFile, c.DepsUsageEvidence, c.ReportDependency,
c.ReportDependencyGraph, c.ReportLicense, c.ReportMalware, c.ReportPackage,
c.ReportPackageManifest, c.ReportProject, c.ReportScorecard,
c.ReportScorecardCheck, c.ReportSlsaProvenance, c.ReportVulnerability,
} {
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 *CodeSourceFileMutation:
return c.CodeSourceFile.mutate(ctx, m)
case *DepsUsageEvidenceMutation:
return c.DepsUsageEvidence.mutate(ctx, m)
case *ReportDependencyMutation:
return c.ReportDependency.mutate(ctx, m)
case *ReportDependencyGraphMutation:
return c.ReportDependencyGraph.mutate(ctx, m)
case *ReportLicenseMutation:
return c.ReportLicense.mutate(ctx, m)
case *ReportMalwareMutation:
return c.ReportMalware.mutate(ctx, m)
case *ReportPackageMutation:
return c.ReportPackage.mutate(ctx, m)
case *ReportPackageManifestMutation:
return c.ReportPackageManifest.mutate(ctx, m)
case *ReportProjectMutation:
return c.ReportProject.mutate(ctx, m)
case *ReportScorecardMutation:
return c.ReportScorecard.mutate(ctx, m)
case *ReportScorecardCheckMutation:
return c.ReportScorecardCheck.mutate(ctx, m)
case *ReportSlsaProvenanceMutation:
return c.ReportSlsaProvenance.mutate(ctx, m)
case *ReportVulnerabilityMutation:
return c.ReportVulnerability.mutate(ctx, m)
default:
return nil, fmt.Errorf("ent: unknown mutation type %T", m)
}
}
// CodeSourceFileClient is a client for the CodeSourceFile schema.
type CodeSourceFileClient struct {
config
}
// NewCodeSourceFileClient returns a client for the CodeSourceFile from the given config.
func NewCodeSourceFileClient(c config) *CodeSourceFileClient {
return &CodeSourceFileClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `codesourcefile.Hooks(f(g(h())))`.
func (c *CodeSourceFileClient) Use(hooks ...Hook) {
c.hooks.CodeSourceFile = append(c.hooks.CodeSourceFile, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `codesourcefile.Intercept(f(g(h())))`.
func (c *CodeSourceFileClient) Intercept(interceptors ...Interceptor) {
c.inters.CodeSourceFile = append(c.inters.CodeSourceFile, interceptors...)
}
// Create returns a builder for creating a CodeSourceFile entity.
func (c *CodeSourceFileClient) Create() *CodeSourceFileCreate {
mutation := newCodeSourceFileMutation(c.config, OpCreate)
return &CodeSourceFileCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of CodeSourceFile entities.
func (c *CodeSourceFileClient) CreateBulk(builders ...*CodeSourceFileCreate) *CodeSourceFileCreateBulk {
return &CodeSourceFileCreateBulk{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 *CodeSourceFileClient) MapCreateBulk(slice any, setFunc func(*CodeSourceFileCreate, int)) *CodeSourceFileCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &CodeSourceFileCreateBulk{err: fmt.Errorf("calling to CodeSourceFileClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*CodeSourceFileCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &CodeSourceFileCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for CodeSourceFile.
func (c *CodeSourceFileClient) Update() *CodeSourceFileUpdate {
mutation := newCodeSourceFileMutation(c.config, OpUpdate)
return &CodeSourceFileUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *CodeSourceFileClient) UpdateOne(csf *CodeSourceFile) *CodeSourceFileUpdateOne {
mutation := newCodeSourceFileMutation(c.config, OpUpdateOne, withCodeSourceFile(csf))
return &CodeSourceFileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *CodeSourceFileClient) UpdateOneID(id int) *CodeSourceFileUpdateOne {
mutation := newCodeSourceFileMutation(c.config, OpUpdateOne, withCodeSourceFileID(id))
return &CodeSourceFileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for CodeSourceFile.
func (c *CodeSourceFileClient) Delete() *CodeSourceFileDelete {
mutation := newCodeSourceFileMutation(c.config, OpDelete)
return &CodeSourceFileDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *CodeSourceFileClient) DeleteOne(csf *CodeSourceFile) *CodeSourceFileDeleteOne {
return c.DeleteOneID(csf.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *CodeSourceFileClient) DeleteOneID(id int) *CodeSourceFileDeleteOne {
builder := c.Delete().Where(codesourcefile.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &CodeSourceFileDeleteOne{builder}
}
// Query returns a query builder for CodeSourceFile.
func (c *CodeSourceFileClient) Query() *CodeSourceFileQuery {
return &CodeSourceFileQuery{
config: c.config,
ctx: &QueryContext{Type: TypeCodeSourceFile},
inters: c.Interceptors(),
}
}
// Get returns a CodeSourceFile entity by its id.
func (c *CodeSourceFileClient) Get(ctx context.Context, id int) (*CodeSourceFile, error) {
return c.Query().Where(codesourcefile.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *CodeSourceFileClient) GetX(ctx context.Context, id int) *CodeSourceFile {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryDepsUsageEvidences queries the deps_usage_evidences edge of a CodeSourceFile.
func (c *CodeSourceFileClient) QueryDepsUsageEvidences(csf *CodeSourceFile) *DepsUsageEvidenceQuery {
query := (&DepsUsageEvidenceClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := csf.ID
step := sqlgraph.NewStep(
sqlgraph.From(codesourcefile.Table, codesourcefile.FieldID, id),
sqlgraph.To(depsusageevidence.Table, depsusageevidence.FieldID),
sqlgraph.Edge(sqlgraph.O2M, true, codesourcefile.DepsUsageEvidencesTable, codesourcefile.DepsUsageEvidencesColumn),
)
fromV = sqlgraph.Neighbors(csf.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *CodeSourceFileClient) Hooks() []Hook {
return c.hooks.CodeSourceFile
}
// Interceptors returns the client interceptors.
func (c *CodeSourceFileClient) Interceptors() []Interceptor {
return c.inters.CodeSourceFile
}
func (c *CodeSourceFileClient) mutate(ctx context.Context, m *CodeSourceFileMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&CodeSourceFileCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&CodeSourceFileUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&CodeSourceFileUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&CodeSourceFileDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown CodeSourceFile mutation op: %q", m.Op())
}
}
// DepsUsageEvidenceClient is a client for the DepsUsageEvidence schema.
type DepsUsageEvidenceClient struct {
config
}
// NewDepsUsageEvidenceClient returns a client for the DepsUsageEvidence from the given config.
func NewDepsUsageEvidenceClient(c config) *DepsUsageEvidenceClient {
return &DepsUsageEvidenceClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `depsusageevidence.Hooks(f(g(h())))`.
func (c *DepsUsageEvidenceClient) Use(hooks ...Hook) {
c.hooks.DepsUsageEvidence = append(c.hooks.DepsUsageEvidence, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `depsusageevidence.Intercept(f(g(h())))`.
func (c *DepsUsageEvidenceClient) Intercept(interceptors ...Interceptor) {
c.inters.DepsUsageEvidence = append(c.inters.DepsUsageEvidence, interceptors...)
}
// Create returns a builder for creating a DepsUsageEvidence entity.
func (c *DepsUsageEvidenceClient) Create() *DepsUsageEvidenceCreate {
mutation := newDepsUsageEvidenceMutation(c.config, OpCreate)
return &DepsUsageEvidenceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of DepsUsageEvidence entities.
func (c *DepsUsageEvidenceClient) CreateBulk(builders ...*DepsUsageEvidenceCreate) *DepsUsageEvidenceCreateBulk {
return &DepsUsageEvidenceCreateBulk{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 *DepsUsageEvidenceClient) MapCreateBulk(slice any, setFunc func(*DepsUsageEvidenceCreate, int)) *DepsUsageEvidenceCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &DepsUsageEvidenceCreateBulk{err: fmt.Errorf("calling to DepsUsageEvidenceClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*DepsUsageEvidenceCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &DepsUsageEvidenceCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for DepsUsageEvidence.
func (c *DepsUsageEvidenceClient) Update() *DepsUsageEvidenceUpdate {
mutation := newDepsUsageEvidenceMutation(c.config, OpUpdate)
return &DepsUsageEvidenceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *DepsUsageEvidenceClient) UpdateOne(due *DepsUsageEvidence) *DepsUsageEvidenceUpdateOne {
mutation := newDepsUsageEvidenceMutation(c.config, OpUpdateOne, withDepsUsageEvidence(due))
return &DepsUsageEvidenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *DepsUsageEvidenceClient) UpdateOneID(id int) *DepsUsageEvidenceUpdateOne {
mutation := newDepsUsageEvidenceMutation(c.config, OpUpdateOne, withDepsUsageEvidenceID(id))
return &DepsUsageEvidenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for DepsUsageEvidence.
func (c *DepsUsageEvidenceClient) Delete() *DepsUsageEvidenceDelete {
mutation := newDepsUsageEvidenceMutation(c.config, OpDelete)
return &DepsUsageEvidenceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *DepsUsageEvidenceClient) DeleteOne(due *DepsUsageEvidence) *DepsUsageEvidenceDeleteOne {
return c.DeleteOneID(due.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *DepsUsageEvidenceClient) DeleteOneID(id int) *DepsUsageEvidenceDeleteOne {
builder := c.Delete().Where(depsusageevidence.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &DepsUsageEvidenceDeleteOne{builder}
}
// Query returns a query builder for DepsUsageEvidence.
func (c *DepsUsageEvidenceClient) Query() *DepsUsageEvidenceQuery {
return &DepsUsageEvidenceQuery{
config: c.config,
ctx: &QueryContext{Type: TypeDepsUsageEvidence},
inters: c.Interceptors(),
}
}
// Get returns a DepsUsageEvidence entity by its id.
func (c *DepsUsageEvidenceClient) Get(ctx context.Context, id int) (*DepsUsageEvidence, error) {
return c.Query().Where(depsusageevidence.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *DepsUsageEvidenceClient) GetX(ctx context.Context, id int) *DepsUsageEvidence {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryUsedIn queries the used_in edge of a DepsUsageEvidence.
func (c *DepsUsageEvidenceClient) QueryUsedIn(due *DepsUsageEvidence) *CodeSourceFileQuery {
query := (&CodeSourceFileClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := due.ID
step := sqlgraph.NewStep(
sqlgraph.From(depsusageevidence.Table, depsusageevidence.FieldID, id),
sqlgraph.To(codesourcefile.Table, codesourcefile.FieldID),
sqlgraph.Edge(sqlgraph.M2O, false, depsusageevidence.UsedInTable, depsusageevidence.UsedInColumn),
)
fromV = sqlgraph.Neighbors(due.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *DepsUsageEvidenceClient) Hooks() []Hook {
return c.hooks.DepsUsageEvidence
}
// Interceptors returns the client interceptors.
func (c *DepsUsageEvidenceClient) Interceptors() []Interceptor {
return c.inters.DepsUsageEvidence
}
func (c *DepsUsageEvidenceClient) mutate(ctx context.Context, m *DepsUsageEvidenceMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&DepsUsageEvidenceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&DepsUsageEvidenceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&DepsUsageEvidenceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&DepsUsageEvidenceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown DepsUsageEvidence mutation op: %q", m.Op())
}
}
// ReportDependencyClient is a client for the ReportDependency schema.
type ReportDependencyClient struct {
config
}
// NewReportDependencyClient returns a client for the ReportDependency from the given config.
func NewReportDependencyClient(c config) *ReportDependencyClient {
return &ReportDependencyClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportdependency.Hooks(f(g(h())))`.
func (c *ReportDependencyClient) Use(hooks ...Hook) {
c.hooks.ReportDependency = append(c.hooks.ReportDependency, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportdependency.Intercept(f(g(h())))`.
func (c *ReportDependencyClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportDependency = append(c.inters.ReportDependency, interceptors...)
}
// Create returns a builder for creating a ReportDependency entity.
func (c *ReportDependencyClient) Create() *ReportDependencyCreate {
mutation := newReportDependencyMutation(c.config, OpCreate)
return &ReportDependencyCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportDependency entities.
func (c *ReportDependencyClient) CreateBulk(builders ...*ReportDependencyCreate) *ReportDependencyCreateBulk {
return &ReportDependencyCreateBulk{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 *ReportDependencyClient) MapCreateBulk(slice any, setFunc func(*ReportDependencyCreate, int)) *ReportDependencyCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportDependencyCreateBulk{err: fmt.Errorf("calling to ReportDependencyClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportDependencyCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportDependencyCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportDependency.
func (c *ReportDependencyClient) Update() *ReportDependencyUpdate {
mutation := newReportDependencyMutation(c.config, OpUpdate)
return &ReportDependencyUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportDependencyClient) UpdateOne(rd *ReportDependency) *ReportDependencyUpdateOne {
mutation := newReportDependencyMutation(c.config, OpUpdateOne, withReportDependency(rd))
return &ReportDependencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportDependencyClient) UpdateOneID(id int) *ReportDependencyUpdateOne {
mutation := newReportDependencyMutation(c.config, OpUpdateOne, withReportDependencyID(id))
return &ReportDependencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportDependency.
func (c *ReportDependencyClient) Delete() *ReportDependencyDelete {
mutation := newReportDependencyMutation(c.config, OpDelete)
return &ReportDependencyDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportDependencyClient) DeleteOne(rd *ReportDependency) *ReportDependencyDeleteOne {
return c.DeleteOneID(rd.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportDependencyClient) DeleteOneID(id int) *ReportDependencyDeleteOne {
builder := c.Delete().Where(reportdependency.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportDependencyDeleteOne{builder}
}
// Query returns a query builder for ReportDependency.
func (c *ReportDependencyClient) Query() *ReportDependencyQuery {
return &ReportDependencyQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportDependency},
inters: c.Interceptors(),
}
}
// Get returns a ReportDependency entity by its id.
func (c *ReportDependencyClient) Get(ctx context.Context, id int) (*ReportDependency, error) {
return c.Query().Where(reportdependency.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportDependencyClient) GetX(ctx context.Context, id int) *ReportDependency {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportDependency.
func (c *ReportDependencyClient) QueryPackage(rd *ReportDependency) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rd.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportdependency.Table, reportdependency.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportdependency.PackageTable, reportdependency.PackageColumn),
)
fromV = sqlgraph.Neighbors(rd.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportDependencyClient) Hooks() []Hook {
return c.hooks.ReportDependency
}
// Interceptors returns the client interceptors.
func (c *ReportDependencyClient) Interceptors() []Interceptor {
return c.inters.ReportDependency
}
func (c *ReportDependencyClient) mutate(ctx context.Context, m *ReportDependencyMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportDependencyCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportDependencyUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportDependencyUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportDependencyDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportDependency mutation op: %q", m.Op())
}
}
// ReportDependencyGraphClient is a client for the ReportDependencyGraph schema.
type ReportDependencyGraphClient struct {
config
}
// NewReportDependencyGraphClient returns a client for the ReportDependencyGraph from the given config.
func NewReportDependencyGraphClient(c config) *ReportDependencyGraphClient {
return &ReportDependencyGraphClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportdependencygraph.Hooks(f(g(h())))`.
func (c *ReportDependencyGraphClient) Use(hooks ...Hook) {
c.hooks.ReportDependencyGraph = append(c.hooks.ReportDependencyGraph, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportdependencygraph.Intercept(f(g(h())))`.
func (c *ReportDependencyGraphClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportDependencyGraph = append(c.inters.ReportDependencyGraph, interceptors...)
}
// Create returns a builder for creating a ReportDependencyGraph entity.
func (c *ReportDependencyGraphClient) Create() *ReportDependencyGraphCreate {
mutation := newReportDependencyGraphMutation(c.config, OpCreate)
return &ReportDependencyGraphCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportDependencyGraph entities.
func (c *ReportDependencyGraphClient) CreateBulk(builders ...*ReportDependencyGraphCreate) *ReportDependencyGraphCreateBulk {
return &ReportDependencyGraphCreateBulk{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 *ReportDependencyGraphClient) MapCreateBulk(slice any, setFunc func(*ReportDependencyGraphCreate, int)) *ReportDependencyGraphCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportDependencyGraphCreateBulk{err: fmt.Errorf("calling to ReportDependencyGraphClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportDependencyGraphCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportDependencyGraphCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportDependencyGraph.
func (c *ReportDependencyGraphClient) Update() *ReportDependencyGraphUpdate {
mutation := newReportDependencyGraphMutation(c.config, OpUpdate)
return &ReportDependencyGraphUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportDependencyGraphClient) UpdateOne(rdg *ReportDependencyGraph) *ReportDependencyGraphUpdateOne {
mutation := newReportDependencyGraphMutation(c.config, OpUpdateOne, withReportDependencyGraph(rdg))
return &ReportDependencyGraphUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportDependencyGraphClient) UpdateOneID(id int) *ReportDependencyGraphUpdateOne {
mutation := newReportDependencyGraphMutation(c.config, OpUpdateOne, withReportDependencyGraphID(id))
return &ReportDependencyGraphUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportDependencyGraph.
func (c *ReportDependencyGraphClient) Delete() *ReportDependencyGraphDelete {
mutation := newReportDependencyGraphMutation(c.config, OpDelete)
return &ReportDependencyGraphDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportDependencyGraphClient) DeleteOne(rdg *ReportDependencyGraph) *ReportDependencyGraphDeleteOne {
return c.DeleteOneID(rdg.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportDependencyGraphClient) DeleteOneID(id int) *ReportDependencyGraphDeleteOne {
builder := c.Delete().Where(reportdependencygraph.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportDependencyGraphDeleteOne{builder}
}
// Query returns a query builder for ReportDependencyGraph.
func (c *ReportDependencyGraphClient) Query() *ReportDependencyGraphQuery {
return &ReportDependencyGraphQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportDependencyGraph},
inters: c.Interceptors(),
}
}
// Get returns a ReportDependencyGraph entity by its id.
func (c *ReportDependencyGraphClient) Get(ctx context.Context, id int) (*ReportDependencyGraph, error) {
return c.Query().Where(reportdependencygraph.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportDependencyGraphClient) GetX(ctx context.Context, id int) *ReportDependencyGraph {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// Hooks returns the client hooks.
func (c *ReportDependencyGraphClient) Hooks() []Hook {
return c.hooks.ReportDependencyGraph
}
// Interceptors returns the client interceptors.
func (c *ReportDependencyGraphClient) Interceptors() []Interceptor {
return c.inters.ReportDependencyGraph
}
func (c *ReportDependencyGraphClient) mutate(ctx context.Context, m *ReportDependencyGraphMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportDependencyGraphCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportDependencyGraphUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportDependencyGraphUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportDependencyGraphDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportDependencyGraph mutation op: %q", m.Op())
}
}
// ReportLicenseClient is a client for the ReportLicense schema.
type ReportLicenseClient struct {
config
}
// NewReportLicenseClient returns a client for the ReportLicense from the given config.
func NewReportLicenseClient(c config) *ReportLicenseClient {
return &ReportLicenseClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportlicense.Hooks(f(g(h())))`.
func (c *ReportLicenseClient) Use(hooks ...Hook) {
c.hooks.ReportLicense = append(c.hooks.ReportLicense, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportlicense.Intercept(f(g(h())))`.
func (c *ReportLicenseClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportLicense = append(c.inters.ReportLicense, interceptors...)
}
// Create returns a builder for creating a ReportLicense entity.
func (c *ReportLicenseClient) Create() *ReportLicenseCreate {
mutation := newReportLicenseMutation(c.config, OpCreate)
return &ReportLicenseCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportLicense entities.
func (c *ReportLicenseClient) CreateBulk(builders ...*ReportLicenseCreate) *ReportLicenseCreateBulk {
return &ReportLicenseCreateBulk{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 *ReportLicenseClient) MapCreateBulk(slice any, setFunc func(*ReportLicenseCreate, int)) *ReportLicenseCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportLicenseCreateBulk{err: fmt.Errorf("calling to ReportLicenseClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportLicenseCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportLicenseCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportLicense.
func (c *ReportLicenseClient) Update() *ReportLicenseUpdate {
mutation := newReportLicenseMutation(c.config, OpUpdate)
return &ReportLicenseUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportLicenseClient) UpdateOne(rl *ReportLicense) *ReportLicenseUpdateOne {
mutation := newReportLicenseMutation(c.config, OpUpdateOne, withReportLicense(rl))
return &ReportLicenseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportLicenseClient) UpdateOneID(id int) *ReportLicenseUpdateOne {
mutation := newReportLicenseMutation(c.config, OpUpdateOne, withReportLicenseID(id))
return &ReportLicenseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportLicense.
func (c *ReportLicenseClient) Delete() *ReportLicenseDelete {
mutation := newReportLicenseMutation(c.config, OpDelete)
return &ReportLicenseDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportLicenseClient) DeleteOne(rl *ReportLicense) *ReportLicenseDeleteOne {
return c.DeleteOneID(rl.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportLicenseClient) DeleteOneID(id int) *ReportLicenseDeleteOne {
builder := c.Delete().Where(reportlicense.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportLicenseDeleteOne{builder}
}
// Query returns a query builder for ReportLicense.
func (c *ReportLicenseClient) Query() *ReportLicenseQuery {
return &ReportLicenseQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportLicense},
inters: c.Interceptors(),
}
}
// Get returns a ReportLicense entity by its id.
func (c *ReportLicenseClient) Get(ctx context.Context, id int) (*ReportLicense, error) {
return c.Query().Where(reportlicense.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportLicenseClient) GetX(ctx context.Context, id int) *ReportLicense {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportLicense.
func (c *ReportLicenseClient) QueryPackage(rl *ReportLicense) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rl.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportlicense.Table, reportlicense.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportlicense.PackageTable, reportlicense.PackageColumn),
)
fromV = sqlgraph.Neighbors(rl.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportLicenseClient) Hooks() []Hook {
return c.hooks.ReportLicense
}
// Interceptors returns the client interceptors.
func (c *ReportLicenseClient) Interceptors() []Interceptor {
return c.inters.ReportLicense
}
func (c *ReportLicenseClient) mutate(ctx context.Context, m *ReportLicenseMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportLicenseCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportLicenseUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportLicenseUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportLicenseDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportLicense mutation op: %q", m.Op())
}
}
// ReportMalwareClient is a client for the ReportMalware schema.
type ReportMalwareClient struct {
config
}
// NewReportMalwareClient returns a client for the ReportMalware from the given config.
func NewReportMalwareClient(c config) *ReportMalwareClient {
return &ReportMalwareClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportmalware.Hooks(f(g(h())))`.
func (c *ReportMalwareClient) Use(hooks ...Hook) {
c.hooks.ReportMalware = append(c.hooks.ReportMalware, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportmalware.Intercept(f(g(h())))`.
func (c *ReportMalwareClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportMalware = append(c.inters.ReportMalware, interceptors...)
}
// Create returns a builder for creating a ReportMalware entity.
func (c *ReportMalwareClient) Create() *ReportMalwareCreate {
mutation := newReportMalwareMutation(c.config, OpCreate)
return &ReportMalwareCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportMalware entities.
func (c *ReportMalwareClient) CreateBulk(builders ...*ReportMalwareCreate) *ReportMalwareCreateBulk {
return &ReportMalwareCreateBulk{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 *ReportMalwareClient) MapCreateBulk(slice any, setFunc func(*ReportMalwareCreate, int)) *ReportMalwareCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportMalwareCreateBulk{err: fmt.Errorf("calling to ReportMalwareClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportMalwareCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportMalwareCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportMalware.
func (c *ReportMalwareClient) Update() *ReportMalwareUpdate {
mutation := newReportMalwareMutation(c.config, OpUpdate)
return &ReportMalwareUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportMalwareClient) UpdateOne(rm *ReportMalware) *ReportMalwareUpdateOne {
mutation := newReportMalwareMutation(c.config, OpUpdateOne, withReportMalware(rm))
return &ReportMalwareUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportMalwareClient) UpdateOneID(id int) *ReportMalwareUpdateOne {
mutation := newReportMalwareMutation(c.config, OpUpdateOne, withReportMalwareID(id))
return &ReportMalwareUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportMalware.
func (c *ReportMalwareClient) Delete() *ReportMalwareDelete {
mutation := newReportMalwareMutation(c.config, OpDelete)
return &ReportMalwareDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportMalwareClient) DeleteOne(rm *ReportMalware) *ReportMalwareDeleteOne {
return c.DeleteOneID(rm.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportMalwareClient) DeleteOneID(id int) *ReportMalwareDeleteOne {
builder := c.Delete().Where(reportmalware.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportMalwareDeleteOne{builder}
}
// Query returns a query builder for ReportMalware.
func (c *ReportMalwareClient) Query() *ReportMalwareQuery {
return &ReportMalwareQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportMalware},
inters: c.Interceptors(),
}
}
// Get returns a ReportMalware entity by its id.
func (c *ReportMalwareClient) Get(ctx context.Context, id int) (*ReportMalware, error) {
return c.Query().Where(reportmalware.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportMalwareClient) GetX(ctx context.Context, id int) *ReportMalware {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportMalware.
func (c *ReportMalwareClient) QueryPackage(rm *ReportMalware) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rm.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportmalware.Table, reportmalware.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.O2O, true, reportmalware.PackageTable, reportmalware.PackageColumn),
)
fromV = sqlgraph.Neighbors(rm.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportMalwareClient) Hooks() []Hook {
return c.hooks.ReportMalware
}
// Interceptors returns the client interceptors.
func (c *ReportMalwareClient) Interceptors() []Interceptor {
return c.inters.ReportMalware
}
func (c *ReportMalwareClient) mutate(ctx context.Context, m *ReportMalwareMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportMalwareCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportMalwareUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportMalwareUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportMalwareDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportMalware mutation op: %q", m.Op())
}
}
// ReportPackageClient is a client for the ReportPackage schema.
type ReportPackageClient struct {
config
}
// NewReportPackageClient returns a client for the ReportPackage from the given config.
func NewReportPackageClient(c config) *ReportPackageClient {
return &ReportPackageClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportpackage.Hooks(f(g(h())))`.
func (c *ReportPackageClient) Use(hooks ...Hook) {
c.hooks.ReportPackage = append(c.hooks.ReportPackage, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportpackage.Intercept(f(g(h())))`.
func (c *ReportPackageClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportPackage = append(c.inters.ReportPackage, interceptors...)
}
// Create returns a builder for creating a ReportPackage entity.
func (c *ReportPackageClient) Create() *ReportPackageCreate {
mutation := newReportPackageMutation(c.config, OpCreate)
return &ReportPackageCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportPackage entities.
func (c *ReportPackageClient) CreateBulk(builders ...*ReportPackageCreate) *ReportPackageCreateBulk {
return &ReportPackageCreateBulk{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 *ReportPackageClient) MapCreateBulk(slice any, setFunc func(*ReportPackageCreate, int)) *ReportPackageCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportPackageCreateBulk{err: fmt.Errorf("calling to ReportPackageClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportPackageCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportPackageCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportPackage.
func (c *ReportPackageClient) Update() *ReportPackageUpdate {
mutation := newReportPackageMutation(c.config, OpUpdate)
return &ReportPackageUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportPackageClient) UpdateOne(rp *ReportPackage) *ReportPackageUpdateOne {
mutation := newReportPackageMutation(c.config, OpUpdateOne, withReportPackage(rp))
return &ReportPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportPackageClient) UpdateOneID(id int) *ReportPackageUpdateOne {
mutation := newReportPackageMutation(c.config, OpUpdateOne, withReportPackageID(id))
return &ReportPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportPackage.
func (c *ReportPackageClient) Delete() *ReportPackageDelete {
mutation := newReportPackageMutation(c.config, OpDelete)
return &ReportPackageDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportPackageClient) DeleteOne(rp *ReportPackage) *ReportPackageDeleteOne {
return c.DeleteOneID(rp.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportPackageClient) DeleteOneID(id int) *ReportPackageDeleteOne {
builder := c.Delete().Where(reportpackage.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportPackageDeleteOne{builder}
}
// Query returns a query builder for ReportPackage.
func (c *ReportPackageClient) Query() *ReportPackageQuery {
return &ReportPackageQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportPackage},
inters: c.Interceptors(),
}
}
// Get returns a ReportPackage entity by its id.
func (c *ReportPackageClient) Get(ctx context.Context, id int) (*ReportPackage, error) {
return c.Query().Where(reportpackage.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportPackageClient) GetX(ctx context.Context, id int) *ReportPackage {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryManifests queries the manifests edge of a ReportPackage.
func (c *ReportPackageClient) QueryManifests(rp *ReportPackage) *ReportPackageManifestQuery {
query := (&ReportPackageManifestClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportpackagemanifest.Table, reportpackagemanifest.FieldID),
sqlgraph.Edge(sqlgraph.M2M, true, reportpackage.ManifestsTable, reportpackage.ManifestsPrimaryKey...),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryVulnerabilities queries the vulnerabilities edge of a ReportPackage.
func (c *ReportPackageClient) QueryVulnerabilities(rp *ReportPackage) *ReportVulnerabilityQuery {
query := (&ReportVulnerabilityClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportvulnerability.Table, reportvulnerability.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.VulnerabilitiesTable, reportpackage.VulnerabilitiesColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryLicenses queries the licenses edge of a ReportPackage.
func (c *ReportPackageClient) QueryLicenses(rp *ReportPackage) *ReportLicenseQuery {
query := (&ReportLicenseClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportlicense.Table, reportlicense.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.LicensesTable, reportpackage.LicensesColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryDependencies queries the dependencies edge of a ReportPackage.
func (c *ReportPackageClient) QueryDependencies(rp *ReportPackage) *ReportDependencyQuery {
query := (&ReportDependencyClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportdependency.Table, reportdependency.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.DependenciesTable, reportpackage.DependenciesColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryMalwareAnalysis queries the malware_analysis edge of a ReportPackage.
func (c *ReportPackageClient) QueryMalwareAnalysis(rp *ReportPackage) *ReportMalwareQuery {
query := (&ReportMalwareClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportmalware.Table, reportmalware.FieldID),
sqlgraph.Edge(sqlgraph.O2O, false, reportpackage.MalwareAnalysisTable, reportpackage.MalwareAnalysisColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryProjects queries the projects edge of a ReportPackage.
func (c *ReportPackageClient) QueryProjects(rp *ReportPackage) *ReportProjectQuery {
query := (&ReportProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportproject.Table, reportproject.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.ProjectsTable, reportpackage.ProjectsColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QuerySlsaProvenances queries the slsa_provenances edge of a ReportPackage.
func (c *ReportPackageClient) QuerySlsaProvenances(rp *ReportPackage) *ReportSlsaProvenanceQuery {
query := (&ReportSlsaProvenanceClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackage.Table, reportpackage.FieldID, id),
sqlgraph.To(reportslsaprovenance.Table, reportslsaprovenance.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportpackage.SlsaProvenancesTable, reportpackage.SlsaProvenancesColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportPackageClient) Hooks() []Hook {
return c.hooks.ReportPackage
}
// Interceptors returns the client interceptors.
func (c *ReportPackageClient) Interceptors() []Interceptor {
return c.inters.ReportPackage
}
func (c *ReportPackageClient) mutate(ctx context.Context, m *ReportPackageMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportPackageCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportPackageUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportPackageUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportPackageDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportPackage mutation op: %q", m.Op())
}
}
// ReportPackageManifestClient is a client for the ReportPackageManifest schema.
type ReportPackageManifestClient struct {
config
}
// NewReportPackageManifestClient returns a client for the ReportPackageManifest from the given config.
func NewReportPackageManifestClient(c config) *ReportPackageManifestClient {
return &ReportPackageManifestClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportpackagemanifest.Hooks(f(g(h())))`.
func (c *ReportPackageManifestClient) Use(hooks ...Hook) {
c.hooks.ReportPackageManifest = append(c.hooks.ReportPackageManifest, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportpackagemanifest.Intercept(f(g(h())))`.
func (c *ReportPackageManifestClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportPackageManifest = append(c.inters.ReportPackageManifest, interceptors...)
}
// Create returns a builder for creating a ReportPackageManifest entity.
func (c *ReportPackageManifestClient) Create() *ReportPackageManifestCreate {
mutation := newReportPackageManifestMutation(c.config, OpCreate)
return &ReportPackageManifestCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportPackageManifest entities.
func (c *ReportPackageManifestClient) CreateBulk(builders ...*ReportPackageManifestCreate) *ReportPackageManifestCreateBulk {
return &ReportPackageManifestCreateBulk{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 *ReportPackageManifestClient) MapCreateBulk(slice any, setFunc func(*ReportPackageManifestCreate, int)) *ReportPackageManifestCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportPackageManifestCreateBulk{err: fmt.Errorf("calling to ReportPackageManifestClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportPackageManifestCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportPackageManifestCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportPackageManifest.
func (c *ReportPackageManifestClient) Update() *ReportPackageManifestUpdate {
mutation := newReportPackageManifestMutation(c.config, OpUpdate)
return &ReportPackageManifestUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportPackageManifestClient) UpdateOne(rpm *ReportPackageManifest) *ReportPackageManifestUpdateOne {
mutation := newReportPackageManifestMutation(c.config, OpUpdateOne, withReportPackageManifest(rpm))
return &ReportPackageManifestUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportPackageManifestClient) UpdateOneID(id int) *ReportPackageManifestUpdateOne {
mutation := newReportPackageManifestMutation(c.config, OpUpdateOne, withReportPackageManifestID(id))
return &ReportPackageManifestUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportPackageManifest.
func (c *ReportPackageManifestClient) Delete() *ReportPackageManifestDelete {
mutation := newReportPackageManifestMutation(c.config, OpDelete)
return &ReportPackageManifestDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportPackageManifestClient) DeleteOne(rpm *ReportPackageManifest) *ReportPackageManifestDeleteOne {
return c.DeleteOneID(rpm.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportPackageManifestClient) DeleteOneID(id int) *ReportPackageManifestDeleteOne {
builder := c.Delete().Where(reportpackagemanifest.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportPackageManifestDeleteOne{builder}
}
// Query returns a query builder for ReportPackageManifest.
func (c *ReportPackageManifestClient) Query() *ReportPackageManifestQuery {
return &ReportPackageManifestQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportPackageManifest},
inters: c.Interceptors(),
}
}
// Get returns a ReportPackageManifest entity by its id.
func (c *ReportPackageManifestClient) Get(ctx context.Context, id int) (*ReportPackageManifest, error) {
return c.Query().Where(reportpackagemanifest.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportPackageManifestClient) GetX(ctx context.Context, id int) *ReportPackageManifest {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackages queries the packages edge of a ReportPackageManifest.
func (c *ReportPackageManifestClient) QueryPackages(rpm *ReportPackageManifest) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rpm.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportpackagemanifest.Table, reportpackagemanifest.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2M, false, reportpackagemanifest.PackagesTable, reportpackagemanifest.PackagesPrimaryKey...),
)
fromV = sqlgraph.Neighbors(rpm.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportPackageManifestClient) Hooks() []Hook {
return c.hooks.ReportPackageManifest
}
// Interceptors returns the client interceptors.
func (c *ReportPackageManifestClient) Interceptors() []Interceptor {
return c.inters.ReportPackageManifest
}
func (c *ReportPackageManifestClient) mutate(ctx context.Context, m *ReportPackageManifestMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportPackageManifestCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportPackageManifestUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportPackageManifestUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportPackageManifestDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportPackageManifest mutation op: %q", m.Op())
}
}
// ReportProjectClient is a client for the ReportProject schema.
type ReportProjectClient struct {
config
}
// NewReportProjectClient returns a client for the ReportProject from the given config.
func NewReportProjectClient(c config) *ReportProjectClient {
return &ReportProjectClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportproject.Hooks(f(g(h())))`.
func (c *ReportProjectClient) Use(hooks ...Hook) {
c.hooks.ReportProject = append(c.hooks.ReportProject, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportproject.Intercept(f(g(h())))`.
func (c *ReportProjectClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportProject = append(c.inters.ReportProject, interceptors...)
}
// Create returns a builder for creating a ReportProject entity.
func (c *ReportProjectClient) Create() *ReportProjectCreate {
mutation := newReportProjectMutation(c.config, OpCreate)
return &ReportProjectCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportProject entities.
func (c *ReportProjectClient) CreateBulk(builders ...*ReportProjectCreate) *ReportProjectCreateBulk {
return &ReportProjectCreateBulk{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 *ReportProjectClient) MapCreateBulk(slice any, setFunc func(*ReportProjectCreate, int)) *ReportProjectCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportProjectCreateBulk{err: fmt.Errorf("calling to ReportProjectClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportProjectCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportProjectCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportProject.
func (c *ReportProjectClient) Update() *ReportProjectUpdate {
mutation := newReportProjectMutation(c.config, OpUpdate)
return &ReportProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportProjectClient) UpdateOne(rp *ReportProject) *ReportProjectUpdateOne {
mutation := newReportProjectMutation(c.config, OpUpdateOne, withReportProject(rp))
return &ReportProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportProjectClient) UpdateOneID(id int) *ReportProjectUpdateOne {
mutation := newReportProjectMutation(c.config, OpUpdateOne, withReportProjectID(id))
return &ReportProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportProject.
func (c *ReportProjectClient) Delete() *ReportProjectDelete {
mutation := newReportProjectMutation(c.config, OpDelete)
return &ReportProjectDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportProjectClient) DeleteOne(rp *ReportProject) *ReportProjectDeleteOne {
return c.DeleteOneID(rp.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportProjectClient) DeleteOneID(id int) *ReportProjectDeleteOne {
builder := c.Delete().Where(reportproject.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportProjectDeleteOne{builder}
}
// Query returns a query builder for ReportProject.
func (c *ReportProjectClient) Query() *ReportProjectQuery {
return &ReportProjectQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportProject},
inters: c.Interceptors(),
}
}
// Get returns a ReportProject entity by its id.
func (c *ReportProjectClient) Get(ctx context.Context, id int) (*ReportProject, error) {
return c.Query().Where(reportproject.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportProjectClient) GetX(ctx context.Context, id int) *ReportProject {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportProject.
func (c *ReportProjectClient) QueryPackage(rp *ReportProject) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportproject.Table, reportproject.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportproject.PackageTable, reportproject.PackageColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryScorecard queries the scorecard edge of a ReportProject.
func (c *ReportProjectClient) QueryScorecard(rp *ReportProject) *ReportScorecardQuery {
query := (&ReportScorecardClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportproject.Table, reportproject.FieldID, id),
sqlgraph.To(reportscorecard.Table, reportscorecard.FieldID),
sqlgraph.Edge(sqlgraph.O2O, false, reportproject.ScorecardTable, reportproject.ScorecardColumn),
)
fromV = sqlgraph.Neighbors(rp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportProjectClient) Hooks() []Hook {
return c.hooks.ReportProject
}
// Interceptors returns the client interceptors.
func (c *ReportProjectClient) Interceptors() []Interceptor {
return c.inters.ReportProject
}
func (c *ReportProjectClient) mutate(ctx context.Context, m *ReportProjectMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportProjectCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportProjectUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportProjectUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportProjectDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportProject mutation op: %q", m.Op())
}
}
// ReportScorecardClient is a client for the ReportScorecard schema.
type ReportScorecardClient struct {
config
}
// NewReportScorecardClient returns a client for the ReportScorecard from the given config.
func NewReportScorecardClient(c config) *ReportScorecardClient {
return &ReportScorecardClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportscorecard.Hooks(f(g(h())))`.
func (c *ReportScorecardClient) Use(hooks ...Hook) {
c.hooks.ReportScorecard = append(c.hooks.ReportScorecard, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportscorecard.Intercept(f(g(h())))`.
func (c *ReportScorecardClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportScorecard = append(c.inters.ReportScorecard, interceptors...)
}
// Create returns a builder for creating a ReportScorecard entity.
func (c *ReportScorecardClient) Create() *ReportScorecardCreate {
mutation := newReportScorecardMutation(c.config, OpCreate)
return &ReportScorecardCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportScorecard entities.
func (c *ReportScorecardClient) CreateBulk(builders ...*ReportScorecardCreate) *ReportScorecardCreateBulk {
return &ReportScorecardCreateBulk{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 *ReportScorecardClient) MapCreateBulk(slice any, setFunc func(*ReportScorecardCreate, int)) *ReportScorecardCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportScorecardCreateBulk{err: fmt.Errorf("calling to ReportScorecardClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportScorecardCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportScorecardCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportScorecard.
func (c *ReportScorecardClient) Update() *ReportScorecardUpdate {
mutation := newReportScorecardMutation(c.config, OpUpdate)
return &ReportScorecardUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportScorecardClient) UpdateOne(rs *ReportScorecard) *ReportScorecardUpdateOne {
mutation := newReportScorecardMutation(c.config, OpUpdateOne, withReportScorecard(rs))
return &ReportScorecardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportScorecardClient) UpdateOneID(id int) *ReportScorecardUpdateOne {
mutation := newReportScorecardMutation(c.config, OpUpdateOne, withReportScorecardID(id))
return &ReportScorecardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportScorecard.
func (c *ReportScorecardClient) Delete() *ReportScorecardDelete {
mutation := newReportScorecardMutation(c.config, OpDelete)
return &ReportScorecardDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportScorecardClient) DeleteOne(rs *ReportScorecard) *ReportScorecardDeleteOne {
return c.DeleteOneID(rs.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportScorecardClient) DeleteOneID(id int) *ReportScorecardDeleteOne {
builder := c.Delete().Where(reportscorecard.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportScorecardDeleteOne{builder}
}
// Query returns a query builder for ReportScorecard.
func (c *ReportScorecardClient) Query() *ReportScorecardQuery {
return &ReportScorecardQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportScorecard},
inters: c.Interceptors(),
}
}
// Get returns a ReportScorecard entity by its id.
func (c *ReportScorecardClient) Get(ctx context.Context, id int) (*ReportScorecard, error) {
return c.Query().Where(reportscorecard.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportScorecardClient) GetX(ctx context.Context, id int) *ReportScorecard {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryProject queries the project edge of a ReportScorecard.
func (c *ReportScorecardClient) QueryProject(rs *ReportScorecard) *ReportProjectQuery {
query := (&ReportProjectClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rs.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportscorecard.Table, reportscorecard.FieldID, id),
sqlgraph.To(reportproject.Table, reportproject.FieldID),
sqlgraph.Edge(sqlgraph.O2O, true, reportscorecard.ProjectTable, reportscorecard.ProjectColumn),
)
fromV = sqlgraph.Neighbors(rs.driver.Dialect(), step)
return fromV, nil
}
return query
}
// QueryChecks queries the checks edge of a ReportScorecard.
func (c *ReportScorecardClient) QueryChecks(rs *ReportScorecard) *ReportScorecardCheckQuery {
query := (&ReportScorecardCheckClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rs.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportscorecard.Table, reportscorecard.FieldID, id),
sqlgraph.To(reportscorecardcheck.Table, reportscorecardcheck.FieldID),
sqlgraph.Edge(sqlgraph.O2M, false, reportscorecard.ChecksTable, reportscorecard.ChecksColumn),
)
fromV = sqlgraph.Neighbors(rs.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportScorecardClient) Hooks() []Hook {
return c.hooks.ReportScorecard
}
// Interceptors returns the client interceptors.
func (c *ReportScorecardClient) Interceptors() []Interceptor {
return c.inters.ReportScorecard
}
func (c *ReportScorecardClient) mutate(ctx context.Context, m *ReportScorecardMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportScorecardCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportScorecardUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportScorecardUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportScorecardDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportScorecard mutation op: %q", m.Op())
}
}
// ReportScorecardCheckClient is a client for the ReportScorecardCheck schema.
type ReportScorecardCheckClient struct {
config
}
// NewReportScorecardCheckClient returns a client for the ReportScorecardCheck from the given config.
func NewReportScorecardCheckClient(c config) *ReportScorecardCheckClient {
return &ReportScorecardCheckClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportscorecardcheck.Hooks(f(g(h())))`.
func (c *ReportScorecardCheckClient) Use(hooks ...Hook) {
c.hooks.ReportScorecardCheck = append(c.hooks.ReportScorecardCheck, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportscorecardcheck.Intercept(f(g(h())))`.
func (c *ReportScorecardCheckClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportScorecardCheck = append(c.inters.ReportScorecardCheck, interceptors...)
}
// Create returns a builder for creating a ReportScorecardCheck entity.
func (c *ReportScorecardCheckClient) Create() *ReportScorecardCheckCreate {
mutation := newReportScorecardCheckMutation(c.config, OpCreate)
return &ReportScorecardCheckCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportScorecardCheck entities.
func (c *ReportScorecardCheckClient) CreateBulk(builders ...*ReportScorecardCheckCreate) *ReportScorecardCheckCreateBulk {
return &ReportScorecardCheckCreateBulk{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 *ReportScorecardCheckClient) MapCreateBulk(slice any, setFunc func(*ReportScorecardCheckCreate, int)) *ReportScorecardCheckCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportScorecardCheckCreateBulk{err: fmt.Errorf("calling to ReportScorecardCheckClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportScorecardCheckCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportScorecardCheckCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportScorecardCheck.
func (c *ReportScorecardCheckClient) Update() *ReportScorecardCheckUpdate {
mutation := newReportScorecardCheckMutation(c.config, OpUpdate)
return &ReportScorecardCheckUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportScorecardCheckClient) UpdateOne(rsc *ReportScorecardCheck) *ReportScorecardCheckUpdateOne {
mutation := newReportScorecardCheckMutation(c.config, OpUpdateOne, withReportScorecardCheck(rsc))
return &ReportScorecardCheckUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportScorecardCheckClient) UpdateOneID(id int) *ReportScorecardCheckUpdateOne {
mutation := newReportScorecardCheckMutation(c.config, OpUpdateOne, withReportScorecardCheckID(id))
return &ReportScorecardCheckUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportScorecardCheck.
func (c *ReportScorecardCheckClient) Delete() *ReportScorecardCheckDelete {
mutation := newReportScorecardCheckMutation(c.config, OpDelete)
return &ReportScorecardCheckDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportScorecardCheckClient) DeleteOne(rsc *ReportScorecardCheck) *ReportScorecardCheckDeleteOne {
return c.DeleteOneID(rsc.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportScorecardCheckClient) DeleteOneID(id int) *ReportScorecardCheckDeleteOne {
builder := c.Delete().Where(reportscorecardcheck.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportScorecardCheckDeleteOne{builder}
}
// Query returns a query builder for ReportScorecardCheck.
func (c *ReportScorecardCheckClient) Query() *ReportScorecardCheckQuery {
return &ReportScorecardCheckQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportScorecardCheck},
inters: c.Interceptors(),
}
}
// Get returns a ReportScorecardCheck entity by its id.
func (c *ReportScorecardCheckClient) Get(ctx context.Context, id int) (*ReportScorecardCheck, error) {
return c.Query().Where(reportscorecardcheck.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportScorecardCheckClient) GetX(ctx context.Context, id int) *ReportScorecardCheck {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryScorecard queries the scorecard edge of a ReportScorecardCheck.
func (c *ReportScorecardCheckClient) QueryScorecard(rsc *ReportScorecardCheck) *ReportScorecardQuery {
query := (&ReportScorecardClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rsc.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportscorecardcheck.Table, reportscorecardcheck.FieldID, id),
sqlgraph.To(reportscorecard.Table, reportscorecard.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportscorecardcheck.ScorecardTable, reportscorecardcheck.ScorecardColumn),
)
fromV = sqlgraph.Neighbors(rsc.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportScorecardCheckClient) Hooks() []Hook {
return c.hooks.ReportScorecardCheck
}
// Interceptors returns the client interceptors.
func (c *ReportScorecardCheckClient) Interceptors() []Interceptor {
return c.inters.ReportScorecardCheck
}
func (c *ReportScorecardCheckClient) mutate(ctx context.Context, m *ReportScorecardCheckMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportScorecardCheckCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportScorecardCheckUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportScorecardCheckUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportScorecardCheckDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportScorecardCheck mutation op: %q", m.Op())
}
}
// ReportSlsaProvenanceClient is a client for the ReportSlsaProvenance schema.
type ReportSlsaProvenanceClient struct {
config
}
// NewReportSlsaProvenanceClient returns a client for the ReportSlsaProvenance from the given config.
func NewReportSlsaProvenanceClient(c config) *ReportSlsaProvenanceClient {
return &ReportSlsaProvenanceClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportslsaprovenance.Hooks(f(g(h())))`.
func (c *ReportSlsaProvenanceClient) Use(hooks ...Hook) {
c.hooks.ReportSlsaProvenance = append(c.hooks.ReportSlsaProvenance, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportslsaprovenance.Intercept(f(g(h())))`.
func (c *ReportSlsaProvenanceClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportSlsaProvenance = append(c.inters.ReportSlsaProvenance, interceptors...)
}
// Create returns a builder for creating a ReportSlsaProvenance entity.
func (c *ReportSlsaProvenanceClient) Create() *ReportSlsaProvenanceCreate {
mutation := newReportSlsaProvenanceMutation(c.config, OpCreate)
return &ReportSlsaProvenanceCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportSlsaProvenance entities.
func (c *ReportSlsaProvenanceClient) CreateBulk(builders ...*ReportSlsaProvenanceCreate) *ReportSlsaProvenanceCreateBulk {
return &ReportSlsaProvenanceCreateBulk{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 *ReportSlsaProvenanceClient) MapCreateBulk(slice any, setFunc func(*ReportSlsaProvenanceCreate, int)) *ReportSlsaProvenanceCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportSlsaProvenanceCreateBulk{err: fmt.Errorf("calling to ReportSlsaProvenanceClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportSlsaProvenanceCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportSlsaProvenanceCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportSlsaProvenance.
func (c *ReportSlsaProvenanceClient) Update() *ReportSlsaProvenanceUpdate {
mutation := newReportSlsaProvenanceMutation(c.config, OpUpdate)
return &ReportSlsaProvenanceUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportSlsaProvenanceClient) UpdateOne(rsp *ReportSlsaProvenance) *ReportSlsaProvenanceUpdateOne {
mutation := newReportSlsaProvenanceMutation(c.config, OpUpdateOne, withReportSlsaProvenance(rsp))
return &ReportSlsaProvenanceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportSlsaProvenanceClient) UpdateOneID(id int) *ReportSlsaProvenanceUpdateOne {
mutation := newReportSlsaProvenanceMutation(c.config, OpUpdateOne, withReportSlsaProvenanceID(id))
return &ReportSlsaProvenanceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportSlsaProvenance.
func (c *ReportSlsaProvenanceClient) Delete() *ReportSlsaProvenanceDelete {
mutation := newReportSlsaProvenanceMutation(c.config, OpDelete)
return &ReportSlsaProvenanceDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportSlsaProvenanceClient) DeleteOne(rsp *ReportSlsaProvenance) *ReportSlsaProvenanceDeleteOne {
return c.DeleteOneID(rsp.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportSlsaProvenanceClient) DeleteOneID(id int) *ReportSlsaProvenanceDeleteOne {
builder := c.Delete().Where(reportslsaprovenance.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportSlsaProvenanceDeleteOne{builder}
}
// Query returns a query builder for ReportSlsaProvenance.
func (c *ReportSlsaProvenanceClient) Query() *ReportSlsaProvenanceQuery {
return &ReportSlsaProvenanceQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportSlsaProvenance},
inters: c.Interceptors(),
}
}
// Get returns a ReportSlsaProvenance entity by its id.
func (c *ReportSlsaProvenanceClient) Get(ctx context.Context, id int) (*ReportSlsaProvenance, error) {
return c.Query().Where(reportslsaprovenance.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportSlsaProvenanceClient) GetX(ctx context.Context, id int) *ReportSlsaProvenance {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportSlsaProvenance.
func (c *ReportSlsaProvenanceClient) QueryPackage(rsp *ReportSlsaProvenance) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rsp.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportslsaprovenance.Table, reportslsaprovenance.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportslsaprovenance.PackageTable, reportslsaprovenance.PackageColumn),
)
fromV = sqlgraph.Neighbors(rsp.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportSlsaProvenanceClient) Hooks() []Hook {
return c.hooks.ReportSlsaProvenance
}
// Interceptors returns the client interceptors.
func (c *ReportSlsaProvenanceClient) Interceptors() []Interceptor {
return c.inters.ReportSlsaProvenance
}
func (c *ReportSlsaProvenanceClient) mutate(ctx context.Context, m *ReportSlsaProvenanceMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportSlsaProvenanceCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportSlsaProvenanceUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportSlsaProvenanceUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportSlsaProvenanceDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportSlsaProvenance mutation op: %q", m.Op())
}
}
// ReportVulnerabilityClient is a client for the ReportVulnerability schema.
type ReportVulnerabilityClient struct {
config
}
// NewReportVulnerabilityClient returns a client for the ReportVulnerability from the given config.
func NewReportVulnerabilityClient(c config) *ReportVulnerabilityClient {
return &ReportVulnerabilityClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `reportvulnerability.Hooks(f(g(h())))`.
func (c *ReportVulnerabilityClient) Use(hooks ...Hook) {
c.hooks.ReportVulnerability = append(c.hooks.ReportVulnerability, hooks...)
}
// Intercept adds a list of query interceptors to the interceptors stack.
// A call to `Intercept(f, g, h)` equals to `reportvulnerability.Intercept(f(g(h())))`.
func (c *ReportVulnerabilityClient) Intercept(interceptors ...Interceptor) {
c.inters.ReportVulnerability = append(c.inters.ReportVulnerability, interceptors...)
}
// Create returns a builder for creating a ReportVulnerability entity.
func (c *ReportVulnerabilityClient) Create() *ReportVulnerabilityCreate {
mutation := newReportVulnerabilityMutation(c.config, OpCreate)
return &ReportVulnerabilityCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of ReportVulnerability entities.
func (c *ReportVulnerabilityClient) CreateBulk(builders ...*ReportVulnerabilityCreate) *ReportVulnerabilityCreateBulk {
return &ReportVulnerabilityCreateBulk{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 *ReportVulnerabilityClient) MapCreateBulk(slice any, setFunc func(*ReportVulnerabilityCreate, int)) *ReportVulnerabilityCreateBulk {
rv := reflect.ValueOf(slice)
if rv.Kind() != reflect.Slice {
return &ReportVulnerabilityCreateBulk{err: fmt.Errorf("calling to ReportVulnerabilityClient.MapCreateBulk with wrong type %T, need slice", slice)}
}
builders := make([]*ReportVulnerabilityCreate, rv.Len())
for i := 0; i < rv.Len(); i++ {
builders[i] = c.Create()
setFunc(builders[i], i)
}
return &ReportVulnerabilityCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for ReportVulnerability.
func (c *ReportVulnerabilityClient) Update() *ReportVulnerabilityUpdate {
mutation := newReportVulnerabilityMutation(c.config, OpUpdate)
return &ReportVulnerabilityUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *ReportVulnerabilityClient) UpdateOne(rv *ReportVulnerability) *ReportVulnerabilityUpdateOne {
mutation := newReportVulnerabilityMutation(c.config, OpUpdateOne, withReportVulnerability(rv))
return &ReportVulnerabilityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *ReportVulnerabilityClient) UpdateOneID(id int) *ReportVulnerabilityUpdateOne {
mutation := newReportVulnerabilityMutation(c.config, OpUpdateOne, withReportVulnerabilityID(id))
return &ReportVulnerabilityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for ReportVulnerability.
func (c *ReportVulnerabilityClient) Delete() *ReportVulnerabilityDelete {
mutation := newReportVulnerabilityMutation(c.config, OpDelete)
return &ReportVulnerabilityDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *ReportVulnerabilityClient) DeleteOne(rv *ReportVulnerability) *ReportVulnerabilityDeleteOne {
return c.DeleteOneID(rv.ID)
}
// DeleteOneID returns a builder for deleting the given entity by its id.
func (c *ReportVulnerabilityClient) DeleteOneID(id int) *ReportVulnerabilityDeleteOne {
builder := c.Delete().Where(reportvulnerability.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &ReportVulnerabilityDeleteOne{builder}
}
// Query returns a query builder for ReportVulnerability.
func (c *ReportVulnerabilityClient) Query() *ReportVulnerabilityQuery {
return &ReportVulnerabilityQuery{
config: c.config,
ctx: &QueryContext{Type: TypeReportVulnerability},
inters: c.Interceptors(),
}
}
// Get returns a ReportVulnerability entity by its id.
func (c *ReportVulnerabilityClient) Get(ctx context.Context, id int) (*ReportVulnerability, error) {
return c.Query().Where(reportvulnerability.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *ReportVulnerabilityClient) GetX(ctx context.Context, id int) *ReportVulnerability {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// QueryPackage queries the package edge of a ReportVulnerability.
func (c *ReportVulnerabilityClient) QueryPackage(rv *ReportVulnerability) *ReportPackageQuery {
query := (&ReportPackageClient{config: c.config}).Query()
query.path = func(context.Context) (fromV *sql.Selector, _ error) {
id := rv.ID
step := sqlgraph.NewStep(
sqlgraph.From(reportvulnerability.Table, reportvulnerability.FieldID, id),
sqlgraph.To(reportpackage.Table, reportpackage.FieldID),
sqlgraph.Edge(sqlgraph.M2O, true, reportvulnerability.PackageTable, reportvulnerability.PackageColumn),
)
fromV = sqlgraph.Neighbors(rv.driver.Dialect(), step)
return fromV, nil
}
return query
}
// Hooks returns the client hooks.
func (c *ReportVulnerabilityClient) Hooks() []Hook {
return c.hooks.ReportVulnerability
}
// Interceptors returns the client interceptors.
func (c *ReportVulnerabilityClient) Interceptors() []Interceptor {
return c.inters.ReportVulnerability
}
func (c *ReportVulnerabilityClient) mutate(ctx context.Context, m *ReportVulnerabilityMutation) (Value, error) {
switch m.Op() {
case OpCreate:
return (&ReportVulnerabilityCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdate:
return (&ReportVulnerabilityUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpUpdateOne:
return (&ReportVulnerabilityUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
case OpDelete, OpDeleteOne:
return (&ReportVulnerabilityDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
default:
return nil, fmt.Errorf("ent: unknown ReportVulnerability mutation op: %q", m.Op())
}
}
// hooks and interceptors per client, for fast access.
type (
hooks struct {
CodeSourceFile, DepsUsageEvidence, ReportDependency, ReportDependencyGraph,
ReportLicense, ReportMalware, ReportPackage, ReportPackageManifest,
ReportProject, ReportScorecard, ReportScorecardCheck, ReportSlsaProvenance,
ReportVulnerability []ent.Hook
}
inters struct {
CodeSourceFile, DepsUsageEvidence, ReportDependency, ReportDependencyGraph,
ReportLicense, ReportMalware, ReportPackage, ReportPackageManifest,
ReportProject, ReportScorecard, ReportScorecardCheck, ReportSlsaProvenance,
ReportVulnerability []ent.Interceptor
}
)
