Merge pull request #28 from kintone/cursor_api

Cursor api

Author: josh-vo

app.go

@@ -24,7 +24,7 @@ import (
 )
 
 const (
-	NAME            = "kintone-go-SDK"
+	NAME            = "go-kintone"
 	VERSION         = "0.3.0"
 	DEFAULT_TIMEOUT = time.Second * 600 // Default value for App.Timeout
 )
@@ -124,7 +124,7 @@ type App struct {
 	basicAuth         bool          // true to use Basic Authentication.
 	basicAuthUser     string        // User name for Basic Authentication.
 	basicAuthPassword string        // Password for Basic Authentication.
-	userAgentHeader   string        // User-agent request header string
+	extUserAgent      string        // User-agent request header string
 }
 
 // SetBasicAuth enables use of HTTP basic authentication for access
@@ -152,12 +152,71 @@ func (app *App) GetBasicAuthPassword() string {
 
 // SetUserAgentHeader set custom user-agent header for http request
 func (app *App) SetUserAgentHeader(userAgentHeader string) {
-	app.userAgentHeader = userAgentHeader
+	app.extUserAgent = userAgentHeader
 }
 
 // GetUserAgentHeader get user-agent header string
 func (app *App) GetUserAgentHeader() string {
-	return app.userAgentHeader
+	userAgent := NAME + "/" + VERSION
+	if len(app.extUserAgent) > 0 {
+		return userAgent + " " + app.extUserAgent
+	}
+	return userAgent
+}
+
+func (app *App) createUrl(api string, query string) url.URL {
+	path := fmt.Sprintf("/k/v1/%s.json", api)
+	if app.GuestSpaceId > 0 {
+		path = fmt.Sprintf("/k/guest/%d/v1/%s.json", app.GuestSpaceId, api)
+	}
+
+	resultUrl := url.URL{
+		Scheme: "https",
+		Host:   app.Domain,
+		Path:   path,
+	}
+
+	if len(query) > 0 {
+		resultUrl.RawQuery = query
+	}
+	return resultUrl
+}
+func (app *App) setAuth(request *http.Request) {
+	if app.basicAuth {
+		request.SetBasicAuth(app.basicAuthUser, app.basicAuthPassword)
+	}
+
+	if len(app.ApiToken) > 0 {
+		request.Header.Set("X-Cybozu-API-Token", app.ApiToken)
+	}
+
+	if len(app.User) > 0 && len(app.Password) > 0 {
+		request.Header.Set("X-Cybozu-Authorization", base64.StdEncoding.EncodeToString(
+			[]byte(app.User+":"+app.Password)))
+	}
+}
+
+//NewRequest create a request connect to kintone api.
+func (app *App) NewRequest(method, url string, body io.Reader) (*http.Request, error) {
+	bodyData := io.Reader(nil)
+	if body != nil {
+		bodyData = body
+	}
+
+	request, err := http.NewRequest(method, url, bodyData)
+	if err != nil {
+		return nil, err
+	}
+
+	request.Header.Set("User-Agent", app.GetUserAgentHeader())
+
+	if method != "GET" {
+		request.Header.Set("Content-Type", "application/json")
+	}
+
+	app.setAuth(request)
+
+	return request, nil
 }
 
 func (app *App) newRequest(method, api string, body io.Reader) (*http.Request, error) {
@@ -191,12 +250,8 @@ func (app *App) newRequest(method, api string, body io.Reader) (*http.Request, e
 		req.Header.Set("X-Cybozu-API-Token", app.ApiToken)
 	}
 	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", app.GetUserAgentHeader())
 
-	if len(app.GetUserAgentHeader()) != 0 {
-		req.Header.Set("User-Agent", app.userAgentHeader)
-	} else {
-		req.Header.Set("User-Agent", NAME+"/"+VERSION)
-	}
 	return req, nil
 }
 
@@ -1000,3 +1055,82 @@ func (app *App) Fields() (map[string]*FieldInfo, error) {
 	}
 	return ret, nil
 }
