xorm

パッケージインストール

go get github.com/go-xorm/xorm

実行

func main() {
    db, err := xorm.NewEngine("mysql", "root:password@/{db名}")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // GET
    user := User{ID: 1}
    db.Get(&user)
    fmt.Printf("%v", user.Name)

    // Insert
    user := User{Name: "mmm"}
    engine.Insert(&user)
}

参考

https://github.com/go-xorm/xorm

godotenv

パッケージダウンロード

go get github.com/joho/godotenv

kintone.env

app.yamlと同階層に配置

KINTONE_DOMAIN="{値をセット}"
KINTONE_USER="{値をセット}"
KINTONE_PASSWORD="{値をセット}"

ファイル読込

func init() {
    err := godotenv.Load("kintone.env")
    if err != nil {
        log.Fatal("Error loading .env file")
    }
    log.Print(os.Getenv("KINTONE_DOMAIN")) // 値の読み込みが可能
}

参考

https://github.com/joho/godotenv

urlエンコーディング スペースを%20に。

url.Values

values := url.Values{}
values.Add("app", "1")
values.Add("query", "limit 100")
query := values.Encode()
log.Print(query) // app=1&query=limit+100 スペースはプラスに変換される

url

u := url.URL{
    Scheme: "https",
    Host:   "test.com",
    RawPath:  "/records",
    RawQuery: "app=1&query=limit 100",
}
log.Print(u.String()) // https://test.com?app=1&query=limit 100 スペースはエンコードされていない

url.URLのpathのみ%20でエンコードされるのでそれを使う。

query := "app=1&query=limit 100"
query = (&url.URL{Path: query}).String()
u := url.URL{
    Scheme:   "https",
    Host:     "test.com",
    RawPath:  "/records",
    RawQuery: query,
}
log.Print(u.String()) // https://test.com?app=1&query=limit%20100 スペースは%20にエンコードされる

gae datastore 開発環境

goapp serve

の後、

http://localhost:8080

の開発環境のWEBアプリケーションからレコードを作成して、
以下からレコードの内容を確認することができる

http://localhost:8000/datastore

compute engine 初期設定

インスタンスにSSH接続

gcloud compute ssh {インスタンス名} --zone {リージョン名} 

各種インストール

// apt-get update
sudo apt-get update

// git
sudo apt-get install git

// go
sudo apt-get install golang
sudo mkdir -p ~/go
echo "export GOPATH=$HOME/go" >> ~/.bashrc
echo "export PATH=$PATH:$HOME/go/bin:/usr/local/go/bin" >> ~/.bashrc
source ~/.bashrc
go version //確認
go env // 確認

// npm
sudo apt-get install nodejs
sudo apt-get install nodejs-legacy
sudo apt-get install npm

// phantomjs
npm install -g phantomjs
which phantomjs // 確認

参考

http://qiita.com/kent_ocean/items/5bfb7b69973f78b8c843

ファイル強制ダウンロード

// File ...
type File struct{}

// Download ...
func (f File) Download(c *gin.Context) {

// ファイル名取得
fileName := c.Query("fileName")
fileName = url.QueryEscape(fileName) // 日本語が文字化けないようにURLエンコード

// 強制ダウンロード設定
c.Writer.Header().Set("Content-Type", "application/force-download")

// ファイル名をセット
c.Writer.Header().Set("Content-disposition", fmt.Sprintf("attachment; filename=\"%s\"", fileName))
}

Kintone API Unmarshal Typeに分類

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

const (
    FtSingleLineText = "SINGLE_LINE_TEXT"
)

// Record ...
type Record struct {
    // Fields   map[string]interface{}
    ID     int
    Fields map[string]Field
}

// RawRecord ...
type RawRecord map[string]struct {
    Type  string      `json:"type"`
    Value interface{} `json:"value"`
}

// Field ...
type Field interface {
    // value() string
}

// UnmarshalJSON ...
func (r *Record) UnmarshalJSON(body []byte) (err error) {
    rawRecord := RawRecord{}
    if err = json.Unmarshal(body, &rawRecord); err == nil {
        fields := make(map[string]Field)
        for code, v := range rawRecord {
            switch v.Type {
            case FtSingleLineText:
                var field Field = SingleLineTextField(v.Value.(string))
                fields[code] = field
            }
        }
        r.Fields = fields
        return
    }
    return
}

// SingleLineTextField ...
type SingleLineTextField string

func (SingleLineTextField) String() string {
    return "aa"
}

func main() {
    b := []byte(`{"record":{"name":{"type":"SINGLE_LINE_TEXT","value":"yohei"}}}`)

    request := struct {
        Record Record `json:"record"`
    }{}
    if err := json.Unmarshal(b, &request); err != nil {
        log.Print(err)
    }
    fmt.Print(fmt.Sprintf("%v", request.Record.Fields["name"]))
}

line bot api json unmarshal

package main

import (
    "encoding/json"
    "log"
)

// EventType ...
type EventType string

const (
    // EventTypeMessage ...
    EventTypeMessage EventType = "message"
    // EventTypeFollow ...
    EventTypeFollow EventType = "follow"
)

// Message ...
type Message interface {
    // json.Marshaler
    // message()
}

// MessageType ...
type MessageType string

const (
    // MessageTypeText ...
    MessageTypeText MessageType = "text"
    // MessageTypeImage ...
    MessageTypeImage MessageType = "image"
)

// TextMessage ...
type TextMessage struct {
    ID   string
    Text string
}

// Event ...
type Event struct {
    Type    EventType
    Message Message
}

type rawEvent struct {
    Type    EventType        `json:"type"`
    Message *rawEventMessage `json:"message"`
}

type rawEventMessage struct {
    Type MessageType `json:"type"`
    Text string      `json:"text"`
}

// UnmarshalJSON ...
func (e *Event) UnmarshalJSON(body []byte) (err error) {
    rawEvent := rawEvent{}
    if err = json.Unmarshal(body, &rawEvent); err != nil {
        return
    }
    e.Type = rawEvent.Type

    switch rawEvent.Type {
    case EventTypeMessage:
        switch rawEvent.Message.Type {
        case MessageTypeText:
            e.Message = &TextMessage{
                Text: rawEvent.Message.Text,
            }
        }
    }
    return
}

func main() {
    b := []byte(`{"events":[{"type":"message","message":{"type":"text", "text":"hello"}}]}`)

    request := struct {
        Events []*Event `json:"events"`
    }{}
    if err := json.Unmarshal(b, &request); err != nil {
        log.Print(err)
    }
    log.Print(request.Events[0].Message)
}