|
@@ -1,761 +0,0 @@
|
|
|
-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...)
|
|
|
-}
|