ai/api
1
0
Fork 0
Code Activity

first gen

Browse Source
This commit is contained in:
syui
2022-08-31 16:49:08 +09:00
committed by syui
parent d40e30944b
commit 22734a4b4c
89 changed files with 25861 additions and 16973 deletions
Download Patch File Download Diff File Expand all files Collapse all files

304
ent/ogent/oas_cfg_gen.go
View File

@ -3,132 +3,195 @@
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/metric/instrument"
"go.opentelemetry.io/otel/trace"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/middleware"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/otelogen"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
// Allocate option closure once.
clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
// Allocate option closure once.
serverSpanKind = trace.WithSpanKind(trace.SpanKindServer)
)
// bufPool is pool of bytes.Buffer for encoding and decoding.
var bufPool = &sync.Pool{
New: func() interface{} {
return new(bytes.Buffer)
},
}
type (
optionFunc[C any] func(*C)
otelOptionFunc func(*otelConfig)
)
// getBuf returns buffer from pool.
func getBuf() *bytes.Buffer {
return bufPool.Get().(*bytes.Buffer)
}
// putBuf puts buffer to pool.
func putBuf(b *bytes.Buffer) {
b.Reset()
bufPool.Put(b)
}
type config struct {
type otelConfig struct {
TracerProvider trace.TracerProvider
Tracer trace.Tracer
MeterProvider metric.MeterProvider
Meter metric.Meter
Client ht.Client
NotFound http.HandlerFunc
}
func newConfig(opts ...Option) config {
cfg := config{
TracerProvider: otel.GetTracerProvider(),
MeterProvider: metric.NewNoopMeterProvider(),
Client: http.DefaultClient,
NotFound: http.NotFound,
func (cfg *otelConfig) initOTEL() {
if cfg.TracerProvider == nil {
cfg.TracerProvider = otel.GetTracerProvider()
}
for _, opt := range opts {
opt.apply(&cfg)
if cfg.MeterProvider == nil {
cfg.MeterProvider = metric.NewNoopMeterProvider()
}
cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
trace.WithInstrumentationVersion(otelogen.SemVersion()),
)
cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name)
}
// ErrorHandler is error handler.
type ErrorHandler = ogenerrors.ErrorHandler
type serverConfig struct {
otelConfig
NotFound http.HandlerFunc
MethodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)
ErrorHandler ErrorHandler
Prefix string
Middleware Middleware
MaxMultipartMemory int64
}
// ServerOption is server config option.
type ServerOption interface {
applyServer(*serverConfig)
}
var _ = []ServerOption{
(optionFunc[serverConfig])(nil),
(otelOptionFunc)(nil),
}
func (o optionFunc[C]) applyServer(c *C) {
o(c)
}
func (o otelOptionFunc) applyServer(c *serverConfig) {
o(&c.otelConfig)
}
func newServerConfig(opts ...ServerOption) serverConfig {
cfg := serverConfig{
NotFound: http.NotFound,
MethodNotAllowed: func(w http.ResponseWriter, r *http.Request, allowed string) {
w.Header().Set("Allow", allowed)
w.WriteHeader(http.StatusMethodNotAllowed)
},
ErrorHandler: ogenerrors.DefaultErrorHandler,
Middleware: nil,
MaxMultipartMemory: 32 << 20, // 32 MB
}
for _, opt := range opts {
opt.applyServer(&cfg)
}
cfg.initOTEL()
return cfg
}
type Option interface {
apply(*config)
type baseServer struct {
cfg serverConfig
requests instrument.Int64Counter
errors instrument.Int64Counter
duration instrument.Int64Histogram
}
type optionFunc func(*config)
func (s baseServer) notFound(w http.ResponseWriter, r *http.Request) {
s.cfg.NotFound(w, r)
}
func (o optionFunc) apply(c *config) {
func (s baseServer) notAllowed(w http.ResponseWriter, r *http.Request, allowed string) {
s.cfg.MethodNotAllowed(w, r, allowed)
}
func (cfg serverConfig) baseServer() (s baseServer, err error) {
s = baseServer{cfg: cfg}
if s.requests, err = s.cfg.Meter.Int64Counter(otelogen.ServerRequestCount); err != nil {
return s, err
}
if s.errors, err = s.cfg.Meter.Int64Counter(otelogen.ServerErrorsCount); err != nil {
return s, err
}
if s.duration, err = s.cfg.Meter.Int64Histogram(otelogen.ServerDuration); err != nil {
return s, err
}
return s, nil
}
type clientConfig struct {
otelConfig
Client ht.Client
}
// ClientOption is client config option.
type ClientOption interface {
applyClient(*clientConfig)
}
var _ = []ClientOption{
(optionFunc[clientConfig])(nil),
(otelOptionFunc)(nil),
}
func (o optionFunc[C]) applyClient(c *C) {
o(c)
}
func (o otelOptionFunc) applyClient(c *clientConfig) {
o(&c.otelConfig)
}
func newClientConfig(opts ...ClientOption) clientConfig {
cfg := clientConfig{
Client: http.DefaultClient,
}
for _, opt := range opts {
opt.applyClient(&cfg)
}
cfg.initOTEL()
return cfg
}
type baseClient struct {
cfg clientConfig
requests instrument.Int64Counter
errors instrument.Int64Counter
duration instrument.Int64Histogram
}
func (cfg clientConfig) baseClient() (c baseClient, err error) {
c = baseClient{cfg: cfg}
if c.requests, err = c.cfg.Meter.Int64Counter(otelogen.ClientRequestCount); err != nil {
return c, err
}
if c.errors, err = c.cfg.Meter.Int64Counter(otelogen.ClientErrorsCount); err != nil {
return c, err
}
if c.duration, err = c.cfg.Meter.Int64Histogram(otelogen.ClientDuration); err != nil {
return c, err
}
return c, nil
}
// Option is config option.
type Option interface {
ServerOption
ClientOption
}
// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
return optionFunc(func(cfg *config) {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.TracerProvider = provider
}
@ -139,7 +202,7 @@ func WithTracerProvider(provider trace.TracerProvider) Option {
//
// If none is specified, the metric.NewNoopMeterProvider is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
return optionFunc(func(cfg *config) {
return otelOptionFunc(func(cfg *otelConfig) {
if provider != nil {
cfg.MeterProvider = provider
}
@ -147,19 +210,68 @@ func WithMeterProvider(provider metric.MeterProvider) Option {
}
// WithClient specifies http client to use.
func WithClient(client ht.Client) Option {
return optionFunc(func(cfg *config) {
func WithClient(client ht.Client) ClientOption {
return optionFunc[clientConfig](func(cfg *clientConfig) {
if client != nil {
cfg.Client = client
}
})
}
// WithNotFound specifies http handler to use.
func WithNotFound(notFound http.HandlerFunc) Option {
return optionFunc(func(cfg *config) {
// WithNotFound specifies Not Found handler to use.
func WithNotFound(notFound http.HandlerFunc) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if notFound != nil {
cfg.NotFound = notFound
}
})
}
// WithMethodNotAllowed specifies Method Not Allowed handler to use.
func WithMethodNotAllowed(methodNotAllowed func(w http.ResponseWriter, r *http.Request, allowed string)) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if methodNotAllowed != nil {
cfg.MethodNotAllowed = methodNotAllowed
}
})
}
// WithErrorHandler specifies error handler to use.
func WithErrorHandler(h ErrorHandler) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if h != nil {
cfg.ErrorHandler = h
}
})
}
// WithPathPrefix specifies server path prefix.
func WithPathPrefix(prefix string) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
cfg.Prefix = prefix
})
}
// WithMiddleware specifies middlewares to use.
func WithMiddleware(m ...Middleware) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
switch len(m) {
case 0:
cfg.Middleware = nil
case 1:
cfg.Middleware = m[0]
default:
cfg.Middleware = middleware.ChainMiddlewares(m...)
}
})
}
// WithMaxMultipartMemory specifies limit of memory for storing file parts.
// File parts which can't be stored in memory will be stored on disk in temporary files.
func WithMaxMultipartMemory(max int64) ServerOption {
return optionFunc[serverConfig](func(cfg *serverConfig) {
if max > 0 {
cfg.MaxMultipartMemory = max
}
})
}

