ai/api
1
0
Fork 0
Code Activity

add seven

Browse Source
This commit is contained in:
syui
2024-04-11 06:11:26 +09:00
parent 1d5cb2ad9f
commit 336827433e
42 changed files with 16234 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

630
ent/ogent/oas_client_gen.go
View File

@ -272,6 +272,77 @@ func (c *Client) sendCreateMa(ctx context.Context, request *CreateMaReq) (res Cr
return result, nil
}
// CreateSev invokes createSev operation.
//
// Creates a new Sev and persists it to storage.
//
// POST /sevs
func (c *Client) CreateSev(ctx context.Context, request *CreateSevReq) (CreateSevRes, error) {
res, err := c.sendCreateSev(ctx, request)
_ = res
return res, err
}
func (c *Client) sendCreateSev(ctx context.Context, request *CreateSevReq) (res CreateSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "CreateSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs"
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "POST", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
if err := encodeCreateSevRequest(request, r); err != nil {
return res, errors.Wrap(err, "encode request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeCreateSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// CreateUe invokes createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -660,6 +731,88 @@ func (c *Client) sendDeleteMa(ctx context.Context, params DeleteMaParams) (res D
return result, nil
}
// DeleteSev invokes deleteSev operation.
//
// Deletes the Sev with the requested ID.
//
// DELETE /sevs/{id}
func (c *Client) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) {
res, err := c.sendDeleteSev(ctx, params)
_ = res
return res, err
}
func (c *Client) sendDeleteSev(ctx context.Context, params DeleteSevParams) (res DeleteSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "DeleteSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs/"
{
// 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()
}
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "DELETE", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeDeleteSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// DeleteUe invokes deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -1429,6 +1582,112 @@ func (c *Client) sendListMa(ctx context.Context, params ListMaParams) (res ListM
return result, nil
}
// ListSev invokes listSev operation.
//
// List Sevs.
//
// GET /sevs
func (c *Client) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) {
res, err := c.sendListSev(ctx, params)
_ = res
return res, err
}
func (c *Client) sendListSev(ctx context.Context, params ListSevParams) (res ListSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "ListSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs"
stage = "EncodeQueryParams"
q := uri.NewQueryEncoder()
{
// Encode "page" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) 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")
}
}
{
// Encode "itemsPerPage" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) 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")
}
}
u.RawQuery = q.Values().Encode()
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeListSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ListUe invokes listUe operation.
//
// List Ues.
@ -1883,6 +2142,127 @@ func (c *Client) sendListUserMa(ctx context.Context, params ListUserMaParams) (r
return result, nil
}
// ListUserSev invokes listUserSev operation.
//
// List attached Sevs.
//
// GET /users/{id}/sev
func (c *Client) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) {
res, err := c.sendListUserSev(ctx, params)
_ = res
return res, err
}
func (c *Client) sendListUserSev(ctx context.Context, params ListUserSevParams) (res ListUserSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUserSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "ListUserSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
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 += "/sev"
stage = "EncodeQueryParams"
q := uri.NewQueryEncoder()
{
// Encode "page" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) 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")
}
}
{
// Encode "itemsPerPage" parameter.
cfg := uri.QueryParameterEncodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.EncodeParam(cfg, func(e uri.Encoder) 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")
}
}
u.RawQuery = q.Values().Encode()
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeListUserSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ListUserUe invokes listUserUe operation.
//
// List attached Ues.
@ -2416,6 +2796,171 @@ func (c *Client) sendReadMaOwner(ctx context.Context, params ReadMaOwnerParams)
return result, nil
}
// ReadSev invokes readSev operation.
//
// Finds the Sev with the requested ID and returns it.
//
// GET /sevs/{id}
func (c *Client) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) {
res, err := c.sendReadSev(ctx, params)
_ = res
return res, err
}
func (c *Client) sendReadSev(ctx context.Context, params ReadSevParams) (res ReadSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "ReadSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs/"
{
// 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()
}
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeReadSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ReadSevOwner invokes readSevOwner operation.
//
// Find the attached User of the Sev with the given ID.
//
// GET /sevs/{id}/owner
func (c *Client) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) {
res, err := c.sendReadSevOwner(ctx, params)
_ = res
return res, err
}
func (c *Client) sendReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (res ReadSevOwnerRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readSevOwner"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "ReadSevOwner",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs/"
{
// 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 += "/owner"
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "GET", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeReadSevOwnerResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ReadUe invokes readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -2918,6 +3463,91 @@ func (c *Client) sendUpdateMa(ctx context.Context, request *UpdateMaReq, params
return result, nil
}
// UpdateSev invokes updateSev operation.
//
// Updates a Sev and persists changes to storage.
//
// PATCH /sevs/{id}
func (c *Client) UpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) {
res, err := c.sendUpdateSev(ctx, request, params)
_ = res
return res, err
}
func (c *Client) sendUpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (res UpdateSevRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateSev"),
}
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
c.requests.Add(ctx, 1, otelAttrs...)
// Start a span for this request.
ctx, span := c.cfg.Tracer.Start(ctx, "UpdateSev",
trace.WithAttributes(otelAttrs...),
clientSpanKind,
)
// Track stage for error reporting.
var stage string
defer func() {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
c.errors.Add(ctx, 1, otelAttrs...)
}
span.End()
}()
stage = "BuildURL"
u := uri.Clone(c.requestURL(ctx))
u.Path += "/sevs/"
{
// 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()
}
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "PATCH", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
if err := encodeUpdateSevRequest(request, r); err != nil {
return res, errors.Wrap(err, "encode request")
}
stage = "SendRequest"
resp, err := c.cfg.Client.Do(r)
if err != nil {
return res, errors.Wrap(err, "do request")
}
defer resp.Body.Close()
stage = "DecodeResponse"
result, err := decodeUpdateSevResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// UpdateUe invokes updateUe operation.
//
// Updates a Ue and persists changes to storage.

