Update API spec.

Modify generator script to use the Stone cli directly.

Author: Diwaker Gupta

dropbox/auth/types.go

@@ -35,3 +35,32 @@ const (
 	AuthErrorInvalidSelectAdmin = "invalid_select_admin"
 	AuthErrorOther              = "other"
 )
+
+// RateLimitError : Error occurred because the app is being rate limited.
+type RateLimitError struct {
+	// Reason : The reason why the app is being rate limited.
+	Reason *RateLimitReason `json:"reason"`
+	// RetryAfter : The number of seconds that the app should wait before making
+	// another request.
+	RetryAfter uint64 `json:"retry_after"`
+}
+
+// NewRateLimitError returns a new RateLimitError instance
+func NewRateLimitError(Reason *RateLimitReason) *RateLimitError {
+	s := new(RateLimitError)
+	s.Reason = Reason
+	s.RetryAfter = 1
+	return s
+}
+
+// RateLimitReason : has no documentation (yet)
+type RateLimitReason struct {
+	dropbox.Tagged
+}
+
+// Valid tag values for RateLimitReason
+const (
+	RateLimitReasonTooManyRequests        = "too_many_requests"
+	RateLimitReasonTooManyWriteOperations = "too_many_write_operations"
+	RateLimitReasonOther                  = "other"
+)

dropbox/files/client.go

