kpt-tmr-group/pkg/apierr/apierr_gen.go

package apierr

import (
	common "kpt-tmr-group/proto/go/backend/common"

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

// NewErrUnauthorized create err with default message
func NewErrUnauthorized(err ...error) *Error {
	return New(common.Error_UNAUTHORIZED).With(err...)
}

// ErrUnauthorized create err with locales
func ErrUnauthorized(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_UNAUTHORIZED).With(err...)
}

// AbortUnauthorized abort with status code and log common.Error_UNAUTHORIZED to newrelic
func AbortUnauthorized(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrUnauthorized(c, err...))
}

// AbortStatusUnauthorized abort with status code and log common.Error_UNAUTHORIZED to newrelic
func AbortStatusUnauthorized(c *gin.Context, err ...error) {
	AbortUnauthorized(c, 401, err...)
}

// NewErrBadRequest create err with default message
func NewErrBadRequest(err ...error) *Error {
	return New(common.Error_BAD_REQUEST).With(err...)
}

// ErrBadRequest create err with locales
func ErrBadRequest(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_BAD_REQUEST).With(err...)
}

// AbortBadRequest abort with status code and log common.Error_BAD_REQUEST to newrelic
func AbortBadRequest(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrBadRequest(c, err...))
}

// AbortStatusBadRequest abort with status code and log common.Error_BAD_REQUEST to newrelic
func AbortStatusBadRequest(c *gin.Context, err ...error) {
	AbortBadRequest(c, 400, err...)
}

// NewErrInvalidContentType create err with default message
func NewErrInvalidContentType(err ...error) *Error {
	return New(common.Error_INVALID_CONTENT_TYPE).With(err...)
}

// ErrInvalidContentType create err with locales
func ErrInvalidContentType(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_CONTENT_TYPE).With(err...)
}

// AbortInvalidContentType abort with status code and log common.Error_INVALID_CONTENT_TYPE to newrelic
func AbortInvalidContentType(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidContentType(c, err...))
}

// AbortStatusInvalidContentType abort with status code and log common.Error_INVALID_CONTENT_TYPE to newrelic
func AbortStatusInvalidContentType(c *gin.Context, err ...error) {
	AbortInvalidContentType(c, 400, err...)
}

// NewErrInvalidContentEncoding create err with default message
func NewErrInvalidContentEncoding(err ...error) *Error {
	return New(common.Error_INVALID_CONTENT_ENCODING).With(err...)
}

// ErrInvalidContentEncoding create err with locales
func ErrInvalidContentEncoding(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_CONTENT_ENCODING).With(err...)
}

// AbortInvalidContentEncoding abort with status code and log common.Error_INVALID_CONTENT_ENCODING to newrelic
func AbortInvalidContentEncoding(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidContentEncoding(c, err...))
}

// AbortStatusInvalidContentEncoding abort with status code and log common.Error_INVALID_CONTENT_ENCODING to newrelic
func AbortStatusInvalidContentEncoding(c *gin.Context, err ...error) {
	AbortInvalidContentEncoding(c, 400, err...)
}

// NewErrTooManyRequests create err with default message
func NewErrTooManyRequests(err ...error) *Error {
	return New(common.Error_TOO_MANY_REQUESTS).With(err...)
}

// ErrTooManyRequests create err with locales
func ErrTooManyRequests(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_TOO_MANY_REQUESTS).With(err...)
}

// AbortTooManyRequests abort with status code and log common.Error_TOO_MANY_REQUESTS to newrelic
func AbortTooManyRequests(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrTooManyRequests(c, err...))
}

// AbortStatusTooManyRequests abort with status code and log common.Error_TOO_MANY_REQUESTS to newrelic
func AbortStatusTooManyRequests(c *gin.Context, err ...error) {
	AbortTooManyRequests(c, 429, err...)
}

// NewErrInvalidStorageType create err with default message
func NewErrInvalidStorageType(err ...error) *Error {
	return New(common.Error_INVALID_STORAGE_TYPE).With(err...)
}