1731
ent/ogent/oas_client_gen.go
View File

File diff suppressed because it is too large Load Diff

71
ent/ogent/oas_defaults_gen.go
View File

@ -1,71 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)

2199
ent/ogent/oas_handlers_gen.go
View File

File diff suppressed because it is too large Load Diff

72
ent/ogent/oas_interfaces_gen.go
View File

@ -1,22 +1,74 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
type CreateUsersRes interface {
createUsersRes()
type CreateCardRes interface {
createCardRes()
}
type DeleteUsersRes interface {
deleteUsersRes()
type CreateGroupRes interface {
createGroupRes()
}
type ListUsersRes interface {
listUsersRes()
type CreateUserRes interface {
createUserRes()
}
type ReadUsersRes interface {
readUsersRes()
type DeleteCardRes interface {
deleteCardRes()
}
type UpdateUsersRes interface {
updateUsersRes()
type DeleteGroupRes interface {
deleteGroupRes()
}
type DeleteUserRes interface {
deleteUserRes()
}
type ListCardRes interface {
listCardRes()
}
type ListGroupRes interface {
listGroupRes()
}
type ListGroupUsersRes interface {
listGroupUsersRes()
}
type ListUserCardRes interface {
listUserCardRes()
}
type ListUserRes interface {
listUserRes()
}
type ReadCardOwnerRes interface {
readCardOwnerRes()
}
type ReadCardRes interface {
readCardRes()
}
type ReadGroupRes interface {
readGroupRes()
}
type ReadUserRes interface {
readUserRes()
}
type UpdateCardRes interface {
updateCardRes()
}
type UpdateGroupRes interface {
updateGroupRes()
}
type UpdateUserRes interface {
updateUserRes()
}

4404
ent/ogent/oas_json_gen.go
View File

File diff suppressed because it is too large Load Diff

10
ent/ogent/oas_middleware_gen.go Normal file
View File

@ -0,0 +1,10 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"github.com/ogen-go/ogen/middleware"
)
// Middleware is middleware type.
type Middleware = middleware.Middleware

339
ent/ogent/oas_param_dec_gen.go
View File

@ -1,339 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func decodeDeleteUsersParams(args [1]string, r *http.Request) (DeleteUsersParams, error) {
var (
params DeleteUsersParams
)
// Decode path: id.
{
param := args[0]
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return params, err
}
} else {
return params, errors.New("path: id: not specified")
}
}
return params, nil
}
func decodeDrawDoneParams(args [1]string, r *http.Request) (DrawDoneParams, error) {
var (
params DrawDoneParams
)
// Decode path: id.
{
param := args[0]
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return params, err
}
} else {
return params, errors.New("path: id: not specified")
}
}
return params, nil
}
func decodeDrawStartParams(args [1]string, r *http.Request) (DrawStartParams, error) {
var (
params DrawStartParams
)
// Decode path: id.
{
param := args[0]
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return params, err
}
} else {
return params, errors.New("path: id: not specified")
}
}
return params, nil
}
func decodeListUsersParams(args [0]string, r *http.Request) (ListUsersParams, error) {
var (
params ListUsersParams
queryArgs = r.URL.Query()
)
// Decode query: page.
{
values, ok := queryArgs["page"]
if ok {
d := uri.NewQueryDecoder(uri.QueryDecoderConfig{
Values: values,
Style: uri.QueryStyleForm,
Explode: true,
})
if err := func() error {
var paramsDotPageVal int
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}(); err != nil {
return params, errors.Wrap(err, "query: page: parse")
}
}
}
// Decode query: itemsPerPage.
{
values, ok := queryArgs["itemsPerPage"]
if ok {
d := uri.NewQueryDecoder(uri.QueryDecoderConfig{
Values: values,
Style: uri.QueryStyleForm,
Explode: true,
})
if err := func() error {
var paramsDotItemsPerPageVal int
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}(); err != nil {
return params, errors.Wrap(err, "query: itemsPerPage: parse")
}
}
}
return params, nil
}
func decodeReadUsersParams(args [1]string, r *http.Request) (ReadUsersParams, error) {
var (
params ReadUsersParams
)
// Decode path: id.
{
param := args[0]
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return params, err
}
} else {
return params, errors.New("path: id: not specified")
}
}
return params, nil
}
func decodeUpdateUsersParams(args [1]string, r *http.Request) (UpdateUsersParams, error) {
var (
params UpdateUsersParams
)
// Decode path: id.
{
param := args[0]
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
s, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(s)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return params, err
}
} else {
return params, errors.New("path: id: not specified")
}
}
return params, nil
}

101
ent/ogent/oas_param_gen.go
View File

