func (self *Base64String) UnmarshalJSON(b []byte) (err error) {
if err = json.Unmarshal(b, self); err != nil {
return err
}
_, err = base64.StdEncoding.DecodeString(string(*self))
return
}
func (self *ByteString) UnmarshalJSON(b []byte) error {
s := ""
if err := json.Unmarshal(b, &s); err != nil {
return err
}
self.Bytes = []byte(s)
return nil
}
// This example uses RawMessage to delay parsing part of a JSON message.
func ExampleRawMessage() {
type Color struct {
Space string
Point json.RawMessage // delay parsing until we know the color space
}
type RGB struct {
R uint8
G uint8
B uint8
}
type YCbCr struct {
Y uint8
Cb int8
Cr int8
}
var j = []byte(`[
{"Space": "YCbCr", "Point": {"Y": 255, "Cb": 0, "Cr": -10}},
{"Space": "RGB", "Point": {"R": 98, "G": 218, "B": 255}}
]`)
var colors []Color
err := json.Unmarshal(j, &colors)
if err != nil {
log.Fatalln("error:", err)
}
for _, c := range colors {
var dst interface{}
switch c.Space {
case "RGB":
dst = new(RGB)
case "YCbCr":
dst = new(YCbCr)
}
err := json.Unmarshal(c.Point, dst)
if err != nil {
log.Fatalln("error:", err)
}
fmt.Println(c.Space, dst)
}
// Output:
// YCbCr &{255 0 -10}
// RGB &{98 218 255}
}
func (self *Time) UnmarshalJSON(b []byte, args ...interface{}) (err error) {
if len(args) == 1 {
if s, ok := args[0].(string); ok && s == "bigquery" {
t := time.Time{}
if err = json.Unmarshal(b, &t); err != nil {
return
}
self.Time = t
return
}
}
var s string
if err = json.Unmarshal(b, &s); err == nil {
if s != "" {
self.Time, err = time.Parse(ISO8601DateTimeFormat, s)
} else {
self.Time = time.Time{}
}
}
return
}
func TestToAndFromJSONInsideWrapper(t *testing.T) {
for i := 0; i < 1000; i++ {
k := randomKey(5)
w := &testWrapper{
Id: k,
Name: "hehu",
}
enc, err := json.Marshal(w)
if err != nil {
t.Fatalf(err.Error())
}
var i interface{}
err = json.Unmarshal(enc, &i)
if err != nil {
t.Fatalf("Bad json: %#v: %v", string(enc), err.Error())
}
w2 := &testWrapper{}
if err := json.Unmarshal(enc, w2); err != nil {
t.Fatalf(err.Error())
}
if !reflect.DeepEqual(w, w2) {
t.Fatalf("%+v != %+v", w, w2)
}
w3 := &testWrapperString{}
if err := json.Unmarshal(enc, w3); err != nil {
t.Fatalf(err.Error())
}
k2, err := Decode(w3.Id)
if err != nil {
t.Fatalf(err.Error())
}
if !k.Equal(k2) {
t.Fatalf("%v != %v", k, k2)
}
}
}
func ExampleUnmarshal() {
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
type Animal struct {
Name string
Order string
}
var animals []Animal
err := json.Unmarshal(jsonBlob, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)
// Output:
// [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
}
func TestToAndFromJSON(t *testing.T) {
for i := 0; i < 1000; i++ {
k := randomKey(5)
enc, err := k.MarshalJSON()
if err != nil {
t.Fatalf(err.Error())
}
var i interface{}
err = json.Unmarshal(enc, &i)
if err != nil {
t.Fatalf("Bad json: %#v: %v", string(enc), err.Error())
}
k2 := Key("")
if err := k2.UnmarshalJSON(enc); err != nil {
t.Fatalf(err.Error())
}
if !reflect.DeepEqual(k, k2) {
t.Fatalf("\n%#v\n%#v\n", k, k2)
}
}
}
func (self *SearchResponse) Copy(result interface{}) (err error) {
sources := make(Sources, len(self.Hits.Hits))
for index, hit := range self.Hits.Hits {
sources[index] = hit.Source
}
buf, err := json.Marshal(sources)
if err != nil {
return
}
resultValue := reflect.ValueOf(result).Elem()
for resultValue.Kind() == reflect.Ptr {
resultValue = resultValue.Elem()
}
if err = json.Unmarshal(buf, resultValue.FieldByName("Items").Addr().Interface()); err != nil {
return
}
resultValue.FieldByName("Total").Set(reflect.ValueOf(self.Hits.Total))
resultValue.FieldByName("Page").Set(reflect.ValueOf(self.Page))
resultValue.FieldByName("PerPage").Set(reflect.ValueOf(self.PerPage))
return
}
/*
InsertTable data will assume that AssertTable for the type of the provided interface{} has been called beforehand, and
push this particular instance into BigQuery.
*/
func (self *BigQuery) InsertTableData(i interface{}) (err error) {
j := map[string]gbigquery.JsonValue{}
b, err := json.Marshal(i, "bigquery")
if err != nil {
return
}
if err = json.Unmarshal(b, &j); err != nil {
return
}
cropStrings(j)
if b, err = time.Now().MarshalJSON(); err != nil {
return
}
s := ""
if err = json.Unmarshal(b, &s); err != nil {
return
}
j["_inserted_at"] = s
request := &gbigquery.TableDataInsertAllRequest{
Rows: []*gbigquery.TableDataInsertAllRequestRows{
&gbigquery.TableDataInsertAllRequestRows{
Json: j,
},
},
}
typ := reflect.TypeOf(i)
for typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
for i := 0; i < typ.NumField(); i++ {
if typ.Field(i).Tag.Get("bigquery") == "-" {
name := typ.Field(i).Name
if jsonTag := typ.Field(i).Tag.Get("json"); jsonTag != "" {
if splitTag := strings.Split(jsonTag, ","); splitTag[0] != "" {
name = splitTag[0]
}
}
delete(j, name)
}
}
tabledataService := gbigquery.NewTabledataService(self.GetService())
tableDataList, err := tabledataService.InsertAll(self.GetProjectId(), self.GetDatasetId(), typ.Name(), request).Do()
if err != nil {
return
}
// Build insert errors error message
if len(tableDataList.InsertErrors) != 0 {
prettyJ := utils.Prettify(j)
errorStrings := []string{}
for _, errors := range tableDataList.InsertErrors {
for _, errorProto := range errors.Errors {
errorStrings = append(errorStrings, fmt.Sprintf("\nReason:%v,\nMessage:%v,\nLocation:%v", errorProto.Reason, errorProto.Message, errorProto.Location))
}
}
errorStrings = append(errorStrings, fmt.Sprintf("BigQuery: Error inserting json %v into table %v:", prettyJ, typ.Name()))
err = errors.Errorf(strings.Join(errorStrings, "\n"))
}
return
}
func Search(c ElasticSearchContext, query *SearchRequest, index, typ string) (result *SearchResponse, err error) {
if query.Size == 0 {
query.Size = 10
}
index = processIndexName(index)
url := c.GetElasticService()
if index == "" {
url += "/_all"
} else {
url += "/" + index
}
if typ != "" {
url += "/" + typ
}
url += "/_search"
b, err := json.Marshal(query)
if err != nil {
return
}
request, err := http.NewRequest("POST", url, bytes.NewBuffer(b))
if err != nil {
return
}
if c.GetElasticUsername() != "" {
request.SetBasicAuth(c.GetElasticUsername(), c.GetElasticPassword())
}
response, err := c.Client().Do(request)
if err != nil {
return
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
err = errors.Errorf("Bad status trying to search in elasticsearch %v: %v", url, response.Status)
return
}
result = &SearchResponse{}
bodyBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
return
}
if err = json.Unmarshal(bodyBytes, &result); err != nil {
var secondTry interface{}
if err = json.Unmarshal(bodyBytes, &secondTry); err != nil {
return
}
err = errors.Errorf("Unable to marshal %v into %#v", utils.Prettify(secondTry), result)
return
}
c.Debugf("Elasticsearch took %v, url:%s", result.Took, url)
result.Page = 1 + (query.From / query.Size)
result.PerPage = query.Size
return
}
/*
DocHandler will return a handler that renders the documentation for all routes registerd with DocHandle.
The resulting func will do this by going through each route in DocumentedRoutes and render the endpoint
using the provided template, providing it template functions to render separate endpoints, types, sub types
and examples of types.
*/
func DocHandler(templ *template.Template) http.Handler {
return httpcontext.HandlerFunc(func(c httpcontext.HTTPContextLogger) (err error) {
c.Resp().Header().Set("Content-Type", "text/html; charset=UTF-8")
// we define a func to render a type
// it basically just executes the "TypeTemplate" with the provided
// stack to avoid infinite recursion
renderType := func(t JSONType, stack []string) (result string, err error) {
// if the type is already mentioned in one of the parents we have already mentioned,
// bail
for _, parent := range stack {
if parent != "" && parent == t.ReflectType.Name() {
result = fmt.Sprintf("[loop protector enabled, render stack: %v]", stack)
return
}
}
stack = append(stack, t.ReflectType.Name())
buf := &bytes.Buffer{}
// then execute the TypeTemplate with this type and this stack
if err = templ.ExecuteTemplate(buf, "TypeTemplate", map[string]interface{}{
"Type": t,
"Stack": stack,
}); err != nil {
return
}
result = buf.String()
return
}
// routes are documented alphabetically
sort.Sort(routes)
// define all the functions that we left empty earlier
err = templ.Funcs(map[string]interface{}{
"RenderEndpoint": func(r DocumentedRoute) (string, error) {
return r.Render(templ.Lookup("EndpointTemplate"))
},
"RenderSubType": func(t JSONType, stack []string) (result string, err error) {
return renderType(t, stack)
},
"RenderType": func(t JSONType) (result string, err error) {
return renderType(t, nil)
},
"First": first,
"Example": func(r JSONType) (result string, err error) {
// this will render an example of the provided JSONType
defer func() {
if e := recover(); e != nil {
result = fmt.Sprintf("%v\n%s", e, utils.Stack())
}
}()
x := utils.Example(r.ReflectType)
b, err := json.MarshalIndent(x, "", " ")
if err != nil {
return
}
if len(r.Fields) > 0 {
var i interface{}
if err = json.Unmarshal(b, &i); err != nil {
return
}
if m, ok := i.(map[string]interface{}); ok {
newMap := map[string]interface{}{}
for k, v := range m {
if _, found := r.Fields[k]; found {
newMap[k] = v
}
}
if b, err = json.MarshalIndent(newMap, "", " "); err != nil {
return
}
}
}
result = string(b)
return
},
}).Execute(c.Resp(), map[string]interface{}{
"Endpoints": routes,
})
return
})
}