CODEWITHSUNDEEP
jsongo
stigward
stigward

Reputation: 157

Editing Json in Go without Unmarshalling into Structs First

I am having a bit of an issue. So I am writing a tool in go that works with some json files. The way the tool works is the devops member who is using it is supposed to upload their json file into the specified folder within the project and then that json file is used from there to deploy an api in api-gateway (the json is actually a swagger with extensions but that isn't particularly important to my question)

The issue I am having is I need to update ONE line in the json. Each file passed in will be different, but it is guaranteed to have a url in the same spot every time, just due to the nature of the project. I need to update this url in an automated fashion.

Due to the fact the json files are different, setting up hard coded structs and unmarshalling in order to edit is out of the question. The objective is for the devops members to not even have to go into the code, but rather just to deploy their files, which is the reason I was hoping for this to be automated.

So far my research has yielded nothing. It appears that Go only supports editing json if it is first unmarshaled into structs (see Modifying JSON file using Golang). Is there a way to edit without the structs if i know for a fact what I am looking for will always be available within the json, despite each file being different?

This is only my first month using go, so there may be a simple solution. I have seen some mention of scanners from the megajson library, but I cannot seem to get that to work either

{
"paths": {
    "/account": {
        "post": {
            "something": "body",
            "api": {
                "uri": "http://thisiswhereineedtoedit.com"
            }
        }
    }
}

}

Upvotes: 4

Views: 2685

Answers (3)

hnd4r7
hnd4r7

Reputation: 7

You can try filepath pkg from cross-plane runtime. You specify the JSON path and get or set the result you want like the example in the above link.

Upvotes: 0

Thundercat
Thundercat

Reputation: 121119

Unmarshal to interface{}. Walk down nested objects to find the object with the value to set. Set the value. Marshal back to JSON.

var root interface{}
if err := json.Unmarshal(d, &root); err != nil {
    log.Fatal(err)
}

// Walk down path to target object.
v := root
var path = []string{"paths", "/account", "post", "api"}
for i, k := range path {
    m, ok := v.(map[string]interface{})
    if !ok {
        log.Fatalf("map not found at %s", strings.Join(path[:i+1], ", "))
    }
    v, ok = m[k]
    if !ok {
        log.Fatalf("value not found at %s", strings.Join(path[:i+1], ", "))
    }
}

// Set value in the target object.
m, ok := v.(map[string]interface{})
if !ok {
    log.Fatalf("map not found at %s", strings.Join(path, ", "))
}
m["uri"] = "the new URI"

// Marshal back to JSON. Variable d is []byte with the JSON
d, err := json.Marshal(root)
if err != nil {
    log.Fatal(err)
}

Replace calls to log.Fatal with whatever error handling is appropriate for your application.

playground example

Upvotes: 5

Mihailo
Mihailo

Reputation: 4917

One way you can solve this is by reading the file and changing it.

Lets say you have the file as you mentioned:

example.json

{
    "paths": {
        "/account": {
            "post": {
                "something": "body",
                "api": {
                    "uri": "http://thisiswhereineedtoedit.com"
                }
            }
        }
    }
}

And we want to change the line with "uri" in it.
You should be more specific then I was in this example, make a placeholder or something - to avoid changing the wrong line.

You can use a small program that would look something like this:

package main

import (
    "io/ioutil"
    "log"
    "strings"
)

func main() {
    file := "./example.json"
    url := "\"uri\": \"supreme-uri\""

    // Read the file
    input, err := ioutil.ReadFile(file)
    if err != nil {
        log.Fatalln(err)
    }

    // Split it into lines
    lines := strings.Split(string(input), "\n")

    // Find the line that contains our "placeholder" / "uri"
    for i, line := range lines {
        if strings.Contains(line, "\"uri\":") {
            // Replace the line
            lines[i] = "\"uri\": " + url
        }
    }

    // Join lines and write to file
    output := strings.Join(lines, "\n")
    err = ioutil.WriteFile(file, []byte(output), 0644)
    if err != nil {
        log.Fatalln(err)
    }
}

And after running the program our example.json file now looks like this:

{
    "paths": {
        "/account": {
            "post": {
                "something": "body",
                "api": {
"uri": "supreme-uri"
                }
            }
        }
    }
}

Hope you find this solution useful, Good luck! :]

Upvotes: 1

Related Questions