ai/api
1
0
Fork 0
Code Activity

first

Browse Source
This commit is contained in:
syui
2022-08-31 15:18:14 +09:00
commit d40e30944b
61 changed files with 21400 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
ent/ogent/oas_cfg_gen.go Normal file
View File

@ -0,0 +1,165 @@
// 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
)
// bufPool is pool of bytes.Buffer for encoding and decoding.
var bufPool = &sync.Pool{
New: func() interface{} {
return new(bytes.Buffer)
},
}
// 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 {
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,
}
for _, opt := range opts {
opt.apply(&cfg)
}
cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
trace.WithInstrumentationVersion(otelogen.SemVersion()),
)
cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name)
return cfg
}
type Option interface {
apply(*config)
}
type optionFunc func(*config)
func (o optionFunc) apply(c *config) {
o(c)
}
// 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) {
if provider != nil {
cfg.TracerProvider = provider
}
})
}
// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the metric.NewNoopMeterProvider is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
return optionFunc(func(cfg *config) {
if provider != nil {
cfg.MeterProvider = provider
}
})
}
// WithClient specifies http client to use.
func WithClient(client ht.Client) Option {
return optionFunc(func(cfg *config) {
if client != nil {
cfg.Client = client
}
})
}
// WithNotFound specifies http handler to use.
func WithNotFound(notFound http.HandlerFunc) Option {
return optionFunc(func(cfg *config) {
if notFound != nil {
cfg.NotFound = notFound
}
})
}

564
ent/ogent/oas_client_gen.go Normal file
View File

