kinda working json unmarshal

cmd/main/main.go.txt

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/xuri/excelize/v2"
+)
+
+// Initial concept from https://stackoverflow.com/q/68621039
+
+var end = errors.New("invalid end of array or object")
+
+func main() {
+	file, err := ioutil.ReadFile("test.json")
+	if err != nil {
+		panic(err)
+	}
+
+	testkey, err := objectKeys([]byte(file))
+	fmt.Println(testkey, err)
+	return
+
+	var data interface{}
+	json.Unmarshal(file, &data) // reading all json data
+	//fmt.Println(data)
+	t, ok := data.([]interface{}) // assertion Interface
+	_ = ok
+	//fmt.Printf("%[1]v  %[1]T\n", t) //map[string]interface {}
+
+	myMap := t[0] // aim here to get APP, Company and Category which will be the column name of Excel sheet
+	fmt.Printf("myMap: %v\n", myMap)
+	columnData, _ := myMap.(map[string]interface{}) // extract the underlying concrete data from interface
+	fmt.Printf("columnData: %v\n", columnData)
+	keys := make([]string, 0, len(columnData)) // creating and initializing slice to store column
+	for k := range columnData {
+		fmt.Printf("%[1]v %[1]T\n", k)
+		keys = append(keys, k)
+	}
+
+	return
+
+	xlsx := excelize.NewFile()
+	sheetName := "Sheet1"
+	xlsx.SetSheetName(xlsx.GetSheetName(1), sheetName)
+	c := 'A'
+	asciiValue := int(c)
+	var a string
+	for i := 0; i < len(keys); i++ {
+		a = string(asciiValue)
+		xlsx.SetCellValue(sheetName, a+"1", keys[i])
+		asciiValue++
+	}
+	err = xlsx.SaveAs("./Onkar.xlsx")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("Excel file generated sucessfully")
+}
+
+func objectKeys(b []byte) ([]string, error) {
+	d := json.NewDecoder(bytes.NewReader(b))
+	t, err := d.Token()
+	if err != nil {
+		return nil, err
+	}
+	if t != json.Delim('{') {
+		return nil, errors.New("expected start of object")
+	}
+	var keys []string
+	for {
+		t, err := d.Token()
+		if err != nil {
+			return nil, err
+		}
+		if t == json.Delim('}') {
+			return keys, nil
+		}
+		keys = append(keys, t.(string))
+		if err := skipValue(d); err != nil {
+			return nil, err
+		}
+	}
+}
+func skipValue(d *json.Decoder) error {
+	t, err := d.Token()
+	if err != nil {
+		return err
+	}
+	switch t {
+	case json.Delim('['), json.Delim('{'):
+		for {
+			if err := skipValue(d); err != nil {
+				if err == end {
+					break
+				}
+				return err
+			}
+		}
+	case json.Delim(']'), json.Delim('}'):
+		return end
+	}
+	return nil
+}

go.mod

@@ -0,0 +1,9 @@
+module json2excel
+
+go 1.19
+
+require github.com/iancoleman/orderedmap v0.2.0
+
+//require internal/ordered v1.0.0
+
+//replace internal/ordered => ./internal/ordered

go.sum

@@ -0,0 +1,2 @@
+github.com/iancoleman/orderedmap v0.2.0 h1:sq1N/TFpYH++aViPcaKjys3bDClUEU7s5B+z6jq8pNA=
+github.com/iancoleman/orderedmap v0.2.0/go.mod h1:N0Wam8K1arqPXNWjMo21EXnBPOPp36vB07FNRdD2geA=

internal/ordered/go.mod.txt

@@ -0,0 +1,3 @@
+module ordered
+
+go 1.19

internal/ordered/ordered.go.txt