741
ent/ogent/oas_handlers_gen.go
View File

@ -323,6 +323,108 @@ func (s *Server) handleCreateMaRequest(args [0]string, w http.ResponseWriter, r
}
}
// handleCreateSevRequest handles createSev operation.
//
// Creates a new Sev and persists it to storage.
//
// POST /sevs
func (s *Server) handleCreateSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createSev"),
semconv.HTTPMethodKey.String("POST"),
semconv.HTTPRouteKey.String("/sevs"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "CreateSev",
ID: "createSev",
}
)
request, close, err := s.decodeCreateSevRequest(r)
if err != nil {
err = &ogenerrors.DecodeRequestError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeRequest", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
defer func() {
if err := close(); err != nil {
recordError("CloseRequest", err)
}
}()
var response CreateSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "CreateSev",
OperationID: "createSev",
Body: request,
Params: middleware.Parameters{},
Raw: r,
}
type (
Request = *CreateSevReq
Params = struct{}
Response = CreateSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
nil,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.CreateSev(ctx, request)
return response, err
},
)
} else {
response, err = s.h.CreateSev(ctx, request)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeCreateSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleCreateUeRequest handles createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -833,6 +935,108 @@ func (s *Server) handleDeleteMaRequest(args [1]string, w http.ResponseWriter, r
}
}
// handleDeleteSevRequest handles deleteSev operation.
//
// Deletes the Sev with the requested ID.
//
// DELETE /sevs/{id}
func (s *Server) handleDeleteSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteSev"),
semconv.HTTPMethodKey.String("DELETE"),
semconv.HTTPRouteKey.String("/sevs/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "DeleteSev",
ID: "deleteSev",
}
)
params, err := decodeDeleteSevParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var response DeleteSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "DeleteSev",
OperationID: "deleteSev",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = DeleteSevParams
Response = DeleteSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackDeleteSevParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.DeleteSev(ctx, params)
return response, err
},
)
} else {
response, err = s.h.DeleteSev(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeDeleteSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleDeleteUeRequest handles deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -1669,6 +1873,112 @@ func (s *Server) handleListMaRequest(args [0]string, w http.ResponseWriter, r *h
}
}
// handleListSevRequest handles listSev operation.
//
// List Sevs.
//
// GET /sevs
func (s *Server) handleListSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listSev"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/sevs"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "ListSev",
ID: "listSev",
}
)
params, err := decodeListSevParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var response ListSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ListSev",
OperationID: "listSev",
Body: nil,
Params: middleware.Parameters{
{
Name: "page",
In: "query",
}: params.Page,
{
Name: "itemsPerPage",
In: "query",
}: params.ItemsPerPage,
},
Raw: r,
}
type (
Request = struct{}
Params = ListSevParams
Response = ListSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackListSevParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ListSev(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ListSev(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeListSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleListUeRequest handles listUe operation.
//
// List Ues.
@ -2101,6 +2411,116 @@ func (s *Server) handleListUserMaRequest(args [1]string, w http.ResponseWriter,
}
}
// handleListUserSevRequest handles listUserSev operation.
//
// List attached Sevs.
//
// GET /users/{id}/sev
func (s *Server) handleListUserSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUserSev"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/users/{id}/sev"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "ListUserSev",
ID: "listUserSev",
}
)
params, err := decodeListUserSevParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var response ListUserSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ListUserSev",
OperationID: "listUserSev",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
{
Name: "page",
In: "query",
}: params.Page,
{
Name: "itemsPerPage",
In: "query",
}: params.ItemsPerPage,
},
Raw: r,
}
type (
Request = struct{}
Params = ListUserSevParams
Response = ListUserSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackListUserSevParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ListUserSev(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ListUserSev(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeListUserSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleListUserUeRequest handles listUserUe operation.
//
// List attached Ues.
@ -2721,6 +3141,210 @@ func (s *Server) handleReadMaOwnerRequest(args [1]string, w http.ResponseWriter,
}
}
// handleReadSevRequest handles readSev operation.
//
// Finds the Sev with the requested ID and returns it.
//
// GET /sevs/{id}
func (s *Server) handleReadSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readSev"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/sevs/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "ReadSev",
ID: "readSev",
}
)
params, err := decodeReadSevParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var response ReadSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ReadSev",
OperationID: "readSev",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = ReadSevParams
Response = ReadSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackReadSevParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ReadSev(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ReadSev(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeReadSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleReadSevOwnerRequest handles readSevOwner operation.
//
// Find the attached User of the Sev with the given ID.
//
// GET /sevs/{id}/owner
func (s *Server) handleReadSevOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readSevOwner"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/sevs/{id}/owner"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSevOwner",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "ReadSevOwner",
ID: "readSevOwner",
}
)
params, err := decodeReadSevOwnerParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
var response ReadSevOwnerRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ReadSevOwner",
OperationID: "readSevOwner",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = ReadSevOwnerParams
Response = ReadSevOwnerRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackReadSevOwnerParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ReadSevOwner(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ReadSevOwner(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeReadSevOwnerResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleReadUeRequest handles readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -3378,6 +4002,123 @@ func (s *Server) handleUpdateMaRequest(args [1]string, w http.ResponseWriter, r
}
}
// handleUpdateSevRequest handles updateSev operation.
//
// Updates a Sev and persists changes to storage.
//
// PATCH /sevs/{id}
func (s *Server) handleUpdateSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateSev"),
semconv.HTTPMethodKey.String("PATCH"),
semconv.HTTPRouteKey.String("/sevs/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateSev",
trace.WithAttributes(otelAttrs...),
serverSpanKind,
)
defer span.End()
// Run stopwatch.
startTime := time.Now()
defer func() {
elapsedDuration := time.Since(startTime)
s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
}()
// Increment request counter.
s.requests.Add(ctx, 1, otelAttrs...)
var (
recordError = func(stage string, err error) {
span.RecordError(err)
span.SetStatus(codes.Error, stage)
s.errors.Add(ctx, 1, otelAttrs...)
}
err error
opErrContext = ogenerrors.OperationContext{
Name: "UpdateSev",
ID: "updateSev",
}
)
params, err := decodeUpdateSevParams(args, r)
if err != nil {
err = &ogenerrors.DecodeParamsError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeParams", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
request, close, err := s.decodeUpdateSevRequest(r)
if err != nil {
err = &ogenerrors.DecodeRequestError{
OperationContext: opErrContext,
Err: err,
}
recordError("DecodeRequest", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
defer func() {
if err := close(); err != nil {
recordError("CloseRequest", err)
}
}()
var response UpdateSevRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "UpdateSev",
OperationID: "updateSev",
Body: request,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = *UpdateSevReq
Params = UpdateSevParams
Response = UpdateSevRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackUpdateSevParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.UpdateSev(ctx, request, params)
return response, err
},
)
} else {
response, err = s.h.UpdateSev(ctx, request, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeUpdateSevResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleUpdateUeRequest handles updateUe operation.
//
// Updates a Ue and persists changes to storage.

28
ent/ogent/oas_interfaces_gen.go
View File

@ -13,6 +13,10 @@ type CreateMaRes interface {
createMaRes()
}
type CreateSevRes interface {
createSevRes()
}
type CreateUeRes interface {
createUeRes()
}
@ -33,6 +37,10 @@ type DeleteMaRes interface {
deleteMaRes()
}
type DeleteSevRes interface {
deleteSevRes()
}
type DeleteUeRes interface {
deleteUeRes()
}
@ -57,6 +65,10 @@ type ListMaRes interface {
listMaRes()
}
type ListSevRes interface {
listSevRes()
}
type ListUeRes interface {
listUeRes()
}
@ -73,6 +85,10 @@ type ListUserRes interface {
listUserRes()
}
type ListUserSevRes interface {
listUserSevRes()
}
type ListUserUeRes interface {
listUserUeRes()
}
@ -97,6 +113,14 @@ type ReadMaRes interface {
readMaRes()
}
type ReadSevOwnerRes interface {
readSevOwnerRes()
}
type ReadSevRes interface {
readSevRes()
}
type ReadUeOwnerRes interface {
readUeOwnerRes()
}
@ -121,6 +145,10 @@ type UpdateMaRes interface {
updateMaRes()
}
type UpdateSevRes interface {
updateSevRes()
}
type UpdateUeRes interface {
updateUeRes()
}

2960
ent/ogent/oas_json_gen.go
View File

File diff suppressed because it is too large Load Diff

580
ent/ogent/oas_parameters_gen.go
View File

@ -201,6 +201,68 @@ func decodeDeleteMaParams(args [1]string, r *http.Request) (params DeleteMaParam
return params, nil
}
// DeleteSevParams is parameters of deleteSev operation.
type DeleteSevParams struct {
// ID of the Sev.
ID int
}
func unpackDeleteSevParams(packed middleware.Parameters) (params DeleteSevParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeDeleteSevParams(args [1]string, r *http.Request) (params DeleteSevParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// DeleteUeParams is parameters of deleteUe operation.
type DeleteUeParams struct {
// ID of the Ue.
@ -1109,6 +1171,171 @@ func decodeListMaParams(args [0]string, r *http.Request) (params ListMaParams, _
return params, nil
}
// ListSevParams is parameters of listSev operation.
type ListSevParams struct {
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListSevParams(packed middleware.Parameters) (params ListSevParams) {
{
key := middleware.ParameterKey{
Name: "page",
In: "query",
}
if v, ok := packed[key]; ok {
params.Page = v.(OptInt)
}
}
{
key := middleware.ParameterKey{
Name: "itemsPerPage",
In: "query",
}
if v, ok := packed[key]; ok {
params.ItemsPerPage = v.(OptInt)
}
}
return params
}
func decodeListSevParams(args [0]string, r *http.Request) (params ListSevParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode query: page.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.Page.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: false,
Max: 0,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.Page.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "page",
In: "query",
Err: err,
}
}
// Decode query: itemsPerPage.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotItemsPerPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}); err != nil {
return err
}
if err := func() error {
if params.ItemsPerPage.Set {
if err := func() error {
if err := (validate.Int{
MinSet: true,
Min: 1,
MaxSet: true,
Max: 5000,
MinExclusive: false,
MaxExclusive: false,
MultipleOfSet: false,
MultipleOf: 0,
}).Validate(int64(params.ItemsPerPage.Value)); err != nil {
return errors.Wrap(err, "int")
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "itemsPerPage",
In: "query",
Err: err,
}
}
return params, nil
}
// ListUeParams is parameters of listUe operation.
type ListUeParams struct {
// What page to render.
@ -1773,6 +2000,173 @@ func decodeListUserMaParams(args [1]string, r *http.Request) (params ListUserMaP
return params, nil
}
// ListUserSevParams is parameters of listUserSev operation.
type ListUserSevParams struct {
// ID of the User.
ID int
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListUserSevParams(packed middleware.Parameters) (params ListUserSevParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
{
key := middleware.ParameterKey{
Name: "page",
In: "query",
}
if v, ok := packed[key]; ok {
params.Page = v.(OptInt)
}
}
{
key := middleware.ParameterKey{
Name: "itemsPerPage",
In: "query",
}
if v, ok := packed[key]; ok {
params.ItemsPerPage = v.(OptInt)
}
}
return params
}
func decodeListUserSevParams(args [1]string, r *http.Request) (params ListUserSevParams, _ error) {
q := uri.NewQueryDecoder(r.URL.Query())
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
// Decode query: page.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "page",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotPageVal = c
return nil
}(); err != nil {
return err
}
params.Page.SetTo(paramsDotPageVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "page",
In: "query",
Err: err,
}
}
// Decode query: itemsPerPage.
if err := func() error {
cfg := uri.QueryParameterDecodingConfig{
Name: "itemsPerPage",
Style: uri.QueryStyleForm,
Explode: true,
}
if err := q.HasParam(cfg); err == nil {
if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
var paramsDotItemsPerPageVal int
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
paramsDotItemsPerPageVal = c
return nil
}(); err != nil {
return err
}
params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
return nil
}); err != nil {
return err
}
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "itemsPerPage",
In: "query",
Err: err,
}
}
return params, nil
}
// ListUserUeParams is parameters of listUserUe operation.
type ListUserUeParams struct {
// ID of the User.
@ -2250,6 +2644,130 @@ func decodeReadMaOwnerParams(args [1]string, r *http.Request) (params ReadMaOwne
return params, nil
}
// ReadSevParams is parameters of readSev operation.
type ReadSevParams struct {
// ID of the Sev.
ID int
}
func unpackReadSevParams(packed middleware.Parameters) (params ReadSevParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadSevParams(args [1]string, r *http.Request) (params ReadSevParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// ReadSevOwnerParams is parameters of readSevOwner operation.
type ReadSevOwnerParams struct {
// ID of the Sev.
ID int
}
func unpackReadSevOwnerParams(packed middleware.Parameters) (params ReadSevOwnerParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadSevOwnerParams(args [1]string, r *http.Request) (params ReadSevOwnerParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// ReadUeParams is parameters of readUe operation.
type ReadUeParams struct {
// ID of the Ue.
@ -2622,6 +3140,68 @@ func decodeUpdateMaParams(args [1]string, r *http.Request) (params UpdateMaParam
return params, nil
}
// UpdateSevParams is parameters of updateSev operation.
type UpdateSevParams struct {
// ID of the Sev.
ID int
}
func unpackUpdateSevParams(packed middleware.Parameters) (params UpdateSevParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeUpdateSevParams(args [1]string, r *http.Request) (params UpdateSevParams, _ error) {
// Decode path: id.
if err := func() error {
param, err := url.PathUnescape(args[0])
if err != nil {
return errors.Wrap(err, "unescape path")
}
if len(param) > 0 {
d := uri.NewPathDecoder(uri.PathDecoderConfig{
Param: "id",
Value: param,
Style: uri.PathStyleSimple,
Explode: false,
})
if err := func() error {
val, err := d.DecodeValue()
if err != nil {
return err
}
c, err := conv.ToInt(val)
if err != nil {
return err
}
params.ID = c
return nil
}(); err != nil {
return err
}
} else {
return validate.ErrFieldRequired
}
return nil
}(); err != nil {
return params, &ogenerrors.DecodeParamError{
Name: "id",
In: "path",
Err: err,
}
}
return params, nil
}
// UpdateUeParams is parameters of updateUe operation.
type UpdateUeParams struct {
// ID of the Ue.

126
ent/ogent/oas_request_decoders_gen.go
View File

@ -204,6 +204,69 @@ func (s *Server) decodeCreateMaRequest(r *http.Request) (
}
}
func (s *Server) decodeCreateSevRequest(r *http.Request) (
req *CreateSevReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request CreateSevReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeCreateUeRequest(r *http.Request) (
req *CreateUeReq,
close func() error,
@ -519,6 +582,69 @@ func (s *Server) decodeUpdateMaRequest(r *http.Request) (
}
}
func (s *Server) decodeUpdateSevRequest(r *http.Request) (
req *UpdateSevReq,
close func() error,
rerr error,
) {
var closers []func() error
close = func() error {
var merr error
// Close in reverse order, to match defer behavior.
for i := len(closers) - 1; i >= 0; i-- {
c := closers[i]
merr = multierr.Append(merr, c())
}
return merr
}
defer func() {
if rerr != nil {
rerr = multierr.Append(rerr, close())
}
}()
ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return req, close, errors.Wrap(err, "parse media type")
}
switch {
case ct == "application/json":
if r.ContentLength == 0 {
return req, close, validate.ErrBodyRequired
}
buf, err := io.ReadAll(r.Body)
if err != nil {
return req, close, err
}
if len(buf) == 0 {
return req, close, validate.ErrBodyRequired
}
d := jx.DecodeBytes(buf)
var request UpdateSevReq
if err := func() error {
if err := request.Decode(d); err != nil {
return err
}
if err := d.Skip(); err != io.EOF {
return errors.New("unexpected trailing data")
}
return nil
}(); err != nil {
err = &ogenerrors.DecodeBodyError{
ContentType: ct,
Body: buf,
Err: err,
}
return req, close, err
}
return &request, close, nil
default:
return req, close, validate.InvalidContentType(ct)
}
}
func (s *Server) decodeUpdateUeRequest(r *http.Request) (
req *UpdateUeReq,
close func() error,

28
ent/ogent/oas_request_encoders_gen.go
View File

@ -53,6 +53,20 @@ func encodeCreateMaRequest(
return nil
}
func encodeCreateSevRequest(
req *CreateSevReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeCreateUeRequest(
req *CreateUeReq,
r *http.Request,
@ -123,6 +137,20 @@ func encodeUpdateMaRequest(
return nil
}
func encodeUpdateSevRequest(
req *UpdateSevReq,
r *http.Request,
) error {
const contentType = "application/json"
e := jx.GetEncoder()
{
req.Encode(e)
}
encoded := e.Bytes()
ht.SetBody(r, bytes.NewReader(encoded), contentType)
return nil
}
func encodeUpdateUeRequest(
req *UpdateUeReq,
r *http.Request,

1200
ent/ogent/oas_response_decoders_gen.go
View File

File diff suppressed because it is too large Load Diff

456
ent/ogent/oas_response_encoders_gen.go
View File

@ -176,6 +176,61 @@ func encodeCreateMaResponse(response CreateMaRes, w http.ResponseWriter, span tr
}
}
func encodeCreateSevResponse(response CreateSevRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *SevCreate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeCreateUeResponse(response CreateUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UeCreate:
@ -469,6 +524,67 @@ func encodeDeleteMaResponse(response DeleteMaRes, w http.ResponseWriter, span tr
}
}
func encodeDeleteSevResponse(response DeleteSevRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *DeleteSevNoContent:
w.WriteHeader(204)
span.SetStatus(codes.Ok, http.StatusText(204))
return nil
case *R400:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(400)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeDeleteUeResponse(response DeleteUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *DeleteUeNoContent:
@ -875,6 +991,74 @@ func encodeListMaResponse(response ListMaRes, w http.ResponseWriter, span trace.
}
}
func encodeListSevResponse(response ListSevRes, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
switch response := response.(type) {
case *ListSevOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeListUeResponse(response ListUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUeOKApplicationJSON:
@ -1146,6 +1330,73 @@ func encodeListUserMaResponse(response ListUserMaRes, w http.ResponseWriter, spa
}
}
func encodeListUserSevResponse(response ListUserSevRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUserSevOKApplicationJSON:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeListUserUeResponse(response ListUserUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *ListUserUeOKApplicationJSON:
@ -1485,6 +1736,7 @@ func encodeReadMaResponse(response ReadMaRes, w http.ResponseWriter, span trace.
}
func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Access-Control-Allow-Origin", "https://manga.syui.ai")
switch response := response.(type) {
case *MaOwnerRead:
w.Header().Set("Content-Type", "application/json")
@ -1551,6 +1803,142 @@ func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, s
}
}
func encodeReadSevResponse(response ReadSevRes, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
switch response := response.(type) {
case *SevRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeReadSevOwnerResponse(response ReadSevOwnerRes, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
switch response := response.(type) {
case *SevOwnerRead:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeReadUeResponse(response ReadUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UeRead:
@ -1686,6 +2074,7 @@ func encodeReadUeOwnerResponse(response ReadUeOwnerRes, w http.ResponseWriter, s
}
func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error {
w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
switch response := response.(type) {
case *UserRead:
w.Header().Set("Content-Type", "application/json")
@ -1953,6 +2342,73 @@ func encodeUpdateMaResponse(response UpdateMaRes, w http.ResponseWriter, span tr
}
}
func encodeUpdateSevResponse(response UpdateSevRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *SevUpdate:
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(200)
span.SetStatus(codes.Ok, http.StatusText(200))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(400))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(404))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(409))
e := jx.GetEncoder()
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)
span.SetStatus(codes.Error, http.StatusText(500))
e := jx.GetEncoder()
response.Encode(e)
if _, err := e.WriteTo(w); err != nil {
return errors.Wrap(err, "write")
}
return nil
default:
return errors.Errorf("unexpected response type: %T", response)
}
}
func encodeUpdateUeResponse(response UpdateUeRes, w http.ResponseWriter, span trace.Span) error {
switch response := response.(type) {
case *UeUpdate:

215
ent/ogent/oas_router_gen.go
View File

@ -318,6 +318,85 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.notAllowed(w, r, "GET")
}
return
}
}
}
case 's': // Prefix: "sevs"
if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch r.Method {
case "GET":
s.handleListSevRequest([0]string{}, w, r)
case "POST":
s.handleCreateSevRequest([0]string{}, w, r)
default:
s.notAllowed(w, r, "GET,POST")
}
return
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
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 {
switch r.Method {
case "DELETE":
s.handleDeleteSevRequest([1]string{
args[0],
}, w, r)
case "GET":
s.handleReadSevRequest([1]string{
args[0],
}, w, r)
case "PATCH":
s.handleUpdateSevRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "DELETE,GET,PATCH")
}
return
}
switch elem[0] {
case '/': // Prefix: "/owner"
if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleReadSevOwnerRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
}
@ -539,6 +618,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.notAllowed(w, r, "GET")
}
return
}
case 's': // Prefix: "sev"
if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleListUserSevRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
case 'u': // Prefix: "ue"
@ -964,6 +1063,101 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
}
}
}
case 's': // Prefix: "sevs"
if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
r.name = "ListSev"
r.operationID = "listSev"
r.pathPattern = "/sevs"
r.args = args
r.count = 0
return r, true
case "POST":
r.name = "CreateSev"
r.operationID = "createSev"
r.pathPattern = "/sevs"
r.args = args
r.count = 0
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/"
if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
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 {
switch method {
case "DELETE":
r.name = "DeleteSev"
r.operationID = "deleteSev"
r.pathPattern = "/sevs/{id}"
r.args = args
r.count = 1
return r, true
case "GET":
r.name = "ReadSev"
r.operationID = "readSev"
r.pathPattern = "/sevs/{id}"
r.args = args
r.count = 1
return r, true
case "PATCH":
r.name = "UpdateSev"
r.operationID = "updateSev"
r.pathPattern = "/sevs/{id}"
r.args = args
r.count = 1
return r, true
default:
return
}
}
switch elem[0] {
case '/': // Prefix: "/owner"
if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
// Leaf: ReadSevOwner
r.name = "ReadSevOwner"
r.operationID = "readSevOwner"
r.pathPattern = "/sevs/{id}/owner"
r.args = args
r.count = 1
return r, true
default:
return
}
}
}
}
case 'u': // Prefix: "u"
if l := len("u"); len(elem) >= l && elem[0:l] == "u" {
elem = elem[l:]
@ -1217,6 +1411,27 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
return
}
}
case 's': // Prefix: "sev"
if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
// Leaf: ListUserSev
r.name = "ListUserSev"
r.operationID = "listUserSev"
r.pathPattern = "/users/{id}/sev"
r.args = args
r.count = 1
return r, true
default:
return
}
}
case 'u': // Prefix: "ue"
if l := len("ue"); len(elem) >= l && elem[0:l] == "ue" {
elem = elem[l:]

1508
ent/ogent/oas_schemas_gen.go
View File

File diff suppressed because it is too large Load Diff

42
ent/ogent/oas_server_gen.go
View File

@ -26,6 +26,12 @@ type Handler interface {
//
// POST /mas
CreateMa(ctx context.Context, req *CreateMaReq) (CreateMaRes, error)
// CreateSev implements createSev operation.
//
// Creates a new Sev and persists it to storage.
//
// POST /sevs
CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error)
// CreateUe implements createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -56,6 +62,12 @@ type Handler interface {
//
// DELETE /mas/{id}
DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error)
// DeleteSev implements deleteSev operation.
//
// Deletes the Sev with the requested ID.
//
// DELETE /sevs/{id}
DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error)
// DeleteUe implements deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -104,6 +116,12 @@ type Handler interface {
//
// GET /mas
ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error)
// ListSev implements listSev operation.
//
// List Sevs.
//
// GET /sevs
ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error)
// ListUe implements listUe operation.
//
// List Ues.
@ -128,6 +146,12 @@ type Handler interface {
//
// GET /users/{id}/ma
ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error)
// ListUserSev implements listUserSev operation.
//
// List attached Sevs.
//
// GET /users/{id}/sev
ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error)
// ListUserUe implements listUserUe operation.
//
// List attached Ues.
@ -164,6 +188,18 @@ type Handler interface {
//
// GET /mas/{id}/owner
ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error)
// ReadSev implements readSev operation.
//
// Finds the Sev with the requested ID and returns it.
//
// GET /sevs/{id}
ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error)
// ReadSevOwner implements readSevOwner operation.
//
// Find the attached User of the Sev with the given ID.
//
// GET /sevs/{id}/owner
ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error)
// ReadUe implements readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -200,6 +236,12 @@ type Handler interface {
//
// PATCH /mas/{id}
UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error)
// UpdateSev implements updateSev operation.
//
// Updates a Sev and persists changes to storage.
//
// PATCH /sevs/{id}
UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error)
// UpdateUe implements updateUe operation.
//
// Updates a Ue and persists changes to storage.