@ -0,0 +1,564 @@
// 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
)
// Client implements OAS client.
type Client struct {
serverURL *url.URL
cfg config
requests metric.Int64Counter
errors metric.Int64Counter
duration metric.Int64Histogram
}
// NewClient initializes new Client defined by OAS.
func NewClient(serverURL string, opts ...Option) (*Client, error) {
u, err := url.Parse(serverURL)
if err != nil {
return nil, err
}
c := &Client{
cfg: newConfig(opts...),
serverURL: u,
}
if c.requests, err = c.cfg.Meter.NewInt64Counter(otelogen.ClientRequestCount); err != nil {
return nil, err
}
if c.errors, err = c.cfg.Meter.NewInt64Counter(otelogen.ClientErrorsCount); err != nil {
return nil, err
}
if c.duration, err = c.cfg.Meter.NewInt64Histogram(otelogen.ClientDuration); err != nil {
return nil, err
}
return c, nil
}
// CreateUsers invokes createUsers operation.
//
// Creates a new Users and persists it to storage.
//
// POST /users
func (c *Client) CreateUsers(ctx context.Context, request CreateUsersReq) (res CreateUsersRes, err error) {
if err := func() error {
if err := request.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "validate")
}
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createUsers"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "CreateUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
var (
contentType string
reqBody io.Reader
)
contentType = "application/json"
buf, err := encodeCreateUsersRequestJSON(request, span)
if err != nil {
return res, err
}
defer jx.PutEncoder(buf)
reqBody = bytes.NewReader(buf.Bytes())
u := uri.Clone(c.serverURL)
u.Path += "/users"
r := ht.NewRequest(ctx, "POST", u, reqBody)
defer ht.PutRequest(r)
r.Header.Set("Content-Type", contentType)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeCreateUsersResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// DeleteUsers invokes deleteUsers operation.
//
// Deletes the Users with the requested ID.
//
// DELETE /users/{id}
func (c *Client) DeleteUsers(ctx context.Context, params DeleteUsersParams) (res DeleteUsersRes, err error) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteUsers"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "DeleteUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
u := uri.Clone(c.serverURL)
u.Path += "/users/"
{
// Encode "id" parameter.
e := uri.NewPathEncoder(uri.PathEncoderConfig{
Param: "id",
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
return e.EncodeValue(conv.IntToString(params.ID))
}(); err != nil {
return res, errors.Wrap(err, "encode path")
}
u.Path += e.Result()
}
r := ht.NewRequest(ctx, "DELETE", u, nil)
defer ht.PutRequest(r)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeDeleteUsersResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// DrawDone invokes drawDone operation.
//
// PUT /users/{id}/d
func (c *Client) DrawDone(ctx context.Context, params DrawDoneParams) (res DrawDoneNoContent, err error) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("drawDone"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "DrawDone",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
u := uri.Clone(c.serverURL)
u.Path += "/users/"
{
// Encode "id" parameter.
e := uri.NewPathEncoder(uri.PathEncoderConfig{
Param: "id",
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
return e.EncodeValue(conv.IntToString(params.ID))
}(); err != nil {
return res, errors.Wrap(err, "encode path")
}
u.Path += e.Result()
}
u.Path += "/d"
r := ht.NewRequest(ctx, "PUT", u, nil)
defer ht.PutRequest(r)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeDrawDoneResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// DrawStart invokes drawStart operation.
//
// PATCH /users/{id}/start
func (c *Client) DrawStart(ctx context.Context, params DrawStartParams) (res DrawStartNoContent, err error) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("drawStart"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "DrawStart",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
u := uri.Clone(c.serverURL)
u.Path += "/users/"
{
// Encode "id" parameter.
e := uri.NewPathEncoder(uri.PathEncoderConfig{
Param: "id",
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
return e.EncodeValue(conv.IntToString(params.ID))
}(); err != nil {
return res, errors.Wrap(err, "encode path")
}
u.Path += e.Result()
}
u.Path += "/start"
r := ht.NewRequest(ctx, "PATCH", u, nil)
defer ht.PutRequest(r)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeDrawStartResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ListUsers invokes listUsers operation.
//
// List Users.
//
// GET /users
func (c *Client) ListUsers(ctx context.Context, params ListUsersParams) (res ListUsersRes, err error) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUsers"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "ListUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
u := uri.Clone(c.serverURL)
u.Path += "/users"
q := u.Query()
{
// Encode "page" parameter.
e := uri.NewQueryEncoder(uri.QueryEncoderConfig{
Style: uri.QueryStyleForm,
Explode: true,
})
if err := func() error {
if val, ok := params.Page.Get(); ok {
return e.EncodeValue(conv.IntToString(val))
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "encode query")
}
q["page"] = e.Result()
}
{
// Encode "itemsPerPage" parameter.
e := uri.NewQueryEncoder(uri.QueryEncoderConfig{
Style: uri.QueryStyleForm,
Explode: true,
})
if err := func() error {
if val, ok := params.ItemsPerPage.Get(); ok {
return e.EncodeValue(conv.IntToString(val))
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "encode query")
}
q["itemsPerPage"] = e.Result()
}
u.RawQuery = q.Encode()
r := ht.NewRequest(ctx, "GET", u, nil)
defer ht.PutRequest(r)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeListUsersResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ReadUsers invokes readUsers operation.
//
// Finds the Users with the requested ID and returns it.
//
// GET /users/{id}
func (c *Client) ReadUsers(ctx context.Context, params ReadUsersParams) (res ReadUsersRes, err error) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readUsers"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "ReadUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
u := uri.Clone(c.serverURL)
u.Path += "/users/"
{
// Encode "id" parameter.
e := uri.NewPathEncoder(uri.PathEncoderConfig{
Param: "id",
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
return e.EncodeValue(conv.IntToString(params.ID))
}(); err != nil {
return res, errors.Wrap(err, "encode path")
}
u.Path += e.Result()
}
r := ht.NewRequest(ctx, "GET", u, nil)
defer ht.PutRequest(r)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeReadUsersResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// UpdateUsers invokes updateUsers operation.
//
// Updates a Users and persists changes to storage.
//
// PATCH /users/{id}
func (c *Client) UpdateUsers(ctx context.Context, request UpdateUsersReq, params UpdateUsersParams) (res UpdateUsersRes, err error) {
if err := func() error {
if err := request.Validate(); err != nil {
return err
}
return nil
}(); err != nil {
return res, errors.Wrap(err, "validate")
}
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateUsers"),
}
ctx, span := c.cfg.Tracer.Start(ctx, "UpdateUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindClient),
)
defer func() {
if err != nil {
span.RecordError(err)
c.errors.Add(ctx, 1, otelAttrs...)
} else {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
span.End()
}()
c.requests.Add(ctx, 1, otelAttrs...)
var (
contentType string
reqBody io.Reader
)
contentType = "application/json"
buf, err := encodeUpdateUsersRequestJSON(request, span)
if err != nil {
return res, err
}
defer jx.PutEncoder(buf)
reqBody = bytes.NewReader(buf.Bytes())
u := uri.Clone(c.serverURL)
u.Path += "/users/"
{
// Encode "id" parameter.
e := uri.NewPathEncoder(uri.PathEncoderConfig{
Param: "id",
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
return e.EncodeValue(conv.IntToString(params.ID))
}(); err != nil {
return res, errors.Wrap(err, "encode path")
}
u.Path += e.Result()
}
r := ht.NewRequest(ctx, "PATCH", u, reqBody)
defer ht.PutRequest(r)
r.Header.Set("Content-Type", contentType)
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
result, err := decodeUpdateUsersResponse(resp, span)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}

71
ent/ogent/oas_defaults_gen.go Normal file
View File

@ -0,0 +1,71 @@
// 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
)

390
ent/ogent/oas_handlers_gen.go Normal file
View File

@ -0,0 +1,390 @@
// 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
)
// HandleCreateUsersRequest handles createUsers operation.
//
// POST /users
func (s *Server) handleCreateUsersRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createUsers"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
request, err := decodeCreateUsersRequest(r, span)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.CreateUsers(ctx, request)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeCreateUsersResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleDeleteUsersRequest handles deleteUsers operation.
//
// DELETE /users/{id}
func (s *Server) handleDeleteUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteUsers"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeDeleteUsersParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.DeleteUsers(ctx, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeDeleteUsersResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleDrawDoneRequest handles drawDone operation.
//
// PUT /users/{id}/d
func (s *Server) handleDrawDoneRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("drawDone"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "DrawDone",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeDrawDoneParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.DrawDone(ctx, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeDrawDoneResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleDrawStartRequest handles drawStart operation.
//
// PATCH /users/{id}/start
func (s *Server) handleDrawStartRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("drawStart"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "DrawStart",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeDrawStartParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.DrawStart(ctx, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeDrawStartResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleListUsersRequest handles listUsers operation.
//
// GET /users
func (s *Server) handleListUsersRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUsers"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeListUsersParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.ListUsers(ctx, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeListUsersResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleReadUsersRequest handles readUsers operation.
//
// GET /users/{id}
func (s *Server) handleReadUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readUsers"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeReadUsersParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.ReadUsers(ctx, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeReadUsersResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
// HandleUpdateUsersRequest handles updateUsers operation.
//
// PATCH /users/{id}
func (s *Server) handleUpdateUsersRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
startTime := time.Now()
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateUsers"),
}
ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateUsers",
trace.WithAttributes(otelAttrs...),
trace.WithSpanKind(trace.SpanKindServer),
)
s.requests.Add(ctx, 1, otelAttrs...)
defer span.End()
var err error
params, err := decodeUpdateUsersParams(args, r)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
request, err := decodeUpdateUsersRequest(r, span)
if err != nil {
s.badRequest(ctx, w, span, otelAttrs, err)
return
}
response, err := s.h.UpdateUsers(ctx, request, params)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Internal")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusInternalServerError, err)
return
}
if err := encodeUpdateUsersResponse(response, w, span); err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, "Response")
s.errors.Add(ctx, 1, otelAttrs...)
return
}
span.SetStatus(codes.Ok, "Ok")
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}
func (s *Server) badRequest(ctx context.Context, w http.ResponseWriter, span trace.Span, otelAttrs []attribute.KeyValue, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, "BadRequest")
s.errors.Add(ctx, 1, otelAttrs...)
respondError(w, http.StatusBadRequest, err)
}
func respondError(w http.ResponseWriter, code int, err error) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
data, writeErr := json.Marshal(struct {
ErrorMessage string `json:"error_message"`
}{
ErrorMessage: err.Error(),
})
if writeErr == nil {
w.Write(data)
}
}

22
ent/ogent/oas_interfaces_gen.go Normal file
View File

@ -0,0 +1,22 @@
// Code generated by ogen, DO NOT EDIT.
package ogent
type CreateUsersRes interface {
createUsersRes()
}
type DeleteUsersRes interface {
deleteUsersRes()
}
type ListUsersRes interface {
listUsersRes()
}
type ReadUsersRes interface {
readUsersRes()
}
type UpdateUsersRes interface {
updateUsersRes()
}

2885
ent/ogent/oas_json_gen.go Normal file
View File

File diff suppressed because it is too large Load Diff

339
ent/ogent/oas_param_dec_gen.go Normal file
View File

@ -0,0 +1,339 @@
// 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 Normal file
View File

@ -0,0 +1,101 @@
// 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
}

