129 lines
3.5 KiB
Go
129 lines
3.5 KiB
Go
package model
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
// Error represents an error response.
|
|
type Error struct {
|
|
Code string `json:"code"`
|
|
Paths string `json:"paths,omitempty"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
// Error implements the error interface for the Error struct.
|
|
func (e *Error) Error() string {
|
|
return fmt.Sprintf("Error: Code=%s, Path=%s, Message=%s", e.Code, e.Paths, e.Message)
|
|
}
|
|
|
|
// SchemaValidationErr represents a collection of schema validation failures.
|
|
type SchemaValidationErr struct {
|
|
Errors []Error
|
|
}
|
|
|
|
// Error implements the error interface for SchemaValidationErr.
|
|
func (e *SchemaValidationErr) Error() string {
|
|
var errorMessages []string
|
|
for _, err := range e.Errors {
|
|
errorMessages = append(errorMessages, fmt.Sprintf("%s: %s", err.Paths, err.Message))
|
|
}
|
|
return strings.Join(errorMessages, "; ")
|
|
}
|
|
|
|
// BecknError converts SchemaValidationErr into a Beckn-compliant Error response.
|
|
func (e *SchemaValidationErr) BecknError() *Error {
|
|
if len(e.Errors) == 0 {
|
|
return &Error{
|
|
Code: http.StatusText(http.StatusBadRequest),
|
|
Message: "Schema validation error.",
|
|
}
|
|
}
|
|
|
|
// Collect all error paths and messages
|
|
var paths []string
|
|
var messages []string
|
|
for _, err := range e.Errors {
|
|
if err.Paths != "" {
|
|
paths = append(paths, err.Paths)
|
|
}
|
|
messages = append(messages, err.Message)
|
|
}
|
|
|
|
return &Error{
|
|
Code: http.StatusText(http.StatusBadRequest),
|
|
Paths: strings.Join(paths, ";"),
|
|
Message: strings.Join(messages, "; "),
|
|
}
|
|
}
|
|
|
|
// SignValidationErr represents an error that occurs during signature validation.
|
|
type SignValidationErr struct {
|
|
error
|
|
}
|
|
|
|
// NewSignValidationErrf creates a new SignValidationErr with a formatted message.
|
|
func NewSignValidationErrf(format string, a ...any) *SignValidationErr {
|
|
return &SignValidationErr{fmt.Errorf(format, a...)}
|
|
}
|
|
|
|
// NewSignValidationErr creates a new SignValidationErr from an existing error.
|
|
func NewSignValidationErr(e error) *SignValidationErr {
|
|
return &SignValidationErr{e}
|
|
}
|
|
|
|
// BecknError converts SignValidationErr into a Beckn-compliant Error response.
|
|
func (e *SignValidationErr) BecknError() *Error {
|
|
return &Error{
|
|
Code: http.StatusText(http.StatusUnauthorized),
|
|
Message: "Signature Validation Error: " + e.Error(),
|
|
}
|
|
}
|
|
|
|
// BadReqErr represents an error related to a bad request.
|
|
type BadReqErr struct {
|
|
error
|
|
}
|
|
|
|
// NewBadReqErr creates a new BadReqErr from an existing error.
|
|
func NewBadReqErr(err error) *BadReqErr {
|
|
return &BadReqErr{err}
|
|
}
|
|
|
|
// NewBadReqErrf creates a new BadReqErr with a formatted message.
|
|
func NewBadReqErrf(format string, a ...any) *BadReqErr {
|
|
return &BadReqErr{fmt.Errorf(format, a...)}
|
|
}
|
|
|
|
// BecknError converts BadReqErr into a Beckn-compliant Error response.
|
|
func (e *BadReqErr) BecknError() *Error {
|
|
return &Error{
|
|
Code: http.StatusText(http.StatusBadRequest),
|
|
Message: "BAD Request: " + e.Error(),
|
|
}
|
|
}
|
|
|
|
// NotFoundErr represents an error for a missing resource or endpoint.
|
|
type NotFoundErr struct {
|
|
error
|
|
}
|
|
|
|
// NewNotFoundErr creates a new NotFoundErr from an existing error.
|
|
func NewNotFoundErr(err error) *NotFoundErr {
|
|
return &NotFoundErr{err}
|
|
}
|
|
|
|
// NewNotFoundErrf creates a new NotFoundErr with a formatted message.
|
|
func NewNotFoundErrf(format string, a ...any) *NotFoundErr {
|
|
return &NotFoundErr{fmt.Errorf(format, a...)}
|
|
}
|
|
|
|
// BecknError converts NotFoundErr into a Beckn-compliant Error response.
|
|
func (e *NotFoundErr) BecknError() *Error {
|
|
return &Error{
|
|
Code: http.StatusText(http.StatusNotFound),
|
|
Message: "Endpoint not found: " + e.Error(),
|
|
}
|
|
}
|