@@ -0,0 +1,267 @@
+// Package ordered provided a type OrderedMap for use in JSON handling
+// although JSON spec says the keys order of an object should not matter
+// but sometimes when working with particular third-party proprietary code
+// which has incorrect using the keys order, we have to maintain the object keys
+// in the same order of incoming JSON object, this package is useful for these cases.
+//
+// Disclaimer:
+// same as Go's default [map](https://blog.golang.org/go-maps-in-action),
+// this OrderedMap is not safe for concurrent use, if need atomic access, may use a sync.Mutex to synchronize.
+package ordered
+
+// Refers
+//  JSON and Go        https://blog.golang.org/json-and-go
+//  Go-Ordered-JSON    https://github.com/virtuald/go-ordered-json
+//  Python OrderedDict https://github.com/python/cpython/blob/2.7/Lib/collections.py#L38
+//  port OrderedDict   https://github.com/cevaris/ordered_map
+
+import (
+	"bytes"
+	"container/list"
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// the key-value pair type, for initializing from a list of key-value pairs, or for looping entries in the same order
+type KVPair struct {
+	Key   string
+	Value interface{}
+}
+
+type m map[string]interface{}
+
+// the OrderedMap type, has similar operations as the default map, but maintained
+// the keys order of inserted; similar to map, all single key operations (Get/Set/Delete) runs at O(1).
+type OrderedMap struct {
+	m
+	l    *list.List
+	keys map[string]*list.Element // the double linked list for delete and lookup to be O(1)
+}
+
+// Create a new OrderedMap
+func NewOrderedMap() *OrderedMap {
+	return &OrderedMap{
+		m:    make(map[string]interface{}),
+		l:    list.New(),
+		keys: make(map[string]*list.Element),
+	}
+}
+
+// Create a new OrderedMap and populate from a list of key-value pairs
+func NewOrderedMapFromKVPairs(pairs []*KVPair) *OrderedMap {
+	om := NewOrderedMap()
+	for _, pair := range pairs {
+		om.Set(pair.Key, pair.Value)
+	}
+	return om
+}
+
+// return all keys
+// func (om *OrderedMap) Keys() []string { return om.keys }
+
+// set value for particular key, this will remember the order of keys inserted
+// but if the key already exists, the order is not updated.
+func (om *OrderedMap) Set(key string, value interface{}) {
+	if _, ok := om.m[key]; !ok {
+		om.keys[key] = om.l.PushBack(key)
+	}
+	om.m[key] = value
+}
+
+// Check if value exists
+func (om *OrderedMap) Has(key string) bool {
+	_, ok := om.m[key]
+	return ok
+}
+
+// Get value for particular key, or nil if not exist; but don't rely on nil for non-exist; should check by Has or GetValue
+func (om *OrderedMap) Get(key string) interface{} {
+	return om.m[key]
+}
+
+// Get value and exists together
+func (om *OrderedMap) GetValue(key string) (value interface{}, ok bool) {
+	value, ok = om.m[key]
+	return
+}
+
+// deletes the element with the specified key (m[key]) from the map. If there is no such element, this is a no-op.
+func (om *OrderedMap) Delete(key string) (value interface{}, ok bool) {
+	value, ok = om.m[key]
+	if ok {
+		om.l.Remove(om.keys[key])
+		delete(om.keys, key)
+		delete(om.m, key)
+	}
+	return
+}
+
+// Iterate all key/value pairs in the same order of object constructed
+func (om *OrderedMap) EntriesIter() func() (*KVPair, bool) {
+	e := om.l.Front()
+	return func() (*KVPair, bool) {
+		if e != nil {
+			key := e.Value.(string)
+			e = e.Next()
+			return &KVPair{key, om.m[key]}, true
+		}
+		return nil, false
+	}
+}
+
+// Iterate all key/value pairs in the reverse order of object constructed
+func (om *OrderedMap) EntriesReverseIter() func() (*KVPair, bool) {
+	e := om.l.Back()
+	return func() (*KVPair, bool) {
+		if e != nil {
+			key := e.Value.(string)
+			e = e.Prev()
+			return &KVPair{key, om.m[key]}, true
+		}
+		return nil, false
+	}
+}
+
+// this implements type json.Marshaler interface, so can be called in json.Marshal(om)
+func (om *OrderedMap) MarshalJSON() (res []byte, err error) {
+	res = append(res, '{')
+	front, back := om.l.Front(), om.l.Back()
+	for e := front; e != nil; e = e.Next() {
+		k := e.Value.(string)
+		res = append(res, fmt.Sprintf("%q:", k)...)
+		var b []byte
+		b, err = json.Marshal(om.m[k])
+		if err != nil {
+			return
+		}
+		res = append(res, b...)
+		if e != back {
+			res = append(res, ',')
+		}
+	}
+	res = append(res, '}')
+	// fmt.Printf("marshalled: %v: %#v\n", res, res)
+	return
+}
+
+// this implements type json.Unmarshaler interface, so can be called in json.Unmarshal(data, om)
+func (om *OrderedMap) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.UseNumber()
+
+	// must open with a delim token '{'
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+	if delim, ok := t.(json.Delim); !ok || delim != '{' {
+		return fmt.Errorf("expect JSON object open with '{'")
+	}
+
+	err = om.parseobject(dec)
+	if err != nil {
+		return err
+	}
+
+	t, err = dec.Token()
+	if err != io.EOF {
+		return fmt.Errorf("expect end of JSON object but got more token: %T: %v or err: %v", t, t, err)
+	}
+
+	return nil
+}
+
+func (om *OrderedMap) parseobject(dec *json.Decoder) (err error) {
+	var t json.Token
+	for dec.More() {
+		t, err = dec.Token()
+		if err != nil {
+			return err
+		}
+
+		key, ok := t.(string)
+		if !ok {
+			return fmt.Errorf("expecting JSON key should be always a string: %T: %v", t, t)
+		}
+
+		t, err = dec.Token()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+
+		var value interface{}
+		value, err = handledelim(t, dec)
+		if err != nil {
+			return err
+		}
+
+		// om.keys = append(om.keys, key)
+		om.keys[key] = om.l.PushBack(key)
+		om.m[key] = value
+	}
+
+	t, err = dec.Token()
+	if err != nil {
+		return err
+	}
+	if delim, ok := t.(json.Delim); !ok || delim != '}' {
+		return fmt.Errorf("expect JSON object close with '}'")
+	}
+
+	return nil
+}
+
+func parsearray(dec *json.Decoder) (arr []interface{}, err error) {
+	var t json.Token
+	arr = make([]interface{}, 0)
+	for dec.More() {
+		t, err = dec.Token()
+		if err != nil {
+			return
+		}
+
+		var value interface{}
+		value, err = handledelim(t, dec)
+		if err != nil {
+			return
+		}
+		arr = append(arr, value)
+	}
+	t, err = dec.Token()
+	if err != nil {
+		return
+	}
+	if delim, ok := t.(json.Delim); !ok || delim != ']' {
+		err = fmt.Errorf("expect JSON array close with ']'")
+		return
+	}
+
+	return
+}
+
+func handledelim(t json.Token, dec *json.Decoder) (res interface{}, err error) {
+	if delim, ok := t.(json.Delim); ok {
+		switch delim {
+		case '{':
+			om2 := NewOrderedMap()
+			err = om2.parseobject(dec)
+			if err != nil {
+				return
+			}
+			return om2, nil
+		case '[':
+			var value []interface{}
+			value, err = parsearray(dec)
+			if err != nil {
+				return
+			}
+			return value, nil
+		default:
+			return nil, fmt.Errorf("Unexpected delimiter: %q", delim)
+		}
+	}
+	return t, nil
+}