// ErrInvalidStorageType create err with locales
func ErrInvalidStorageType(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_STORAGE_TYPE).With(err...)
}

// AbortInvalidStorageType abort with status code and log common.Error_INVALID_STORAGE_TYPE to newrelic
func AbortInvalidStorageType(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidStorageType(c, err...))
}

// AbortStatusInvalidStorageType abort with status code and log common.Error_INVALID_STORAGE_TYPE to newrelic
func AbortStatusInvalidStorageType(c *gin.Context, err ...error) {
	AbortInvalidStorageType(c, 400, err...)
}

// NewErrInvalidDeData create err with default message
func NewErrInvalidDeData(err ...error) *Error {
	return New(common.Error_INVALID_DE_DATA).With(err...)
}

// ErrInvalidDeData create err with locales
func ErrInvalidDeData(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_DE_DATA).With(err...)
}

// AbortInvalidDeData abort with status code and log common.Error_INVALID_DE_DATA to newrelic
func AbortInvalidDeData(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidDeData(c, err...))
}

// AbortStatusInvalidDeData abort with status code and log common.Error_INVALID_DE_DATA to newrelic
func AbortStatusInvalidDeData(c *gin.Context, err ...error) {
	AbortInvalidDeData(c, 400, err...)
}

// NewErrCheckinRepeated create err with default message
func NewErrCheckinRepeated(err ...error) *Error {
	return New(common.Error_CHECKIN_REPEATED).With(err...)
}

// ErrCheckinRepeated create err with locales
func ErrCheckinRepeated(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_CHECKIN_REPEATED).With(err...)
}

// AbortCheckinRepeated abort with status code and log common.Error_CHECKIN_REPEATED to newrelic
func AbortCheckinRepeated(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrCheckinRepeated(c, err...))
}

// AbortStatusCheckinRepeated abort with status code and log common.Error_CHECKIN_REPEATED to newrelic
func AbortStatusCheckinRepeated(c *gin.Context, err ...error) {
	AbortCheckinRepeated(c, 400, err...)
}

// NewErrCourseNotFound create err with default message
func NewErrCourseNotFound(err ...error) *Error {
	return New(common.Error_COURSE_NOT_FOUND).With(err...)
}

// ErrCourseNotFound create err with locales
func ErrCourseNotFound(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_COURSE_NOT_FOUND).With(err...)
}

// AbortCourseNotFound abort with status code and log common.Error_COURSE_NOT_FOUND to newrelic
func AbortCourseNotFound(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrCourseNotFound(c, err...))
}

// AbortStatusCourseNotFound abort with status code and log common.Error_COURSE_NOT_FOUND to newrelic
func AbortStatusCourseNotFound(c *gin.Context, err ...error) {
	AbortCourseNotFound(c, 400, err...)
}

// NewErrCourseNotInterest create err with default message
func NewErrCourseNotInterest(err ...error) *Error {
	return New(common.Error_COURSE_NOT_INTEREST).With(err...)
}

// ErrCourseNotInterest create err with locales
func ErrCourseNotInterest(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_COURSE_NOT_INTEREST).With(err...)
}

// AbortCourseNotInterest abort with status code and log common.Error_COURSE_NOT_INTEREST to newrelic
func AbortCourseNotInterest(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrCourseNotInterest(c, err...))
}

// AbortStatusCourseNotInterest abort with status code and log common.Error_COURSE_NOT_INTEREST to newrelic
func AbortStatusCourseNotInterest(c *gin.Context, err ...error) {
	AbortCourseNotInterest(c, 500, err...)
}

// NewErrModuleNotFound create err with default message
func NewErrModuleNotFound(err ...error) *Error {
	return New(common.Error_MODULE_NOT_FOUND).With(err...)
}

// ErrModuleNotFound create err with locales
func ErrModuleNotFound(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_MODULE_NOT_FOUND).With(err...)
}

