HomeCoffeeCode

Let’s face it sometimes all we need is just to get something out of a JSON response without actually needing to go all the way and create structs to reflect its internals.

The quick and dirty solution to this is a map with a string as a key and an interface{} (think Object in any other language) which can then be accessed with mymap[“key”]

and if needed cast on the fly like this: mymap[“key”].(string)

Problem is this all works super easy and out of the box with a one level json. The issue is when you would need to access something more internal. Let’s take this JSON example:


{
"data": {
"gid": "1140824417098551",
"resource_type": "task",
"created_at": "2019-09-20T07:17:05.161Z",
"modified_at": "2019-09-20T07:17:05.161Z",
"name": "test from postman",
"resource_subtype": "default_task",
"notes": "notes from postman",
"assignee": {
"gid": "1139046208196844",
"resource_type": "user",
"name": "Fabio Russo"
},
"completed": false,
"assignee_status": "inbox",
"completed_at": null,
"due_on": null,
"due_at": null,
"projects": [
{
"gid": "1139411274392065",
"resource_type": "project",
"name": "test"
}
],
"start_on": null,
"tags": [],
}
}


With some omissis this is a typical response when adding a task with the Asana API. Let’s say I just need to print out or store the task id (in this json “gid”).
If I just do it like this:


var response map[string]interface{}
respBody, err := ioutil.ReadAll(resp.Body)
if err = json.Unmarshal(respBody, &response); err != nil {
//error code here
}


Now let’s say I’d love to do something that other languages allow such as:  responseID := response["data"]["gid"]


But that’s asking too much. And if I do it in two steps: responseData := response["data"]


I can’t just do  responseGID := responseData["gid"]


because responseData is an interface{} and not a map[string]interface{} aka a json object we can inspect.
The solution is simple: just cast the responseData into what it really is: a map[string]interface{} because we know it is.

I end up with a response object that I can use like this:

responseData := response["data"].(map[string]interface{})
taskID := responseData["gid"].(string)


Which will totally work as long as we know the json structure in advance (which we would need to even in the case we’d be using structs for the job).

I was banging my head against this for hours and then I found the solution.

While attempting to Decode a jpg image from base64 I kept getting a missing SOI marker error.

And then I found out that it’s way easier to just use image.Decode (the generic version from the “image” package directly) which will basically decode anything you throw at it 🙂

base64Data := b64.NewDecoder(b64.StdEncoding, strings.NewReader(userData))
img, str, err := image.Decode(base64Data)
if err != nil {
    log.Println("Error decoding image: " + err.Error() + " str: " + str)
}

Maybe this can save somebody a little time.

Just putting this here because I’ve been looking for hours without finding the right connection string. So basically if you’re using sqlx for example you’re going to need a connection string for your go app.

The easiest thing is to place this as an environment var in your app.yaml. In order to do this your app.yaml might look like this:

runtime: go111
env_variables:
  DATABASE_URL: "postgres://username:password@/databasename?host=/cloudsql/example:us-central1:example123"

After /cloudsql/ you’ll have your instancename (hint just run gcloud sql instances describe yourproject) from the command line and you’ll find a “connectionName” key, that’s the one

the trick was to 1) not use a host but /databasename directly and 2) using host= and not socket or unix_socket

N.B. This will work with a STANDARD GAE + Cloud Postgres

In the Go code it’s as simple as:

  
url := os.Getenv("DATABASE_URL")
DB, err = sqlx.Open("postgres", url)

Let’s face it, we’ve all been there. We started our career with SQL, found it cumbersome and difficult to remember, had too many DataManager classes around to encapsulate queries and got tired of all that work. Then suddenly we were hit by the light at the end of the tunnel.. an ORM.. in my case Hibernate was love at first sight. No more fussing with SQL dialects, no more Stored Procedures on Oracle, something reusable, write once run on any DB, real java style. And then just sometimes you’d hit a wall where some really crazy query or nested selects weren’t as easy without having to really know every nuance of the library, and even then it sometimes wouldn’t work. And then there was the Heap growing like crazy, garbage collection to tame, too many objects being pulled into memory during a massive select. Of course there was also data mapping, but that was even more xml, no thanks. Then came Ruby on Rails with ActiveRecord and all its beauty and ease. Everything was a breeze. Except it wasn’t and sometimes you’d still need to do some nasty native query. But hey it was nice. Most of the time. Until of course it took more code and workarounds to make AR behave like a very specific native query that just couldn’t be mapped. And maybe it ended up with more code, more loops and more memory than necessary. And don’t even get me started on performance! And so recently (like a couple of years now) I came to know Go. Go is plain but in a subtle way. But database wise it doesn’t come with a lot of extras attached. So I went back to having structs mapped to tables (well not only) and to using plain old native SQL (yes I have the luxury of saying I want Postgres because Heroku or other services will just allow me to). And so everything became sort of “simple” again. Of course there’s more work involved. I have query files that are pure SQL and call them from my code. I need to cycle through results or just assign a query result to an array and all. But.. and this is very important, I have two big wins: 1) I have complete control 2) I have super performant code

The only downside is you need to really know your SQL.. but hey… SQL is something that will never die, just like C and Linux. So learning it is investing in a lifelong skill anyway. Plus the amount of control is simply stunning. No more walls. No more coding around a barrier or lack of implementation in a library. This feels like home. Yep.

I was looking for a simple way of tinting an NSImage the way I’m used to doing with UIImage but it appears that Cocoa is a little behind Cocoa Touch in this regard. I found many different solutions but none of them worked out of the box with Swift 4. This is what I came up with eventually and works as expected.

extension NSImage {
    func tinting(with tintColor: NSColor) -> NSImage {
        guard let cgImage = self.cgImage(forProposedRect: nil, context: nil, hints: nil) else { return self }
        
        return NSImage(size: size, flipped: false) { bounds in
            guard let context = NSGraphicsContext.current?.cgContext else { return false }
            tintColor.set()
            context.clip(to: bounds, mask: cgImage)
            context.fill(bounds)
            return true
        }
    }
}

Here’s a nice little extension I wrote to create NSColors given an html string and vice versa getting an html string from an existing NSColor. Hope it’s useful.

extension NSColor {
    
    public convenience init?(htmlString: String) {
        let hexColor = htmlString.replacingOccurrences(of: "#", with: "")
        
        let scanner = Scanner(string: hexColor)
        var hexNumber: UInt64 = 0
        
        if scanner.scanHexInt64(&hexNumber) {
            let red = CGFloat(((hexNumber & 0xFF0000) >> 16)) / 255.0
            let green = CGFloat(((hexNumber & 0x00FF00) >> 8)) / 255.0
            let blue = CGFloat(((hexNumber & 0x0000FF) >> 0)) / 255.0
            self.init(red: red, green: green, blue: blue, alpha: 1.0)
            return
        }

        return nil
    }
    
    func toHTMLString() -> String {
        var r: CGFloat = 0
        var g: CGFloat = 0
        var b: CGFloat = 0
        var a: CGFloat = 0
        self.getRed(&r, green: &g, blue: &b, alpha: &a)
        return String(
            format: "#%02X%02X%02X",
            Int(r * 0xff),
            Int(g * 0xff),
            Int(b * 0xff)
        )
    }
}