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  }