// AbortModuleNotFound abort with status code and log common.Error_MODULE_NOT_FOUND to newrelic
func AbortModuleNotFound(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrModuleNotFound(c, err...))
}

// AbortStatusModuleNotFound abort with status code and log common.Error_MODULE_NOT_FOUND to newrelic
func AbortStatusModuleNotFound(c *gin.Context, err ...error) {
	AbortModuleNotFound(c, 400, err...)
}

// NewErrUserCourseAlreadyAdded create err with default message
func NewErrUserCourseAlreadyAdded(err ...error) *Error {
	return New(common.Error_USER_COURSE_ALREADY_ADDED).With(err...)
}

// ErrUserCourseAlreadyAdded create err with locales
func ErrUserCourseAlreadyAdded(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_USER_COURSE_ALREADY_ADDED).With(err...)
}

// AbortUserCourseAlreadyAdded abort with status code and log common.Error_USER_COURSE_ALREADY_ADDED to newrelic
func AbortUserCourseAlreadyAdded(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrUserCourseAlreadyAdded(c, err...))
}

// AbortStatusUserCourseAlreadyAdded abort with status code and log common.Error_USER_COURSE_ALREADY_ADDED to newrelic
func AbortStatusUserCourseAlreadyAdded(c *gin.Context, err ...error) {
	AbortUserCourseAlreadyAdded(c, 400, err...)
}

// NewErrUserCourseNotFound create err with default message
func NewErrUserCourseNotFound(err ...error) *Error {
	return New(common.Error_USER_COURSE_NOT_FOUND).With(err...)
}

// ErrUserCourseNotFound create err with locales
func ErrUserCourseNotFound(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_USER_COURSE_NOT_FOUND).With(err...)
}

// AbortUserCourseNotFound abort with status code and log common.Error_USER_COURSE_NOT_FOUND to newrelic
func AbortUserCourseNotFound(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrUserCourseNotFound(c, err...))
}

// AbortStatusUserCourseNotFound abort with status code and log common.Error_USER_COURSE_NOT_FOUND to newrelic
func AbortStatusUserCourseNotFound(c *gin.Context, err ...error) {
	AbortUserCourseNotFound(c, 400, err...)
}

// NewErrPtLimited create err with default message
func NewErrPtLimited(err ...error) *Error {
	return New(common.Error_PT_LIMITED).With(err...)
}

// ErrPtLimited create err with locales
func ErrPtLimited(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_PT_LIMITED).With(err...)
}

// AbortPtLimited abort with status code and log common.Error_PT_LIMITED to newrelic
func AbortPtLimited(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrPtLimited(c, err...))
}

// AbortStatusPtLimited abort with status code and log common.Error_PT_LIMITED to newrelic
func AbortStatusPtLimited(c *gin.Context, err ...error) {
	AbortPtLimited(c, 400, err...)
}

// NewErrInvalidPrice create err with default message
func NewErrInvalidPrice(err ...error) *Error {
	return New(common.Error_INVALID_PRICE).With(err...)
}

// ErrInvalidPrice create err with locales
func ErrInvalidPrice(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_PRICE).With(err...)
}

// AbortInvalidPrice abort with status code and log common.Error_INVALID_PRICE to newrelic
func AbortInvalidPrice(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidPrice(c, err...))
}

// AbortStatusInvalidPrice abort with status code and log common.Error_INVALID_PRICE to newrelic
func AbortStatusInvalidPrice(c *gin.Context, err ...error) {
	AbortInvalidPrice(c, 400, err...)
}

// NewErrInvalidProductId create err with default message
func NewErrInvalidProductId(err ...error) *Error {
	return New(common.Error_INVALID_PRODUCT_ID).With(err...)
}

// ErrInvalidProductId create err with locales
func ErrInvalidProductId(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_PRODUCT_ID).With(err...)
}

// AbortInvalidProductId abort with status code and log common.Error_INVALID_PRODUCT_ID to newrelic
func AbortInvalidProductId(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidProductId(c, err...))
}

