schmorrison
commented
3 years ago Here is my view of things:
package zoho
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"mime/multipart"
"net/http"
"net/url"
"os"
"path/filepath"
"reflect"
"github.com/schmorrison/go-querystring/query" // small change from 'github.com/google/go-querystring/query'
)
// Endpoint defines the data required to interact with most Zoho REST api endpoints
type Endpoint struct {
Method HTTPMethod
URL string
Name string
ResponseData interface{}
RequestBody interface{}
URLParameters map[string]Parameter
Headers map[string]string
BodyFormat BodyFormat
Attachment string
}
// Parameter is used to provide URL Parameters to zoho endpoints
type Parameter string
type BodyFormat string
const (
JSON = ""
JSON_STRING = "jsonString"
FILE = "file"
URL = "url" // Added new BodyFormat option
)
// HTTPRequest is the function which actually performs the request to a Zoho endpoint as specified by the provided endpoint
func (z *Zoho) HTTPRequest(endpoint *Endpoint) (err error) {
if reflect.TypeOf(endpoint.ResponseData).Kind() != reflect.Ptr {
return fmt.Errorf("Failed, you must pass a pointer in the ResponseData field of endpoint")
}
// Load and renew access token if expired
err = z.CheckForSavedTokens()
if err == ErrTokenExpired {
err := z.RefreshTokenRequest()
if err != nil {
return fmt.Errorf("Failed to refresh the access token: %s: %s", endpoint.Name, err)
}
}
// Retrieve URL parameters
endpointURL := endpoint.URL
q := url.Values{}
for k, v := range endpoint.URLParameters {
if v != "" {
q.Set(k, string(v))
}
}
var (
req *http.Request
reqBody io.Reader
contentType string
)
// Has a body, likely a CRUD operation (still possibly JSONString)
if endpoint.BodyFormat == JSON || endpoint.BodyFormat == JSON_STRING {
if endpoint.RequestBody != nil {
// JSON Marshal the body
marshalledBody, err := json.Marshal(endpoint.RequestBody)
if err != nil {
return fmt.Errorf("Failed to create json from request body")
}
reqBody = bytes.NewReader(marshalledBody)
contentType = "application/x-www-form-urlencoded; charset=UTF-8"
}
}
if endpoint.BodyFormat == JSON_STRING || endpoint.BodyFormat == FILE {
// Create a multipart form
var b bytes.Buffer
w := multipart.NewWriter(&b)
switch endpoint.BodyFormat {
case JSON_STRING:
// Use the form to create the proper field
fw, err := w.CreateFormField("JSONString")
if err != nil {
return err
}
// Copy the request body JSON into the field
if _, err = io.Copy(fw, reqBody); err != nil {
return err
}
// Close the multipart writer to set the terminating boundary
err = w.Close()
if err != nil {
return err
}
case FILE:
// Retreive the file contents
fileReader, err := os.Open(endpoint.Attachment)
if err != nil {
return err
}
defer fileReader.Close()
// Create the correct form field
part, err := w.CreateFormFile("attachment", filepath.Base(endpoint.Attachment))
if err != nil {
return err
}
// copy the file contents to the form
if _, err = io.Copy(part, fileReader); err != nil {
return err
}
err = w.Close()
if err != nil {
return err
}
}
reqBody = &b
contentType = w.FormDataContentType()
}
// New BodyFormat encoding option
if endpoint.BodyFormat == URL {
body, err := query.Values(endpoint.RequestBody) // send struct into the newly imported package
if err != nil {
return err
}
reqBody = strings.NewReader(body.Encode()) // write to body
contentType = "application/x-www-form-urlencoded; charset=UTF-8"
}
/// NOTHING CHANGED PAST THIS POINT
req, err = http.NewRequest(string(endpoint.Method), fmt.Sprintf("%s?%s", endpointURL, q.Encode()), reqBody)
if err != nil {
return fmt.Errorf("Failed to create a request for %s: %s", endpoint.Name, err)
}
req.Header.Set("Content-Type", contentType)
// Add global authorization header
req.Header.Add("Authorization", "Zoho-oauthtoken "+z.oauth.token.AccessToken)
// Add specific endpoint headers
for k, v := range endpoint.Headers {
req.Header.Add(k, v)
}
resp, err := z.client.Do(req)
if err != nil {
return fmt.Errorf("Failed to perform request for %s: %s", endpoint.Name, err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Errorf("Failed to read body of response for %s: got status %s: %s", endpoint.Name, resolveStatus(resp), err)
}
dataType := reflect.TypeOf(endpoint.ResponseData).Elem()
data := reflect.New(dataType).Interface()
err = json.Unmarshal(body, data)
if err != nil {
return fmt.Errorf("Failed to unmarshal data from response for %s: got status %s: %s", endpoint.Name, resolveStatus(resp), err)
}
endpoint.ResponseData = data
return nil
}
..............................................................................Please review this and let me know what you think. Test it out to make sure it works with your project and endpoints.
Thanks again for the PR!
ysahil97
Hi Sam
As discussed, I have written some API's for Zoho Bookings API which we currently want to use. The api's implemented here are related to appointments, staffs, resources, services and workspaces. Please let me know if there are any doubts or concerns in this pull request.