+
+//CreateCursor return the meta data of the Cursor in this application
+func (app *App) CreateCursor(fields []string, query string, size uint64) (*Cursor, error) {
+	type cursor struct {
+		App    uint64   `json:"app"`
+		Fields []string `json:"fields"`
+		Size   uint64   `json:"size"`
+		Query  string   `json:"query"`
+	}
+	data := cursor{App: app.AppId, Fields: fields, Size: size, Query: query}
+	jsonData, _ := json.Marshal(data)
+	url := app.createUrl("records/cursor", "")
+	request, err := app.NewRequest("POST", url.String(), bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+	response, err := app.do(request)
+	if err != nil {
+		return nil, err
+	}
+	body, err := parseResponse(response)
+	if err != nil {
+		return nil, err
+	}
+	result, err := decodeCursor(body)
+	return result, nil
+}
+
+// DeleteCursor - Delete cursor by id
+func (app *App) DeleteCursor(id string) error {
+	type requestBody struct {
+		Id string `json:"id"`
+	}
+	data, err := json.Marshal(requestBody{Id: id})
+	if err != nil {
+		return err
+	}
+
+	url := app.createUrl("records/cursor", "")
+	request, err := app.NewRequest("DELETE", url.String(), bytes.NewBuffer(data))
+	if err != nil {
+		return err
+	}
+
+	response, err := app.do(request)
+	if err != nil {
+		return err
+	}
+
+	_, err = parseResponse(response)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+//Using Cursor Id to get all records
+//GetRecordsByCursor return the meta data of the Record in this application
+func (app *App) GetRecordsByCursor(id string) (*GetRecordsCursorResponse, error) {
+	url := app.createUrl("records/cursor", "id="+id)
+	request, err := app.NewRequest("GET", url.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	response, err := app.do(request)
+	if err != nil {
+		return nil, err
+	}
+	data, err := parseResponse(response)
+	if err != nil {
+		return nil, err
+	}
+	recordsCursorResponse, err := DecodeGetRecordsCursorResponse(data)
+	if err != nil {
+		return nil, err
+	}
+	return recordsCursorResponse, nil
+}

app_test.go

@@ -6,35 +6,40 @@ package kintone
 
 import (
 	"bytes"
+	"fmt"
 	"io/ioutil"
-	"os"
 	"strings"
 	"testing"
 	"time"
 )
 
+const KINTONE_DOMAIN = "YOUR_DOMAIN"
+const KINTONE_USER = "YOUR_KINTONE_USER"
+const KINTONE_PASSWORD = "YOUR_KINTONE_PASSWORD"
+const KINTONE_API_TOKEN = "YOUR_API_TOKEN"
+
 func newApp(appID uint64) *App {
 	return &App{
-		Domain:   os.Getenv("KINTONE_DOMAIN"),
-		User:     os.Getenv("KINTONE_USER"),
-		Password: os.Getenv("KINTONE_PASSWORD"),
+		Domain:   KINTONE_DOMAIN,
+		User:     KINTONE_USER,
+		Password: KINTONE_PASSWORD,
 		AppId:    appID,
 	}
 }
 
 func newAppWithApiToken(appId uint64) *App {
 	return &App{
-		Domain:   os.Getenv("KINTONE_DOMAIN"),
-		ApiToken: os.Getenv("KINTONE_API_TOKEN"),
+		Domain:   KINTONE_DOMAIN,
+		ApiToken: KINTONE_API_TOKEN,
 		AppId:    appId,
 	}
 }
 
 func newAppInGuestSpace(appId uint64, guestSpaceId uint64) *App {
 	return &App{
-		Domain:       os.Getenv("KINTONE_DOMAIN"),
-		User:         os.Getenv("KINTONE_USER"),
-		Password:     os.Getenv("KINTONE_PASSWORD"),
+		Domain:       KINTONE_DOMAIN,
+		User:         KINTONE_USER,
+		Password:     KINTONE_PASSWORD,
 		AppId:        appId,
 		GuestSpaceId: guestSpaceId,
 	}
@@ -82,7 +87,6 @@ func TestGetRecord(t *testing.T) {
 		t.Log(len(recs))
 	}
 }
-
 func TestAddRecord(t *testing.T) {
 	a := newApp(9004)
 	if len(a.Password) == 0 {
@@ -171,6 +175,58 @@ func TestDeleteRecord(t *testing.T) {
 	}
 }
 
+func TestGetRecordsByCursor(t *testing.T) {
+	app := newApp(18)
+
+	if len(app.Password) == 0 {
+		t.Skip()
+	}
+
+	cursor := app.createCursorForTest()
+	record, err := app.GetRecordsByCursor(string(cursor.Id))
+
+	if err != nil {
+		t.Errorf("TestGetCursor is failed: %v", err)
+	}
+	fmt.Println(record)
+
+}
+
+func (app *App) createCursorForTest() *Cursor {
+	cursor, err := app.CreateCursor([]string{"$id", "Status"}, "", 400)
+	fmt.Println("cursor", cursor)
+	if err != nil {
+		fmt.Println("createCursorForTest failed: ", err)
+	}
+	return cursor
+}
+
+func TestDeleteCursor(t *testing.T) {
+	app := newApp(18)
+	if len(app.Password) == 0 {
+		t.Skip()
+	}
+
+	cursor := app.createCursorForTest()
+	fmt.Println("cursor", cursor)
+	err := app.DeleteCursor(string(cursor.Id))
+
+	if err != nil {
+		t.Errorf("TestDeleteCursor is failed: %v", err)
+	}
+}
+
+func TestCreateCursor(t *testing.T) {
+	app := newApp(18)
+	if len(app.Password) == 0 {
+		t.Skip()
+	}
+	_, err := app.CreateCursor([]string{"$id", "date"}, "", 100)
+	if err != nil {
+		t.Errorf("TestCreateCurSor is failed: %v", err)
+	}
+}
+
 func TestFields(t *testing.T) {
 	a := newApp(8326)
 	if len(a.Password) == 0 {

cursor.go

@@ -0,0 +1,39 @@
+package kintone
+
+import (
+	"encoding/json"
+)
+
+//Object Cursor structure
+type Cursor struct {
+	Id         string `json:"id"`
+	TotalCount string `json:"totalCount"`
+}
+type GetRecordsCursorResponse struct {
+	Records []*Record `json:"records"`
+	Next    bool      `json:"next"`
+}
+
+//decodeCursor decodes JSON response for cursor api
+func decodeCursor(b []byte) (c *Cursor, err error) {
+	err = json.Unmarshal(b, &c)
+	if err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+func DecodeGetRecordsCursorResponse(b []byte) (rc *GetRecordsCursorResponse, err error) {
+	var t struct {
+		Next bool `json:"next"`
+	}
+	err = json.Unmarshal(b, &t)
+	if err != nil {
+		return nil, err
+	}
+	listRecord, err := DecodeRecords(b)
+	if err != nil {
+		return nil, err
+	}
+	getRecordsCursorResponse := &GetRecordsCursorResponse{Records: listRecord, Next: t.Next}
+	return getRecordsCursorResponse, nil
+}

cursor_test.go

@@ -0,0 +1,16 @@
+package kintone
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestDecodeCursor(t *testing.T) {
+	data := []byte(`{"id":"aaaaaaaaaaaaaaaaaa","totalCount":"null"}`)
+	cursor, err := decodeCursor(data)
+	if err != nil {
+		t.Errorf("TestDecodeCursor is failed: %v", err)
+
+	}
+	fmt.Println(cursor)
+}

record.go

@@ -324,6 +324,7 @@ func DecodeRecords(b []byte) ([]*Record, error) {
 	if err != nil {
 		return nil, errors.New("Invalid JSON format")
 	}
+
 	rec_list := make([]*Record, len(t.Records))
 	for i, rd := range t.Records {
 		r, err := decodeRecordData(rd)