api_gorest.go

// Code generated by gorest; DO NOT EDIT.

package api

import (
	"encoding/json"
	"fmt"
	"mime/multipart"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
)

const handlerNameKey = "handler"

type ParamPlace int

const (
	UndefinedPlace ParamPlace = iota
	InBody
	InCookie
	InFormData
	InHeader
	InPath
	InQuery
)

type ContentType int

const (
	UndefinedContentType ContentType = iota
	AppJSON
	AppXML
	AppFormUrlencoded
	MultipartFormData
	TextPlain
)

type FieldError struct {
	In      ParamPlace
	Field   string
	Message string
	Reason  error
}

func NewFieldError(in ParamPlace, f string, msg string, err error) FieldError {
	return FieldError{
		In:      in,
		Field:   f,
		Message: msg,
		Reason:  err,
	}
}

type PaymentGatewayAPI interface {
	// GET /v1/example/:year/:user
	Example(in ExampleRequest, c *gin.Context)

	// GET /v1/files/:filename
	GetFile(in GetFileRequest, c *gin.Context)

	// GET /v1/payment
	GetPayment(in GetPaymentRequest, c *gin.Context)
	// POST /v1/payment
	ProvidePayment(in ProvidePaymentRequest, c *gin.Context)

	// POST /v1/user
	CreateUser(in CreateUserRequest, c *gin.Context)

	// GET /v1/user/:userId
	GetUser(in GetUserRequest, c *gin.Context)

	// Service methods
	ProcessMakeRequestErrors(c *gin.Context, errors []FieldError)
	ProcessValidateErrors(c *gin.Context, errors []FieldError)
}

type PaymentGatewayAPIServer struct {
	Srv PaymentGatewayAPI
}

// _PaymentGatewayAPI_Example_Handler

type ExampleRequest struct {
	Path  ExampleRequestPath
	Query ExampleRequestQuery
}

func (t ExampleRequest) Validate() (errors []FieldError) {
	// Path field validators
	errors = t.Path.Validate()
	if errors != nil {
		return
	}
	// Query field validators
	errors = t.Query.Validate()
	if errors != nil {
		return
	}
	return
}

type ExampleRequestPath struct {
	User string
	Year int64
}

func (t ExampleRequestPath) Validate() (errors []FieldError) {
	// User field validators
	// Year field validators
	return
}

type ExampleRequestQuery struct {
	Debug    bool
	From     time.Time
	FromDate time.Time
	Sum      Decimal
	Test     string
	To       time.Time
}

func (t ExampleRequestQuery) Validate() (errors []FieldError) {
	// Debug field validators
	// From field validators
	// FromDate field validators
	// Sum field validators
	// Test field validators
	// To field validators
	return
}

func MakeExampleRequest(c *gin.Context) (result ExampleRequest, errors []FieldError) {
	result.Path, errors = MakeExampleRequestPath(c)
	if errors != nil {
		return
	}

	result.Query, errors = MakeExampleRequestQuery(c)
	if errors != nil {
		return
	}
	return
}

func MakeExampleRequestPath(c *gin.Context) (result ExampleRequestPath, errors []FieldError) {
	var err error

	userStr, _ := c.Params.Get("user")
	result.User = userStr

	yearStr, ok := c.Params.Get("year")
	if !ok {
		yearStr = "23"
	}
	result.Year, err = strconv.ParseInt(yearStr, 10, 64)
	if err != nil {
		errors = append(errors, NewFieldError(InPath, "year", "can't parse as 64 bit integer", err))
	}
	return
}