// AbortStatusInvalidProductId abort with status code and log common.Error_INVALID_PRODUCT_ID to newrelic
func AbortStatusInvalidProductId(c *gin.Context, err ...error) {
	AbortInvalidProductId(c, 400, err...)
}

// NewErrInvalidOrderNumber create err with default message
func NewErrInvalidOrderNumber(err ...error) *Error {
	return New(common.Error_INVALID_ORDER_NUMBER).With(err...)
}

// ErrInvalidOrderNumber create err with locales
func ErrInvalidOrderNumber(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_ORDER_NUMBER).With(err...)
}

// AbortInvalidOrderNumber abort with status code and log common.Error_INVALID_ORDER_NUMBER to newrelic
func AbortInvalidOrderNumber(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidOrderNumber(c, err...))
}

// AbortStatusInvalidOrderNumber abort with status code and log common.Error_INVALID_ORDER_NUMBER to newrelic
func AbortStatusInvalidOrderNumber(c *gin.Context, err ...error) {
	AbortInvalidOrderNumber(c, 400, err...)
}

// NewErrInvalidUserId create err with default message
func NewErrInvalidUserId(err ...error) *Error {
	return New(common.Error_INVALID_USER_ID).With(err...)
}

// ErrInvalidUserId create err with locales
func ErrInvalidUserId(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_USER_ID).With(err...)
}

// AbortInvalidUserId abort with status code and log common.Error_INVALID_USER_ID to newrelic
func AbortInvalidUserId(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidUserId(c, err...))
}

// AbortStatusInvalidUserId abort with status code and log common.Error_INVALID_USER_ID to newrelic
func AbortStatusInvalidUserId(c *gin.Context, err ...error) {
	AbortInvalidUserId(c, 400, err...)
}

// NewErrInvalidReceipt create err with default message
func NewErrInvalidReceipt(err ...error) *Error {
	return New(common.Error_INVALID_RECEIPT).With(err...)
}

// ErrInvalidReceipt create err with locales
func ErrInvalidReceipt(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INVALID_RECEIPT).With(err...)
}

// AbortInvalidReceipt abort with status code and log common.Error_INVALID_RECEIPT to newrelic
func AbortInvalidReceipt(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInvalidReceipt(c, err...))
}

// AbortStatusInvalidReceipt abort with status code and log common.Error_INVALID_RECEIPT to newrelic
func AbortStatusInvalidReceipt(c *gin.Context, err ...error) {
	AbortInvalidReceipt(c, 400, err...)
}

// NewErrEmptyIosReceipt create err with default message
func NewErrEmptyIosReceipt(err ...error) *Error {
	return New(common.Error_EMPTY_IOS_RECEIPT).With(err...)
}

// ErrEmptyIosReceipt create err with locales
func ErrEmptyIosReceipt(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_EMPTY_IOS_RECEIPT).With(err...)
}

// AbortEmptyIosReceipt abort with status code and log common.Error_EMPTY_IOS_RECEIPT to newrelic
func AbortEmptyIosReceipt(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrEmptyIosReceipt(c, err...))
}

// AbortStatusEmptyIosReceipt abort with status code and log common.Error_EMPTY_IOS_RECEIPT to newrelic
func AbortStatusEmptyIosReceipt(c *gin.Context, err ...error) {
	AbortEmptyIosReceipt(c, 500, err...)
}

// NewErrUserPlanLimitedCourseCount create err with default message
func NewErrUserPlanLimitedCourseCount(err ...error) *Error {
	return New(common.Error_USER_PLAN_LIMITED_COURSE_COUNT).With(err...)
}

// ErrUserPlanLimitedCourseCount create err with locales
func ErrUserPlanLimitedCourseCount(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_USER_PLAN_LIMITED_COURSE_COUNT).With(err...)
}

// AbortUserPlanLimitedCourseCount abort with status code and log common.Error_USER_PLAN_LIMITED_COURSE_COUNT to newrelic
func AbortUserPlanLimitedCourseCount(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrUserPlanLimitedCourseCount(c, err...))
}