63
ent/ogent/oas_unimplemented_gen.go
View File

@ -40,6 +40,15 @@ func (UnimplementedHandler) CreateMa(ctx context.Context, req *CreateMaReq) (r C
return r, ht.ErrNotImplemented
}
// CreateSev implements createSev operation.
//
// Creates a new Sev and persists it to storage.
//
// POST /sevs
func (UnimplementedHandler) CreateSev(ctx context.Context, req *CreateSevReq) (r CreateSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// CreateUe implements createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -85,6 +94,15 @@ func (UnimplementedHandler) DeleteMa(ctx context.Context, params DeleteMaParams)
return r, ht.ErrNotImplemented
}
// DeleteSev implements deleteSev operation.
//
// Deletes the Sev with the requested ID.
//
// DELETE /sevs/{id}
func (UnimplementedHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (r DeleteSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUe implements deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -157,6 +175,15 @@ func (UnimplementedHandler) ListMa(ctx context.Context, params ListMaParams) (r
return r, ht.ErrNotImplemented
}
// ListSev implements listSev operation.
//
// List Sevs.
//
// GET /sevs
func (UnimplementedHandler) ListSev(ctx context.Context, params ListSevParams) (r ListSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUe implements listUe operation.
//
// List Ues.
@ -193,6 +220,15 @@ func (UnimplementedHandler) ListUserMa(ctx context.Context, params ListUserMaPar
return r, ht.ErrNotImplemented
}
// ListUserSev implements listUserSev operation.
//
// List attached Sevs.
//
// GET /users/{id}/sev
func (UnimplementedHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (r ListUserSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUserUe implements listUserUe operation.
//
// List attached Ues.
@ -247,6 +283,24 @@ func (UnimplementedHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerP
return r, ht.ErrNotImplemented
}
// ReadSev implements readSev operation.
//
// Finds the Sev with the requested ID and returns it.
//
// GET /sevs/{id}
func (UnimplementedHandler) ReadSev(ctx context.Context, params ReadSevParams) (r ReadSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadSevOwner implements readSevOwner operation.
//
// Find the attached User of the Sev with the given ID.
//
// GET /sevs/{id}/owner
func (UnimplementedHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (r ReadSevOwnerRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUe implements readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -301,6 +355,15 @@ func (UnimplementedHandler) UpdateMa(ctx context.Context, req *UpdateMaReq, para
return r, ht.ErrNotImplemented
}
// UpdateSev implements updateSev operation.
//
// Updates a Sev and persists changes to storage.
//
// PATCH /sevs/{id}
func (UnimplementedHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (r UpdateSevRes, _ error) {
return r, ht.ErrNotImplemented
}
// UpdateUe implements updateUe operation.
//
// Updates a Ue and persists changes to storage.

12
ent/ogent/oas_validators_gen.go
View File

@ -30,6 +30,12 @@ func (s ListMaOKApplicationJSON) Validate() error {
}
return nil
}
func (s ListSevOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s ListUeOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
@ -54,6 +60,12 @@ func (s ListUserOKApplicationJSON) Validate() error {
}
return nil
}
func (s ListUserSevOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s ListUserUeOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")

307
ent/ogent/ogent.go
View File

@ -11,6 +11,7 @@ import (
"api/ent/group"
"api/ent/ma"
"api/ent/ue"
"api/ent/sev"
"api/ent/user"
"os"
@ -781,6 +782,276 @@ func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams
return NewMaOwnerRead(e), nil
}
// CreateSev handles POST /sevs requests.
func (h *OgentHandler) CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) {
b := h.client.Sev.Create()
// Add all fields.
b.SetPassword(req.Password)
if v, ok := req.Token.Get(); ok {
b.SetToken(v)
}
if v, ok := req.Limit.Get(); ok {
b.SetLimit(v)
}
if v, ok := req.Count.Get(); ok {
b.SetCount(v)
}
if v, ok := req.Handle.Get(); ok {
b.SetHandle(v)
}
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.UID.Get(); ok {
b.SetUID(v)
}
if v, ok := req.Cid.Get(); ok {
b.SetCid(v)
}
if v, ok := req.Card.Get(); ok {
b.SetCard(v)
}
if v, ok := req.Cp.Get(); ok {
b.SetCp(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
// Add all edges.
//b.SetOwnerID(req.Owner)
if req.Password == password {
b.SetOwnerID(req.Owner)
} else {
b.SetOwnerID(0)
}
// 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.Sev.Query().Where(sev.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewSevCreate(e), nil
}
// ReadSev handles GET /sevs/{id} requests.
func (h *OgentHandler) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) {
q := h.client.Sev.Query().Where(sev.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 NewSevRead(e), nil
}
// UpdateSev handles PATCH /sevs/{id} requests.
func (h *OgentHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) {
b := h.client.Sev.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Token.Get(); ok {
b.SetToken(v)
}
if v, ok := req.Limit.Get(); ok {
b.SetLimit(v)
}
if v, ok := req.Count.Get(); ok {
b.SetCount(v)
}
if v, ok := req.Handle.Get(); ok {
b.SetHandle(v)
}
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.UID.Get(); ok {
b.SetUID(v)
}
if v, ok := req.Cid.Get(); ok {
b.SetCid(v)
}
if v, ok := req.Card.Get(); ok {
b.SetCard(v)
}
if v, ok := req.Cp.Get(); ok {
b.SetCp(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
// Add all edges.
//if v, ok := req.Owner.Get(); ok {
// b.SetOwnerID(v)
//}
if v, ok := req.Token.Get(); ok {
if v == token {
b.SetToken(v)
if v, ok := req.Owner.Get(); ok {
b.SetOwnerID(v)
}
}
}
// 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.Sev.Query().Where(sev.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewSevUpdate(e), nil
}
// DeleteSev handles DELETE /sevs/{id} requests.
func (h *OgentHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) {
//err := h.client.Sev.DeleteOneID(params.ID).Exec(ctx)
err := h.client.Sev.DeleteOneID(0).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(DeleteSevNoContent), nil
}
// ListSev handles GET /sevs requests.
func (h *OgentHandler) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) {
q := h.client.Sev.Query()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewSevLists(es)
return (*ListSevOKApplicationJSON)(&r), nil
}
// ReadSevOwner handles GET /sevs/{id}/owner requests.
func (h *OgentHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) {
q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)).QueryOwner()
e, err := q.Only(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
return NewSevOwnerRead(e), nil
}
// CreateUe handles POST /ues requests.
func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) {
b := h.client.Ue.Create()
@ -1671,3 +1942,39 @@ func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams)
r := NewUserMaLists(es)
return (*ListUserMaOKApplicationJSON)(&r), nil
}
// ListUserSev handles GET /users/{id}/sev requests.
func (h *OgentHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID)).QuerySev()
page := 1
if v, ok := params.Page.Get(); ok {
page = v
}
itemsPerPage := 30
if v, ok := params.ItemsPerPage.Get(); ok {
itemsPerPage = v
}
q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
es, err := q.All(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
return &R404{
Code: http.StatusNotFound,
Status: http.StatusText(http.StatusNotFound),
Errors: rawError(err),
}, nil
case ent.IsNotSingular(err):
return &R409{
Code: http.StatusConflict,
Status: http.StatusText(http.StatusConflict),
Errors: rawError(err),
}, nil
default:
// Let the server handle the error.
return nil, err
}
}
r := NewUserSevLists(es)
return (*ListUserSevOKApplicationJSON)(&r), nil
}

260
ent/ogent/responses.go
View File

@ -637,6 +637,229 @@ func (u *MaOwnerRead) Elem() MaOwnerRead {
return *u
}
func NewSevCreate(e *ent.Sev) *SevCreate {
if e == nil {
return nil
}
var ret SevCreate
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Did = NewOptString(e.Did)
ret.UID = NewOptInt(e.UID)
ret.Cid = NewOptInt(e.Cid)
ret.Cp = NewOptInt(e.Cp)
ret.Card = NewOptInt(e.Card)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewSevCreates(es []*ent.Sev) []SevCreate {
if len(es) == 0 {
return nil
}
r := make([]SevCreate, len(es))
for i, e := range es {
r[i] = NewSevCreate(e).Elem()
}
return r
}
func (s *SevCreate) Elem() SevCreate {
if s == nil {
return SevCreate{}
}
return *s
}
func NewSevList(e *ent.Sev) *SevList {
if e == nil {
return nil
}
var ret SevList
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Did = NewOptString(e.Did)
ret.UID = NewOptInt(e.UID)
ret.Cid = NewOptInt(e.Cid)
ret.Cp = NewOptInt(e.Cp)
ret.Card = NewOptInt(e.Card)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewSevLists(es []*ent.Sev) []SevList {
if len(es) == 0 {
return nil
}
r := make([]SevList, len(es))
for i, e := range es {
r[i] = NewSevList(e).Elem()
}
return r
}
func (s *SevList) Elem() SevList {
if s == nil {
return SevList{}
}
return *s
}
func NewSevRead(e *ent.Sev) *SevRead {
if e == nil {
return nil
}
var ret SevRead
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Did = NewOptString(e.Did)
ret.UID = NewOptInt(e.UID)
ret.Cid = NewOptInt(e.Cid)
ret.Cp = NewOptInt(e.Cp)
ret.Card = NewOptInt(e.Card)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewSevReads(es []*ent.Sev) []SevRead {
if len(es) == 0 {
return nil
}
r := make([]SevRead, len(es))
for i, e := range es {
r[i] = NewSevRead(e).Elem()
}
return r
}
func (s *SevRead) Elem() SevRead {
if s == nil {
return SevRead{}
}
return *s
}
func NewSevUpdate(e *ent.Sev) *SevUpdate {
if e == nil {
return nil
}
var ret SevUpdate
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Did = NewOptString(e.Did)
ret.UID = NewOptInt(e.UID)
ret.Cid = NewOptInt(e.Cid)
ret.Cp = NewOptInt(e.Cp)
ret.Card = NewOptInt(e.Card)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewSevUpdates(es []*ent.Sev) []SevUpdate {
if len(es) == 0 {
return nil
}
r := make([]SevUpdate, len(es))
for i, e := range es {
r[i] = NewSevUpdate(e).Elem()
}
return r
}
func (s *SevUpdate) Elem() SevUpdate {
if s == nil {
return SevUpdate{}
}
return *s
}
func NewSevOwnerRead(e *ent.User) *SevOwnerRead {
if e == nil {
return nil
}
var ret SevOwnerRead
ret.ID = e.ID
ret.Username = e.Username
ret.Did = NewOptString(e.Did)
ret.Member = NewOptBool(e.Member)
ret.Book = NewOptBool(e.Book)
ret.Manga = NewOptBool(e.Manga)
ret.Badge = NewOptBool(e.Badge)
ret.Bsky = NewOptBool(e.Bsky)
ret.Mastodon = NewOptBool(e.Mastodon)
ret.Delete = NewOptBool(e.Delete)
ret.Handle = NewOptBool(e.Handle)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.RaidAt = NewOptDateTime(e.RaidAt)
ret.ServerAt = NewOptDateTime(e.ServerAt)
ret.EggAt = NewOptDateTime(e.EggAt)
ret.Luck = NewOptInt(e.Luck)
ret.LuckAt = NewOptDateTime(e.LuckAt)
ret.Like = NewOptInt(e.Like)
ret.LikeRank = NewOptInt(e.LikeRank)
ret.LikeAt = NewOptDateTime(e.LikeAt)
ret.Fav = NewOptInt(e.Fav)
ret.Ten = NewOptBool(e.Ten)
ret.TenSu = NewOptInt(e.TenSu)
ret.TenKai = NewOptInt(e.TenKai)
ret.Aiten = NewOptInt(e.Aiten)
ret.TenCard = NewOptString(e.TenCard)
ret.TenDelete = NewOptString(e.TenDelete)
ret.TenPost = NewOptString(e.TenPost)
ret.TenGet = NewOptString(e.TenGet)
ret.TenAt = NewOptDateTime(e.TenAt)
ret.Next = NewOptString(e.Next)
ret.Room = NewOptInt(e.Room)
ret.Model = NewOptBool(e.Model)
ret.ModelAt = NewOptDateTime(e.ModelAt)
ret.ModelAttack = NewOptInt(e.ModelAttack)
ret.ModelLimit = NewOptInt(e.ModelLimit)
ret.ModelSkill = NewOptInt(e.ModelSkill)
ret.ModelMode = NewOptInt(e.ModelMode)
ret.ModelCritical = NewOptInt(e.ModelCritical)
ret.ModelCriticalD = NewOptInt(e.ModelCriticalD)
ret.Game = NewOptBool(e.Game)
ret.GameTest = NewOptBool(e.GameTest)
ret.GameEnd = NewOptBool(e.GameEnd)
ret.GameAccount = NewOptBool(e.GameAccount)
ret.GameLv = NewOptInt(e.GameLv)
ret.Coin = NewOptInt(e.Coin)
ret.CoinOpen = NewOptBool(e.CoinOpen)
ret.CoinAt = NewOptDateTime(e.CoinAt)
return &ret
}
func NewSevOwnerReads(es []*ent.User) []SevOwnerRead {
if len(es) == 0 {
return nil
}
r := make([]SevOwnerRead, len(es))
for i, e := range es {
r[i] = NewSevOwnerRead(e).Elem()
}
return r
}
func (u *SevOwnerRead) Elem() SevOwnerRead {
if u == nil {
return SevOwnerRead{}
}
return *u
}
func NewUeCreate(e *ent.Ue) *UeCreate {
if e == nil {
return nil
@ -1262,6 +1485,43 @@ func (m *UserMaList) Elem() UserMaList {
return *m
}
func NewUserSevList(e *ent.Sev) *UserSevList {
if e == nil {
return nil
}
var ret UserSevList
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Did = NewOptString(e.Did)
ret.UID = NewOptInt(e.UID)
ret.Cid = NewOptInt(e.Cid)
ret.Cp = NewOptInt(e.Cp)
ret.Card = NewOptInt(e.Card)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUserSevLists(es []*ent.Sev) []UserSevList {
if len(es) == 0 {
return nil
}
r := make([]UserSevList, len(es))
for i, e := range es {
r[i] = NewUserSevList(e).Elem()
}
return r
}
func (s *UserSevList) Elem() UserSevList {
if s == nil {
return UserSevList{}
}
return *s
}
func NewUserUeList(e *ent.Ue) *UserUeList {
if e == nil {
return nil