func MakeExampleRequestQuery(c *gin.Context) (result ExampleRequestQuery, errors []FieldError) {
	var err error

	debugStr, _ := c.GetQuery("debug")
	switch strings.ToLower(debugStr) {
	case "1", "true", "t":
		result.Debug = true
	case "0", "false", "f":
		result.Debug = false
	default:
		errors = append(errors, NewFieldError(InQuery, "debug", "can't parse as boolean", nil))
	}

	fromStr, _ := c.GetQuery("from")
	result.From, err = time.Parse(time.RFC3339, fromStr)
	if err != nil {
		errors = append(errors, NewFieldError(InQuery, "from", "can't parse as RFC3339 time", err))
	}

	fromDateStr, _ := c.GetQuery("fromDate")
	result.FromDate, err = time.Parse("2006-01-02", fromDateStr)
	if err != nil {
		errors = append(errors, NewFieldError(InQuery, "fromDate", "can't parse as RFC3339 date", err))
	}

	sumStr, ok := c.GetQuery("sum")
	if !ok {
		sumStr = "10"
	}
	result.Sum = Decimal{}
	if err = result.Sum.SetFromString(sumStr); err != nil {
		errors = append(errors, NewFieldError(InQuery, "sum", fmt.Sprintf("can't create from string '%s'", sumStr), err))
	}

	testStr, _ := c.GetQuery("test")
	result.Test = testStr

	toStr, _ := c.GetQuery("to")
	toSec, err := strconv.ParseInt(toStr, 10, 64)
	if err != nil {
		errors = append(errors, NewFieldError(InQuery, "to", "can't parse as 64 bit integer", err))
	} else {
		result.To = time.Unix(toSec, 0)
	}
	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_Example_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "Example")

	req, errors := MakeExampleRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.Example(req, c)
}

// _PaymentGatewayAPI_GetFile_Handler

type GetFileRequest struct {
	Path GetFileRequestPath
}

func (t GetFileRequest) Validate() (errors []FieldError) {
	// Path field validators
	errors = t.Path.Validate()
	if errors != nil {
		return
	}
	return
}

type GetFileRequestPath struct {
	Filename string
}

func (t GetFileRequestPath) Validate() (errors []FieldError) {
	// Filename field validators
	return
}

func MakeGetFileRequest(c *gin.Context) (result GetFileRequest, errors []FieldError) {
	result.Path, errors = MakeGetFileRequestPath(c)
	if errors != nil {
		return
	}
	return
}

func MakeGetFileRequestPath(c *gin.Context) (result GetFileRequestPath, errors []FieldError) {
	filenameStr, _ := c.Params.Get("filename")
	result.Filename = filenameStr

	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_GetFile_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "GetFile")

	req, errors := MakeGetFileRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.GetFile(req, c)
}

// _PaymentGatewayAPI_GetPayment_Handler

type GetPaymentRequest struct {
	Query GetPaymentRequestQuery
}

func (t GetPaymentRequest) Validate() (errors []FieldError) {
	// Query field validators
	errors = t.Query.Validate()
	if errors != nil {
		return
	}
	return
}

type GetPaymentRequestQuery struct {
	Async string
	ID    string
}

func (t GetPaymentRequestQuery) Validate() (errors []FieldError) {
	// Async field validators
	var asyncInEnum bool
	for _, elem := range [...]string{
		"true",
		"false",
	} {
		if elem == t.Async {
			asyncInEnum = true
			break
		}
	}
	if !asyncInEnum {
		errors = append(errors, NewFieldError(UndefinedPlace, "async", "allowed values: [true false]", nil))
	}

	// ID field validators
	return
}

func MakeGetPaymentRequest(c *gin.Context) (result GetPaymentRequest, errors []FieldError) {
	result.Query, errors = MakeGetPaymentRequestQuery(c)
	if errors != nil {
		return
	}
	return
}

func MakeGetPaymentRequestQuery(c *gin.Context) (result GetPaymentRequestQuery, errors []FieldError) {
	asyncStr, _ := c.GetQuery("async")
	result.Async = asyncStr

	idStr, _ := c.GetQuery("id")
	result.ID = idStr

	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_GetPayment_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "GetPayment")

	req, errors := MakeGetPaymentRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.GetPayment(req, c)
}

// _PaymentGatewayAPI_ProvidePayment_Handler

type ProvidePaymentRequest struct {
	Body ProvidePaymentRequestBody
}

func (t ProvidePaymentRequest) Validate() (errors []FieldError) {
	// Body field validators
	errors = t.Body.Validate()
	if errors != nil {
		return
	}
	return
}

type ProvidePaymentRequestBody struct {
	JSON Payment
	Type ContentType
}

func (t ProvidePaymentRequestBody) Validate() (errors []FieldError) {
	// JSON field validators
	errors = t.JSON.Validate()
	if errors != nil {
		return
	}
	return
}

func MakeProvidePaymentRequest(c *gin.Context) (result ProvidePaymentRequest, errors []FieldError) {
	result.Body, errors = MakeProvidePaymentRequestBody(c)
	if errors != nil {
		return
	}
	return
}

