oas_handlers_gen.go

// Code generated by ogen, DO NOT EDIT.

package senzingchatapi

import (
	"context"
	"net/http"
	"time"

	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/codes"
	"go.opentelemetry.io/otel/metric"
	semconv "go.opentelemetry.io/otel/semconv/v1.19.0"
	"go.opentelemetry.io/otel/trace"

	"github.com/ogen-go/ogen/middleware"
	"github.com/ogen-go/ogen/ogenerrors"
	"github.com/ogen-go/ogen/otelogen"
)

// handleEntityDetailsEntityDetailsGetRequest handles entity_details_entity_details_get operation.
//
// Retrieve entity data based on the ID of a resolved identity.
//
// GET /entity_details
func (s *Server) handleEntityDetailsEntityDetailsGetRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
	otelAttrs := []attribute.KeyValue{
		otelogen.OperationID("entity_details_entity_details_get"),
		semconv.HTTPMethodKey.String("GET"),
		semconv.HTTPRouteKey.String("/entity_details"),
	}

	// Start a span for this request.
	ctx, span := s.cfg.Tracer.Start(r.Context(), "EntityDetailsEntityDetailsGet",
		trace.WithAttributes(otelAttrs...),
		serverSpanKind,
	)
	defer span.End()

	// Run stopwatch.
	startTime := time.Now()
	defer func() {
		elapsedDuration := time.Since(startTime)
		// Use floating point division here for higher precision (instead of Millisecond method).
		s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
	}()

	// Increment request counter.
	s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

	var (
		recordError = func(stage string, err error) {
			span.RecordError(err)
			span.SetStatus(codes.Error, stage)
			s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
		}
		err          error
		opErrContext = ogenerrors.OperationContext{
			Name: "EntityDetailsEntityDetailsGet",
			ID:   "entity_details_entity_details_get",
		}
	)
	params, err := decodeEntityDetailsEntityDetailsGetParams(args, argsEscaped, r)
	if err != nil {
		err = &ogenerrors.DecodeParamsError{
			OperationContext: opErrContext,
			Err:              err,
		}
		recordError("DecodeParams", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	var response EntityDetailsEntityDetailsGetRes
	if m := s.cfg.Middleware; m != nil {
		mreq := middleware.Request{
			Context:       ctx,
			OperationName: "EntityDetailsEntityDetailsGet",
			OperationID:   "entity_details_entity_details_get",
			Body:          nil,
			Params: middleware.Parameters{
				{
					Name: "entity_id",
					In:   "query",
				}: params.EntityID,
			},
			Raw: r,
		}

		type (
			Request  = struct{}
			Params   = EntityDetailsEntityDetailsGetParams
			Response = EntityDetailsEntityDetailsGetRes
		)
		response, err = middleware.HookMiddleware[
			Request,
			Params,
			Response,
		](
			m,
			mreq,
			unpackEntityDetailsEntityDetailsGetParams,
			func(ctx context.Context, request Request, params Params) (response Response, err error) {
				response, err = s.h.EntityDetailsEntityDetailsGet(ctx, params)
				return response, err
			},
		)
	} else {
		response, err = s.h.EntityDetailsEntityDetailsGet(ctx, params)
	}
	if err != nil {
		recordError("Internal", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	if err := encodeEntityDetailsEntityDetailsGetResponse(response, w, span); err != nil {
		recordError("EncodeResponse", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}
}

// handleEntityHowEntityHowGetRequest handles entity_how_entity_how_get operation.
//
// Determines and details steps-by-step how records resolved to an ENTITY_ID.
//
// GET /entity_how
func (s *Server) handleEntityHowEntityHowGetRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
	otelAttrs := []attribute.KeyValue{
		otelogen.OperationID("entity_how_entity_how_get"),
		semconv.HTTPMethodKey.String("GET"),
		semconv.HTTPRouteKey.String("/entity_how"),
	}

	// Start a span for this request.
	ctx, span := s.cfg.Tracer.Start(r.Context(), "EntityHowEntityHowGet",
		trace.WithAttributes(otelAttrs...),
		serverSpanKind,
	)
	defer span.End()

	// Run stopwatch.
	startTime := time.Now()
	defer func() {
		elapsedDuration := time.Since(startTime)
		// Use floating point division here for higher precision (instead of Millisecond method).
		s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
	}()

	// Increment request counter.
	s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

	var (
		recordError = func(stage string, err error) {
			span.RecordError(err)
			span.SetStatus(codes.Error, stage)
			s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
		}
		err          error
		opErrContext = ogenerrors.OperationContext{
			Name: "EntityHowEntityHowGet",
			ID:   "entity_how_entity_how_get",
		}
	)
	params, err := decodeEntityHowEntityHowGetParams(args, argsEscaped, r)
	if err != nil {
		err = &ogenerrors.DecodeParamsError{
			OperationContext: opErrContext,
			Err:              err,
		}
		recordError("DecodeParams", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	var response EntityHowEntityHowGetRes
	if m := s.cfg.Middleware; m != nil {
		mreq := middleware.Request{
			Context:       ctx,
			OperationName: "EntityHowEntityHowGet",
			OperationID:   "entity_how_entity_how_get",
			Body:          nil,
			Params: middleware.Parameters{
				{
					Name: "entity_id",
					In:   "query",
				}: params.EntityID,
			},
			Raw: r,
		}

		type (
			Request  = struct{}
			Params   = EntityHowEntityHowGetParams
			Response = EntityHowEntityHowGetRes
		)
		response, err = middleware.HookMiddleware[
			Request,
			Params,
			Response,
		](
			m,
			mreq,
			unpackEntityHowEntityHowGetParams,
			func(ctx context.Context, request Request, params Params) (response Response, err error) {
				response, err = s.h.EntityHowEntityHowGet(ctx, params)
				return response, err
			},
		)
	} else {
		response, err = s.h.EntityHowEntityHowGet(ctx, params)
	}
	if err != nil {
		recordError("Internal", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	if err := encodeEntityHowEntityHowGetResponse(response, w, span); err != nil {
		recordError("EncodeResponse", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}
}

// handleEntityReportEntityReportGetRequest handles entity_report_entity_report_get operation.
//
// Return 10 entities with either matches, possible matches, or relationships.
//
// GET /entity_report
func (s *Server) handleEntityReportEntityReportGetRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
	otelAttrs := []attribute.KeyValue{
		otelogen.OperationID("entity_report_entity_report_get"),
		semconv.HTTPMethodKey.String("GET"),
		semconv.HTTPRouteKey.String("/entity_report"),
	}

	// Start a span for this request.
	ctx, span := s.cfg.Tracer.Start(r.Context(), "EntityReportEntityReportGet",
		trace.WithAttributes(otelAttrs...),
		serverSpanKind,
	)
	defer span.End()

	// Run stopwatch.
	startTime := time.Now()
	defer func() {
		elapsedDuration := time.Since(startTime)
		// Use floating point division here for higher precision (instead of Millisecond method).
		s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
	}()

	// Increment request counter.
	s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

	var (
		recordError = func(stage string, err error) {
			span.RecordError(err)
			span.SetStatus(codes.Error, stage)
			s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
		}
		err          error
		opErrContext = ogenerrors.OperationContext{
			Name: "EntityReportEntityReportGet",
			ID:   "entity_report_entity_report_get",
		}
	)
	params, err := decodeEntityReportEntityReportGetParams(args, argsEscaped, r)
	if err != nil {
		err = &ogenerrors.DecodeParamsError{
			OperationContext: opErrContext,
			Err:              err,
		}
		recordError("DecodeParams", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	var response EntityReportEntityReportGetRes
	if m := s.cfg.Middleware; m != nil {
		mreq := middleware.Request{
			Context:       ctx,
			OperationName: "EntityReportEntityReportGet",
			OperationID:   "entity_report_entity_report_get",
			Body:          nil,
			Params: middleware.Parameters{
				{
					Name: "export_flags",
					In:   "query",
				}: params.ExportFlags,
			},
			Raw: r,
		}

		type (
			Request  = struct{}
			Params   = EntityReportEntityReportGetParams
			Response = EntityReportEntityReportGetRes
		)
		response, err = middleware.HookMiddleware[
			Request,
			Params,
			Response,
		](
			m,
			mreq,
			unpackEntityReportEntityReportGetParams,
			func(ctx context.Context, request Request, params Params) (response Response, err error) {
				response, err = s.h.EntityReportEntityReportGet(ctx, params)
				return response, err
			},
		)
	} else {
		response, err = s.h.EntityReportEntityReportGet(ctx, params)
	}
	if err != nil {
		recordError("Internal", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	if err := encodeEntityReportEntityReportGetResponse(response, w, span); err != nil {
		recordError("EncodeResponse", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}
}

// handleEntitySearchEntitySearchPostRequest handles entity_search_entity_search_post operation.
//
// Retrieves entity data based on a user-specified set of entity attributes.
//
// POST /entity_search
func (s *Server) handleEntitySearchEntitySearchPostRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
	otelAttrs := []attribute.KeyValue{
		otelogen.OperationID("entity_search_entity_search_post"),
		semconv.HTTPMethodKey.String("POST"),
		semconv.HTTPRouteKey.String("/entity_search"),
	}

	// Start a span for this request.
	ctx, span := s.cfg.Tracer.Start(r.Context(), "EntitySearchEntitySearchPost",
		trace.WithAttributes(otelAttrs...),
		serverSpanKind,
	)
	defer span.End()

	// Run stopwatch.
	startTime := time.Now()
	defer func() {
		elapsedDuration := time.Since(startTime)
		// Use floating point division here for higher precision (instead of Millisecond method).
		s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...))
	}()

	// Increment request counter.
	s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...))

	var (
		recordError = func(stage string, err error) {
			span.RecordError(err)
			span.SetStatus(codes.Error, stage)
			s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...))
		}
		err          error
		opErrContext = ogenerrors.OperationContext{
			Name: "EntitySearchEntitySearchPost",
			ID:   "entity_search_entity_search_post",
		}
	)
	request, close, err := s.decodeEntitySearchEntitySearchPostRequest(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 EntitySearchEntitySearchPostRes
	if m := s.cfg.Middleware; m != nil {
		mreq := middleware.Request{
			Context:       ctx,
			OperationName: "EntitySearchEntitySearchPost",
			OperationID:   "entity_search_entity_search_post",
			Body:          request,
			Params:        middleware.Parameters{},
			Raw:           r,
		}

		type (
			Request  = *SearchAttributes
			Params   = struct{}
			Response = EntitySearchEntitySearchPostRes
		)
		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.EntitySearchEntitySearchPost(ctx, request)
				return response, err
			},
		)
	} else {
		response, err = s.h.EntitySearchEntitySearchPost(ctx, request)
	}
	if err != nil {
		recordError("Internal", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}

	if err := encodeEntitySearchEntitySearchPostResponse(response, w, span); err != nil {
		recordError("EncodeResponse", err)
		s.cfg.ErrorHandler(ctx, w, r, err)
		return
	}
}