api/api.go

   1 package api
   2
   3 import (
   4         "net/http"
   5         "unicode"
   6
   7         "github.com/gin-gonic/gin"
   8 )
   9
  10 var CONFIG Config
  11
  12 type Config struct {
  13         JwtSecret           string `toml:"jwt_secret"`
  14         PasswordResetSecret string `toml:"password_reset_secret"`
  15         FreeSMSUser         string `toml:"free_sms_user"`
  16         FreeSMSPass         string `toml:"free_sms_pass"`
  17 }
  18
  19 func SetConfig(config Config) {
  20         CONFIG = config
  21
  22         JWT_SECRET = []byte(config.JwtSecret)
  23         PASSWORD_RESET_SECRET = []byte(config.PasswordResetSecret)
  24 }
  25
  26 type Error struct {
  27         Code        ErrorCode
  28         UserMessage string
  29         err         error
  30 }
  31
  32 func (e Error) Err() error {
  33         if e.err != nil {
  34                 return e
  35         }
  36
  37         return nil
  38 }
  39
  40 func (e Error) Error() string {
  41         if e.err != nil {
  42                 return e.err.Error()
  43         }
  44
  45         return ""
  46 }
  47
  48 func NewInternalError(err error) *Error {
  49         return &Error{InternalError, "internal error", err}
  50 }
  51
  52 func ToSnake(in string) string {
  53         runes := []rune(in)
  54         length := len(runes)
  55
  56         var out []rune
  57         for i := 0; i < length; i++ {
  58                 if i > 0 && unicode.IsUpper(runes[i]) && ((i+1 < length && unicode.IsLower(runes[i+1])) || unicode.IsLower(runes[i-1])) {
  59                         out = append(out, '_')
  60                 }
  61                 out = append(out, unicode.ToLower(runes[i]))
  62         }
  63
  64         return string(out)
  65 }
  66
  67 type Response struct {
  68         StatusCode Status    `json:"-"`
  69         ErrorCode  ErrorCode `json:"-"`
  70
  71         Status   string      `json:"status"`
  72         Code     string      `json:"code,omitempty"`
  73         Response interface{} `json:"response,omitempty"`
  74         Message  string      `json:"message,omitempty"`
  75 }
  76
  77 func (r Response) populateStatus() Response {
  78         r.Status = ToSnake(r.StatusCode.String())
  79
  80         if r.ErrorCode != 0 {
  81                 r.Code = ToSnake(r.ErrorCode.String())
  82         }
  83
  84         return r
  85 }
  86
  87 func ErrorResponse(code ErrorCode, message string) Response {
  88         return Response{
  89                 StatusCode: NOK,
  90                 ErrorCode:  code,
  91                 Message:    message,
  92         }
  93 }
  94
  95 func SuccessResponse(data interface{}) Response {
  96         return Response{
  97                 StatusCode: OK,
  98                 Response:   data,
  99         }
 100 }
 101
 102 func WriteJsonResponse(response Response, c *gin.Context) {
 103         response = response.populateStatus()
 104
 105         c.JSON(StatusToHttpCode(response.StatusCode, response.ErrorCode), response)
 106 }
 107
 108 func WriteBinary(contentType string, b []byte, c *gin.Context) {
 109         c.Data(http.StatusOK, contentType, b)
 110 }
 111
 112 type Middleware func(*gin.Context) *Error
 113
 114 func M(handler Middleware) gin.HandlerFunc {
 115         return func(c *gin.Context) {
 116                 err := handler(c)
 117
 118                 if err != nil {
 119                         WriteJsonResponse(ErrorResponse(err.Code, err.UserMessage), c)
 120                         c.Error(err)
 121                         c.Abort()
 122                 } else {
 123                         c.Next()
 124                 }
 125         }
 126 }
 127
 128 type Query interface {
 129         ValidateParams() *Error
 130         Run() (interface{}, *Error)
 131 }
 132
 133 func RunQuery(query Query, c *gin.Context) {
 134         if err := query.ValidateParams(); err != nil {
 135                 WriteJsonResponse(ErrorResponse(err.Code, err.UserMessage), c)
 136                 c.Error(err)
 137                 return
 138         }
 139
 140         if out, err := query.Run(); err != nil {
 141                 WriteJsonResponse(ErrorResponse(err.Code, err.UserMessage), c)
 142                 c.Error(err)
 143         } else {
 144                 WriteJsonResponse(SuccessResponse(out), c)
 145         }
 146 }