159
ent/ogent/oas_req_dec_gen.go Normal file
View File

@ -0,0 +1,159 @@
// 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 Normal file
View File

@ -0,0 +1,87 @@
// 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
}

747
ent/ogent/oas_res_dec_gen.go Normal file
View File

@ -0,0 +1,747 @@
// 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 Normal file
View File

@ -0,0 +1,395 @@
// 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)
}
}

467
ent/ogent/oas_router_gen.go Normal file
View File

@ -0,0 +1,467 @@
// 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 (s *Server) notFound(w http.ResponseWriter, r *http.Request) {
s.cfg.NotFound(w, r)
}
// ServeHTTP serves http request as defined by OpenAPI v3 specification,
// calling handler that matches the path or returning not found error.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
elem := r.URL.Path
if len(elem) == 0 {
s.notFound(w, r)
return
}
args := [1]string{}
// Static code generated router with unwrapped path search.
switch r.Method {
case "DELETE":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Leaf parameter
args[0] = elem
elem = ""
if len(elem) == 0 {
// Leaf: DeleteUsers
s.handleDeleteUsersRequest([1]string{
args[0],
}, w, r)
return
}
}
case "GET":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users"
if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
s.handleListUsersRequest([0]string{}, w, r)
return
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Leaf parameter
args[0] = elem
elem = ""
if len(elem) == 0 {
// Leaf: ReadUsers
s.handleReadUsersRequest([1]string{
args[0],
}, w, r)
return
}
}
}
case "PATCH":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
s.handleUpdateUsersRequest([1]string{
args[0],
}, w, r)
return
}
switch elem[0] {
case '/': // Prefix: "/start"
if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: DrawStart
s.handleDrawStartRequest([1]string{
args[0],
}, w, r)
return
}
}
}
case "POST":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users"
if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: CreateUsers
s.handleCreateUsersRequest([0]string{}, w, r)
return
}
}
case "PUT":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/d"
if l := len("/d"); len(elem) >= l && elem[0:l] == "/d" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: DrawDone
s.handleDrawDoneRequest([1]string{
args[0],
}, w, r)
return
}
}
}
}
s.notFound(w, r)
}
// Route is route object.
type Route struct {
name string
count int
args [1]string
}
// OperationID returns OpenAPI operationId.
func (r Route) OperationID() string {
return r.name
}
// Args returns parsed arguments.
func (r Route) Args() []string {
return r.args[:r.count]
}
// FindRoute finds Route for given method and path.
func (s *Server) FindRoute(method, path string) (r Route, _ bool) {
var (
args = [1]string{}
elem = path
)
r.args = args
if elem == "" {
return r, false
}
// Static code generated router with unwrapped path search.
switch method {
case "DELETE":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Leaf parameter
args[0] = elem
elem = ""
if len(elem) == 0 {
// Leaf: DeleteUsers
r.name = "DeleteUsers"
r.args = args
r.count = 1
return r, true
}
}
case "GET":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users"
if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
r.name = "ListUsers"
r.args = args
r.count = 0
return r, true
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Leaf parameter
args[0] = elem
elem = ""
if len(elem) == 0 {
// Leaf: ReadUsers
r.name = "ReadUsers"
r.args = args
r.count = 1
return r, true
}
}
}
case "PATCH":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
r.name = "UpdateUsers"
r.args = args
r.count = 1
return r, true
}
switch elem[0] {
case '/': // Prefix: "/start"
if l := len("/start"); len(elem) >= l && elem[0:l] == "/start" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: DrawStart
r.name = "DrawStart"
r.args = args
r.count = 1
return r, true
}
}
}
case "POST":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users"
if l := len("/users"); len(elem) >= l && elem[0:l] == "/users" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: CreateUsers
r.name = "CreateUsers"
r.args = args
r.count = 0
return r, true
}
}
case "PUT":
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/users/"
if l := len("/users/"); len(elem) >= l && elem[0:l] == "/users/" {
elem = elem[l:]
} else {
break
}
// Param: "id"
// Match until "/"
idx := strings.IndexByte(elem, '/')
if idx < 0 {
idx = len(elem)
}
args[0] = elem[:idx]
elem = elem[idx:]
if len(elem) == 0 {
break
}
switch elem[0] {
case '/': // Prefix: "/d"
if l := len("/d"); len(elem) >= l && elem[0:l] == "/d" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf: DrawDone
r.name = "DrawDone"
r.args = args
r.count = 1
return r, true
}
}
}
}
return r, false
}