func MakeProvidePaymentRequestBody(c *gin.Context) (result ProvidePaymentRequestBody, errors []FieldError) {
	contentType := c.Request.Header.Get("Content-Type")

	if contentType == "" {
		errors = append(errors, NewFieldError(InBody, "-", "no content type specified", nil))
		return
	}
	contentType = strings.Split(contentType, ";")[0]

	switch contentType {
	case "application/json":
		result.Type = AppJSON
		if err := json.NewDecoder(c.Request.Body).Decode(&result.JSON); err != nil {
			errors = append(errors, NewFieldError(InBody, "requestBody", "can't decode body from JSON", err))
		}

	default:
		errors = append(errors, NewFieldError(InBody, "-", "unknown content type", nil))
	}
	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_ProvidePayment_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "ProvidePayment")

	req, errors := MakeProvidePaymentRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.ProvidePayment(req, c)
}

// _PaymentGatewayAPI_CreateUser_Handler

type CreateUserRequest struct {
	Body CreateUserRequestBody
}

func (t CreateUserRequest) Validate() (errors []FieldError) {
	// Body field validators
	errors = t.Body.Validate()
	if errors != nil {
		return
	}
	return
}

type CreateUserRequestBody struct {
	Form CreateUserRequestBodyForm
	Type ContentType
}

func (t CreateUserRequestBody) Validate() (errors []FieldError) {
	// Form field validators
	errors = t.Form.Validate()
	if errors != nil {
		return
	}
	return
}

type CreateUserRequestBodyForm struct {
	Age    int64
	Avatar *multipart.FileHeader
	Email  string
	Name   string
}

func (t CreateUserRequestBodyForm) Validate() (errors []FieldError) {
	// Age field validators
	// Avatar field validators
	// Email field validators
	// Name field validators
	return
}

func MakeCreateUserRequest(c *gin.Context) (result CreateUserRequest, errors []FieldError) {
	result.Body, errors = MakeCreateUserRequestBody(c)
	if errors != nil {
		return
	}
	return
}

func MakeCreateUserRequestBody(c *gin.Context) (result CreateUserRequestBody, errors []FieldError) {
	contentType := c.Request.Header.Get("Content-Type")

	if contentType == "" {
		errors = append(errors, NewFieldError(InBody, "-", "no content type specified", nil))
		return
	}
	contentType = strings.Split(contentType, ";")[0]

	switch contentType {
	case "multipart/form-data":
		result.Type = MultipartFormData
		result.Form, errors = MakeCreateUserRequestBodyForm(c)
		if errors != nil {
			return
		}

	default:
		errors = append(errors, NewFieldError(InBody, "-", "unknown content type", nil))
	}
	return
}

func MakeCreateUserRequestBodyForm(c *gin.Context) (result CreateUserRequestBodyForm, errors []FieldError) {
	var err error

	form, err := c.MultipartForm()
	if err != nil {
		errors = append(errors, NewFieldError(InFormData, "", "can't parse multipart form", err))
		return
	}

	getFormValue := func(param string) (string, bool) {
		values, ok := form.Value[param]
		if !ok {
			return "", false
		}
		if len(values) == 0 {
			return "", false
		}
		return values[0], true
	}

	ageStr, _ := getFormValue("age")
	result.Age, err = strconv.ParseInt(ageStr, 10, 0)
	if err != nil {
		errors = append(errors, NewFieldError(InFormData, "age", "can't parse as integer", err))
	}

	result.Avatar, err = c.FormFile("avatar")
	if err != nil {
		errors = append(errors, NewFieldError(InFormData, "avatar", "can't extract file from form-data", err))
	}

	emailStr, _ := getFormValue("email")
	result.Email = emailStr

	nameStr, _ := getFormValue("name")
	result.Name = nameStr

	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_CreateUser_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "CreateUser")

	req, errors := MakeCreateUserRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.CreateUser(req, c)
}

// _PaymentGatewayAPI_GetUser_Handler

type GetUserRequest struct {
	Path GetUserRequestPath
}

func (t GetUserRequest) Validate() (errors []FieldError) {
	// Path field validators
	errors = t.Path.Validate()
	if errors != nil {
		return
	}
	return
}