main.go

@@ -0,0 +1,236 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+
+	"github.com/iancoleman/orderedmap"
+)
+
+// Initial concept from https://stackoverflow.com/q/68621039
+
+func main() {
+	parentNode := "input"
+	s, err := ioutil.ReadFile("test.json")
+	if err != nil {
+		panic(err)
+	}
+
+	//TestUnmarshalJSON()
+
+	o := orderedmap.New()
+	err = json.Unmarshal([]byte(s), &o)
+	if err != nil {
+		fmt.Printf("JSON Unmarshal error", err)
+	}
+
+	// Get a reference to the top level node we specified earlier
+	// TODO - validate this key exists
+	vislice, ok := o.Get(parentNode)
+	if !ok {
+		fmt.Printf("Missing key for multitype array")
+	}
+	vslice := vislice.([]interface{})
+
+	// Get the keys for the first element so we know what the column names will be
+	columnMap := vslice[0].(orderedmap.OrderedMap)
+	columnNames := columnMap.Keys()
+	fmt.Printf("Creating excel workbook with following headings : '%v'\n", columnNames)
+
+	for i, v := range vslice {
+		// Print the contents each slice
+		//fmt.Printf("'%d' : '%v'\n", i, v)
+
+		fmt.Printf("Slice element %d\n", i)
+
+		// Print each key-value pair contained in this slice
+		vmap := v.(orderedmap.OrderedMap)
+		k := vmap.Keys()
+		for j := range k {
+			e, _ := vmap.Get(k[j])
+			fmt.Printf("'%s' : '%v'\n", k[j], e)
+		}
+		//fmt.Printf("k: %v\n", k)
+	}
+
+	/*
+		//Test https://gitlab.com/c0b/go-ordered-json
+		var om *ordered.OrderedMap = ordered.NewOrderedMap()
+		err = json.Unmarshal([]byte(file), om)
+		if err != nil {
+			fmt.Printf("error: '%s'\n", err)
+		}
+
+		iter := om.EntriesIter()
+		for {
+			pair, ok := iter()
+			if !ok {
+				break
+			}
+			fmt.Printf("%-12s: %v\n", pair.Key, pair.Value)
+		}
+	*/
+
+	/*
+	   var data interface{}
+	   json.Unmarshal(file, &data) // reading all json data
+	   //fmt.Println(data)
+	   t, ok := data.([]interface{}) // assertion Interface
+	   _ = ok
+	   //fmt.Printf("%[1]v  %[1]T\n", t) //map[string]interface {}
+
+	   myMap := t[0] // aim here to get APP, Company and Category which will be the column name of Excel sheet
+	   fmt.Printf("myMap: %v\n", myMap)
+	   columnData, _ := myMap.(map[string]interface{}) // extract the underlying concrete data from interface
+	   fmt.Printf("columnData: %v\n", columnData)
+	   keys := make([]string, 0, len(columnData)) // creating and initializing slice to store column
+
+	   	for k := range columnData {
+	   		fmt.Printf("%[1]v %[1]T\n", k)
+	   		keys = append(keys, k)
+	   	}
+
+	   return
+
+	   xlsx := excelize.NewFile()
+	   sheetName := "Sheet1"
+	   xlsx.SetSheetName(xlsx.GetSheetName(1), sheetName)
+	   c := 'A'
+	   asciiValue := int(c)
+	   var a string
+
+	   	for i := 0; i < len(keys); i++ {
+	   		a = string(asciiValue)
+	   		xlsx.SetCellValue(sheetName, a+"1", keys[i])
+	   		asciiValue++
+	   	}
+
+	   err = xlsx.SaveAs("./Onkar.xlsx")
+
+	   	if err != nil {
+	   		fmt.Println(err)
+	   		return
+	   	}
+
+	   fmt.Println("Excel file generated sucessfully")
+	*/
+}
+
+func TestUnmarshalJSON() {
+	s := `{
+  "number": 4,
+  "string": "x",
+  "z": 1,
+  "a": "should not break with unclosed { character in value",
+  "b": 3,
+  "slice": [
+    "1",
+    1
+  ],
+  "orderedmap": {
+    "e": 1,
+    "a { nested key with brace": "with a }}}} }} {{{ brace value",
+	"after": {
+		"link": "test {{{ with even deeper nested braces }"
+	}
+  },
+  "test\"ing": 9,
+  "after": 1,
+  "multitype_array": [
+    "test",
+	1,
+	{ "map": "obj", "it" : 5, ":colon in key": "colon: in value" },
+	[{"inner": "map"}]
+  ],
+  "should not break with { character in key": 1
+}`
+	o := orderedmap.New()
+	err := json.Unmarshal([]byte(s), &o)
+	if err != nil {
+		fmt.Printf("JSON Unmarshal error", err)
+	}
+	// Check the root keys
+	expectedKeys := []string{
+		"number",
+		"string",
+		"z",
+		"a",
+		"b",
+		"slice",
+		"orderedmap",
+		"test\"ing",
+		"after",
+		"multitype_array",
+		"should not break with { character in key",
+	}
+	k := o.Keys()
+	for i := range k {
+		if k[i] != expectedKeys[i] {
+			fmt.Printf("Unmarshal root key order", i, k[i], "!=", expectedKeys[i])
+		}
+	}
+	// Check nested maps are converted to orderedmaps
+	// nested 1 level deep
+	expectedKeys = []string{
+		"e",
+		"a { nested key with brace",
+		"after",
+	}
+	vi, ok := o.Get("orderedmap")
+	if !ok {
+		fmt.Printf("Missing key for nested map 1 deep")
+	}
+	v := vi.(orderedmap.OrderedMap)
+	k = v.Keys()
+	for i := range k {
+		if k[i] != expectedKeys[i] {
+			fmt.Printf("Key order for nested map 1 deep ", i, k[i], "!=", expectedKeys[i])
+		}
+	}
+	// nested 2 levels deep
+	expectedKeys = []string{
+		"link",
+	}
+	vi, ok = v.Get("after")
+	if !ok {
+		fmt.Printf("Missing key for nested map 2 deep")
+	}
+	v = vi.(orderedmap.OrderedMap)
+	k = v.Keys()
+	for i := range k {
+		if k[i] != expectedKeys[i] {
+			fmt.Printf("Key order for nested map 2 deep", i, k[i], "!=", expectedKeys[i])
+		}
+	}
+	// multitype array
+	expectedKeys = []string{
+		"map",
+		"it",
+		":colon in key",
+	}
+	vislice, ok := o.Get("multitype_array")
+	if !ok {
+		fmt.Printf("Missing key for multitype array")
+	}
+	vslice := vislice.([]interface{})
+	vmap := vslice[2].(orderedmap.OrderedMap)
+	k = vmap.Keys()
+	for i := range k {
+		if k[i] != expectedKeys[i] {
+			fmt.Printf("Key order for nested map 2 deep", i, k[i], "!=", expectedKeys[i])
+		}
+	}
+	// nested map 3 deep
+	vislice, _ = o.Get("multitype_array")
+	vslice = vislice.([]interface{})
+	expectedKeys = []string{"inner"}
+	vinnerslice := vslice[3].([]interface{})
+	vinnermap := vinnerslice[0].(orderedmap.OrderedMap)
+	k = vinnermap.Keys()
+	for i := range k {
+		if k[i] != expectedKeys[i] {
+			fmt.Printf("Key order for nested map 3 deep", i, k[i], "!=", expectedKeys[i])
+		}
+	}
+}