@@ -161,6 +161,24 @@ type Client interface {
 	// to the given file path. A single request should not upload more than 150
 	// MB of file contents.
 	UploadSessionFinish(arg *UploadSessionFinishArg, content io.Reader) (res *FileMetadata, err error)
+	// UploadSessionFinishBatch : This route helps you commit many files at once
+	// into a user's Dropbox. Use `uploadSessionStart` and
+	// `uploadSessionAppendV2` to upload file contents. We recommend uploading
+	// many files in parallel to increase throughput. Once the file contents
+	// have been uploaded, rather than calling `uploadSessionFinish`, use this
+	// route to finish all your upload sessions in a single request.
+	// `UploadSessionStartArg.close` or `UploadSessionAppendArg.close` needs to
+	// be true for last `uploadSessionStart` or `uploadSessionAppendV2` call.
+	// This route will return job_id immediately and do the async commit job in
+	// background. We have another route `uploadSessionFinishBatchCheck` to
+	// check the job status. For the same account, this route should be executed
+	// serially. That means you should not start next job before current job
+	// finishes. Also we only allow up to 1000 entries in a single request
+	UploadSessionFinishBatch(arg *UploadSessionFinishBatchArg) (res *async.LaunchEmptyResult, err error)
+	// UploadSessionFinishBatchCheck : Returns the status of an asynchronous job
+	// for `uploadSessionFinishBatch`. If success, it returns list of result for
+	// each entry
+	UploadSessionFinishBatchCheck(arg *async.PollArg) (res *UploadSessionFinishBatchJobStatus, err error)
 	// UploadSessionStart : Upload sessions allow you to upload a single file
 	// using multiple requests. This call starts a new upload session with the
 	// given data.  You can then use `uploadSessionAppendV2` to add more data
@@ -2714,6 +2732,160 @@ func (dbx *apiImpl) UploadSessionFinish(arg *UploadSessionFinishArg, content io.
 	return
 }
 
+//UploadSessionFinishBatchAPIError is an error-wrapper for the upload_session/finish_batch route
+type UploadSessionFinishBatchAPIError struct {
+	dropbox.APIError
+	EndpointError struct{} `json:"error"`
+}
+
+func (dbx *apiImpl) UploadSessionFinishBatch(arg *UploadSessionFinishBatchArg) (res *async.LaunchEmptyResult, err error) {
+	cli := dbx.Client
+
+	if dbx.Config.Verbose {
+		log.Printf("arg: %v", arg)
+	}
+	b, err := json.Marshal(arg)
+	if err != nil {
+		return
+	}
+
+	req, err := http.NewRequest("POST", (*dropbox.Context)(dbx).GenerateURL("api", "files", "upload_session/finish_batch"), bytes.NewReader(b))
+	if err != nil {
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if dbx.Config.AsMemberID != "" {
+		req.Header.Set("Dropbox-API-Select-User", dbx.Config.AsMemberID)
+	}
+	if dbx.Config.Verbose {
+		log.Printf("req: %v", req)
+	}
+	resp, err := cli.Do(req)
+	if dbx.Config.Verbose {
+		log.Printf("resp: %v", resp)
+	}
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+
+	if dbx.Config.Verbose {
+		log.Printf("body: %s", body)
+	}
+	if resp.StatusCode != 200 {
+		if resp.StatusCode == 409 {
+			var apiError UploadSessionFinishBatchAPIError
+			err = json.Unmarshal(body, &apiError)
+			if err != nil {
+				return
+			}
+			err = apiError
+			return
+		}
+		var apiError dropbox.APIError
+		if resp.StatusCode == 400 {
+			apiError.ErrorSummary = string(body)
+			err = apiError
+			return
+		}
+		err = json.Unmarshal(body, &apiError)
+		if err != nil {
+			return
+		}
+		err = apiError
+		return
+	}
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+//UploadSessionFinishBatchCheckAPIError is an error-wrapper for the upload_session/finish_batch/check route
+type UploadSessionFinishBatchCheckAPIError struct {
+	dropbox.APIError
+	EndpointError *async.PollError `json:"error"`
+}
+
+func (dbx *apiImpl) UploadSessionFinishBatchCheck(arg *async.PollArg) (res *UploadSessionFinishBatchJobStatus, err error) {
+	cli := dbx.Client
+
+	if dbx.Config.Verbose {
+		log.Printf("arg: %v", arg)
+	}
+	b, err := json.Marshal(arg)
+	if err != nil {
+		return
+	}
+
+	req, err := http.NewRequest("POST", (*dropbox.Context)(dbx).GenerateURL("api", "files", "upload_session/finish_batch/check"), bytes.NewReader(b))
+	if err != nil {
+		return
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if dbx.Config.AsMemberID != "" {
+		req.Header.Set("Dropbox-API-Select-User", dbx.Config.AsMemberID)
+	}
+	if dbx.Config.Verbose {
+		log.Printf("req: %v", req)
+	}
+	resp, err := cli.Do(req)
+	if dbx.Config.Verbose {
+		log.Printf("resp: %v", resp)
+	}
+	if err != nil {
+		return
+	}
+
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+
+	if dbx.Config.Verbose {
+		log.Printf("body: %s", body)
+	}
+	if resp.StatusCode != 200 {
+		if resp.StatusCode == 409 {
+			var apiError UploadSessionFinishBatchCheckAPIError
+			err = json.Unmarshal(body, &apiError)
+			if err != nil {
+				return
+			}
+			err = apiError
+			return
+		}
+		var apiError dropbox.APIError
+		if resp.StatusCode == 400 {
+			apiError.ErrorSummary = string(body)
+			err = apiError
+			return
+		}
+		err = json.Unmarshal(body, &apiError)
+		if err != nil {
+			return
+		}
+		err = apiError
+		return
+	}
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
 //UploadSessionStartAPIError is an error-wrapper for the upload_session/start route
 type UploadSessionStartAPIError struct {
 	dropbox.APIError

dropbox/files/types.go

@@ -2079,6 +2079,110 @@ func NewUploadSessionFinishArg(Cursor *UploadSessionCursor, Commit *CommitInfo)
 	return s
 }
 
+// UploadSessionFinishBatchArg : has no documentation (yet)
+type UploadSessionFinishBatchArg struct {
+	// Entries : Commit information for each file in the batch.
+	Entries []*UploadSessionFinishArg `json:"entries"`
+}
+
+// NewUploadSessionFinishBatchArg returns a new UploadSessionFinishBatchArg instance
+func NewUploadSessionFinishBatchArg(Entries []*UploadSessionFinishArg) *UploadSessionFinishBatchArg {
+	s := new(UploadSessionFinishBatchArg)
+	s.Entries = Entries
+	return s
+}
+
+// UploadSessionFinishBatchJobStatus : has no documentation (yet)
+type UploadSessionFinishBatchJobStatus struct {
+	dropbox.Tagged
+	// Complete : The `uploadSessionFinishBatch` has finished.
+	Complete *UploadSessionFinishBatchResult `json:"complete,omitempty"`
+}
+
+// Valid tag values for UploadSessionFinishBatchJobStatus
+const (
+	UploadSessionFinishBatchJobStatusComplete = "complete"
+)
+
+// UnmarshalJSON deserializes into a UploadSessionFinishBatchJobStatus instance
+func (u *UploadSessionFinishBatchJobStatus) UnmarshalJSON(body []byte) error {
+	type wrap struct {
+		dropbox.Tagged
+		// Complete : The `uploadSessionFinishBatch` has finished.
+		Complete json.RawMessage `json:"complete,omitempty"`
+	}
+	var w wrap
+	if err := json.Unmarshal(body, &w); err != nil {
+		return err
+	}
+	u.Tag = w.Tag
+	switch u.Tag {
+	case "complete":
+		if err := json.Unmarshal(body, &u.Complete); err != nil {
+			return err
+		}
+
+	}
+	return nil
+}
+
+// UploadSessionFinishBatchResult : has no documentation (yet)
+type UploadSessionFinishBatchResult struct {
+	// Entries : Commit result for each file in the batch.
+	Entries []*UploadSessionFinishBatchResultEntry `json:"entries"`
+}
+
+// NewUploadSessionFinishBatchResult returns a new UploadSessionFinishBatchResult instance
+func NewUploadSessionFinishBatchResult(Entries []*UploadSessionFinishBatchResultEntry) *UploadSessionFinishBatchResult {
+	s := new(UploadSessionFinishBatchResult)
+	s.Entries = Entries
+	return s
+}
+
+// UploadSessionFinishBatchResultEntry : has no documentation (yet)
+type UploadSessionFinishBatchResultEntry struct {
+	dropbox.Tagged
+	// Success : has no documentation (yet)
+	Success *FileMetadata `json:"success,omitempty"`
+	// Failure : has no documentation (yet)
+	Failure *UploadSessionFinishError `json:"failure,omitempty"`
+}
+
+// Valid tag values for UploadSessionFinishBatchResultEntry
+const (
+	UploadSessionFinishBatchResultEntrySuccess = "success"
+	UploadSessionFinishBatchResultEntryFailure = "failure"
+)
+
+// UnmarshalJSON deserializes into a UploadSessionFinishBatchResultEntry instance
+func (u *UploadSessionFinishBatchResultEntry) UnmarshalJSON(body []byte) error {
+	type wrap struct {
+		dropbox.Tagged
+		// Success : has no documentation (yet)
+		Success json.RawMessage `json:"success,omitempty"`
+		// Failure : has no documentation (yet)
+		Failure json.RawMessage `json:"failure,omitempty"`
+	}
+	var w wrap
+	if err := json.Unmarshal(body, &w); err != nil {
+		return err
+	}
+	u.Tag = w.Tag
+	switch u.Tag {
+	case "success":
+		if err := json.Unmarshal(body, &u.Success); err != nil {
+			return err
+		}
+
+	case "failure":
+		if err := json.Unmarshal(w.Failure, &u.Failure); err != nil {
+			return err
+		}
+
+	}
+	return nil
+}
+
 // UploadSessionFinishError : has no documentation (yet)
 type UploadSessionFinishError struct {
 	dropbox.Tagged