type GetUserRequestPath struct {
	UserID string
}

func (t GetUserRequestPath) Validate() (errors []FieldError) {
	// UserID field validators
	return
}

func MakeGetUserRequest(c *gin.Context) (result GetUserRequest, errors []FieldError) {
	result.Path, errors = MakeGetUserRequestPath(c)
	if errors != nil {
		return
	}
	return
}

func MakeGetUserRequestPath(c *gin.Context) (result GetUserRequestPath, errors []FieldError) {
	userIdStr, _ := c.Params.Get("userId")
	result.UserID = userIdStr

	return
}

func (server PaymentGatewayAPIServer) _PaymentGatewayAPI_GetUser_Handler(c *gin.Context) {
	c.Set(handlerNameKey, "GetUser")

	req, errors := MakeGetUserRequest(c)
	if len(errors) > 0 {
		server.Srv.ProcessMakeRequestErrors(c, errors)
		return
	}

	errors = req.Validate()
	if len(errors) > 0 {
		server.Srv.ProcessValidateErrors(c, errors)
		return
	}

	server.Srv.GetUser(req, c)
}

// Router
func RegisterRoutes(r *gin.Engine, api PaymentGatewayAPI) {
	e := &PaymentGatewayAPIServer{api}

	r.Handle("GET", "/v1/example/:year/:user", e._PaymentGatewayAPI_Example_Handler)

	r.Handle("GET", "/v1/files/:filename", e._PaymentGatewayAPI_GetFile_Handler)

	r.Handle("GET", "/v1/payment", e._PaymentGatewayAPI_GetPayment_Handler)
	r.Handle("POST", "/v1/payment", e._PaymentGatewayAPI_ProvidePayment_Handler)

	r.Handle("POST", "/v1/user", e._PaymentGatewayAPI_CreateUser_Handler)

	r.Handle("GET", "/v1/user/:userId", e._PaymentGatewayAPI_GetUser_Handler)
}

type HandlerRegister func(operationID, httpMethod, relativePath string, handler gin.HandlerFunc)

// CustomRouter
func RegisterRoutesCustom(handlerRegister HandlerRegister, api PaymentGatewayAPI) {
	e := &PaymentGatewayAPIServer{api}

	handlerRegister("Example", "GET", "/v1/example/:year/:user", e._PaymentGatewayAPI_Example_Handler)

	handlerRegister("GetFile", "GET", "/v1/files/:filename", e._PaymentGatewayAPI_GetFile_Handler)

	handlerRegister("GetPayment", "GET", "/v1/payment", e._PaymentGatewayAPI_GetPayment_Handler)
	handlerRegister("ProvidePayment", "POST", "/v1/payment", e._PaymentGatewayAPI_ProvidePayment_Handler)

	handlerRegister("CreateUser", "POST", "/v1/user", e._PaymentGatewayAPI_CreateUser_Handler)

	handlerRegister("GetUser", "GET", "/v1/user/:userId", e._PaymentGatewayAPI_GetUser_Handler)
}

type ID string

func (t ID) Validate() (errors []FieldError) {
	return
}

type Payment struct {
	MerchantID string          `json:"merchant_id"`
	Meta       json.RawMessage `json:"meta"`
	PaymentID  ID              `json:"payment_id"`
	Sum        Decimal         `json:"sum"`
	Type       string          `json:"type"`
}

func (t Payment) Validate() (errors []FieldError) {
	// MerchantID field validators
	// Meta field validators
	// PaymentID field validators
	errors = t.PaymentID.Validate()
	if errors != nil {
		return
	}
	// Sum field validators
	// Type field validators
	var typeInEnum bool
	for _, elem := range [...]string{
		"deposit",
		"payment",
	} {
		if elem == t.Type {
			typeInEnum = true
			break
		}
	}
	if !typeInEnum {
		errors = append(errors, NewFieldError(UndefinedPlace, "type", "allowed values: [deposit payment]", nil))
	}

	return
}

type Payments []Payment

func (t Payments) Validate() (errors []FieldError) {
	return
}

// Custom types

type FromStringSetter interface {
	SetFromString(string) error
}

var _ json.Marshaler = (*Decimal)(nil)
var _ json.Unmarshaler = (*Decimal)(nil)
var _ FromStringSetter = (*Decimal)(nil)