github.com/ars0915/glossika-exercise@v0.0.0-20240904180321-a5617a00d892/util/cGin/gin.go (about) 1 package cGin 2 3 import ( 4 "fmt" 5 "net/http" 6 "runtime" 7 "strconv" 8 9 "github.com/gin-gonic/gin" 10 "github.com/sirupsen/logrus" 11 12 "github.com/ars0915/glossika-exercise/util/cError" 13 "github.com/ars0915/glossika-exercise/util/log" 14 "github.com/ars0915/glossika-exercise/util/paging" 15 ) 16 17 type meta struct { 18 *paging.Paginator 19 Code int `json:"code"` 20 Message string `json:"message"` 21 } 22 23 // func (p meta) MarshalJSON() ([]byte, error) { 24 // type Alias meta 25 // s := struct { 26 // *Alias 27 // }{ 28 // Alias: (*Alias)(&p), 29 // } 30 31 // if p.Paginator != nil { 32 // snakeCaseJSON := jsoniter.Config{}.Froze() 33 // bytes, err := snakeCaseJSON.Marshal(&s) 34 // return bytes, err 35 // } 36 37 // return json.Marshal(&s) 38 // } 39 40 type Wrap struct { 41 Meta meta `json:"meta"` 42 Data interface{} `json:"data"` 43 } 44 45 type Context struct { 46 *gin.Context 47 wrap Wrap 48 err error 49 code int 50 customError *CustomError 51 } 52 53 type DetailFields map[string]interface{} 54 55 var prefixCode *int 56 57 func SetResponseCodePrefix(prefix int) { 58 prefixCode = &prefix 59 } 60 61 func NewContext(c *gin.Context) *Context { 62 return &Context{ 63 Context: c, 64 wrap: Wrap{}, 65 } 66 } 67 68 type HandlerFunc func(*Context) 69 70 func (cGinFun HandlerFunc) GinFunc() gin.HandlerFunc { 71 return func(c *gin.Context) { 72 ctx := NewContext(c) 73 cGinFun(ctx) 74 } 75 } 76 77 func (c *Context) GetPaginator() paging.Paginator { 78 var ( 79 page = paging.DefaultPage 80 limit = paging.DefaultLimit 81 err error 82 ) 83 pageStr, pageOK := c.GetQuery(paging.PageKeyName) 84 if pageOK { 85 page, err = strconv.Atoi(pageStr) 86 if err != nil || page <= 0 { 87 page = paging.DefaultPage 88 } 89 } 90 91 limitStr, limitOK := c.GetQuery(paging.LimitKeyName) 92 if limitOK { 93 limit, err = strconv.Atoi(limitStr) 94 if err != nil || limit == 0 || limit > paging.DefaultMaxLimit { 95 limit = paging.DefaultLimit 96 } 97 } 98 99 offset := (page - 1) * limit 100 return paging.Paginator{ 101 Limit: limit, 102 Page: page, 103 Offset: offset, 104 } 105 } 106 107 // Response serializes the given struct as JSON into the response body. 108 func (c *Context) Response(httpCode int, msg string) { 109 c.beforeResponse() 110 if c.customError != nil { 111 c.wrap.Meta.Code = c.customError.Code 112 c.wrap.Meta.Message = c.customError.Message 113 httpCode = c.customError.HTTPCode 114 } else { 115 if c.code == 0 { 116 c.WithCode(httpCode) 117 } 118 c.wrap.Meta.Code = c.code 119 c.wrap.Meta.Message = msg 120 } 121 122 c.logError(httpCode) 123 124 c.JSON(httpCode, c.wrap) 125 c.Abort() 126 } 127 128 // WithPaginator set paginator 129 func (c *Context) WithPaginator(page paging.Paginator) *Context { 130 c.wrap.Meta.Paginator = &page 131 return c 132 } 133 134 // WithData set response data 135 func (c *Context) WithData(data interface{}) *Context { 136 c.wrap.Data = data 137 return c 138 } 139 140 // WithError set error 141 func (c *Context) WithError(err error) *Context { 142 c.err = err 143 return c 144 } 145 146 // WithCode set code 147 func (c *Context) WithCode(code int) *Context { 148 if code >= 1000 { 149 logrus.Errorf("Invalid Error Code %d", code) 150 } 151 if prefixCode != nil { 152 code = (*prefixCode * 1000) + code 153 } 154 c.code = code 155 return c 156 } 157 158 func (c *Context) logError(httpCode int) { 159 msg := c.wrap.Meta.Message 160 _, file, line, _ := runtime.Caller(2) 161 ginLog := logrus.WithFields(log.Fields{ 162 "httpSource": fmt.Sprintf("%s:%d", file, line), 163 "responseStatus": httpCode, 164 "requestMethod": c.Request.Method, 165 "requestURL": c.Request.URL.String(), 166 "requestHeader": c.Request.Header, 167 "err": c.err, 168 }) 169 170 logLevel := logrus.InfoLevel 171 if httpCode >= http.StatusInternalServerError { 172 logLevel = logrus.ErrorLevel 173 } else if httpCode >= http.StatusBadRequest { 174 logLevel = logrus.WarnLevel 175 } 176 177 ginLog.Log(logLevel, msg) 178 } 179 180 func (c *Context) beforeResponse() *Context { 181 err := c.err 182 if err != nil { 183 err = cError.Unwrap(err) 184 } 185 switch cErr := err.(type) { 186 case CustomError: 187 c.customError = &cErr 188 c.code = cErr.Code 189 } 190 return c 191 } 192 193 // // Done invoke parent Done method 194 // func (c *Context) Done() <-chan struct{} { 195 // return c.Context.Done() 196 // } 197 198 // // Err invoke parent Err method 199 // func (c *Context) Err() error { 200 // return c.Context.Err() 201 // } 202 203 // Value invoke parent Value method 204 func (c *Context) Value(key interface{}) interface{} { 205 if c.Request != nil { 206 ctx := c.Request.Context() 207 if v := ctx.Value(key); v != nil { 208 return v 209 } 210 } 211 return c.Context.Value(key) 212 }