Subscribed unsubscribe Subscribe Subscribe

OngaLog

最近GOが楽しくて、

Go言語を使ってLineBotを作成してみる

AppEngineとGo言語でLineBotを作成するサンプル

f:id:loosefingers:20170228233709p:plain

Line-Bot-Sandbox

github.com

Go言語でテキストの文字数制限を実行するライブラリ

onga-tec.hatenadiary.jp

以前Goで文字数制限処理をするのにはどうすればいいのか悩んだのだが、 WEBアプリケーションを作成する際に表示文字数制限はよく利用するのでライブラリとしてまとめてみました。

go-text-export

github.com

インストール方法

go get github.com/tkc/go-text-export

簡単な利用方法

Contrary to popular belief, Lorem Ipsum is not simply random text.
It has roots in a piece of classical Latin literature from 45 BC,

上記のようなテキストに対して、チェインメソッドを実行します。

go_text_export.Create(Str).Export(100).SetMoreText(" more..").RemoveWhiteSpace().String()

結果

Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of  more..

ほかにも、テキストからリンクを抽出する処理や改行を置換する処理を実装しています。 何気に面倒な処理が楽になります。 試してみてください。

Go Nested Json Unmarshal

GoでNestされたjsonの扱いがわからなかったのでメモ。

 jStr := `
    {
        "root": {
            "c1": ["cv1"],
            "c2": ["cv2"]
        }
    }
    `

        type Children struct {
                c1 []string `json:"c1"`
                c2 []string `json:"c2"`
        }

        type Root struct {
                c Children `json:"root"`
        }

        var root Root
        if err := json.Unmarshal([]byte(jStr), &root); err != nil {
                log.Fatal(err)
        }
        log.Printf("%+v\n", root)
        

このパッケージも良さそう。 github.com

Go からBIgQueryを扱うサンプル

Goを使ってAWSからBIgQueryにアクセスする必要があるときの処理。

package bigquery

import (
        "log"
        "reflect"
        "io/ioutil"
        "golang.org/x/oauth2"
        "golang.org/x/oauth2/google"
        "google.golang.org/api/bigquery/v2"
)

const projectId = "***"
const dataSetId = "***"
const tableName = "***"

// Type:
// STRING, BYTES, INTEGER, FLOAT, BOOLEAN, TIMESTAMP, DATE, TIME, DATETIME,

type TableModel struct {
        Name    string `column:"name" bq_type:"STRING" bq_mode:"NULLABLE"`
        Address string `column:"address" bq_type:"STRING" bq_mode:"NULLABLE"`
}

func CreateTableSchema(tableModel interface{}) bigquery.TableSchema {

        var schemas = &bigquery.TableSchema{}
        fields := []*bigquery.TableFieldSchema{}
        rt := reflect.TypeOf(tableModel)

        for i := 0; i < rt.NumField(); i++ {
                field := rt.Field(i)
                fields = append(fields,
                        &bigquery.TableFieldSchema{
                                Mode: field.Tag.Get("bq_mode"),
                                Name: field.Tag.Get("column"),
                                Type: field.Tag.Get("bq_type"),
                        },
                )
        }

        schemas.Fields = fields
        return *schemas
}

func CreateInsertRow(tableModel interface{}) []*bigquery.TableDataInsertAllRequestRows {

        rows := make([]*bigquery.TableDataInsertAllRequestRows, 0)
        row := &bigquery.TableDataInsertAllRequestRows{
                Json: make(map[string]bigquery.JsonValue, 0),
        }
        rt := reflect.TypeOf(tableModel)
        rv := reflect.ValueOf(tableModel)

        for i := 0; i < rt.NumField(); i++ {
                value := rv.Field(i).Interface()
                field := rt.Field(i)
                row.Json[field.Tag.Get("column")] = value
                rows = append(rows, row)
        }

        return rows
}

func BqSample() {

        pemKeyBytes, err := ioutil.ReadFile(<your file path>)

        if err != nil {
                panic(err)
        }

        t, err := google.JWTConfigFromJSON(pemKeyBytes, "https://www.googleapis.com/auth/bigquery")

        if err != nil {
                panic(err)
        }

        /*
            Make DataSet
        */

        client := t.Client(oauth2.NoContext)
        service, _ := bigquery.New(client)

        datasetList, _ := service.Datasets.List(projectId).All(false).Do()

        for _, dataset := range datasetList.Datasets {
                log.Print(dataset.DatasetReference.DatasetId)
        }

        /*
            DataSet Get
        */

        Dataset, _ := service.Datasets.Get(projectId, datasetId).Do()
        if Dataset != nil {
                log.Print(Dataset.DatasetReference.DatasetId)
        } else {
                log.Print("dataset not exist")
        }

        ds := bigquery.Dataset{
                DatasetReference:&bigquery.DatasetReference{
                        ProjectId:projectId,
                        DatasetId:"test_dataset",
                },
        }

        /*
            Table List
        */

        service.Datasets.Insert(projectId, &ds).Do()
        TableList, _ := service.Tables.List(projectId, dataSetId).Do()

        for _, tableListTables := range TableList.Tables {
                log.Print(tableListTables.TableReference.TableId)
        }

        /*
            Table Get
        */

        tableListTables, _ := service.Tables.Get(
                projectId,
                dataSetId,
                tableName).Do()

        if tableListTables != nil {
                log.Print(tableListTables.TableReference.TableId)
        } else {
                log.Print("table not exist")
        }

        /*
            Make Table 
        */

        schema := CreateTableSchema(TableModel{})

        table := bigquery.Table{
                TableReference: &bigquery.TableReference{
                        DatasetId: dataSetId,
                        ProjectId: projectId,
                        TableId: tableName,
                },
                Schema:&schema,
        }

        tableRes, _ := service.Tables.Insert(
                projectId,
                dataSetId,
                &table).Do()

        log.Print(tableRes)


        /*
            InsertAll 
        */

        res, _ := service.Tabledata.InsertAll(
                projectId,
                dataSetId,
                tableName,
                &bigquery.TableDataInsertAllRequest{
                        Kind: "bigquery#tableDataInsertAllRequest",
                        Rows: CreateInsertRow(TableModel{Name:"name", Address:"address"}),
                }).Do()

        log.Print(res)


        /*
            Query 
        */

        query := "SELECT address FROM [<project-name>:<dataset-name>.<table-name>] LIMIT 1000"

        result, err := service.Jobs.Query(projectId, &bigquery.QueryRequest{
                Kind:  "bigquery#queryRequest",
                Query: query,
        }).Do()

        for _, row := range result.Rows {
                log.Print(row)
                for _, cell := range row.F {
                        log.Print(cell.V)
                }
        }

}

gist

gist:113726894216fa2982a541362028a696 · GitHub

go get でverisonを指定したいとき

git から直接バージョンを指定する方法で解決した。

git tag -l
git checkout tags/v0.0.2

UbuntuへGo1.7をインストールする

UbuntuへGo1.7をインストールしたのでその時の作業ログ

$ sudo apt-get update
$ sudo apt-get -y upgrade
$ wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz
$ sudo tar -xvf go1.7.4.linux-amd64.tar.gz
$ sudo mv go /usr/local
$ mkdir ~/gocode
$ echo export GOROOT=/usr/local/go  >> ~/.bash_profile
$ echo export GOPATH=$HOME/gocode  >> ~/.bash_profile
$ echo export PATH=$GOPATH/bin:$GOROOT/bin:$PATH  >> ~/.bash_profile
$ source ~/.bash_profile
$ go version

versionが表示されればOK.

go version go1.7.4 linux/amd64