497
ent/ogent/oas_schemas_gen.go Normal file
View File

@ -0,0 +1,497 @@
// 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 CreateUsersReq struct {
User string "json:\"user\""
Chara OptString "json:\"chara\""
Skill OptInt "json:\"skill\""
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Status OptString "json:\"status\""
Comment OptString "json:\"comment\""
CreatedAt OptDateTime "json:\"created_at\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
URL OptString "json:\"url\""
}
// DeleteUsersNoContent is response for DeleteUsers operation.
type DeleteUsersNoContent struct{}
func (*DeleteUsersNoContent) deleteUsersRes() {}
// DrawDoneNoContent is response for DrawDone operation.
type DrawDoneNoContent struct{}
// DrawStartNoContent is response for DrawStart operation.
type DrawStartNoContent struct{}
type ListUsersOKApplicationJSON []UsersList
func (ListUsersOKApplicationJSON) listUsersRes() {}
// NewOptBool returns new OptBool with value set to v.
func NewOptBool(v bool) OptBool {
return OptBool{
Value: v,
Set: true,
}
}
// OptBool is optional bool.
type OptBool struct {
Value bool
Set bool
}
// IsSet returns true if OptBool was set.
func (o OptBool) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptBool) Reset() {
var v bool
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptBool) SetTo(v bool) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptBool) Get() (v bool, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptBool) Or(d bool) bool {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptDateTime returns new OptDateTime with value set to v.
func NewOptDateTime(v time.Time) OptDateTime {
return OptDateTime{
Value: v,
Set: true,
}
}
// OptDateTime is optional time.Time.
type OptDateTime struct {
Value time.Time
Set bool
}
// IsSet returns true if OptDateTime was set.
func (o OptDateTime) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptDateTime) Reset() {
var v time.Time
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptDateTime) SetTo(v time.Time) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptDateTime) Get() (v time.Time, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptDateTime) Or(d time.Time) time.Time {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptFloat64 returns new OptFloat64 with value set to v.
func NewOptFloat64(v float64) OptFloat64 {
return OptFloat64{
Value: v,
Set: true,
}
}
// OptFloat64 is optional float64.
type OptFloat64 struct {
Value float64
Set bool
}
// IsSet returns true if OptFloat64 was set.
func (o OptFloat64) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptFloat64) Reset() {
var v float64
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptFloat64) SetTo(v float64) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptFloat64) Get() (v float64, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptFloat64) Or(d float64) float64 {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptInt returns new OptInt with value set to v.
func NewOptInt(v int) OptInt {
return OptInt{
Value: v,
Set: true,
}
}
// OptInt is optional int.
type OptInt struct {
Value int
Set bool
}
// IsSet returns true if OptInt was set.
func (o OptInt) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptInt) Reset() {
var v int
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptInt) SetTo(v int) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptInt) Get() (v int, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptInt) Or(d int) int {
if v, ok := o.Get(); ok {
return v
}
return d
}
// NewOptString returns new OptString with value set to v.
func NewOptString(v string) OptString {
return OptString{
Value: v,
Set: true,
}
}
// OptString is optional string.
type OptString struct {
Value string
Set bool
}
// IsSet returns true if OptString was set.
func (o OptString) IsSet() bool { return o.Set }
// Reset unsets value.
func (o *OptString) Reset() {
var v string
o.Value = v
o.Set = false
}
// SetTo sets value to v.
func (o *OptString) SetTo(v string) {
o.Set = true
o.Value = v
}
// Get returns value and boolean that denotes whether value was set.
func (o OptString) Get() (v string, ok bool) {
if !o.Set {
return v, false
}
return o.Value, true
}
// Or returns value if set, or given parameter if does not.
func (o OptString) Or(d string) string {
if v, ok := o.Get(); ok {
return v
}
return d
}
type R400 struct {
Code int "json:\"code\""
Status string "json:\"status\""
Errors jx.Raw "json:\"errors\""
}
func (*R400) createUsersRes() {}
func (*R400) deleteUsersRes() {}
func (*R400) listUsersRes() {}
func (*R400) readUsersRes() {}
func (*R400) updateUsersRes() {}
type R404 struct {
Code int "json:\"code\""
Status string "json:\"status\""
Errors jx.Raw "json:\"errors\""
}
func (*R404) deleteUsersRes() {}
func (*R404) listUsersRes() {}
func (*R404) readUsersRes() {}
func (*R404) updateUsersRes() {}
type R409 struct {
Code int "json:\"code\""
Status string "json:\"status\""
Errors jx.Raw "json:\"errors\""
}
func (*R409) createUsersRes() {}
func (*R409) deleteUsersRes() {}
func (*R409) listUsersRes() {}
func (*R409) readUsersRes() {}
func (*R409) updateUsersRes() {}
type R500 struct {
Code int "json:\"code\""
Status string "json:\"status\""
Errors jx.Raw "json:\"errors\""
}
func (*R500) createUsersRes() {}
func (*R500) deleteUsersRes() {}
func (*R500) listUsersRes() {}
func (*R500) readUsersRes() {}
func (*R500) updateUsersRes() {}
type UpdateUsersReq struct {
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Comment OptString "json:\"comment\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
}
// Ref: #/components/schemas/UsersCreate
type UsersCreate struct {
ID int "json:\"id\""
User string "json:\"user\""
Chara OptString "json:\"chara\""
Skill OptInt "json:\"skill\""
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Status OptString "json:\"status\""
Comment OptString "json:\"comment\""
CreatedAt OptDateTime "json:\"created_at\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
URL OptString "json:\"url\""
}
func (*UsersCreate) createUsersRes() {}
// Ref: #/components/schemas/UsersList
type UsersList struct {
ID int "json:\"id\""
User string "json:\"user\""
Chara OptString "json:\"chara\""
Skill OptInt "json:\"skill\""
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Status OptString "json:\"status\""
Comment OptString "json:\"comment\""
CreatedAt OptDateTime "json:\"created_at\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
URL OptString "json:\"url\""
}
// Ref: #/components/schemas/UsersRead
type UsersRead struct {
ID int "json:\"id\""
User string "json:\"user\""
Chara OptString "json:\"chara\""
Skill OptInt "json:\"skill\""
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Status OptString "json:\"status\""
Comment OptString "json:\"comment\""
CreatedAt OptDateTime "json:\"created_at\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
URL OptString "json:\"url\""
}
func (*UsersRead) readUsersRes() {}
// Ref: #/components/schemas/UsersUpdate
type UsersUpdate struct {
ID int "json:\"id\""
User string "json:\"user\""
Chara OptString "json:\"chara\""
Skill OptInt "json:\"skill\""
Hp OptInt "json:\"hp\""
Attack OptInt "json:\"attack\""
Defense OptInt "json:\"defense\""
Critical OptInt "json:\"critical\""
Battle OptInt "json:\"battle\""
Win OptInt "json:\"win\""
Day OptInt "json:\"day\""
Percentage OptFloat64 "json:\"percentage\""
Limit OptBool "json:\"limit\""
Status OptString "json:\"status\""
Comment OptString "json:\"comment\""
CreatedAt OptDateTime "json:\"created_at\""
Next OptString "json:\"next\""
UpdatedAt OptDateTime "json:\"updated_at\""
URL OptString "json:\"url\""
}
func (*UsersUpdate) updateUsersRes() {}

