1116 lines
27 KiB
Go
1116 lines
27 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package ogent
|
|
|
|
import (
|
|
"context"
|
|
"net/url"
|
|
"time"
|
|
|
|
"github.com/go-faster/errors"
|
|
"go.opentelemetry.io/otel/attribute"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"go.opentelemetry.io/otel/trace"
|
|
|
|
"github.com/ogen-go/ogen/conv"
|
|
ht "github.com/ogen-go/ogen/http"
|
|
"github.com/ogen-go/ogen/otelogen"
|
|
"github.com/ogen-go/ogen/uri"
|
|
)
|
|
|
|
// Client implements OAS client.
|
|
type Client struct {
|
|
serverURL *url.URL
|
|
baseClient
|
|
}
|
|
|
|
var _ Handler = struct {
|
|
*Client
|
|
}{}
|
|
|
|
// NewClient initializes new Client defined by OAS.
|
|
func NewClient(serverURL string, opts ...ClientOption) (*Client, error) {
|
|
u, err := url.Parse(serverURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
c, err := newClientConfig(opts...).baseClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Client{
|
|
serverURL: u,
|
|
baseClient: c,
|
|
}, nil
|
|
}
|
|
|
|
type serverURLKey struct{}
|
|
|
|
// WithServerURL sets context key to override server URL.
|
|
func WithServerURL(ctx context.Context, u *url.URL) context.Context {
|
|
return context.WithValue(ctx, serverURLKey{}, u)
|
|
}
|
|
|
|
func (c *Client) requestURL(ctx context.Context) *url.URL {
|
|
u, ok := ctx.Value(serverURLKey{}).(*url.URL)
|
|
if !ok {
|
|
return c.serverURL
|
|
}
|
|
return u
|
|
}
|
|
|
|
// CreatePasswordToken invokes createPasswordToken operation.
|
|
//
|
|
// Creates a new PasswordToken and persists it to storage.
|
|
//
|
|
// POST /password-tokens
|
|
func (c *Client) CreatePasswordToken(ctx context.Context, request *CreatePasswordTokenReq) (CreatePasswordTokenRes, error) {
|
|
res, err := c.sendCreatePasswordToken(ctx, request)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendCreatePasswordToken(ctx context.Context, request *CreatePasswordTokenReq) (res CreatePasswordTokenRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("createPasswordToken"),
|
|
}
|
|
|
|
// 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, "CreatePasswordToken",
|
|
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 += "/password-tokens"
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u, nil)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeCreatePasswordTokenRequest(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 := decodeCreatePasswordTokenResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// CreateUser invokes createUser operation.
|
|
//
|
|
// Creates a new User and persists it to storage.
|
|
//
|
|
// POST /users
|
|
func (c *Client) CreateUser(ctx context.Context, request *CreateUserReq) (CreateUserRes, error) {
|
|
res, err := c.sendCreateUser(ctx, request)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendCreateUser(ctx context.Context, request *CreateUserReq) (res CreateUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("createUser"),
|
|
}
|
|
|
|
// 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, "CreateUser",
|
|
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"
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u, nil)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeCreateUserRequest(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 := decodeCreateUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// DeletePasswordToken invokes deletePasswordToken operation.
|
|
//
|
|
// Deletes the PasswordToken with the requested ID.
|
|
//
|
|
// DELETE /password-tokens/{id}
|
|
func (c *Client) DeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (DeletePasswordTokenRes, error) {
|
|
res, err := c.sendDeletePasswordToken(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendDeletePasswordToken(ctx context.Context, params DeletePasswordTokenParams) (res DeletePasswordTokenRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("deletePasswordToken"),
|
|
}
|
|
|
|
// 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, "DeletePasswordToken",
|
|
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 += "/password-tokens/"
|
|
{
|
|
// 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 := decodeDeletePasswordTokenResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// DeleteUser invokes deleteUser operation.
|
|
//
|
|
// Deletes the User with the requested ID.
|
|
//
|
|
// DELETE /users/{id}
|
|
func (c *Client) DeleteUser(ctx context.Context, params DeleteUserParams) (DeleteUserRes, error) {
|
|
res, err := c.sendDeleteUser(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendDeleteUser(ctx context.Context, params DeleteUserParams) (res DeleteUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("deleteUser"),
|
|
}
|
|
|
|
// 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, "DeleteUser",
|
|
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()
|
|
}
|
|
|
|
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 := decodeDeleteUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListPasswordToken invokes listPasswordToken operation.
|
|
//
|
|
// List PasswordTokens.
|
|
//
|
|
// GET /password-tokens
|
|
func (c *Client) ListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (ListPasswordTokenRes, error) {
|
|
res, err := c.sendListPasswordToken(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListPasswordToken(ctx context.Context, params ListPasswordTokenParams) (res ListPasswordTokenRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listPasswordToken"),
|
|
}
|
|
|
|
// 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, "ListPasswordToken",
|
|
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 += "/password-tokens"
|
|
|
|
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 := decodeListPasswordTokenResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListUser invokes listUser operation.
|
|
//
|
|
// List Users.
|
|
//
|
|
// GET /users
|
|
func (c *Client) ListUser(ctx context.Context, params ListUserParams) (ListUserRes, error) {
|
|
res, err := c.sendListUser(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListUser(ctx context.Context, params ListUserParams) (res ListUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listUser"),
|
|
}
|
|
|
|
// 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, "ListUser",
|
|
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"
|
|
|
|
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 := decodeListUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListUserOwner invokes listUserOwner operation.
|
|
//
|
|
// List attached Owners.
|
|
//
|
|
// GET /users/{id}/owner
|
|
func (c *Client) ListUserOwner(ctx context.Context, params ListUserOwnerParams) (ListUserOwnerRes, error) {
|
|
res, err := c.sendListUserOwner(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListUserOwner(ctx context.Context, params ListUserOwnerParams) (res ListUserOwnerRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listUserOwner"),
|
|
}
|
|
|
|
// 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, "ListUserOwner",
|
|
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 += "/owner"
|
|
|
|
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 := decodeListUserOwnerResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ReadPasswordToken invokes readPasswordToken operation.
|
|
//
|
|
// Finds the PasswordToken with the requested ID and returns it.
|
|
//
|
|
// GET /password-tokens/{id}
|
|
func (c *Client) ReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (ReadPasswordTokenRes, error) {
|
|
res, err := c.sendReadPasswordToken(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendReadPasswordToken(ctx context.Context, params ReadPasswordTokenParams) (res ReadPasswordTokenRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("readPasswordToken"),
|
|
}
|
|
|
|
// 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, "ReadPasswordToken",
|
|
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 += "/password-tokens/"
|
|
{
|
|
// 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 := decodeReadPasswordTokenResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ReadPasswordTokenUser invokes readPasswordTokenUser operation.
|
|
//
|
|
// Find the attached User of the PasswordToken with the given ID.
|
|
//
|
|
// GET /password-tokens/{id}/user
|
|
func (c *Client) ReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (ReadPasswordTokenUserRes, error) {
|
|
res, err := c.sendReadPasswordTokenUser(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendReadPasswordTokenUser(ctx context.Context, params ReadPasswordTokenUserParams) (res ReadPasswordTokenUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("readPasswordTokenUser"),
|
|
}
|
|
|
|
// 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, "ReadPasswordTokenUser",
|
|
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 += "/password-tokens/"
|
|
{
|
|
// 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 += "/user"
|
|
|
|
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 := decodeReadPasswordTokenUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ReadUser invokes readUser operation.
|
|
//
|
|
// Finds the User with the requested ID and returns it.
|
|
//
|
|
// GET /users/{id}
|
|
func (c *Client) ReadUser(ctx context.Context, params ReadUserParams) (ReadUserRes, error) {
|
|
res, err := c.sendReadUser(ctx, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendReadUser(ctx context.Context, params ReadUserParams) (res ReadUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("readUser"),
|
|
}
|
|
|
|
// 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, "ReadUser",
|
|
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()
|
|
}
|
|
|
|
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 := decodeReadUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// UpdatePasswordToken invokes updatePasswordToken operation.
|
|
//
|
|
// Updates a PasswordToken and persists changes to storage.
|
|
//
|
|
// PATCH /password-tokens/{id}
|
|
func (c *Client) UpdatePasswordToken(ctx context.Context, request *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (UpdatePasswordTokenRes, error) {
|
|
res, err := c.sendUpdatePasswordToken(ctx, request, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendUpdatePasswordToken(ctx context.Context, request *UpdatePasswordTokenReq, params UpdatePasswordTokenParams) (res UpdatePasswordTokenRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("updatePasswordToken"),
|
|
}
|
|
|
|
// 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, "UpdatePasswordToken",
|
|
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 += "/password-tokens/"
|
|
{
|
|
// 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 := encodeUpdatePasswordTokenRequest(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 := decodeUpdatePasswordTokenResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// UpdateUser invokes updateUser operation.
|
|
//
|
|
// Updates a User and persists changes to storage.
|
|
//
|
|
// PATCH /users/{id}
|
|
func (c *Client) UpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (UpdateUserRes, error) {
|
|
res, err := c.sendUpdateUser(ctx, request, params)
|
|
_ = res
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendUpdateUser(ctx context.Context, request *UpdateUserReq, params UpdateUserParams) (res UpdateUserRes, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("updateUser"),
|
|
}
|
|
|
|
// 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, "UpdateUser",
|
|
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()
|
|
}
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", u, nil)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeUpdateUserRequest(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 := decodeUpdateUserResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|