github.com/hellobchain/third_party@v0.0.0-20230331131523-deb0478a2e52/gin/render/json.go (about)

     1  // Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
     2  // Use of this source code is governed by a MIT style
     3  // license that can be found in the LICENSE file.
     4  
     5  package render
     6  
     7  import (
     8  	"bytes"
     9  	"fmt"
    10  	"github.com/hellobchain/newcryptosm/http"
    11  	"html/template"
    12  
    13  	"github.com/hellobchain/third_party/gin/internal/bytesconv"
    14  	"github.com/hellobchain/third_party/gin/internal/json"
    15  )
    16  
    17  // JSON contains the given interface object.
    18  type JSON struct {
    19  	Data interface{}
    20  }
    21  
    22  // IndentedJSON contains the given interface object.
    23  type IndentedJSON struct {
    24  	Data interface{}
    25  }
    26  
    27  // SecureJSON contains the given interface object and its prefix.
    28  type SecureJSON struct {
    29  	Prefix string
    30  	Data   interface{}
    31  }
    32  
    33  // JsonpJSON contains the given interface object its callback.
    34  type JsonpJSON struct {
    35  	Callback string
    36  	Data     interface{}
    37  }
    38  
    39  // AsciiJSON contains the given interface object.
    40  type AsciiJSON struct {
    41  	Data interface{}
    42  }
    43  
    44  // PureJSON contains the given interface object.
    45  type PureJSON struct {
    46  	Data interface{}
    47  }
    48  
    49  var jsonContentType = []string{"application/json; charset=utf-8"}
    50  var jsonpContentType = []string{"application/javascript; charset=utf-8"}
    51  var jsonAsciiContentType = []string{"application/json"}
    52  
    53  // Render (JSON) writes data with custom ContentType.
    54  func (r JSON) Render(w http.ResponseWriter) (err error) {
    55  	if err = WriteJSON(w, r.Data); err != nil {
    56  		panic(err)
    57  	}
    58  	return
    59  }
    60  
    61  // WriteContentType (JSON) writes JSON ContentType.
    62  func (r JSON) WriteContentType(w http.ResponseWriter) {
    63  	writeContentType(w, jsonContentType)
    64  }
    65  
    66  // WriteJSON marshals the given interface object and writes it with custom ContentType.
    67  func WriteJSON(w http.ResponseWriter, obj interface{}) error {
    68  	writeContentType(w, jsonContentType)
    69  	jsonBytes, err := json.Marshal(obj)
    70  	if err != nil {
    71  		return err
    72  	}
    73  	_, err = w.Write(jsonBytes)
    74  	return err
    75  }
    76  
    77  // Render (IndentedJSON) marshals the given interface object and writes it with custom ContentType.
    78  func (r IndentedJSON) Render(w http.ResponseWriter) error {
    79  	r.WriteContentType(w)
    80  	jsonBytes, err := json.MarshalIndent(r.Data, "", "    ")
    81  	if err != nil {
    82  		return err
    83  	}
    84  	_, err = w.Write(jsonBytes)
    85  	return err
    86  }
    87  
    88  // WriteContentType (IndentedJSON) writes JSON ContentType.
    89  func (r IndentedJSON) WriteContentType(w http.ResponseWriter) {
    90  	writeContentType(w, jsonContentType)
    91  }
    92  
    93  // Render (SecureJSON) marshals the given interface object and writes it with custom ContentType.
    94  func (r SecureJSON) Render(w http.ResponseWriter) error {
    95  	r.WriteContentType(w)
    96  	jsonBytes, err := json.Marshal(r.Data)
    97  	if err != nil {
    98  		return err
    99  	}
   100  	// if the jsonBytes is array values
   101  	if bytes.HasPrefix(jsonBytes, bytesconv.StringToBytes("[")) && bytes.HasSuffix(jsonBytes,
   102  		bytesconv.StringToBytes("]")) {
   103  		_, err = w.Write(bytesconv.StringToBytes(r.Prefix))
   104  		if err != nil {
   105  			return err
   106  		}
   107  	}
   108  	_, err = w.Write(jsonBytes)
   109  	return err
   110  }
   111  
   112  // WriteContentType (SecureJSON) writes JSON ContentType.
   113  func (r SecureJSON) WriteContentType(w http.ResponseWriter) {
   114  	writeContentType(w, jsonContentType)
   115  }
   116  
   117  // Render (JsonpJSON) marshals the given interface object and writes it and its callback with custom ContentType.
   118  func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
   119  	r.WriteContentType(w)
   120  	ret, err := json.Marshal(r.Data)
   121  	if err != nil {
   122  		return err
   123  	}
   124  
   125  	if r.Callback == "" {
   126  		_, err = w.Write(ret)
   127  		return err
   128  	}
   129  
   130  	callback := template.JSEscapeString(r.Callback)
   131  	_, err = w.Write(bytesconv.StringToBytes(callback))
   132  	if err != nil {
   133  		return err
   134  	}
   135  	_, err = w.Write(bytesconv.StringToBytes("("))
   136  	if err != nil {
   137  		return err
   138  	}
   139  	_, err = w.Write(ret)
   140  	if err != nil {
   141  		return err
   142  	}
   143  	_, err = w.Write(bytesconv.StringToBytes(");"))
   144  	if err != nil {
   145  		return err
   146  	}
   147  
   148  	return nil
   149  }
   150  
   151  // WriteContentType (JsonpJSON) writes Javascript ContentType.
   152  func (r JsonpJSON) WriteContentType(w http.ResponseWriter) {
   153  	writeContentType(w, jsonpContentType)
   154  }
   155  
   156  // Render (AsciiJSON) marshals the given interface object and writes it with custom ContentType.
   157  func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
   158  	r.WriteContentType(w)
   159  	ret, err := json.Marshal(r.Data)
   160  	if err != nil {
   161  		return err
   162  	}
   163  
   164  	var buffer bytes.Buffer
   165  	for _, r := range bytesconv.BytesToString(ret) {
   166  		cvt := string(r)
   167  		if r >= 128 {
   168  			cvt = fmt.Sprintf("\\u%04x", int64(r))
   169  		}
   170  		buffer.WriteString(cvt)
   171  	}
   172  
   173  	_, err = w.Write(buffer.Bytes())
   174  	return err
   175  }
   176  
   177  // WriteContentType (AsciiJSON) writes JSON ContentType.
   178  func (r AsciiJSON) WriteContentType(w http.ResponseWriter) {
   179  	writeContentType(w, jsonAsciiContentType)
   180  }
   181  
   182  // Render (PureJSON) writes custom ContentType and encodes the given interface object.
   183  func (r PureJSON) Render(w http.ResponseWriter) error {
   184  	r.WriteContentType(w)
   185  	encoder := json.NewEncoder(w)
   186  	encoder.SetEscapeHTML(false)
   187  	return encoder.Encode(r.Data)
   188  }
   189  
   190  // WriteContentType (PureJSON) writes custom ContentType.
   191  func (r PureJSON) WriteContentType(w http.ResponseWriter) {
   192  	writeContentType(w, jsonContentType)
   193  }