ai/api
1
0
Fork 0
Code Activity

test manga

Browse Source
This commit is contained in:
syui
2024-04-02 18:57:04 +09:00
parent b48ec9e88c
commit 6a868436e7
40 changed files with 16522 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

630
ent/ogent/oas_client_gen.go
View File

@ -201,6 +201,77 @@ func (c *Client) sendCreateGroup(ctx context.Context, request *CreateGroupReq) (
return result, nil
}
// CreateMa invokes createMa operation.
//
// Creates a new Ma and persists it to storage.
//
// POST /mas
func (c *Client) CreateMa(ctx context.Context, request *CreateMaReq) (CreateMaRes, error) {
res, err := c.sendCreateMa(ctx, request)
_ = res
return res, err
}
func (c *Client) sendCreateMa(ctx context.Context, request *CreateMaReq) (res CreateMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createMa"),
}
// 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, "CreateMa",
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 += "/mas"
stage = "EncodeRequest"
r, err := ht.NewRequest(ctx, "POST", u, nil)
if err != nil {
return res, errors.Wrap(err, "create request")
}
if err := encodeCreateMaRequest(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 := decodeCreateMaResponse(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.
@ -507,6 +578,88 @@ func (c *Client) sendDeleteGroup(ctx context.Context, params DeleteGroupParams)
return result, nil
}
// DeleteMa invokes deleteMa operation.
//
// Deletes the Ma with the requested ID.
//
// DELETE /mas/{id}
func (c *Client) DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error) {
res, err := c.sendDeleteMa(ctx, params)
_ = res
return res, err
}
func (c *Client) sendDeleteMa(ctx context.Context, params DeleteMaParams) (res DeleteMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteMa"),
}
// 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, "DeleteMa",
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 += "/mas/"
{
// 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 := decodeDeleteMaResponse(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.
@ -1170,6 +1323,112 @@ func (c *Client) sendListGroupUsers(ctx context.Context, params ListGroupUsersPa
return result, nil
}
// ListMa invokes listMa operation.
//
// List Mas.
//
// GET /mas
func (c *Client) ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error) {
res, err := c.sendListMa(ctx, params)
_ = res
return res, err
}
func (c *Client) sendListMa(ctx context.Context, params ListMaParams) (res ListMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listMa"),
}
// 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, "ListMa",
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 += "/mas"
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 := decodeListMaResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ListUe invokes listUe operation.
//
// List Ues.
@ -1503,6 +1762,127 @@ func (c *Client) sendListUserCard(ctx context.Context, params ListUserCardParams
return result, nil
}
// ListUserMa invokes listUserMa operation.
//
// List attached Mas.
//
// GET /users/{id}/ma
func (c *Client) ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error) {
res, err := c.sendListUserMa(ctx, params)
_ = res
return res, err
}
func (c *Client) sendListUserMa(ctx context.Context, params ListUserMaParams) (res ListUserMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUserMa"),
}
// 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, "ListUserMa",
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 += "/ma"
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 := decodeListUserMaResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ListUserUe invokes listUserUe operation.
//
// List attached Ues.
@ -1871,6 +2251,171 @@ func (c *Client) sendReadGroup(ctx context.Context, params ReadGroupParams) (res
return result, nil
}
// ReadMa invokes readMa operation.
//
// Finds the Ma with the requested ID and returns it.
//
// GET /mas/{id}
func (c *Client) ReadMa(ctx context.Context, params ReadMaParams) (ReadMaRes, error) {
res, err := c.sendReadMa(ctx, params)
_ = res
return res, err
}
func (c *Client) sendReadMa(ctx context.Context, params ReadMaParams) (res ReadMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readMa"),
}
// 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, "ReadMa",
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 += "/mas/"
{
// 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 := decodeReadMaResponse(resp)
if err != nil {
return res, errors.Wrap(err, "decode response")
}
return result, nil
}
// ReadMaOwner invokes readMaOwner operation.
//
// Find the attached User of the Ma with the given ID.
//
// GET /mas/{id}/owner
func (c *Client) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error) {
res, err := c.sendReadMaOwner(ctx, params)
_ = res
return res, err
}
func (c *Client) sendReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (res ReadMaOwnerRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readMaOwner"),
}
// 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, "ReadMaOwner",
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 += "/mas/"
{
// 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 := decodeReadMaOwnerResponse(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.
@ -2288,6 +2833,91 @@ func (c *Client) sendUpdateGroup(ctx context.Context, request *UpdateGroupReq, p
return result, nil
}
// UpdateMa invokes updateMa operation.
//
// Updates a Ma and persists changes to storage.
//
// PATCH /mas/{id}
func (c *Client) UpdateMa(ctx context.Context, request *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error) {
res, err := c.sendUpdateMa(ctx, request, params)
_ = res
return res, err
}
func (c *Client) sendUpdateMa(ctx context.Context, request *UpdateMaReq, params UpdateMaParams) (res UpdateMaRes, err error) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateMa"),
}
// 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, "UpdateMa",
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 += "/mas/"
{
// 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 := encodeUpdateMaRequest(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 := decodeUpdateMaResponse(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

@ -221,6 +221,108 @@ func (s *Server) handleCreateGroupRequest(args [0]string, w http.ResponseWriter,
}
}
// handleCreateMaRequest handles createMa operation.
//
// Creates a new Ma and persists it to storage.
//
// POST /mas
func (s *Server) handleCreateMaRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("createMa"),
semconv.HTTPMethodKey.String("POST"),
semconv.HTTPRouteKey.String("/mas"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateMa",
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: "CreateMa",
ID: "createMa",
}
)
request, close, err := s.decodeCreateMaRequest(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 CreateMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "CreateMa",
OperationID: "createMa",
Body: request,
Params: middleware.Parameters{},
Raw: r,
}
type (
Request = *CreateMaReq
Params = struct{}
Response = CreateMaRes
)
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.CreateMa(ctx, request)
return response, err
},
)
} else {
response, err = s.h.CreateMa(ctx, request)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeCreateMaResponse(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.
@ -629,6 +731,108 @@ func (s *Server) handleDeleteGroupRequest(args [1]string, w http.ResponseWriter,
}
}
// handleDeleteMaRequest handles deleteMa operation.
//
// Deletes the Ma with the requested ID.
//
// DELETE /mas/{id}
func (s *Server) handleDeleteMaRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("deleteMa"),
semconv.HTTPMethodKey.String("DELETE"),
semconv.HTTPRouteKey.String("/mas/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteMa",
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: "DeleteMa",
ID: "deleteMa",
}
)
params, err := decodeDeleteMaParams(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 DeleteMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "DeleteMa",
OperationID: "deleteMa",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = DeleteMaParams
Response = DeleteMaRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackDeleteMaParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.DeleteMa(ctx, params)
return response, err
},
)
} else {
response, err = s.h.DeleteMa(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeDeleteMaResponse(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.
@ -1359,6 +1563,112 @@ func (s *Server) handleListGroupUsersRequest(args [1]string, w http.ResponseWrit
}
}
// handleListMaRequest handles listMa operation.
//
// List Mas.
//
// GET /mas
func (s *Server) handleListMaRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listMa"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/mas"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListMa",
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: "ListMa",
ID: "listMa",
}
)
params, err := decodeListMaParams(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 ListMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ListMa",
OperationID: "listMa",
Body: nil,
Params: middleware.Parameters{
{
Name: "page",
In: "query",
}: params.Page,
{
Name: "itemsPerPage",
In: "query",
}: params.ItemsPerPage,
},
Raw: r,
}
type (
Request = struct{}
Params = ListMaParams
Response = ListMaRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackListMaParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ListMa(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ListMa(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeListMaResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleListUeRequest handles listUe operation.
//
// List Ues.
@ -1681,6 +1991,116 @@ func (s *Server) handleListUserCardRequest(args [1]string, w http.ResponseWriter
}
}
// handleListUserMaRequest handles listUserMa operation.
//
// List attached Mas.
//
// GET /users/{id}/ma
func (s *Server) handleListUserMaRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("listUserMa"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/users/{id}/ma"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserMa",
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: "ListUserMa",
ID: "listUserMa",
}
)
params, err := decodeListUserMaParams(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 ListUserMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ListUserMa",
OperationID: "listUserMa",
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 = ListUserMaParams
Response = ListUserMaRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackListUserMaParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ListUserMa(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ListUserMa(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeListUserMaResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleListUserUeRequest handles listUserUe operation.
//
// List attached Ues.
@ -2097,6 +2517,210 @@ func (s *Server) handleReadGroupRequest(args [1]string, w http.ResponseWriter, r
}
}
// handleReadMaRequest handles readMa operation.
//
// Finds the Ma with the requested ID and returns it.
//
// GET /mas/{id}
func (s *Server) handleReadMaRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readMa"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/mas/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadMa",
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: "ReadMa",
ID: "readMa",
}
)
params, err := decodeReadMaParams(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 ReadMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ReadMa",
OperationID: "readMa",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = ReadMaParams
Response = ReadMaRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackReadMaParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ReadMa(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ReadMa(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeReadMaResponse(response, w, span); err != nil {
recordError("EncodeResponse", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
}
// handleReadMaOwnerRequest handles readMaOwner operation.
//
// Find the attached User of the Ma with the given ID.
//
// GET /mas/{id}/owner
func (s *Server) handleReadMaOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("readMaOwner"),
semconv.HTTPMethodKey.String("GET"),
semconv.HTTPRouteKey.String("/mas/{id}/owner"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadMaOwner",
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: "ReadMaOwner",
ID: "readMaOwner",
}
)
params, err := decodeReadMaOwnerParams(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 ReadMaOwnerRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "ReadMaOwner",
OperationID: "readMaOwner",
Body: nil,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = struct{}
Params = ReadMaOwnerParams
Response = ReadMaOwnerRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackReadMaOwnerParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.ReadMaOwner(ctx, params)
return response, err
},
)
} else {
response, err = s.h.ReadMaOwner(ctx, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeReadMaOwnerResponse(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.
@ -2637,6 +3261,123 @@ func (s *Server) handleUpdateGroupRequest(args [1]string, w http.ResponseWriter,
}
}
// handleUpdateMaRequest handles updateMa operation.
//
// Updates a Ma and persists changes to storage.
//
// PATCH /mas/{id}
func (s *Server) handleUpdateMaRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
otelAttrs := []attribute.KeyValue{
otelogen.OperationID("updateMa"),
semconv.HTTPMethodKey.String("PATCH"),
semconv.HTTPRouteKey.String("/mas/{id}"),
}
// Start a span for this request.
ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateMa",
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: "UpdateMa",
ID: "updateMa",
}
)
params, err := decodeUpdateMaParams(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.decodeUpdateMaRequest(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 UpdateMaRes
if m := s.cfg.Middleware; m != nil {
mreq := middleware.Request{
Context: ctx,
OperationName: "UpdateMa",
OperationID: "updateMa",
Body: request,
Params: middleware.Parameters{
{
Name: "id",
In: "path",
}: params.ID,
},
Raw: r,
}
type (
Request = *UpdateMaReq
Params = UpdateMaParams
Response = UpdateMaRes
)
response, err = middleware.HookMiddleware[
Request,
Params,
Response,
](
m,
mreq,
unpackUpdateMaParams,
func(ctx context.Context, request Request, params Params) (response Response, err error) {
response, err = s.h.UpdateMa(ctx, request, params)
return response, err
},
)
} else {
response, err = s.h.UpdateMa(ctx, request, params)
}
if err != nil {
recordError("Internal", err)
s.cfg.ErrorHandler(ctx, w, r, err)
return
}
if err := encodeUpdateMaResponse(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

@ -9,6 +9,10 @@ type CreateGroupRes interface {
createGroupRes()
}
type CreateMaRes interface {
createMaRes()
}
type CreateUeRes interface {
createUeRes()
}
@ -25,6 +29,10 @@ type DeleteGroupRes interface {
deleteGroupRes()
}
type DeleteMaRes interface {
deleteMaRes()
}
type DeleteUeRes interface {
deleteUeRes()
}
@ -45,6 +53,10 @@ type ListGroupUsersRes interface {
listGroupUsersRes()
}
type ListMaRes interface {
listMaRes()
}
type ListUeRes interface {
listUeRes()
}
@ -53,6 +65,10 @@ type ListUserCardRes interface {
listUserCardRes()
}
type ListUserMaRes interface {
listUserMaRes()
}
type ListUserRes interface {
listUserRes()
}
@ -73,6 +89,14 @@ type ReadGroupRes interface {
readGroupRes()
}
type ReadMaOwnerRes interface {
readMaOwnerRes()
}
type ReadMaRes interface {
readMaRes()
}
type ReadUeOwnerRes interface {
readUeOwnerRes()
}
@ -93,6 +117,10 @@ type UpdateGroupRes interface {
updateGroupRes()
}
type UpdateMaRes interface {
updateMaRes()
}
type UpdateUeRes interface {
updateUeRes()
}

3198
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

@ -139,6 +139,68 @@ func decodeDeleteGroupParams(args [1]string, r *http.Request) (params DeleteGrou
return params, nil
}
// DeleteMaParams is parameters of deleteMa operation.
type DeleteMaParams struct {
// ID of the Ma.
ID int
}
func unpackDeleteMaParams(packed middleware.Parameters) (params DeleteMaParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeDeleteMaParams(args [1]string, r *http.Request) (params DeleteMaParams, _ 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.
@ -882,6 +944,171 @@ func decodeListGroupUsersParams(args [1]string, r *http.Request) (params ListGro
return params, nil
}
// ListMaParams is parameters of listMa operation.
type ListMaParams struct {
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListMaParams(packed middleware.Parameters) (params ListMaParams) {
{
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 decodeListMaParams(args [0]string, r *http.Request) (params ListMaParams, _ 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.
@ -1379,6 +1606,173 @@ func decodeListUserCardParams(args [1]string, r *http.Request) (params ListUserC
return params, nil
}
// ListUserMaParams is parameters of listUserMa operation.
type ListUserMaParams struct {
// ID of the User.
ID int
// What page to render.
Page OptInt
// Item count to render per page.
ItemsPerPage OptInt
}
func unpackListUserMaParams(packed middleware.Parameters) (params ListUserMaParams) {
{
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 decodeListUserMaParams(args [1]string, r *http.Request) (params ListUserMaParams, _ 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.
@ -1732,6 +2126,130 @@ func decodeReadGroupParams(args [1]string, r *http.Request) (params ReadGroupPar
return params, nil
}
// ReadMaParams is parameters of readMa operation.
type ReadMaParams struct {
// ID of the Ma.
ID int
}
func unpackReadMaParams(packed middleware.Parameters) (params ReadMaParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadMaParams(args [1]string, r *http.Request) (params ReadMaParams, _ 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
}
// ReadMaOwnerParams is parameters of readMaOwner operation.
type ReadMaOwnerParams struct {
// ID of the Ma.
ID int
}
func unpackReadMaOwnerParams(packed middleware.Parameters) (params ReadMaOwnerParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeReadMaOwnerParams(args [1]string, r *http.Request) (params ReadMaOwnerParams, _ 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.
@ -2042,6 +2560,68 @@ func decodeUpdateGroupParams(args [1]string, r *http.Request) (params UpdateGrou
return params, nil
}
// UpdateMaParams is parameters of updateMa operation.
type UpdateMaParams struct {
// ID of the Ma.
ID int
}
func unpackUpdateMaParams(packed middleware.Parameters) (params UpdateMaParams) {
{
key := middleware.ParameterKey{
Name: "id",
In: "path",
}
params.ID = packed[key].(int)
}
return params
}
func decodeUpdateMaParams(args [1]string, r *http.Request) (params UpdateMaParams, _ 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

@ -141,6 +141,69 @@ func (s *Server) decodeCreateGroupRequest(r *http.Request) (
}
}
func (s *Server) decodeCreateMaRequest(r *http.Request) (
req *CreateMaReq,
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 CreateMaReq
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,
@ -393,6 +456,69 @@ func (s *Server) decodeUpdateGroupRequest(r *http.Request) (
}
}
func (s *Server) decodeUpdateMaRequest(r *http.Request) (
req *UpdateMaReq,
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 UpdateMaReq
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

@ -39,6 +39,20 @@ func encodeCreateGroupRequest(
return nil
}
func encodeCreateMaRequest(
req *CreateMaReq,
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,
@ -95,6 +109,20 @@ func encodeUpdateGroupRequest(
return nil
}
func encodeUpdateMaRequest(
req *UpdateMaReq,
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

215
ent/ogent/oas_router_gen.go
View File

@ -239,6 +239,85 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
s.notAllowed(w, r, "GET")
}
return
}
}
}
case 'm': // Prefix: "mas"
if l := len("mas"); len(elem) >= l && elem[0:l] == "mas" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch r.Method {
case "GET":
s.handleListMaRequest([0]string{}, w, r)
case "POST":
s.handleCreateMaRequest([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.handleDeleteMaRequest([1]string{
args[0],
}, w, r)
case "GET":
s.handleReadMaRequest([1]string{
args[0],
}, w, r)
case "PATCH":
s.handleUpdateMaRequest([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.handleReadMaOwnerRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
}
@ -442,6 +521,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
return
}
}
case 'm': // Prefix: "ma"
if l := len("ma"); len(elem) >= l && elem[0:l] == "ma" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
// Leaf node.
switch r.Method {
case "GET":
s.handleListUserMaRequest([1]string{
args[0],
}, w, r)
default:
s.notAllowed(w, r, "GET")
}
return
}
case 'u': // Prefix: "ue"
if l := len("ue"); len(elem) >= l && elem[0:l] == "ue" {
elem = elem[l:]
@ -770,6 +869,101 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
}
}
}
case 'm': // Prefix: "mas"
if l := len("mas"); len(elem) >= l && elem[0:l] == "mas" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
r.name = "ListMa"
r.operationID = "listMa"
r.pathPattern = "/mas"
r.args = args
r.count = 0
return r, true
case "POST":
r.name = "CreateMa"
r.operationID = "createMa"
r.pathPattern = "/mas"
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 = "DeleteMa"
r.operationID = "deleteMa"
r.pathPattern = "/mas/{id}"
r.args = args
r.count = 1
return r, true
case "GET":
r.name = "ReadMa"
r.operationID = "readMa"
r.pathPattern = "/mas/{id}"
r.args = args
r.count = 1
return r, true
case "PATCH":
r.name = "UpdateMa"
r.operationID = "updateMa"
r.pathPattern = "/mas/{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: ReadMaOwner
r.name = "ReadMaOwner"
r.operationID = "readMaOwner"
r.pathPattern = "/mas/{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:]
@ -1002,6 +1196,27 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
}
}
}
case 'm': // Prefix: "ma"
if l := len("ma"); len(elem) >= l && elem[0:l] == "ma" {
elem = elem[l:]
} else {
break
}
if len(elem) == 0 {
switch method {
case "GET":
// Leaf: ListUserMa
r.name = "ListUserMa"
r.operationID = "listUserMa"
r.pathPattern = "/users/{id}/ma"
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:]

1662
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

@ -20,6 +20,12 @@ type Handler interface {
//
// POST /groups
CreateGroup(ctx context.Context, req *CreateGroupReq) (CreateGroupRes, error)
// CreateMa implements createMa operation.
//
// Creates a new Ma and persists it to storage.
//
// POST /mas
CreateMa(ctx context.Context, req *CreateMaReq) (CreateMaRes, error)
// CreateUe implements createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -44,6 +50,12 @@ type Handler interface {
//
// DELETE /groups/{id}
DeleteGroup(ctx context.Context, params DeleteGroupParams) (DeleteGroupRes, error)
// DeleteMa implements deleteMa operation.
//
// Deletes the Ma with the requested ID.
//
// DELETE /mas/{id}
DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error)
// DeleteUe implements deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -86,6 +98,12 @@ type Handler interface {
//
// GET /groups/{id}/users
ListGroupUsers(ctx context.Context, params ListGroupUsersParams) (ListGroupUsersRes, error)
// ListMa implements listMa operation.
//
// List Mas.
//
// GET /mas
ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error)
// ListUe implements listUe operation.
//
// List Ues.
@ -104,6 +122,12 @@ type Handler interface {
//
// GET /users/{id}/card
ListUserCard(ctx context.Context, params ListUserCardParams) (ListUserCardRes, error)
// ListUserMa implements listUserMa operation.
//
// List attached Mas.
//
// GET /users/{id}/ma
ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error)
// ListUserUe implements listUserUe operation.
//
// List attached Ues.
@ -128,6 +152,18 @@ type Handler interface {
//
// GET /groups/{id}
ReadGroup(ctx context.Context, params ReadGroupParams) (ReadGroupRes, error)
// ReadMa implements readMa operation.
//
// Finds the Ma with the requested ID and returns it.
//
// GET /mas/{id}
ReadMa(ctx context.Context, params ReadMaParams) (ReadMaRes, error)
// ReadMaOwner implements readMaOwner operation.
//
// Find the attached User of the Ma with the given ID.
//
// GET /mas/{id}/owner
ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error)
// ReadUe implements readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -158,6 +194,12 @@ type Handler interface {
//
// PATCH /groups/{id}
UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error)
// UpdateMa implements updateMa operation.
//
// Updates a Ma and persists changes to storage.
//
// PATCH /mas/{id}
UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error)
// UpdateUe implements updateUe operation.
//
// Updates a Ue and persists changes to storage.

63
ent/ogent/oas_unimplemented_gen.go
View File

@ -31,6 +31,15 @@ func (UnimplementedHandler) CreateGroup(ctx context.Context, req *CreateGroupReq
return r, ht.ErrNotImplemented
}
// CreateMa implements createMa operation.
//
// Creates a new Ma and persists it to storage.
//
// POST /mas
func (UnimplementedHandler) CreateMa(ctx context.Context, req *CreateMaReq) (r CreateMaRes, _ error) {
return r, ht.ErrNotImplemented
}
// CreateUe implements createUe operation.
//
// Creates a new Ue and persists it to storage.
@ -67,6 +76,15 @@ func (UnimplementedHandler) DeleteGroup(ctx context.Context, params DeleteGroupP
return r, ht.ErrNotImplemented
}
// DeleteMa implements deleteMa operation.
//
// Deletes the Ma with the requested ID.
//
// DELETE /mas/{id}
func (UnimplementedHandler) DeleteMa(ctx context.Context, params DeleteMaParams) (r DeleteMaRes, _ error) {
return r, ht.ErrNotImplemented
}
// DeleteUe implements deleteUe operation.
//
// Deletes the Ue with the requested ID.
@ -130,6 +148,15 @@ func (UnimplementedHandler) ListGroupUsers(ctx context.Context, params ListGroup
return r, ht.ErrNotImplemented
}
// ListMa implements listMa operation.
//
// List Mas.
//
// GET /mas
func (UnimplementedHandler) ListMa(ctx context.Context, params ListMaParams) (r ListMaRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUe implements listUe operation.
//
// List Ues.
@ -157,6 +184,15 @@ func (UnimplementedHandler) ListUserCard(ctx context.Context, params ListUserCar
return r, ht.ErrNotImplemented
}
// ListUserMa implements listUserMa operation.
//
// List attached Mas.
//
// GET /users/{id}/ma
func (UnimplementedHandler) ListUserMa(ctx context.Context, params ListUserMaParams) (r ListUserMaRes, _ error) {
return r, ht.ErrNotImplemented
}
// ListUserUe implements listUserUe operation.
//
// List attached Ues.
@ -193,6 +229,24 @@ func (UnimplementedHandler) ReadGroup(ctx context.Context, params ReadGroupParam
return r, ht.ErrNotImplemented
}
// ReadMa implements readMa operation.
//
// Finds the Ma with the requested ID and returns it.
//
// GET /mas/{id}
func (UnimplementedHandler) ReadMa(ctx context.Context, params ReadMaParams) (r ReadMaRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadMaOwner implements readMaOwner operation.
//
// Find the attached User of the Ma with the given ID.
//
// GET /mas/{id}/owner
func (UnimplementedHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (r ReadMaOwnerRes, _ error) {
return r, ht.ErrNotImplemented
}
// ReadUe implements readUe operation.
//
// Finds the Ue with the requested ID and returns it.
@ -238,6 +292,15 @@ func (UnimplementedHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq
return r, ht.ErrNotImplemented
}
// UpdateMa implements updateMa operation.
//
// Updates a Ma and persists changes to storage.
//
// PATCH /mas/{id}
func (UnimplementedHandler) UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (r UpdateMaRes, _ 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

@ -24,6 +24,12 @@ func (s ListGroupUsersOKApplicationJSON) Validate() error {
}
return nil
}
func (s ListMaOKApplicationJSON) 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")
@ -36,6 +42,12 @@ func (s ListUserCardOKApplicationJSON) Validate() error {
}
return nil
}
func (s ListUserMaOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")
}
return nil
}
func (s ListUserOKApplicationJSON) Validate() error {
if s == nil {
return errors.New("nil is invalid value")

662
ent/ogent/ogent.go
View File

@ -9,9 +9,10 @@ import (
"api/ent"
"api/ent/card"
"api/ent/group"
"api/ent/ma"
"api/ent/ue"
"api/ent/user"
"os"
"github.com/go-faster/jx"
)
@ -66,12 +67,12 @@ func (h *OgentHandler) CreateCard(ctx context.Context, req *CreateCardReq) (Crea
if v, ok := req.CreatedAt.Get(); ok {
b.SetCreatedAt(v)
}
// Add all edges.
if req.Password == password {
b.SetOwnerID(req.Owner)
} else {
b.SetOwnerID(0)
}
// Add all edges.
//b.SetOwnerID(req.Owner)
// Persist to storage.
e, err := b.Save(ctx)
@ -143,6 +144,9 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param
if v, ok := req.Status.Get(); ok {
b.SetStatus(v)
}
if v, ok := req.Token.Get(); ok {
b.SetToken(v)
}
if v, ok := req.Cp.Get(); ok {
b.SetCp(v)
}
@ -156,6 +160,9 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param
b.SetAuthor(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)
@ -164,7 +171,6 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param
}
}
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
@ -198,8 +204,8 @@ func (h *OgentHandler) UpdateCard(ctx context.Context, req *UpdateCardReq, param
// DeleteCard handles DELETE /cards/{id} requests.
func (h *OgentHandler) DeleteCard(ctx context.Context, params DeleteCardParams) (DeleteCardRes, error) {
err := h.client.Card.DeleteOneID(params.ID).Exec(ctx)
//err := h.client.Card.DeleteOneID(0).Exec(ctx)
//err := h.client.Card.DeleteOneID(params.ID).Exec(ctx)
err := h.client.Card.DeleteOneID(0).Exec(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
@ -353,8 +359,7 @@ func (h *OgentHandler) ReadGroup(ctx context.Context, params ReadGroupParams) (R
// UpdateGroup handles PATCH /groups/{id} requests.
func (h *OgentHandler) UpdateGroup(ctx context.Context, req *UpdateGroupReq, params UpdateGroupParams) (UpdateGroupRes, error) {
b := h.client.Group.UpdateOneID(0)
//b := h.client.Group.UpdateOneID(params.ID)
b := h.client.Group.UpdateOneID(params.ID)
// Add all fields.
if v, ok := req.Name.Get(); ok {
b.SetName(v)
@ -494,6 +499,287 @@ func (h *OgentHandler) ListGroupUsers(ctx context.Context, params ListGroupUsers
return (*ListGroupUsersOKApplicationJSON)(&r), nil
}
// CreateMa handles POST /mas requests.
func (h *OgentHandler) CreateMa(ctx context.Context, req *CreateMaReq) (CreateMaRes, error) {
b := h.client.Ma.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.Text.Get(); ok {
b.SetText(v)
}
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.Avatar.Get(); ok {
b.SetAvatar(v)
}
if v, ok := req.Cid.Get(); ok {
b.SetCid(v)
}
if v, ok := req.URI.Get(); ok {
b.SetURI(v)
}
if v, ok := req.Rkey.Get(); ok {
b.SetRkey(v)
}
if v, ok := req.BskyURL.Get(); ok {
b.SetBskyURL(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.Ma.Query().Where(ma.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewMaCreate(e), nil
}
// ReadMa handles GET /mas/{id} requests.
func (h *OgentHandler) ReadMa(ctx context.Context, params ReadMaParams) (ReadMaRes, error) {
q := h.client.Ma.Query().Where(ma.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 NewMaRead(e), nil
}
// UpdateMa handles PATCH /mas/{id} requests.
func (h *OgentHandler) UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error) {
b := h.client.Ma.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.Text.Get(); ok {
b.SetText(v)
}
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.Avatar.Get(); ok {
b.SetAvatar(v)
}
if v, ok := req.Cid.Get(); ok {
b.SetCid(v)
}
if v, ok := req.URI.Get(); ok {
b.SetURI(v)
}
if v, ok := req.Rkey.Get(); ok {
b.SetRkey(v)
}
if v, ok := req.BskyURL.Get(); ok {
b.SetBskyURL(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.Ma.Query().Where(ma.ID(e.ID))
e, err = q.Only(ctx)
if err != nil {
// This should never happen.
return nil, err
}
return NewMaUpdate(e), nil
}
// DeleteMa handles DELETE /mas/{id} requests.
func (h *OgentHandler) DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error) {
err := h.client.Ma.DeleteOneID(0).Exec(ctx)
//err := h.client.Ma.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(DeleteMaNoContent), nil
}
// ListMa handles GET /mas requests.
func (h *OgentHandler) ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error) {
q := h.client.Ma.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 := NewMaLists(es)
return (*ListMaOKApplicationJSON)(&r), nil
}
// ReadMaOwner handles GET /mas/{id}/owner requests.
func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error) {
q := h.client.Ma.Query().Where(ma.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 NewMaOwnerRead(e), nil
}
// CreateUe handles POST /ues requests.
func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) {
b := h.client.Ue.Create()
@ -648,6 +934,9 @@ func (h *OgentHandler) UpdateUe(ctx context.Context, req *UpdateUeReq, params Up
if v, ok := req.Mode.Get(); ok {
b.SetMode(v)
}
if v, ok := req.Token.Get(); ok {
b.SetToken(v)
}
if v, ok := req.Cp.Get(); ok {
b.SetCp(v)
}
@ -670,6 +959,9 @@ func (h *OgentHandler) UpdateUe(ctx context.Context, req *UpdateUeReq, params Up
b.SetAuthor(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)
@ -678,7 +970,6 @@ func (h *OgentHandler) UpdateUe(ctx context.Context, req *UpdateUeReq, params Up
}
}
}
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
@ -712,8 +1003,8 @@ func (h *OgentHandler) UpdateUe(ctx context.Context, req *UpdateUeReq, params Up
// DeleteUe handles DELETE /ues/{id} requests.
func (h *OgentHandler) DeleteUe(ctx context.Context, params DeleteUeParams) (DeleteUeRes, error) {
err := h.client.Ue.DeleteOneID(0).Exec(ctx)
//err := h.client.Ue.DeleteOneID(params.ID).Exec(ctx)
err := h.client.Ue.DeleteOneID(0).Exec(ctx)
if err != nil {
switch {
case ent.IsNotFound(err):
@ -803,7 +1094,14 @@ func (h *OgentHandler) ReadUeOwner(ctx context.Context, params ReadUeOwnerParams
// CreateUser handles POST /users requests.
func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (CreateUserRes, error) {
b := h.client.User.Create()
if v, ok := req.Did.Get(); ok {
// Add all fields.
//b.SetUsername(req.Username)
if req.Password == password {
b.SetUsername(req.Username)
} else {
b.SetUsername("")
}
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.Member.Get(); ok {
@ -948,17 +1246,10 @@ func (h *OgentHandler) CreateUser(ctx context.Context, req *CreateUserReq) (Crea
if v, ok := req.CoinAt.Get(); ok {
b.SetCoinAt(v)
}
// Add all fields.
//b.SetUsername(req.Username)
if req.Password == password {
b.SetUsername(req.Username)
} else {
b.SetUsername("")
}
// Add all edges.
b.AddCardIDs(req.Card...)
b.AddUeIDs(req.Ue...)
b.AddMaIDs(req.Ma...)
// Persist to storage.
e, err := b.Save(ctx)
if err != nil {
@ -1021,152 +1312,159 @@ func (h *OgentHandler) UpdateUser(ctx context.Context, req *UpdateUserReq, param
b := h.client.User.UpdateOneID(params.ID)
if v, ok := req.Token.Get(); ok {
if v == token {
// Add all fields.
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.Member.Get(); ok {
b.SetMember(v)
}
if v, ok := req.Book.Get(); ok {
b.SetBook(v)
}
if v, ok := req.Manga.Get(); ok {
b.SetManga(v)
}
if v, ok := req.Badge.Get(); ok {
b.SetBadge(v)
}
if v, ok := req.Bsky.Get(); ok {
b.SetBsky(v)
}
if v, ok := req.Mastodon.Get(); ok {
b.SetMastodon(v)
}
if v, ok := req.Delete.Get(); ok {
b.SetDelete(v)
}
if v, ok := req.Handle.Get(); ok {
b.SetHandle(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
if v, ok := req.RaidAt.Get(); ok {
b.SetRaidAt(v)
}
if v, ok := req.ServerAt.Get(); ok {
b.SetServerAt(v)
}
if v, ok := req.EggAt.Get(); ok {
b.SetEggAt(v)
}
if v, ok := req.Luck.Get(); ok {
b.SetLuck(v)
}
if v, ok := req.LuckAt.Get(); ok {
b.SetLuckAt(v)
}
if v, ok := req.Like.Get(); ok {
b.SetLike(v)
}
if v, ok := req.LikeRank.Get(); ok {
b.SetLikeRank(v)
}
if v, ok := req.LikeAt.Get(); ok {
b.SetLikeAt(v)
}
if v, ok := req.Fav.Get(); ok {
b.SetFav(v)
}
if v, ok := req.Ten.Get(); ok {
b.SetTen(v)
}
if v, ok := req.TenSu.Get(); ok {
b.SetTenSu(v)
}
if v, ok := req.TenKai.Get(); ok {
b.SetTenKai(v)
}
if v, ok := req.Aiten.Get(); ok {
b.SetAiten(v)
}
if v, ok := req.TenCard.Get(); ok {
b.SetTenCard(v)
}
if v, ok := req.TenDelete.Get(); ok {
b.SetTenDelete(v)
}
if v, ok := req.TenPost.Get(); ok {
b.SetTenPost(v)
}
if v, ok := req.TenGet.Get(); ok {
b.SetTenGet(v)
}
if v, ok := req.TenAt.Get(); ok {
b.SetTenAt(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
if v, ok := req.Room.Get(); ok {
b.SetRoom(v)
}
if v, ok := req.Model.Get(); ok {
b.SetModel(v)
}
if v, ok := req.ModelAt.Get(); ok {
b.SetModelAt(v)
}
if v, ok := req.ModelAttack.Get(); ok {
b.SetModelAttack(v)
}
if v, ok := req.ModelLimit.Get(); ok {
b.SetModelLimit(v)
}
if v, ok := req.ModelSkill.Get(); ok {
b.SetModelSkill(v)
}
if v, ok := req.ModelMode.Get(); ok {
b.SetModelMode(v)
}
if v, ok := req.ModelCritical.Get(); ok {
b.SetModelCritical(v)
}
if v, ok := req.ModelCriticalD.Get(); ok {
b.SetModelCriticalD(v)
}
if v, ok := req.Game.Get(); ok {
b.SetGame(v)
}
if v, ok := req.GameTest.Get(); ok {
b.SetGameTest(v)
}
if v, ok := req.GameEnd.Get(); ok {
b.SetGameEnd(v)
}
if v, ok := req.GameAccount.Get(); ok {
b.SetGameAccount(v)
}
if v, ok := req.GameLv.Get(); ok {
b.SetGameLv(v)
}
if v, ok := req.Coin.Get(); ok {
b.SetCoin(v)
}
if v, ok := req.CoinOpen.Get(); ok {
b.SetCoinOpen(v)
}
if v, ok := req.CoinAt.Get(); ok {
b.SetCoinAt(v)
}
// Add all edges.
if req.Card != nil {
b.ClearCard().AddCardIDs(req.Card...)
}
if req.Ue != nil {
b.ClearUe().AddUeIDs(req.Ue...)
}
// Add all fields.
if v, ok := req.Did.Get(); ok {
b.SetDid(v)
}
if v, ok := req.Member.Get(); ok {
b.SetMember(v)
}
if v, ok := req.Book.Get(); ok {
b.SetBook(v)
}
if v, ok := req.Manga.Get(); ok {
b.SetManga(v)
}
if v, ok := req.Badge.Get(); ok {
b.SetBadge(v)
}
if v, ok := req.Bsky.Get(); ok {
b.SetBsky(v)
}
if v, ok := req.Mastodon.Get(); ok {
b.SetMastodon(v)
}
if v, ok := req.Delete.Get(); ok {
b.SetDelete(v)
}
if v, ok := req.Handle.Get(); ok {
b.SetHandle(v)
}
if v, ok := req.Token.Get(); ok {
b.SetToken(v)
}
if v, ok := req.UpdatedAt.Get(); ok {
b.SetUpdatedAt(v)
}
if v, ok := req.RaidAt.Get(); ok {
b.SetRaidAt(v)
}
if v, ok := req.ServerAt.Get(); ok {
b.SetServerAt(v)
}
if v, ok := req.EggAt.Get(); ok {
b.SetEggAt(v)
}
if v, ok := req.Luck.Get(); ok {
b.SetLuck(v)
}
if v, ok := req.LuckAt.Get(); ok {
b.SetLuckAt(v)
}
if v, ok := req.Like.Get(); ok {
b.SetLike(v)
}
if v, ok := req.LikeRank.Get(); ok {
b.SetLikeRank(v)
}
if v, ok := req.LikeAt.Get(); ok {
b.SetLikeAt(v)
}
if v, ok := req.Fav.Get(); ok {
b.SetFav(v)
}
if v, ok := req.Ten.Get(); ok {
b.SetTen(v)
}
if v, ok := req.TenSu.Get(); ok {
b.SetTenSu(v)
}
if v, ok := req.TenKai.Get(); ok {
b.SetTenKai(v)
}
if v, ok := req.Aiten.Get(); ok {
b.SetAiten(v)
}
if v, ok := req.TenCard.Get(); ok {
b.SetTenCard(v)
}
if v, ok := req.TenDelete.Get(); ok {
b.SetTenDelete(v)
}
if v, ok := req.TenPost.Get(); ok {
b.SetTenPost(v)
}
if v, ok := req.TenGet.Get(); ok {
b.SetTenGet(v)
}
if v, ok := req.TenAt.Get(); ok {
b.SetTenAt(v)
}
if v, ok := req.Next.Get(); ok {
b.SetNext(v)
}
if v, ok := req.Room.Get(); ok {
b.SetRoom(v)
}
if v, ok := req.Model.Get(); ok {
b.SetModel(v)
}
if v, ok := req.ModelAt.Get(); ok {
b.SetModelAt(v)
}
if v, ok := req.ModelAttack.Get(); ok {
b.SetModelAttack(v)
}
if v, ok := req.ModelLimit.Get(); ok {
b.SetModelLimit(v)
}
if v, ok := req.ModelSkill.Get(); ok {
b.SetModelSkill(v)
}
if v, ok := req.ModelMode.Get(); ok {
b.SetModelMode(v)
}
if v, ok := req.ModelCritical.Get(); ok {
b.SetModelCritical(v)
}
if v, ok := req.ModelCriticalD.Get(); ok {
b.SetModelCriticalD(v)
}
if v, ok := req.Game.Get(); ok {
b.SetGame(v)
}
if v, ok := req.GameTest.Get(); ok {
b.SetGameTest(v)
}
if v, ok := req.GameEnd.Get(); ok {
b.SetGameEnd(v)
}
if v, ok := req.GameAccount.Get(); ok {
b.SetGameAccount(v)
}
if v, ok := req.GameLv.Get(); ok {
b.SetGameLv(v)
}
if v, ok := req.Coin.Get(); ok {
b.SetCoin(v)
}
if v, ok := req.CoinOpen.Get(); ok {
b.SetCoinOpen(v)
}
if v, ok := req.CoinAt.Get(); ok {
b.SetCoinAt(v)
}
// Add all edges.
if req.Card != nil {
b.ClearCard().AddCardIDs(req.Card...)
}
if req.Ue != nil {
b.ClearUe().AddUeIDs(req.Ue...)
}
if req.Ma != nil {
b.ClearMa().AddMaIDs(req.Ma...)
}
b.SetToken(v)
}
}
@ -1336,3 +1634,39 @@ func (h *OgentHandler) ListUserUe(ctx context.Context, params ListUserUeParams)
r := NewUserUeLists(es)
return (*ListUserUeOKApplicationJSON)(&r), nil
}
// ListUserMa handles GET /users/{id}/ma requests.
func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error) {
q := h.client.User.Query().Where(user.IDEQ(params.ID)).QueryMa()
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 := NewUserMaLists(es)
return (*ListUserMaOKApplicationJSON)(&r), nil
}

270
ent/ogent/responses.go
View File

@ -406,6 +406,237 @@ func (u *GroupUsersList) Elem() GroupUsersList {
return *u
}
func NewMaCreate(e *ent.Ma) *MaCreate {
if e == nil {
return nil
}
var ret MaCreate
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Text = NewOptString(e.Text)
ret.Did = NewOptString(e.Did)
ret.Avatar = NewOptString(e.Avatar)
ret.Cid = NewOptString(e.Cid)
ret.URI = NewOptString(e.URI)
ret.Rkey = NewOptString(e.Rkey)
ret.BskyURL = NewOptString(e.BskyURL)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewMaCreates(es []*ent.Ma) []MaCreate {
if len(es) == 0 {
return nil
}
r := make([]MaCreate, len(es))
for i, e := range es {
r[i] = NewMaCreate(e).Elem()
}
return r
}
func (m *MaCreate) Elem() MaCreate {
if m == nil {
return MaCreate{}
}
return *m
}
func NewMaList(e *ent.Ma) *MaList {
if e == nil {
return nil
}
var ret MaList
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Text = NewOptString(e.Text)
ret.Did = NewOptString(e.Did)
ret.Avatar = NewOptString(e.Avatar)
ret.Cid = NewOptString(e.Cid)
ret.URI = NewOptString(e.URI)
ret.Rkey = NewOptString(e.Rkey)
ret.BskyURL = NewOptString(e.BskyURL)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewMaLists(es []*ent.Ma) []MaList {
if len(es) == 0 {
return nil
}
r := make([]MaList, len(es))
for i, e := range es {
r[i] = NewMaList(e).Elem()
}
return r
}
func (m *MaList) Elem() MaList {
if m == nil {
return MaList{}
}
return *m
}
func NewMaRead(e *ent.Ma) *MaRead {
if e == nil {
return nil
}
var ret MaRead
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Text = NewOptString(e.Text)
ret.Did = NewOptString(e.Did)
ret.Avatar = NewOptString(e.Avatar)
ret.Cid = NewOptString(e.Cid)
ret.URI = NewOptString(e.URI)
ret.Rkey = NewOptString(e.Rkey)
ret.BskyURL = NewOptString(e.BskyURL)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewMaReads(es []*ent.Ma) []MaRead {
if len(es) == 0 {
return nil
}
r := make([]MaRead, len(es))
for i, e := range es {
r[i] = NewMaRead(e).Elem()
}
return r
}
func (m *MaRead) Elem() MaRead {
if m == nil {
return MaRead{}
}
return *m
}
func NewMaUpdate(e *ent.Ma) *MaUpdate {
if e == nil {
return nil
}
var ret MaUpdate
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Text = NewOptString(e.Text)
ret.Did = NewOptString(e.Did)
ret.Avatar = NewOptString(e.Avatar)
ret.Cid = NewOptString(e.Cid)
ret.URI = NewOptString(e.URI)
ret.Rkey = NewOptString(e.Rkey)
ret.BskyURL = NewOptString(e.BskyURL)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewMaUpdates(es []*ent.Ma) []MaUpdate {
if len(es) == 0 {
return nil
}
r := make([]MaUpdate, len(es))
for i, e := range es {
r[i] = NewMaUpdate(e).Elem()
}
return r
}
func (m *MaUpdate) Elem() MaUpdate {
if m == nil {
return MaUpdate{}
}
return *m
}
func NewMaOwnerRead(e *ent.User) *MaOwnerRead {
if e == nil {
return nil
}
var ret MaOwnerRead
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 NewMaOwnerReads(es []*ent.User) []MaOwnerRead {
if len(es) == 0 {
return nil
}
r := make([]MaOwnerRead, len(es))
for i, e := range es {
r[i] = NewMaOwnerRead(e).Elem()
}
return r
}
func (u *MaOwnerRead) Elem() MaOwnerRead {
if u == nil {
return MaOwnerRead{}
}
return *u
}
func NewUeCreate(e *ent.Ue) *UeCreate {
if e == nil {
return nil
@ -992,6 +1223,45 @@ func (c *UserCardList) Elem() UserCardList {
return *c
}
func NewUserMaList(e *ent.Ma) *UserMaList {
if e == nil {
return nil
}
var ret UserMaList
ret.ID = e.ID
ret.Limit = NewOptBool(e.Limit)
ret.Count = NewOptInt(e.Count)
ret.Handle = NewOptString(e.Handle)
ret.Text = NewOptString(e.Text)
ret.Did = NewOptString(e.Did)
ret.Avatar = NewOptString(e.Avatar)
ret.Cid = NewOptString(e.Cid)
ret.URI = NewOptString(e.URI)
ret.Rkey = NewOptString(e.Rkey)
ret.BskyURL = NewOptString(e.BskyURL)
ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
ret.CreatedAt = NewOptDateTime(e.CreatedAt)
return &ret
}
func NewUserMaLists(es []*ent.Ma) []UserMaList {
if len(es) == 0 {
return nil
}
r := make([]UserMaList, len(es))
for i, e := range es {
r[i] = NewUserMaList(e).Elem()
}
return r
}
func (m *UserMaList) Elem() UserMaList {
if m == nil {
return UserMaList{}
}
return *m
}
func NewUserUeList(e *ent.Ue) *UserUeList {
if e == nil {
return nil