71
ent/ogent/oas_security_gen.go Normal file
View File

@ -0,0 +1,71 @@
// 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
)

142
ent/ogent/oas_server_gen.go Normal file
View File

@ -0,0 +1,142 @@
// 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
)
// Handler handles operations described by OpenAPI v3 specification.
type Handler interface {
// CreateUsers implements createUsers operation.
//
// Creates a new Users and persists it to storage.
//
// POST /users
CreateUsers(ctx context.Context, req CreateUsersReq) (CreateUsersRes, error)
// DeleteUsers implements deleteUsers operation.
//
// Deletes the Users with the requested ID.
//
// DELETE /users/{id}
DeleteUsers(ctx context.Context, params DeleteUsersParams) (DeleteUsersRes, error)
// DrawDone implements drawDone operation.
//
// PUT /users/{id}/d
DrawDone(ctx context.Context, params DrawDoneParams) (DrawDoneNoContent, error)
// DrawStart implements drawStart operation.
//
// PATCH /users/{id}/start
DrawStart(ctx context.Context, params DrawStartParams) (DrawStartNoContent, error)
// ListUsers implements listUsers operation.
//
// List Users.
//
// GET /users
ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error)
// ReadUsers implements readUsers operation.
//
// Finds the Users with the requested ID and returns it.
//
// GET /users/{id}
ReadUsers(ctx context.Context, params ReadUsersParams) (ReadUsersRes, error)
// UpdateUsers implements updateUsers operation.
//
// Updates a Users and persists changes to storage.
//
// PATCH /users/{id}
UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (UpdateUsersRes, 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
}
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 {
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
}