@ -1,101 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
type DeleteUsersParams struct {
// ID of the Users.
ID int
}
type DrawDoneParams struct {
ID int
}
type DrawStartParams struct {
ID int
}
type ListUsersParams struct {
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
type ReadUsersParams struct {
// ID of the Users.
ID int
}
type UpdateUsersParams struct {
// ID of the Users.
ID int
}

1587
ent/ogent/oas_parameters_gen.go Normal file
View File

File diff suppressed because it is too large Load Diff

159
ent/ogent/oas_req_dec_gen.go
View File

@ -1,159 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func decodeCreateUsersRequest(r *http.Request, span trace.Span) (req CreateUsersReq, err error) {
switch ct := r.Header.Get("Content-Type"); ct {
case "application/json":
if r.ContentLength == 0 {
return req, validate.ErrBodyRequired
}
var request CreateUsersReq
buf := getBuf()
defer putBuf(buf)
written, err := io.Copy(buf, r.Body)
if err != nil {
return req, err
}
if written == 0 {
return req, validate.ErrBodyRequired
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return req, errors.Wrap(err, "decode CreateUsers:application/json request")
}
if err := func() error {
if err := request.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return req, errors.Wrap(err, "validate CreateUsers request")
}
return request, nil
default:
return req, validate.InvalidContentType(ct)
}
}
func decodeUpdateUsersRequest(r *http.Request, span trace.Span) (req UpdateUsersReq, err error) {
switch ct := r.Header.Get("Content-Type"); ct {
case "application/json":
if r.ContentLength == 0 {
return req, validate.ErrBodyRequired
}
var request UpdateUsersReq
buf := getBuf()
defer putBuf(buf)
written, err := io.Copy(buf, r.Body)
if err != nil {
return req, err
}
if written == 0 {
return req, validate.ErrBodyRequired
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return req, errors.Wrap(err, "decode UpdateUsers:application/json request")
}
if err := func() error {
if err := request.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return req, errors.Wrap(err, "validate UpdateUsers request")
}
return request, nil
default:
return req, validate.InvalidContentType(ct)
}
}

87
ent/ogent/oas_req_enc_gen.go
View File

@ -1,87 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func encodeCreateUsersRequestJSON(req CreateUsersReq, span trace.Span) (data *jx.Encoder, err error) {
e := jx.GetEncoder()
req.Encode(e)
return e, nil
}
func encodeUpdateUsersRequestJSON(req UpdateUsersReq, span trace.Span) (data *jx.Encoder, err error) {
e := jx.GetEncoder()
req.Encode(e)
return e, nil
}

394
ent/ogent/oas_request_decoders_gen.go Normal file
View File

@ -0,0 +1,394 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"io"
"mime"
"net/http"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"go.uber.org/multierr"
"github.com/ogen-go/ogen/ogenerrors"
"github.com/ogen-go/ogen/validate"
)
func (s *Server) decodeCreateCardRequest(r *http.Request) (
req *CreateCardReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreateCardReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeCreateGroupRequest(r *http.Request) (
req *CreateGroupReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreateGroupReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeCreateUserRequest(r *http.Request) (
req *CreateUserReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreateUserReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdateCardRequest(r *http.Request) (
req *UpdateCardReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdateCardReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdateGroupRequest(r *http.Request) (
req *UpdateGroupReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdateGroupReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdateUserRequest(r *http.Request) (
req *UpdateUserReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdateUserReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}

96
ent/ogent/oas_request_encoders_gen.go Normal file
View File

@ -0,0 +1,96 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"net/http"
"github.com/go-faster/jx"
ht "github.com/ogen-go/ogen/http"
)
func encodeCreateCardRequest(
req *CreateCardReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeCreateGroupRequest(
req *CreateGroupReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeCreateUserRequest(
req *CreateUserReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdateCardRequest(
req *UpdateCardReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdateGroupRequest(
req *UpdateGroupReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdateUserRequest(
req *UpdateUserReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}

747
ent/ogent/oas_res_dec_gen.go
View File

@ -1,747 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func decodeCreateUsersResponse(resp *http.Response, span trace.Span) (res CreateUsersRes, err error) {
switch resp.StatusCode {
case 200:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response UsersCreate
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 400:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R400
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 409:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R409
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 500:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R500
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeDeleteUsersResponse(resp *http.Response, span trace.Span) (res DeleteUsersRes, err error) {
switch resp.StatusCode {
case 204:
return &DeleteUsersNoContent{}, nil
case 400:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R400
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 404:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R404
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 409:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R409
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 500:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R500
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeDrawDoneResponse(resp *http.Response, span trace.Span) (res DrawDoneNoContent, err error) {
switch resp.StatusCode {
case 204:
return DrawDoneNoContent{}, nil
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeDrawStartResponse(resp *http.Response, span trace.Span) (res DrawStartNoContent, err error) {
switch resp.StatusCode {
case 204:
return DrawStartNoContent{}, nil
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeListUsersResponse(resp *http.Response, span trace.Span) (res ListUsersRes, err error) {
switch resp.StatusCode {
case 200:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response ListUsersOKApplicationJSON
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 400:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R400
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 404:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R404
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 409:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R409
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 500:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R500
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeReadUsersResponse(resp *http.Response, span trace.Span) (res ReadUsersRes, err error) {
switch resp.StatusCode {
case 200:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response UsersRead
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 400:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R400
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 404:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R404
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 409:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R409
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 500:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R500
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}
func decodeUpdateUsersResponse(resp *http.Response, span trace.Span) (res UpdateUsersRes, err error) {
switch resp.StatusCode {
case 200:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response UsersUpdate
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 400:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R400
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 404:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R404
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 409:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R409
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
case 500:
switch ct := resp.Header.Get("Content-Type"); ct {
case "application/json":
buf := getBuf()
defer putBuf(buf)
if _, err := io.Copy(buf, resp.Body); err != nil {
return res, err
}
d := jx.GetDecoder()
defer jx.PutDecoder(d)
d.ResetBytes(buf.Bytes())
var response R500
if err := func() error {
if err := response.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return res, err
}
return &response, nil
default:
return res, validate.InvalidContentType(ct)
}
default:
return res, validate.UnexpectedStatusCode(resp.StatusCode)
}
}

395
ent/ogent/oas_res_enc_gen.go
View File

@ -1,395 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func encodeCreateUsersResponse(response CreateUsersRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UsersCreate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("/users"+`: unexpected response type: %T`, response)
}
}
func encodeDeleteUsersResponse(response DeleteUsersRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *DeleteUsersNoContent:
w.WriteHeader(204)
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response)
}
}
func encodeDrawDoneResponse(response DrawDoneNoContent, w http.ResponseWriter, span trace.Span) error {
w.WriteHeader(204)
return nil
}
func encodeDrawStartResponse(response DrawStartNoContent, w http.ResponseWriter, span trace.Span) error {
w.WriteHeader(204)
return nil
}
func encodeListUsersResponse(response ListUsersRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUsersOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("/users"+`: unexpected response type: %T`, response)
}
}
func encodeReadUsersResponse(response ReadUsersRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UsersRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response)
}
}
func encodeUpdateUsersResponse(response UpdateUsersRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UsersUpdate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R404:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(404)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R409:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(409)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
case *R500:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(500)
e := jx.GetEncoder()
defer jx.PutEncoder(e)
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("/users/{id}"+`: unexpected response type: %T`, response)
}
}

3090
ent/ogent/oas_response_decoders_gen.go Normal file
View File

File diff suppressed because it is too large Load Diff

1178
ent/ogent/oas_response_encoders_gen.go Normal file
View File

File diff suppressed because it is too large Load Diff

1008
ent/ogent/oas_router_gen.go
View File

File diff suppressed because it is too large Load Diff

1567
ent/ogent/oas_schemas_gen.go
View File

File diff suppressed because it is too large Load Diff

71
ent/ogent/oas_security_gen.go
View File

@ -1,71 +0,0 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)

212
ent/ogent/oas_server_gen.go
View File

@ -3,140 +3,148 @@
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
// Handler handles operations described by OpenAPI v3 specification.
type Handler interface {
// CreateUsers implements createUsers operation.
// CreateCard implements createCard operation.
//
// Creates a new Users and persists it to storage.
// Creates a new Card and persists it to storage.
//
// POST /cards
CreateCard(ctx context.Context, req *CreateCardReq) (CreateCardRes, error)
// CreateGroup implements createGroup operation.
//
// Creates a new Group and persists it to storage.
//
// POST /groups
CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error)
// CreateUser implements createUser operation.
//
// Creates a new User and persists it to storage.
//
// POST /users
CreateUsers(ctx context.Context, req CreateUsersReq) (CreateUsersRes, error)
// DeleteUsers implements deleteUsers operation.
CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error)
// DeleteCard implements deleteCard operation.
//
// Deletes the Users with the requested ID.
// Deletes the Card with the requested ID.
//
// DELETE /cards/{id}
DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error)
// DeleteGroup implements deleteGroup operation.
//
// Deletes the Group with the requested ID.
//
// DELETE /groups/{id}
DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error)
// DeleteUser implements deleteUser operation.
//
// Deletes the User with the requested ID.
//
// DELETE /users/{id}
DeleteUsers(ctx context.Context, params DeleteUsersParams) (DeleteUsersRes, error)
DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error)
// DrawDone implements drawDone operation.
//
// PUT /users/{id}/d
DrawDone(ctx context.Context, params DrawDoneParams) (DrawDoneNoContent, error)
// Draws a card item as done.
//
// PUT /cards/{id}/d
DrawDone(ctx context.Context, params DrawDoneParams) error
// DrawStart implements drawStart operation.
//
// PATCH /users/{id}/start
DrawStart(ctx context.Context, params DrawStartParams) (DrawStartNoContent, error)
// ListUsers implements listUsers operation.
// Draws a card item as done.
//
// PATCH /users/{id}/card/start
DrawStart(ctx context.Context, params DrawStartParams) error
// ListCard implements listCard operation.
//
// List Cards.
//
// GET /cards
ListCard(ctx context.Context, params ListCardParams) (ListCardRes, error)
// ListGroup implements listGroup operation.
//
// List Groups.
//
// GET /groups
ListGroup(ctx context.Context, params ListGroupParams) (ListGroupRes, error)
// ListGroupUsers implements listGroupUsers operation.
//
// List attached Users.
//
// GET /groups/{id}/users
ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error)
// ListUser implements listUser operation.
//
// List Users.
//
// GET /users
ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error)
// ReadUsers implements readUsers operation.
ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error)
// ListUserCard implements listUserCard operation.
//
// Finds the Users with the requested ID and returns it.
// List attached Cards.
//
// GET /users/{id}/card
ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error)
// ReadCard implements readCard operation.
//
// Finds the Card with the requested ID and returns it.
//
// GET /cards/{id}
ReadCard(ctx context.Context, params ReadCardParams) (ReadCardRes, error)
// ReadCardOwner implements readCardOwner operation.
//
// Find the attached User of the Card with the given ID.
//
// GET /cards/{id}/owner
ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (ReadCardOwnerRes, error)
// ReadGroup implements readGroup operation.
//
// Finds the Group with the requested ID and returns it.
//
// GET /groups/{id}
ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error)
// ReadUser implements readUser operation.
//
// Finds the User with the requested ID and returns it.
//
// GET /users/{id}
ReadUsers(ctx context.Context, params ReadUsersParams) (ReadUsersRes, error)
// UpdateUsers implements updateUsers operation.
ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error)
// UpdateCard implements updateCard operation.
//
// Updates a Users and persists changes to storage.
// Updates a Card and persists changes to storage.
//
// PATCH /cards/{id}
UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error)
// UpdateGroup implements updateGroup operation.
//
// Updates a Group and persists changes to storage.
//
// PATCH /groups/{id}
UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error)
// UpdateUser implements updateUser operation.
//
// Updates a User and persists changes to storage.
//
// PATCH /users/{id}
UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (UpdateUsersRes, error)
UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error)
}
// Server implements http server based on OpenAPI v3 specification and
// calls Handler to handle requests.
type Server struct {
h Handler
cfg config
requests metric.Int64Counter
errors metric.Int64Counter
duration metric.Int64Histogram
h Handler
baseServer
}
func NewServer(h Handler, opts ...Option) (*Server, error) {
s := &Server{
h: h,
cfg: newConfig(opts...),
}
var err error
if s.requests, err = s.cfg.Meter.NewInt64Counter(otelogen.ServerRequestCount); err != nil {
// NewServer creates new Server.
func NewServer(h Handler, opts ...ServerOption) (*Server, error) {
s, err := newServerConfig(opts...).baseServer()
if err != nil {
return nil, err
}
if s.errors, err = s.cfg.Meter.NewInt64Counter(otelogen.ServerErrorsCount); err != nil {
return nil, err
}
if s.duration, err = s.cfg.Meter.NewInt64Histogram(otelogen.ServerDuration); err != nil {
return nil, err
}
return s, nil
return &Server{
h: h,
baseServer: s,
}, nil
}

229
ent/ogent/oas_unimplemented_gen.go
View File

@ -3,133 +3,192 @@
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
var _ Handler = UnimplementedHandler{}
// UnimplementedHandler is no-op Handler which returns http.ErrNotImplemented.
type UnimplementedHandler struct{}
// CreateUsers implements createUsers operation.
var _ Handler = UnimplementedHandler{}
// CreateCard implements createCard operation.
//
// Creates a new Users and persists it to storage.
// Creates a new Card and persists it to storage.
//
// POST /users
func (UnimplementedHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (r CreateUsersRes, _ error) {
// POST /cards
func (UnimplementedHandler) CreateCard(ctx context.Context, req *CreateCardReq) (r CreateCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUsers implements deleteUsers operation.
// CreateGroup implements createGroup operation.
//
// Deletes the Users with the requested ID.
// Creates a new Group and persists it to storage.
//
// POST /groups
func (UnimplementedHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (r CreateGroupRes, _ error) {
return r, ht.ErrNotImplemented
}
// CreateUser implements createUser operation.
//
// Creates a new User and persists it to storage.
//
// POST /users
func (UnimplementedHandler) CreateUser(ctx context.Context, req *CreateUserReq) (r CreateUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteCard implements deleteCard operation.
//
// Deletes the Card with the requested ID.
//
// DELETE /cards/{id}
func (UnimplementedHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (r DeleteCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteGroup implements deleteGroup operation.
//
// Deletes the Group with the requested ID.
//
// DELETE /groups/{id}
func (UnimplementedHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (r DeleteGroupRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUser implements deleteUser operation.
//
// Deletes the User with the requested ID.
//
// DELETE /users/{id}
func (UnimplementedHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams) (r DeleteUsersRes, _ error) {
func (UnimplementedHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (r DeleteUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// DrawDone implements drawDone operation.
//
// PUT /users/{id}/d
func (UnimplementedHandler) DrawDone(ctx context.Context, params DrawDoneParams) (r DrawDoneNoContent, _ error) {
return r, ht.ErrNotImplemented
// Draws a card item as done.
//
// PUT /cards/{id}/d
func (UnimplementedHandler) DrawDone(ctx context.Context, params DrawDoneParams) error {
return ht.ErrNotImplemented
}
// DrawStart implements drawStart operation.
//
// PATCH /users/{id}/start
func (UnimplementedHandler) DrawStart(ctx context.Context, params DrawStartParams) (r DrawStartNoContent, _ error) {
// Draws a card item as done.
//
// PATCH /users/{id}/card/start
func (UnimplementedHandler) DrawStart(ctx context.Context, params DrawStartParams) error {
return ht.ErrNotImplemented
}
// ListCard implements listCard operation.
//
// List Cards.
//
// GET /cards
func (UnimplementedHandler) ListCard(ctx context.Context, params ListCardParams) (r ListCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUsers implements listUsers operation.
// ListGroup implements listGroup operation.
//
// List Groups.
//
// GET /groups
func (UnimplementedHandler) ListGroup(ctx context.Context, params ListGroupParams) (r ListGroupRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListGroupUsers implements listGroupUsers operation.
//
// List attached Users.
//
// GET /groups/{id}/users
func (UnimplementedHandler) ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (r ListGroupUsersRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUser implements listUser operation.
//
// List Users.
//
// GET /users
func (UnimplementedHandler) ListUsers(ctx context.Context, params ListUsersParams) (r ListUsersRes, _ error) {
func (UnimplementedHandler) ListUser(ctx context.Context, params ListUserParams) (r ListUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUsers implements readUsers operation.
// ListUserCard implements listUserCard operation.
//
// Finds the Users with the requested ID and returns it.
// List attached Cards.
//
// GET /users/{id}/card
func (UnimplementedHandler) ListUserCard(ctx context.Context, params ListUserCardParams) (r ListUserCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadCard implements readCard operation.
//
// Finds the Card with the requested ID and returns it.
//
// GET /cards/{id}
func (UnimplementedHandler) ReadCard(ctx context.Context, params ReadCardParams) (r ReadCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadCardOwner implements readCardOwner operation.
//
// Find the attached User of the Card with the given ID.
//
// GET /cards/{id}/owner
func (UnimplementedHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (r ReadCardOwnerRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadGroup implements readGroup operation.
//
// Finds the Group with the requested ID and returns it.
//
// GET /groups/{id}
func (UnimplementedHandler) ReadGroup(ctx context.Context, params ReadGroupParams) (r ReadGroupRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUser implements readUser operation.
//
// Finds the User with the requested ID and returns it.
//
// GET /users/{id}
func (UnimplementedHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (r ReadUsersRes, _ error) {
func (UnimplementedHandler) ReadUser(ctx context.Context, params ReadUserParams) (r ReadUserRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateUsers implements updateUsers operation.
// UpdateCard implements updateCard operation.
//
// Updates a Users and persists changes to storage.
// Updates a Card and persists changes to storage.
//
// PATCH /users/{id}
func (UnimplementedHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (r UpdateUsersRes, _ error) {
// PATCH /cards/{id}
func (UnimplementedHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (r UpdateCardRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateGroup implements updateGroup operation.
//
// Updates a Group and persists changes to storage.
//
// PATCH /groups/{id}
func (UnimplementedHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (r UpdateGroupRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateUser implements updateUser operation.
//
// Updates a User and persists changes to storage.
//
// PATCH /users/{id}
func (UnimplementedHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (r UpdateUserRes, _ error) {
return r, ht.ErrNotImplemented
}

244
ent/ogent/oas_validators_gen.go
View File

@ -3,250 +3,36 @@
package ogent
import (
"bytes"
"context"
"fmt"
"io"
"math"
"math/big"
"math/bits"
"net"
"net/http"
"net/url"
"regexp"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/google/uuid"
"github.com/ogen-go/ogen/conv"
ht "github.com/ogen-go/ogen/http"
"github.com/ogen-go/ogen/json"
"github.com/ogen-go/ogen/otelogen"
"github.com/ogen-go/ogen/uri"
"github.com/ogen-go/ogen/validate"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/trace"
)
// No-op definition for keeping imports.
var (
_ = context.Background()
_ = fmt.Stringer(nil)
_ = strings.Builder{}
_ = errors.Is
_ = sort.Ints
_ = http.MethodGet
_ = io.Copy
_ = json.Marshal
_ = bytes.NewReader
_ = strconv.ParseInt
_ = time.Time{}
_ = conv.ToInt32
_ = uuid.UUID{}
_ = uri.PathEncoder{}
_ = url.URL{}
_ = math.Mod
_ = bits.LeadingZeros64
_ = big.Rat{}
_ = validate.Int{}
_ = ht.NewRequest
_ = net.IP{}
_ = otelogen.Version
_ = attribute.KeyValue{}
_ = trace.TraceIDFromHex
_ = otel.GetTracerProvider
_ = metric.NewNoopMeterProvider
_ = regexp.MustCompile
_ = jx.Null
_ = sync.Pool{}
_ = codes.Unset
)
func (s CreateUsersReq) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s ListUsersOKApplicationJSON) Validate() error {
func (s ListCardOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
var failures []validate.FieldError
for i, elem := range s {
if err := func() error {
if err := elem.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: fmt.Sprintf("[%d]", i),
Error: err,
})
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
return nil
}
func (s ListGroupOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s UpdateUsersReq) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
func (s ListGroupUsersOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s UsersCreate) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
func (s ListUserCardOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s UsersList) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s UsersRead) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
func (s UsersUpdate) Validate() error {
var failures []validate.FieldError
if err := func() error {
if s.Percentage.Set {
if err := func() error {
if err := (validate.Float{}).Validate(float64(s.Percentage.Value)); err != nil {
return errors.Wrap(err, "float")
}
return nil
}(); err != nil {
return err
}
}
return nil
return nil
}(); err != nil {
failures = append(failures, validate.FieldError{
Name: "percentage",
Error: err,
})
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
func (s ListUserOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}

594
ent/ogent/ogent.go
View File

@ -1,4 +1,4 @@
// Code generated by entc, DO NOT EDIT.
// Code generated by ent, DO NOT EDIT.
package ogent
@ -7,7 +7,9 @@ import (
"net/http"
"t/ent"
"t/ent/users"
"t/ent/card"
"t/ent/group"
"t/ent/user"
"github.com/go-faster/jx"
)
@ -27,63 +29,27 @@ func rawError(err error) jx.Raw {
return e.Bytes()
}
// CreateUsers handles POST /users-slice requests.
func (h *OgentHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (CreateUsersRes, error) {
b := h.client.Users.Create()
// CreateCard handles POST /cards requests.
func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (CreateCardRes, error) {
b := h.client.Card.Create()
// Add all fields.
b.SetUser(req.User)
if v, ok := req.Chara.Get(); ok {
b.SetChara(v)
}
if v, ok := req.Skill.Get(); ok {
b.SetSkill(v)
}
if v, ok := req.Hp.Get(); ok {
b.SetHp(v)
}
if v, ok := req.Attack.Get(); ok {
b.SetAttack(v)
}
if v, ok := req.Defense.Get(); ok {
b.SetDefense(v)
}
if v, ok := req.Critical.Get(); ok {
b.SetCritical(v)
}
if v, ok := req.Battle.Get(); ok {
b.SetBattle(v)
}
if v, ok := req.Win.Get(); ok {
b.SetWin(v)
}
if v, ok := req.Day.Get(); ok {
b.SetDay(v)
}
if v, ok := req.Percentage.Get(); ok {
b.SetPercentage(v)
}
if v, ok := req.Limit.Get(); ok {
b.SetLimit(v)
if v, ok := req.Card.Get(); ok {
b.SetCard(v)
}
if v, ok := req.Status.Get(); ok {
b.SetStatus(v)
}
if v, ok := req.Comment.Get(); ok {
b.SetComment(v)
}
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
if v, ok := req.Cp.Get(); ok {
b.SetCp(v)
}
if v, ok := req.URL.Get(); ok {
b.SetURL(v)
}
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
// Add all edges.
b.SetOwnerID(req.Owner)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
@ -106,18 +72,18 @@ func (h *OgentHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (Cre
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.Users.Query().Where(users.ID(e.ID))
q := h.client.Card.Query().Where(card.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUsersCreate(e), nil
return NewCardCreate(e), nil
}
// ReadUsers handles GET /users-slice/{id} requests.
func (h *OgentHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (ReadUsersRes, error) {
q := h.client.Users.Query().Where(users.IDEQ(params.ID))
// ReadCard handles GET /cards/{id} requests.
func (h *OgentHandler) ReadCard(ctx context.Context, params ReadCardParams) (ReadCardRes, error) {
q := h.client.Card.Query().Where(card.IDEQ(params.ID))
e, err := q.Only(ctx)
if err != nil {
switch {
@ -138,50 +104,17 @@ func (h *OgentHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (R
return nil, err
}
}
return NewUsersRead(e), nil
return NewCardRead(e), nil
}
// UpdateUsers handles PATCH /users-slice/{id} requests.
func (h *OgentHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (UpdateUsersRes, error) {
b := h.client.Users.UpdateOneID(params.ID)
// UpdateCard handles PATCH /cards/{id} requests.
func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, params UpdateCardParams) (UpdateCardRes, error) {
b := h.client.Card.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Hp.Get(); ok {
b.SetHp(v)
}
if v, ok := req.Attack.Get(); ok {
b.SetAttack(v)
}
if v, ok := req.Defense.Get(); ok {
b.SetDefense(v)
}
if v, ok := req.Critical.Get(); ok {
b.SetCritical(v)
}
if v, ok := req.Battle.Get(); ok {
b.SetBattle(v)
}
if v, ok := req.Win.Get(); ok {
b.SetWin(v)
}
if v, ok := req.Day.Get(); ok {
b.SetDay(v)
}
if v, ok := req.Percentage.Get(); ok {
b.SetPercentage(v)
}
if v, ok := req.Limit.Get(); ok {
b.SetLimit(v)
}
if v, ok := req.Comment.Get(); ok {
b.SetComment(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
// Add all edges.
if v, ok := req.Owner.Get(); ok {
b.SetOwnerID(v)
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
@ -204,18 +137,18 @@ func (h *OgentHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, para
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.Users.Query().Where(users.ID(e.ID))
q := h.client.Card.Query().Where(card.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUsersUpdate(e), nil
return NewCardUpdate(e), nil
}
// DeleteUsers handles DELETE /users-slice/{id} requests.
func (h *OgentHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams) (DeleteUsersRes, error) {
err := h.client.Users.DeleteOneID(params.ID).Exec(ctx)
// DeleteCard handles DELETE /cards/{id} requests.
func (h *OgentHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) {
err := h.client.Card.DeleteOneID(params.ID).Exec(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
@ -235,13 +168,13 @@ func (h *OgentHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams
return nil, err
}
}
return new(DeleteUsersNoContent), nil
return new(DeleteCardNoContent), nil
}
// ListUsers handles GET /users-slice requests.
func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error) {
q := h.client.Users.Query()
// ListCard handles GET /cards requests.
func (h *OgentHandler) ListCard(ctx context.Context, params ListCardParams) (ListCardRes, error) {
q := h.client.Card.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
@ -250,7 +183,9 @@ func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (L
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).All(ctx)
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
@ -270,5 +205,454 @@ func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (L
return nil, err
}
}
return ListUsersOKApplicationJSON(NewUsersLists(es)), nil
r := NewCardLists(es)
return (*ListCardOKApplicationJSON)(&r), nil
}
// ReadCardOwner handles GET /cards/{id}/owner requests.
func (h *OgentHandler) ReadCardOwner(ctx context.Context, params ReadCardOwnerParams) (ReadCardOwnerRes, error) {
q := h.client.Card.Query().Where(card.IDEQ(params.ID)).QueryOwner()
e, err := q.Only(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return NewCardOwnerRead(e), nil
}
// CreateGroup handles POST /groups requests.
func (h *OgentHandler) CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error) {
b := h.client.Group.Create()
// Add all fields.
b.SetName(req.Name)
// Add all edges.
b.AddUserIDs(req.Users...)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
switch {
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.Group.Query().Where(group.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewGroupCreate(e), nil
}
// ReadGroup handles GET /groups/{id} requests.
func (h *OgentHandler) ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error) {
q := h.client.Group.Query().Where(group.IDEQ(params.ID))
e, err := q.Only(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return NewGroupRead(e), nil
}
// UpdateGroup handles PATCH /groups/{id} requests.
func (h *OgentHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error) {
b := h.client.Group.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Name.Get(); ok {
b.SetName(v)
}
// Add all edges.
if req.Users != nil {
b.ClearUsers().AddUserIDs(req.Users...)
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.Group.Query().Where(group.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewGroupUpdate(e), nil
}
// DeleteGroup handles DELETE /groups/{id} requests.
func (h *OgentHandler) DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error) {
err := h.client.Group.DeleteOneID(params.ID).Exec(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return new(DeleteGroupNoContent), nil
}
// ListGroup handles GET /groups requests.
func (h *OgentHandler) ListGroup(ctx context.Context, params ListGroupParams) (ListGroupRes, error) {
q := h.client.Group.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewGroupLists(es)
return (*ListGroupOKApplicationJSON)(&r), nil
}
// ListGroupUsers handles GET /groups/{id}/users requests.
func (h *OgentHandler) ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error) {
q := h.client.Group.Query().Where(group.IDEQ(params.ID)).QueryUsers()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewGroupUsersLists(es)
return (*ListGroupUsersOKApplicationJSON)(&r), nil
}
// CreateUser handles POST /users requests.
func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) {
b := h.client.User.Create()
// Add all fields.
b.SetUsername(req.Username)
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
// Add all edges.
b.AddCardIDs(req.Card...)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
switch {
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.User.Query().Where(user.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUserCreate(e), nil
}
// ReadUser handles GET /users/{id} requests.
func (h *OgentHandler) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID))
e, err := q.Only(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return NewUserRead(e), nil
}
// UpdateUser handles PATCH /users/{id} requests.
func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) {
b := h.client.User.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
// Add all edges.
if req.Card != nil {
b.ClearCard().AddCardIDs(req.Card...)
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
// Reload the entity to attach all eager-loaded edges.
q := h.client.User.Query().Where(user.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUserUpdate(e), nil
}
// DeleteUser handles DELETE /users/{id} requests.
func (h *OgentHandler) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) {
err := h.client.User.DeleteOneID(params.ID).Exec(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsConstraintError(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return new(DeleteUserNoContent), nil
}
// ListUser handles GET /users requests.
func (h *OgentHandler) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) {
q := h.client.User.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewUserLists(es)
return (*ListUserOKApplicationJSON)(&r), nil
}
// ListUserCard handles GET /users/{id}/card requests.
func (h *OgentHandler) ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID)).QueryCard()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewUserCardLists(es)
return (*ListUserCardOKApplicationJSON)(&r), nil
}

510
ent/ogent/responses.go
View File

@ -1,185 +1,463 @@
// Code generated by entc, DO NOT EDIT.
// Code generated by ent, DO NOT EDIT.
package ogent
import "t/ent"
func NewUsersCreate(e *ent.Users) *UsersCreate {
func NewCardCreate(e *ent.Card) *CardCreate {
if e == nil {
return nil
}
return &UsersCreate{
ID: e.ID,
User: e.User,
Chara: NewOptString(e.Chara),
Skill: NewOptInt(e.Skill),
Hp: NewOptInt(e.Hp),
Attack: NewOptInt(e.Attack),
Defense: NewOptInt(e.Defense),
Critical: NewOptInt(e.Critical),
Battle: NewOptInt(e.Battle),
Win: NewOptInt(e.Win),
Day: NewOptInt(e.Day),
Percentage: NewOptFloat64(e.Percentage),
Limit: NewOptBool(e.Limit),
Status: NewOptString(e.Status),
Comment: NewOptString(e.Comment),
CreatedAt: NewOptDateTime(e.CreatedAt),
Next: NewOptString(e.Next),
UpdatedAt: NewOptDateTime(e.UpdatedAt),
URL: NewOptString(e.URL),
}
var ret CardCreate
ret.ID = e.ID
ret.Card = NewOptInt(e.Card)
ret.Status = NewOptString(e.Status)
ret.Cp = NewOptInt(e.Cp)
ret.URL = NewOptString(e.URL)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUsersCreates(es []*ent.Users) []UsersCreate {
func NewCardCreates(es []*ent.Card) []CardCreate {
if len(es) == 0 {
return nil
}
r := make([]UsersCreate, len(es))
r := make([]CardCreate, len(es))
for i, e := range es {
r[i] = NewUsersCreate(e).Elem()
r[i] = NewCardCreate(e).Elem()
}
return r
}
func (u *UsersCreate) Elem() UsersCreate {
if u != nil {
return UsersCreate{}
func (c *CardCreate) Elem() CardCreate {
if c == nil {
return CardCreate{}
}
return *u
return *c
}
func NewUsersList(e *ent.Users) *UsersList {
func NewCardList(e *ent.Card) *CardList {
if e == nil {
return nil
}
return &UsersList{
ID: e.ID,
User: e.User,
Chara: NewOptString(e.Chara),
Skill: NewOptInt(e.Skill),
Hp: NewOptInt(e.Hp),
Attack: NewOptInt(e.Attack),
Defense: NewOptInt(e.Defense),
Critical: NewOptInt(e.Critical),
Battle: NewOptInt(e.Battle),
Win: NewOptInt(e.Win),
Day: NewOptInt(e.Day),
Percentage: NewOptFloat64(e.Percentage),
Limit: NewOptBool(e.Limit),
Status: NewOptString(e.Status),
Comment: NewOptString(e.Comment),
CreatedAt: NewOptDateTime(e.CreatedAt),
Next: NewOptString(e.Next),
UpdatedAt: NewOptDateTime(e.UpdatedAt),
URL: NewOptString(e.URL),
}
var ret CardList
ret.ID = e.ID
ret.Card = NewOptInt(e.Card)
ret.Status = NewOptString(e.Status)
ret.Cp = NewOptInt(e.Cp)
ret.URL = NewOptString(e.URL)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUsersLists(es []*ent.Users) []UsersList {
func NewCardLists(es []*ent.Card) []CardList {
if len(es) == 0 {
return nil
}
r := make([]UsersList, len(es))
r := make([]CardList, len(es))
for i, e := range es {
r[i] = NewUsersList(e).Elem()
r[i] = NewCardList(e).Elem()
}
return r
}
func (u *UsersList) Elem() UsersList {
if u != nil {
return UsersList{}
func (c *CardList) Elem() CardList {
if c == nil {
return CardList{}
}
return *u
return *c
}
func NewUsersRead(e *ent.Users) *UsersRead {
func NewCardRead(e *ent.Card) *CardRead {
if e == nil {
return nil
}
return &UsersRead{
ID: e.ID,
User: e.User,
Chara: NewOptString(e.Chara),
Skill: NewOptInt(e.Skill),
Hp: NewOptInt(e.Hp),
Attack: NewOptInt(e.Attack),
Defense: NewOptInt(e.Defense),
Critical: NewOptInt(e.Critical),
Battle: NewOptInt(e.Battle),
Win: NewOptInt(e.Win),
Day: NewOptInt(e.Day),
Percentage: NewOptFloat64(e.Percentage),
Limit: NewOptBool(e.Limit),
Status: NewOptString(e.Status),
Comment: NewOptString(e.Comment),
CreatedAt: NewOptDateTime(e.CreatedAt),
Next: NewOptString(e.Next),
UpdatedAt: NewOptDateTime(e.UpdatedAt),
URL: NewOptString(e.URL),
}
var ret CardRead
ret.ID = e.ID
ret.Card = NewOptInt(e.Card)
ret.Status = NewOptString(e.Status)
ret.Cp = NewOptInt(e.Cp)
ret.URL = NewOptString(e.URL)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUsersReads(es []*ent.Users) []UsersRead {
func NewCardReads(es []*ent.Card) []CardRead {
if len(es) == 0 {
return nil
}
r := make([]UsersRead, len(es))
r := make([]CardRead, len(es))
for i, e := range es {
r[i] = NewUsersRead(e).Elem()
r[i] = NewCardRead(e).Elem()
}
return r
}
func (u *UsersRead) Elem() UsersRead {
if u != nil {
return UsersRead{}
func (c *CardRead) Elem() CardRead {
if c == nil {
return CardRead{}
}
return *u
return *c
}
func NewUsersUpdate(e *ent.Users) *UsersUpdate {
func NewCardUpdate(e *ent.Card) *CardUpdate {
if e == nil {
return nil
}
return &UsersUpdate{
ID: e.ID,
User: e.User,
Chara: NewOptString(e.Chara),
Skill: NewOptInt(e.Skill),
Hp: NewOptInt(e.Hp),
Attack: NewOptInt(e.Attack),
Defense: NewOptInt(e.Defense),
Critical: NewOptInt(e.Critical),
Battle: NewOptInt(e.Battle),
Win: NewOptInt(e.Win),
Day: NewOptInt(e.Day),
Percentage: NewOptFloat64(e.Percentage),
Limit: NewOptBool(e.Limit),
Status: NewOptString(e.Status),
Comment: NewOptString(e.Comment),
CreatedAt: NewOptDateTime(e.CreatedAt),
Next: NewOptString(e.Next),
UpdatedAt: NewOptDateTime(e.UpdatedAt),
URL: NewOptString(e.URL),
}
var ret CardUpdate
ret.ID = e.ID
ret.Card = NewOptInt(e.Card)
ret.Status = NewOptString(e.Status)
ret.Cp = NewOptInt(e.Cp)
ret.URL = NewOptString(e.URL)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUsersUpdates(es []*ent.Users) []UsersUpdate {
func NewCardUpdates(es []*ent.Card) []CardUpdate {
if len(es) == 0 {
return nil
}
r := make([]UsersUpdate, len(es))
r := make([]CardUpdate, len(es))
for i, e := range es {
r[i] = NewUsersUpdate(e).Elem()
r[i] = NewCardUpdate(e).Elem()
}
return r
}
func (u *UsersUpdate) Elem() UsersUpdate {
if u != nil {
return UsersUpdate{}
func (c *CardUpdate) Elem() CardUpdate {
if c == nil {
return CardUpdate{}
}
return *c
}
func NewCardOwnerRead(e *ent.User) *CardOwnerRead {
if e == nil {
return nil
}
var ret CardOwnerRead
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewCardOwnerReads(es []*ent.User) []CardOwnerRead {
if len(es) == 0 {
return nil
}
r := make([]CardOwnerRead, len(es))
for i, e := range es {
r[i] = NewCardOwnerRead(e).Elem()
}
return r
}
func (u *CardOwnerRead) Elem() CardOwnerRead {
if u == nil {
return CardOwnerRead{}
}
return *u
}
func NewGroupCreate(e *ent.Group) *GroupCreate {
if e == nil {
return nil
}
var ret GroupCreate
ret.ID = e.ID
ret.Name = e.Name
return &ret
}
func NewGroupCreates(es []*ent.Group) []GroupCreate {
if len(es) == 0 {
return nil
}
r := make([]GroupCreate, len(es))
for i, e := range es {
r[i] = NewGroupCreate(e).Elem()
}
return r
}
func (gr *GroupCreate) Elem() GroupCreate {
if gr == nil {
return GroupCreate{}
}
return *gr
}
func NewGroupList(e *ent.Group) *GroupList {
if e == nil {
return nil
}
var ret GroupList
ret.ID = e.ID
ret.Name = e.Name
return &ret
}
func NewGroupLists(es []*ent.Group) []GroupList {
if len(es) == 0 {
return nil
}
r := make([]GroupList, len(es))
for i, e := range es {
r[i] = NewGroupList(e).Elem()
}
return r
}
func (gr *GroupList) Elem() GroupList {
if gr == nil {
return GroupList{}
}
return *gr
}
func NewGroupRead(e *ent.Group) *GroupRead {
if e == nil {
return nil
}
var ret GroupRead
ret.ID = e.ID
ret.Name = e.Name
return &ret
}
func NewGroupReads(es []*ent.Group) []GroupRead {
if len(es) == 0 {
return nil
}
r := make([]GroupRead, len(es))
for i, e := range es {
r[i] = NewGroupRead(e).Elem()
}
return r
}
func (gr *GroupRead) Elem() GroupRead {
if gr == nil {
return GroupRead{}
}
return *gr
}
func NewGroupUpdate(e *ent.Group) *GroupUpdate {
if e == nil {
return nil
}
var ret GroupUpdate
ret.ID = e.ID
ret.Name = e.Name
return &ret
}
func NewGroupUpdates(es []*ent.Group) []GroupUpdate {
if len(es) == 0 {
return nil
}
r := make([]GroupUpdate, len(es))
for i, e := range es {
r[i] = NewGroupUpdate(e).Elem()
}
return r
}
func (gr *GroupUpdate) Elem() GroupUpdate {
if gr == nil {
return GroupUpdate{}
}
return *gr
}
func NewGroupUsersList(e *ent.User) *GroupUsersList {
if e == nil {
return nil
}
var ret GroupUsersList
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewGroupUsersLists(es []*ent.User) []GroupUsersList {
if len(es) == 0 {
return nil
}
r := make([]GroupUsersList, len(es))
for i, e := range es {
r[i] = NewGroupUsersList(e).Elem()
}
return r
}
func (u *GroupUsersList) Elem() GroupUsersList {
if u == nil {
return GroupUsersList{}
}
return *u
}
func NewUserCreate(e *ent.User) *UserCreate {
if e == nil {
return nil
}
var ret UserCreate
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewUserCreates(es []*ent.User) []UserCreate {
if len(es) == 0 {
return nil
}
r := make([]UserCreate, len(es))
for i, e := range es {
r[i] = NewUserCreate(e).Elem()
}
return r
}
func (u *UserCreate) Elem() UserCreate {
if u == nil {
return UserCreate{}
}
return *u
}
func NewUserList(e *ent.User) *UserList {
if e == nil {
return nil
}
var ret UserList
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewUserLists(es []*ent.User) []UserList {
if len(es) == 0 {
return nil
}
r := make([]UserList, len(es))
for i, e := range es {
r[i] = NewUserList(e).Elem()
}
return r
}
func (u *UserList) Elem() UserList {
if u == nil {
return UserList{}
}
return *u
}
func NewUserRead(e *ent.User) *UserRead {
if e == nil {
return nil
}
var ret UserRead
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewUserReads(es []*ent.User) []UserRead {
if len(es) == 0 {
return nil
}
r := make([]UserRead, len(es))
for i, e := range es {
r[i] = NewUserRead(e).Elem()
}
return r
}
func (u *UserRead) Elem() UserRead {
if u == nil {
return UserRead{}
}
return *u
}
func NewUserUpdate(e *ent.User) *UserUpdate {
if e == nil {
return nil
}
var ret UserUpdate
ret.ID = e.ID
ret.Username = e.Username
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.Next = NewOptString(e.Next)
return &ret
}
func NewUserUpdates(es []*ent.User) []UserUpdate {
if len(es) == 0 {
return nil
}
r := make([]UserUpdate, len(es))
for i, e := range es {
r[i] = NewUserUpdate(e).Elem()
}
return r
}
func (u *UserUpdate) Elem() UserUpdate {
if u == nil {
return UserUpdate{}
}
return *u
}
func NewUserCardList(e *ent.Card) *UserCardList {
if e == nil {
return nil
}
var ret UserCardList
ret.ID = e.ID
ret.Card = NewOptInt(e.Card)
ret.Status = NewOptString(e.Status)
ret.Cp = NewOptInt(e.Cp)
ret.URL = NewOptString(e.URL)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUserCardLists(es []*ent.Card) []UserCardList {
if len(es) == 0 {
return nil
}
r := make([]UserCardList, len(es))
for i, e := range es {
r[i] = NewUserCardList(e).Elem()
}
return r
}
func (c *UserCardList) Elem() UserCardList {
if c == nil {
return UserCardList{}
}
return *c
}