Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

refactor: change the bucket return error type #18

Closed
wants to merge 1 commit into from
Closed

refactor: change the bucket return error type #18

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
164 changes: 123 additions & 41 deletions bucket.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,53 +3,65 @@ package storage_go
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)

func (c *Client) ListBuckets() ([]Bucket, BucketResponseError) {
func (c *Client) ListBuckets() ([]Bucket, error) {
res, err := c.session.Get(c.clientTransport.baseUrl.String() + "/bucket")
if err != nil {
panic(err)
return []Bucket{}, err
}

defer func(Body io.ReadCloser) {
err := Body.Close()
if err != nil {
panic(err)
}
}(res.Body)
defer res.Body.Close()

body, err := io.ReadAll(res.Body)
if err != nil {
panic(err)
return []Bucket{}, err
}

var data []Bucket
err = json.Unmarshal(body, &data)
if err != nil {
return []Bucket{}, err
}

var respError BucketResponseError
err = json.Unmarshal(body, &respError)
_ = json.Unmarshal(body, &respError)
if respError.Errors != "" {
return []Bucket{}, respError
}

return data, respError
return data, nil
}

func (c *Client) GetBucket(id string) (Bucket, BucketResponseError) {
func (c *Client) GetBucket(id string) (Bucket, error) {
res, err := c.session.Get(c.clientTransport.baseUrl.String() + "/bucket/" + id)
if err != nil {
panic(err)
return Bucket{}, err
}

body, err := io.ReadAll(res.Body)
if err != nil {
return Bucket{}, err
}
var data Bucket
var error_ BucketResponseError
err = json.Unmarshal(body, &data)
err = json.Unmarshal(body, &error_)
if err != nil {
return Bucket{}, err
}

return data, error_
var respError BucketResponseError
_ = json.Unmarshal(body, &respError)
if respError.Errors != "" {
return Bucket{}, respError
}

return data, nil
}

func (c *Client) CreateBucket(id string, options BucketOptions) (Bucket, BucketResponseError) {
func (c *Client) CreateBucket(id string, options BucketOptions) (Bucket, error) {
bodyData := map[string]interface{}{
"id": id,
"name": id,
Expand All @@ -63,25 +75,40 @@ func (c *Client) CreateBucket(id string, options BucketOptions) (Bucket, BucketR
if len(options.AllowedMimeTypes) > 0 {
bodyData["allowed_mime_types"] = options.AllowedMimeTypes
}
jsonBody, _ := json.Marshal(bodyData)
jsonBody, err := json.Marshal(bodyData)
if err != nil {
return Bucket{}, err
}

res, err := c.session.Post(c.clientTransport.baseUrl.String()+"/bucket",
"application/json",
bytes.NewBuffer(jsonBody))
if err != nil {
panic(err)
return Bucket{}, err
}

body, err := io.ReadAll(res.Body)
if err != nil {
return Bucket{}, err
}

var data Bucket
var error_ BucketResponseError
var errResp BucketResponseError
err = json.Unmarshal(body, &data)
if err != nil {
return Bucket{}, err
}

data.Public = options.Public
err = json.Unmarshal(body, &error_)
_ = json.Unmarshal(body, &errResp)
if errResp.Errors != "" {
return Bucket{}, errResp
}

return data, error_
return data, nil
}

func (c *Client) UpdateBucket(id string, options BucketOptions) (MessageResponse, BucketResponseError) {
func (c *Client) UpdateBucket(id string, options BucketOptions) (MessageResponse, error) {
bodyData := map[string]interface{}{
"id": id,
"name": id,
Expand All @@ -95,65 +122,120 @@ func (c *Client) UpdateBucket(id string, options BucketOptions) (MessageResponse
if len(options.AllowedMimeTypes) > 0 {
bodyData["allowed_mime_types"] = options.AllowedMimeTypes
}
jsonBody, _ := json.Marshal(bodyData)
jsonBody, err := json.Marshal(bodyData)
if err != nil {
return MessageResponse{}, err
}
request, err := http.NewRequest(http.MethodPut, c.clientTransport.baseUrl.String()+"/bucket/"+id, bytes.NewBuffer(jsonBody))
if err != nil {
return MessageResponse{}, err
}

res, err := c.session.Do(request)
if err != nil {
panic(err)
return MessageResponse{}, err
}

body, err := io.ReadAll(res.Body)
if err != nil {
return MessageResponse{}, err
}

var data MessageResponse
var error_ BucketResponseError
var errResp BucketResponseError
err = json.Unmarshal(body, &data)
err = json.Unmarshal(body, &error_)
if err != nil {
return MessageResponse{}, err
}

_ = json.Unmarshal(body, &errResp)
if errResp.Errors != "" {
return MessageResponse{}, err
}

return data, error_
return data, nil
}

func (c *Client) EmptyBucket(id string) (MessageResponse, BucketResponseError) {
jsonBody, _ := json.Marshal(map[string]interface{}{})
func (c *Client) EmptyBucket(id string) (MessageResponse, error) {
jsonBody, err := json.Marshal(map[string]interface{}{})
if err != nil {
return MessageResponse{}, err
}

res, err := c.session.Post(c.clientTransport.baseUrl.String()+"/bucket/"+id+"/empty", "application/json", bytes.NewBuffer(jsonBody))
if err != nil {
panic(err)
return MessageResponse{}, err
}

body, err := io.ReadAll(res.Body)
if err != nil {
return MessageResponse{}, err
}

var data MessageResponse
var error_ BucketResponseError
var errResp BucketResponseError
err = json.Unmarshal(body, &data)
err = json.Unmarshal(body, &error_)
if err != nil {
return MessageResponse{}, err
}
_ = json.Unmarshal(body, &errResp)
if errResp.Errors != "" {
return data, errResp
}

return data, error_
return data, nil
}

func (c *Client) DeleteBucket(id string) (MessageResponse, BucketResponseError) {
jsonBody, _ := json.Marshal(map[string]interface{}{})
func (c *Client) DeleteBucket(id string) (MessageResponse, error) {
jsonBody, err := json.Marshal(map[string]interface{}{})
if err != nil {
return MessageResponse{}, err
}

request, err := http.NewRequest(http.MethodDelete, c.clientTransport.baseUrl.String()+"/bucket/"+id, bytes.NewBuffer(jsonBody))
if err != nil {
return MessageResponse{}, err
}

res, err := c.session.Do(request)
if err != nil {
panic(err)
return MessageResponse{}, err
}

body, err := io.ReadAll(res.Body)
if err != nil {
return MessageResponse{}, err
}

var data MessageResponse
var error_ BucketResponseError
var errResp BucketResponseError
err = json.Unmarshal(body, &data)
err = json.Unmarshal(body, &error_)
if err != nil {
return MessageResponse{}, err
}

return data, error_
_ = json.Unmarshal(body, &errResp)
if errResp.Errors != "" {
return data, errResp
}

return data, nil
}

type MessageResponse struct {
Message string `json:"message"`
}

type BucketResponseError struct {
Error string `json:"error"`
Errors string `json:"error"`
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I believe it is better to retain it as error because, given the multitude of errors, it should be an array of strings or structs.

Message string `json:"message"`
StatusCode uint16 `json:"statusCode"`
}

func (b BucketResponseError) Error() string {
return fmt.Sprintf("status %d: err %s: message %s", b.StatusCode, b.Errors, b.Message)
}

type Bucket struct {
Id string `json:"id"`
Name string `json:"name"`
Expand Down