135
ent/ogent/oas_unimplemented_gen.go Normal file
View File

@ -0,0 +1,135 @@
// 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
)
var _ Handler = UnimplementedHandler{}
// UnimplementedHandler is no-op Handler which returns http.ErrNotImplemented.
type UnimplementedHandler struct{}
// CreateUsers implements createUsers operation.
//
// Creates a new Users and persists it to storage.
//
// POST /users
func (UnimplementedHandler) CreateUsers(ctx context.Context, req CreateUsersReq) (r CreateUsersRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUsers implements deleteUsers operation.
//
// Deletes the Users with the requested ID.
//
// DELETE /users/{id}
func (UnimplementedHandler) DeleteUsers(ctx context.Context, params DeleteUsersParams) (r DeleteUsersRes, _ 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
}
// DrawStart implements drawStart operation.
//
// PATCH /users/{id}/start
func (UnimplementedHandler) DrawStart(ctx context.Context, params DrawStartParams) (r DrawStartNoContent, _ error) {
return r, ht.ErrNotImplemented
}
// ListUsers implements listUsers operation.
//
// List Users.
//
// GET /users
func (UnimplementedHandler) ListUsers(ctx context.Context, params ListUsersParams) (r ListUsersRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUsers implements readUsers operation.
//
// Finds the Users with the requested ID and returns it.
//
// GET /users/{id}
func (UnimplementedHandler) ReadUsers(ctx context.Context, params ReadUsersParams) (r ReadUsersRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateUsers implements updateUsers operation.
//
// Updates a Users and persists changes to storage.
//
// PATCH /users/{id}
func (UnimplementedHandler) UpdateUsers(ctx context.Context, req UpdateUsersReq, params UpdateUsersParams) (r UpdateUsersRes, _ error) {
return r, ht.ErrNotImplemented
}

252
ent/ogent/oas_validators_gen.go Normal file
View File

@ -0,0 +1,252 @@
// 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 (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 {
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 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}
}
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}
}
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}
}
return nil
}