// AbortStatusUserPlanLimitedCourseCount abort with status code and log common.Error_USER_PLAN_LIMITED_COURSE_COUNT to newrelic
func AbortStatusUserPlanLimitedCourseCount(c *gin.Context, err ...error) {
	AbortUserPlanLimitedCourseCount(c, 500, err...)
}

// NewErrInternalError create err with default message
func NewErrInternalError(err ...error) *Error {
	return New(common.Error_INTERNAL_ERROR).With(err...)
}

// ErrInternalError create err with locales
func ErrInternalError(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_INTERNAL_ERROR).With(err...)
}

// AbortInternalError abort with status code and log common.Error_INTERNAL_ERROR to newrelic
func AbortInternalError(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrInternalError(c, err...))
}

// AbortStatusInternalError abort with status code and log common.Error_INTERNAL_ERROR to newrelic
func AbortStatusInternalError(c *gin.Context, err ...error) {
	AbortInternalError(c, 500, err...)
}

// NewErrJsonpbError create err with default message
func NewErrJsonpbError(err ...error) *Error {
	return New(common.Error_JSONPB_ERROR).With(err...)
}

// ErrJsonpbError create err with locales
func ErrJsonpbError(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_JSONPB_ERROR).With(err...)
}

// AbortJsonpbError abort with status code and log common.Error_JSONPB_ERROR to newrelic
func AbortJsonpbError(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrJsonpbError(c, err...))
}

// AbortStatusJsonpbError abort with status code and log common.Error_JSONPB_ERROR to newrelic
func AbortStatusJsonpbError(c *gin.Context, err ...error) {
	AbortJsonpbError(c, 400, err...)
}

// NewErrJsonError create err with default message
func NewErrJsonError(err ...error) *Error {
	return New(common.Error_JSON_ERROR).With(err...)
}

// ErrJsonError create err with locales
func ErrJsonError(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_JSON_ERROR).With(err...)
}

// AbortJsonError abort with status code and log common.Error_JSON_ERROR to newrelic
func AbortJsonError(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrJsonError(c, err...))
}

// AbortStatusJsonError abort with status code and log common.Error_JSON_ERROR to newrelic
func AbortStatusJsonError(c *gin.Context, err ...error) {
	AbortJsonError(c, 400, err...)
}

// NewErrPbError create err with default message
func NewErrPbError(err ...error) *Error {
	return New(common.Error_PB_ERROR).With(err...)
}

// ErrPbError create err with locales
func ErrPbError(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_PB_ERROR).With(err...)
}

// AbortPbError abort with status code and log common.Error_PB_ERROR to newrelic
func AbortPbError(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrPbError(c, err...))
}

// AbortStatusPbError abort with status code and log common.Error_PB_ERROR to newrelic
func AbortStatusPbError(c *gin.Context, err ...error) {
	AbortPbError(c, 400, err...)
}

// NewErrExternalError create err with default message
func NewErrExternalError(err ...error) *Error {
	return New(common.Error_EXTERNAL_ERROR).With(err...)
}

// ErrExternalError create err with locales
func ErrExternalError(c *gin.Context, err ...error) *Error {
	return WithContext(c, common.Error_EXTERNAL_ERROR).With(err...)
}

// AbortExternalError abort with status code and log common.Error_EXTERNAL_ERROR to newrelic
func AbortExternalError(c *gin.Context, code int, err ...error) {
	for _, e := range err {
		// if err is nil, gin will panic
		if e != nil {
			// so many 4xx error in new relic, only ignore 400/401/404 error, have fun!
			if !shouldIgnoreCode(code) {
				c.Error(e)
			}
		}
	}
	c.AbortWithStatusJSON(code, ErrExternalError(c, err...))
}

// AbortStatusExternalError abort with status code and log common.Error_EXTERNAL_ERROR to newrelic
func AbortStatusExternalError(c *gin.Context, err ...error) {
	AbortExternalError(c, 500, err...)
}