274
ent/ogent/ogent.go Normal file
View File

@ -0,0 +1,274 @@
// Code generated by entc, DO NOT EDIT.
package ogent
import (
"context"
"net/http"
"t/ent"
"t/ent/users"
"github.com/go-faster/jx"
)
// OgentHandler implements the ogen generated Handler interface and uses Ent as data layer.
type OgentHandler struct {
client *ent.Client
}
// NewOgentHandler returns a new OgentHandler.
func NewOgentHandler(c *ent.Client) *OgentHandler { return &OgentHandler{c} }
// rawError renders err as json string.
func rawError(err error) jx.Raw {
var e jx.Encoder
e.Str(err.Error())
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()
// 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.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.URL.Get(); ok {
b.SetURL(v)
}
// Add all edges.
// 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.Users.Query().Where(users.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUsersCreate(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))
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 NewUsersRead(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)
// 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.
// 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.Users.Query().Where(users.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewUsersUpdate(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)
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(DeleteUsersNoContent), nil
}
// ListUsers handles GET /users-slice requests.
func (h *OgentHandler) ListUsers(ctx context.Context, params ListUsersParams) (ListUsersRes, error) {
q := h.client.Users.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
es, err := q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage).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
}
}
return ListUsersOKApplicationJSON(NewUsersLists(es)), nil
}

185
ent/ogent/responses.go Normal file
View File

@ -0,0 +1,185 @@
// Code generated by entc, DO NOT EDIT.
package ogent
import "t/ent"
func NewUsersCreate(e *ent.Users) *UsersCreate {
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),
}
}
func NewUsersCreates(es []*ent.Users) []UsersCreate {
if len(es) == 0 {
return nil
}
r := make([]UsersCreate, len(es))
for i, e := range es {
r[i] = NewUsersCreate(e).Elem()
}
return r
}
func (u *UsersCreate) Elem() UsersCreate {
if u != nil {
return UsersCreate{}
}
return *u
}
func NewUsersList(e *ent.Users) *UsersList {
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),
}
}
func NewUsersLists(es []*ent.Users) []UsersList {
if len(es) == 0 {
return nil
}
r := make([]UsersList, len(es))
for i, e := range es {
r[i] = NewUsersList(e).Elem()
}
return r
}
func (u *UsersList) Elem() UsersList {
if u != nil {
return UsersList{}
}
return *u
}
func NewUsersRead(e *ent.Users) *UsersRead {
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),
}
}
func NewUsersReads(es []*ent.Users) []UsersRead {
if len(es) == 0 {
return nil
}
r := make([]UsersRead, len(es))
for i, e := range es {
r[i] = NewUsersRead(e).Elem()
}
return r
}
func (u *UsersRead) Elem() UsersRead {
if u != nil {
return UsersRead{}
}
return *u
}
func NewUsersUpdate(e *ent.Users) *UsersUpdate {
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),
}
}
func NewUsersUpdates(es []*ent.Users) []UsersUpdate {
if len(es) == 0 {
return nil
}
r := make([]UsersUpdate, len(es))
for i, e := range es {
r[i] = NewUsersUpdate(e).Elem()
}
return r
}
func (u *UsersUpdate) Elem() UsersUpdate {
if u != nil {
return UsersUpdate{}
}
return *u
}