diff --git a/LICENSE b/LICENSE old mode 100644 new mode 100755 diff --git a/README.md b/README.md old mode 100644 new mode 100755 index 0f27829..ad2f9da --- a/README.md +++ b/README.md @@ -11,55 +11,61 @@ Installation go get github.com/rapito/go-shopify ``` -How-to-use +Dependencies +------------ +``` +go get github.com/parnurzeal/gorequest +``` + +Test dependencies +------------ +``` +go get github.com/bitly/go-simplejson +go get github.com/bmizerany/assert +``` + +Use it ---------- -- Get Requests +- GET Requests -``` - import "fmt" - import "github.com/rapito/go-shopify/shopify" - ... - - shop := shopify.New(storeDomain,apiKey,pass) - result, _ := shop.Get("products") - - fmt.Println(string(result)) +```go +import "fmt" +import "github.com/rapito/go-shopify/shopify" + +shop := shopify.New(storeDomain,apiKey,pass) +result, _ := shop.Get("products") + +fmt.Println(string(result)) ``` - Check out the *examples* folder for simple usage. - Read some of the tests at *shopify_test.go* for complete CRUD examples. +- There are some built-in wrappers than you can use, you are welcome to add new ones: + - `GetOrders()` + - `GetOrder(orderID)` + - `GetOrderTransactions(orderID)` + - `GetOrderTransactionsCount(orderID)` + - `GetOrdersCount()` + - `GetProducts()` + - `GetProduct(productID)` + - `GetProductImages(productID)` + - `GetProductVariants(productID)` + Contribution ------------ - + - You may fork this library and modify it as you please. - You can make a pull request and I will be happy to check it out and merge it. - - If you find a bug, create an issue and I will do my best to fix it (someday). + - If you find a bug, create an issue and I will do my best to fix it (someday). Original Work ------------- -While I was looking for something cool to do with this new language im learning -(Go, obviously), I ran into [hammond-bones'](https://github.com/hammond-bones/) **go-shopify** -library. Which inspired me to start creating this one. +While I was looking for something cool to do with this new language im learning +(Go, obviously), I ran into [hammond-bones'](https://github.com/hammond-bones/) **go-shopify** +library. Which inspired me to start creating this one. - Fork it at: [go-shopify](https://github.com/hammond-bones/go-shopify) - -Links ------ - -While I was on my *go-trip* to create this api, I found some awesome libs which made -my life easier. -Check them out, hopefully they'll do the same for you: - - - http://github.com/parnurzeal/gorequest - - http://github.com/bmizerany/assert - - http://github.com/avelino/awesome-go - - Other APIs - ---------- - - - http://github.com/rapito/go-spotify - diff --git a/shopify/discountCode.go b/shopify/discountCode.go new file mode 100755 index 0000000..5be2220 --- /dev/null +++ b/shopify/discountCode.go @@ -0,0 +1,17 @@ +package shopify + +import ( + "fmt" +) + +//CreateDiscountCode creates a discount code +func (shop *Shopify) CreateDiscountCode(priceRule string, discountCode DiscountCode) (*DiscountCode, []error) { + var discountCodeResponse DiscountCodeResponse + response, errors := shop.Post(fmt.Sprintf("price_rules/%v/discount_codes", priceRule), map[string]interface{}{ + "discount_code": discountCode, + }) + if err := unmarshal(response, errors, &discountCodeResponse); len(err) > 0 { + return nil, err + } + return &discountCodeResponse.DiscountCode, nil +} diff --git a/shopify/model.go b/shopify/model.go new file mode 100755 index 0000000..700a9cb --- /dev/null +++ b/shopify/model.go @@ -0,0 +1,315 @@ +package shopify + +import "time" + +//ApplicationCharge is an application charge +type ApplicationCharge struct { + ConfirmationURL string `json:"confirmation_url"` + CreatedAt time.Time `json:"created_at"` + ID int64 `json:"id"` + Name string `json:"name"` + Price string `json:"price"` + ReturnURL string `json:"return_url"` + Status string `json:"status"` + Test string `json:"test"` + UpdatedAt time.Time `json:"updated_at"` +} + +//BillingAddress is a billing address +type BillingAddress struct { + Address1 string `json:"address1"` + Address2 string `json:"address2"` + City string `json:"city"` + Company string `json:"company"` + Country string `json:"country"` + FirstName string `json:"first_name"` + ID int64 `json:"id"` + LastName string `json:"last_name"` + Phone string `json:"phone"` + Province string `json:"province"` + Zip string `json:"zip"` + Name string `json:"name"` + ProvinceCode string `json:"province_code"` + CountryCode string `json:"country_code"` + Default bool `json:"default"` +} + +//ClientDetails are details about a client +type ClientDetails struct { + AcceptLanguage *string `json:"accept_language"` //TODO check + BrowserHeight int `json:"browser_height"` + BrowserIP string `json:"browser_ip"` + BrowserWidth int `json:"browser_width"` + SessionHash *string `json:"session_hash"` + UserAgent *string `json:"user_agent"` +} + +//Customer is a customer +type Customer struct { + AcceptsMarketing bool `json:"accepts_marketing"` + CreatedAt time.Time `json:"created_at"` + Email string `json:"email"` + ID int64 `json:"id"` + FirstName string `json:"first_name"` + Note string `json:"note"` + LastName string `json:"last_name"` + OrdersCount int `json:"orders_count"` + State string `json:"state"` + TotalSpent string `json:"total_spent"` + UpdatedAt time.Time + Tags string `json:"tags"` +} + +//Discount is a discount +type Discount struct { + ID int64 `json:"id"` + DiscountType string `json:"discount_type"` + Code string `json:"code"` + Value string `json:"value"` + EndsAt time.Time `json:"ends_at"` + StartsAt time.Time `json:"starts_at"` + Status string `json:"status"` + MinimumOrderAmount string `json:"minimum_order_amount"` + UsageLimit int `json:"usage_limit"` + AppliesToID int64 `json:"applies_to_id"` + AppliesOnce bool `json:"applies_once"` + AppliesToResource string `json:"applies_to_resource"` + TimesUsed int `json:"times_used"` +} + +//DiscountCode is a discount code +type DiscountCode struct { + ID int `json:"id"` + Amount string `json:"amount,omitempty"` + Code string `json:"code"` + Type string `json:"type,omitempty"` +} + +//Fulfillment is a fulfillment +type Fulfillment struct { + ID int64 `json:"id"` + CreatedAt time.Time `json:"created_at"` + OrderID int64 `json:"order_id"` + Status string `json:"status"` + TrackingCompany string `json:"tracking_company"` + TrackingNumber string `json:"tracking_number"` + UpdatedAt time.Time `json:"updated_at"` +} + +//LineItem is an order line item +type LineItem struct { + FulfillableQuantity int `json:"fulfillable_quantity"` + FulfillmentService *string `json:"fulfillment_service"` + FulfillmentStatus *string `json:"fulfillment_status"` + Grams int `json:"grams"` + ID int64 `json:"id"` + Price string `json:"price"` //e.g. 199.99 + ProductID int64 `json:"product_id"` + Quantity int `json:"id"` + RequiresShipping bool `json:"requires_shipping"` + SKU string `json:"sku"` + Title string `json:"title"` + VariantID int64 `json:"variant_id"` + VariantTitle string `json:"variant_title"` + Vendor string `json:"vendor"` + GiftCard *bool `json:"gift_card"` + Taxable bool `json:"taxable"` + TaxLines []TaxLine `json:"tax_line"` + TotalDiscount string `json:"total_discount"` +} + +//NoteAttribute is a note attribute +type NoteAttribute struct { + Name string `json:"name"` + Value string `json:"value"` +} + +//Order is a product +type Order struct { + BillingAddress *BillingAddress `json:"billing_address"` + BrowserIP string `json:"browser_ip"` + BuyerAcceptsMarketing bool `json:"buyer_accepts_marketing"` + CancelReason *string `json:"cancel_reason"` + CancelledAt *time.Time `json:"cancelled_at"` + ClientDetails *ClientDetails `json:"client_details"` + ClosedAt *time.Time `json:"closed_at"` + CreatedAt time.Time `json:"created_at"` + Currency string `json:"currency"` + Customer *Customer `json:"customer"` + DiscountCodes *[]DiscountCode `json:"discount_codes"` + Email string `json:"email"` + FinancialStatus string `json:"financial_status"` + Fulfillments *[]Fulfillment `json:"fulfillments"` + FulfillmentStatus string `json:"fulfillment_status"` + Tags string `json:"tags"` + ID int64 `json:"id"` + InventoryBehaviour string `json:"inventory_behaviour"` //used only in create + LandingSite string `json:"landing_site"` + LineItems []LineItem `json:"line_items"` + Name string `json:"name"` + Note *string `json:"note"` + NoteAttributes *[]NoteAttribute `json:"note_attributes"` + Number int64 `json:"number"` + OrderNumber int64 `json:"order_number"` + PaymentGatewayNames []string `json:"payment_gateway_names"` + ProcessedAt time.Time `json:"processed_at"` + ProcessingMethod string `json:"processing_method"` + ReferringSite string `json:"referring_site"` + Refunds *[]Refund `json:"refunds"` + SendReceipt bool `json:"send_receipt"` //used only in create + SendFulfillmentReceipt bool `json:"send_fulfillment_receipt"` //used only in create + ShippingAddress *ShippingAddress `json:"shipping_address"` + ShippingLines *[]ShippingLine `json:"shipping_lines"` + SourceName string `json:"source_name"` + SubtotalPrice string `json:"subtotal_price"` + TaxLines *[]TaxLine `json:"tax_lines"` + TaxesIncluded bool `json:"taxes_included"` + TotalDiscounts string `json:"total_discounts"` + TotalPrice string `json:"total_price"` + TotalTax string `json:"total_tax"` + TotalWeight float64 `json:"total_weight"` + UpdatedAt time.Time `json:"updatedAt"` +} + +//PaymentDetails are the details about a payment +type PaymentDetails struct { + AvsResultCode *string `json:"avs_result_code"` + CreditCardBin *string `json:"credit_card_bin"` + CvvResultCode *string `json:"cvv_result_code"` + CreditCardNumber string `json:"credit_card_number"` + CreditCardCompany string `json:"credit_card_company"` +} + +//Product is a product +type Product struct { + BodyHTML string `json:"body_html"` + CreatedAt time.Time `json:"created_at"` + Handle string `json:"handle"` + ID int64 `json:"id"` + Images []ProductImage `json:"images"` + Options []map[string]interface{} `json:"options"` + ProductType string `json:"product_type"` + PublishedAt *time.Time `json:"published_at"` + PublishedScope string `json:"published_scope"` + Tags string `json:"tags"` + TemplateSuffix string `json:"template_suffix"` + Title string `json:"title"` + MetafieldsGlobalTitleTag string `json:"metafields_global_title_tag"` + MetafieldsGlobalDescriptionTag string `json:"metafields_global_description_tag"` + UpdatedAt time.Time `json:"updatedAt"` + Variants []Variant `json:"variants"` + Vendor string `json:"vendor"` +} + +//ProductImage is a product's image +type ProductImage struct { + CreatedAt time.Time `json:"created_at"` + ID int64 `json:"id"` + Position int `json:"position"` + ProductID int64 `json:"product_id"` + VariantIDs []int64 `json:"variant_ids"` + Src string `json:"src"` + UpdatedAt time.Time `json:"id"` +} + +//Refund is a refund +type Refund struct { + CreatedAt time.Time `json:"created_at"` + ID int64 `json:"id"` + Note string `json:"note"` + RefundLineItems []RefundLineItem `json:"refund_line_items"` + Restock bool `json:"restock"` + //Transactions []Transaction `json:"transactions"` + UserID int64 `json:"user_id"` + OrderID int64 `json:"order_id"` +} + +//RefundLineItem is a refund line item +type RefundLineItem struct { + ID int64 `json:"id"` + LineItem LineItem `json:"line_item"` + LineItemID int64 `json:"line_item_id"` + Quantity int `json:"quantity"` +} + +//ShippingAddress is a billing address +type ShippingAddress struct { + Address1 string `json:"address1"` + Address2 string `json:"address2"` + City string `json:"city"` + Company string `json:"company"` + Country string `json:"country"` + FirstName string `json:"first_name"` + LastName string `json:"last_name"` + Latitude float64 `json:"latitude"` + Longitude float64 `json:"longitude"` + Phone string `json:"phone"` + Province string `json:"province"` + Zip string `json:"zip"` + Name string `json:"name"` + ProvinceCode string `json:"province_code"` + CountryCode string `json:"country_code"` +} + +//ShippingLine is a shipping line +type ShippingLine struct { + Code string `json:"code"` + Price string `json:"price"` + Source string `json:"source"` + Title string `json:"title"` + TaxLines []TaxLine `json:"tax_lines"` +} + +//TaxLine is a tax line +type TaxLine struct { + Title string `json:"title"` + Price float64 `json:"price"` + Rate float64 `json:"rate"` +} + +//Transaction is a transaction +type Transaction struct { + ID int64 `json:"id"` + OrderID int64 `json:"orderId"` + Amount string `json:"amount"` + Kind string `json:"kind"` + Authorization *string `json:"authorization"` + Message string `json:"message"` + CreatedAt time.Time `json:"created_at"` + DeviceID *string `json:"device_id"` + Gateway string `json:"gateway"` + SourceName string `json:"source_name"` + //PaymentDetails PaymentDetails `json:"payment_details"` + Receipt string `json:"receipt"` + ErrorCode string `json:"error_code"` + Status string `json:"status"` + Test bool `json:"test"` + UserID *int64 `json:"userId"` + Currency string `json:"currency"` +} + +//Variant is a product's variant +type Variant struct { + BarCode string `json:"bar_code"` + CompareAtPrice string `json:"compare_at_price"` + CreatedAt time.Time `json:"created_at"` + FulfillmentService string `json:"fulfillment_service"` + Grams float64 `json:"grams"` + Weight float64 `json:"weight"` + WeightUnit string `json:"weight_unit"` + ID int64 `json:"id"` + InventoryManagement string `json:"inventory_management"` + InventoryPolicy string `json:"inventory_policy"` + InventoryQuantity int `json:"inventory_quantity"` + Option1 string `json:"option1"` + Option2 string `json:"option2"` + Option3 string `json:"option3"` + Position int `json:"position"` + Price string `json:"price"` + ProductID int64 `json:"product_id"` + RequiresShipping bool `json:"requires_shipping"` + SKU string `json:"sku"` + Taxable bool `json:"taxable"` + Title string `json:"title"` + UpdatedAt time.Time `json:"updated_at"` +} diff --git a/shopify/order.go b/shopify/order.go new file mode 100755 index 0000000..e7dee9f --- /dev/null +++ b/shopify/order.go @@ -0,0 +1,116 @@ +package shopify + +import "fmt" + +var emptyBody = make(map[string]string) + +//GetOrders returns all the orders +func (shop *Shopify) GetOrders(parameters map[string]string) ([]Order, []error) { + var orders OrdersResponse + response, errors := shop.GetWithParameters("orders", parameters) + if err := unmarshal(response, errors, &orders); len(err) > 0 { + return nil, err + } + return orders.Orders, nil +} + +//GetOrder returns a order given its id +func (shop *Shopify) GetOrder(orderID int64) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Get(fmt.Sprintf("orders/%v", orderID)) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//CloseOrder closes an order +func (shop *Shopify) CloseOrder(orderID int64) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Post(fmt.Sprintf("orders/%v/close", orderID), emptyBody) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//OpenOrder re-opens an order +func (shop *Shopify) OpenOrder(orderID int64) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Post(fmt.Sprintf("orders/%v/order", orderID), emptyBody) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//CancelOrder cancel an order +func (shop *Shopify) CancelOrder(orderID int64) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Post(fmt.Sprintf("orders/%v/cancel", orderID), emptyBody) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//CreateOrder creates an order +func (shop *Shopify) CreateOrder(order map[string]interface{}) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Post("orders", order) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//EditOrder edits an existing +func (shop *Shopify) EditOrder(orderID int64, order map[string]interface{}) (*Order, []error) { + var orderResponse OrderResponse + order["id"] = orderID + response, errors := shop.Post(fmt.Sprintf("orders/%v", orderID), order) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//DeleteOrder cancel an order +func (shop *Shopify) DeleteOrder(orderID int64) (*Order, []error) { + var orderResponse OrderResponse + response, errors := shop.Delete(fmt.Sprintf("orders/%v", orderID)) + if err := unmarshal(response, errors, &orderResponse); len(err) > 0 { + return nil, err + } + return &orderResponse.Order, nil +} + +//GetOrderTransactions returns the order's transactions +func (shop *Shopify) GetOrderTransactions(orderID int64) ([]Transaction, []error) { + var transactionsResponse TransactionsResponse + response, errors := shop.Get(fmt.Sprintf("orders/%v/transactions", orderID)) + if err := unmarshal(response, errors, &transactionsResponse); len(err) > 0 { + return nil, err + } + return transactionsResponse.Transactions, nil +} + +//GetOrderTransactionsCount returns the order's transactions count +func (shop *Shopify) GetOrderTransactionsCount(orderID int64) (int, []error) { + var count CountResponse + response, errors := shop.Get(fmt.Sprintf("orders/%v/transactions/count", orderID)) + if err := unmarshal(response, errors, &count); len(err) > 0 { + return 0, err + } + return count.Count, nil +} + +//GetOrdersCount returns all the products +func (shop *Shopify) GetOrdersCount() (int, []error) { + var ordersCount CountResponse + response, errors := shop.Get("orders/count") + if err := unmarshal(response, errors, &ordersCount); len(err) > 0 { + return 0, err + } + return ordersCount.Count, nil +} diff --git a/shopify/product.go b/shopify/product.go new file mode 100755 index 0000000..f155a0e --- /dev/null +++ b/shopify/product.go @@ -0,0 +1,43 @@ +package shopify + +import "fmt" + +//GetProducts returns all the orders +func (shopify *Shopify) GetProducts() ([]Product, []error) { + var products ProductsResponse + response, errors := shopify.Get("products") + if err := unmarshal(response, errors, &products); len(err) > 0 { + return nil, err + } + return products.Products, nil +} + +//GetProduct returns all the orders +func (shopify *Shopify) GetProduct(productID int64) (*Product, []error) { + var product ProductResponse + response, errors := shopify.Get(fmt.Sprintf("products/%v", productID)) + if err := unmarshal(response, errors, &product); len(err) > 0 { + return nil, err + } + return &product.Product, nil +} + +//GetProductImages returns all the orders +func (shopify *Shopify) GetProductImages(productID int64) ([]ProductImage, []error) { + var images ImagesResponse + response, errors := shopify.Get(fmt.Sprintf("products/%v/images", productID)) + if err := unmarshal(response, errors, &images); len(err) > 0 { + return nil, err + } + return images.Images, nil +} + +//GetProductVariants returns all the product variants +func (shopify *Shopify) GetProductVariants(productID int64) ([]Variant, []error) { + var variants VariantsResponse + response, errors := shopify.Get(fmt.Sprintf("products/%v/variants", productID)) + if err := unmarshal(response, errors, &variants); len(err) > 0 { + return nil, err + } + return variants.Variants, nil +} diff --git a/shopify/refund.go b/shopify/refund.go new file mode 100755 index 0000000..a2b2784 --- /dev/null +++ b/shopify/refund.go @@ -0,0 +1,15 @@ +package shopify + +import "fmt" + +///admin/orders/#{id}/refunds.json + +//GetOrders returns all the orders +func (shopify *Shopify) GetOrderRefunds(orderID int64, parameters map[string]string) ([]Refund, []error) { + var refunds RefundsResponse + response, errors := shopify.Get(fmt.Sprintf("orders/%v/refunds", orderID)) + if err := unmarshal(response, errors, &refunds); len(err) > 0 { + return nil, err + } + return refunds.Refunds, nil +} diff --git a/shopify/responses.go b/shopify/responses.go new file mode 100755 index 0000000..4b553b2 --- /dev/null +++ b/shopify/responses.go @@ -0,0 +1,50 @@ +package shopify + +//DiscountCodeResponse is a response to /discount_codes endpoint +type DiscountCodeResponse struct { + DiscountCode DiscountCode `json:"discount_code"` +} + +//OrdersResponse is a response to /orders endpoint +type OrdersResponse struct { + Orders []Order `json:"orders"` +} + +//OrderResponse is a response to /orders endpoint +type OrderResponse struct { + Order Order `json:"order"` +} + +//TransactionsResponse is a response to /orders/{id}/transactions +type TransactionsResponse struct { + Transactions []Transaction `json:"transactions"` +} + +type RefundsResponse struct { + Refunds []Refund `json:"refunds"` +} + +//CountResponse is a response to counts endpoint +type CountResponse struct { + Count int `json:"count"` +} + +//ProductsResponse is a response from products +type ProductsResponse struct { + Products []Product `json:"products"` +} + +//ProductResponse is a response for a product +type ProductResponse struct { + Product Product `json:"product"` +} + +//ImagesResponse is a response for product images +type ImagesResponse struct { + Images []ProductImage `json:"images"` +} + +//VariantsResponse is a response for product images +type VariantsResponse struct { + Variants []Variant `json:"variants"` +} diff --git a/shopify/shopify.go b/shopify/shopify.go index 4dc49dc..a40a656 100755 --- a/shopify/shopify.go +++ b/shopify/shopify.go @@ -1,74 +1,40 @@ -// Package shopify: -// go-shopify provides an easy-to-use API -// for making CRUD request to shopify. +// Package shopify provides an easy-to-use API for making CRUD request to shopify. package shopify import ( "fmt" - "encoding/json" + "github.com/parnurzeal/gorequest" ) -// Shopify store struct which we use -// to wrap our request operations. +// Shopify store struct which we use to wrap our request operations. type Shopify struct { // Store domain-name - store string + store string // Store API key - apiKey string + apiKey string // Store password - pass string + pass string } const ( domain = ".myshopify.com/admin" ) -// Creates a New Shopify Store API object with the -// store, apiKey and pass of your store. -// Usage: -// shopify.New("mystore", "XXX","YYY") +// New Creates a New Shopify Store API object with the store, apiKey and pass of your store. +// Usage: shopify.New("mystore", "XXX","YYY") func New(store, apiKey, pass string) Shopify { - - shop := Shopify{store: store, apiKey: apiKey, pass: pass} - // fmt.Println("[New] Creating Shopify client with: ", store, apiKey, pass) - - return shop -} - -// Creates target URL for making a Shopify Request -// to a given endpoint -func (shopify *Shopify) createTargetURL(endpoint string) string { - result := fmt.Sprintf("https://%s:%s@%s%s/%s.json", shopify.apiKey, shopify.pass, shopify.store, domain, endpoint) - return result -} - -// Extracts Json Bytes from map[string]interface -func getJsonBytesFromMap(data map[string]interface{}) ([]byte, error) { - jsonData, err := json.Marshal(data) - if err != nil { - fmt.Println("Invalid data object, can't parse to json:") - fmt.Println("Error:", err) - fmt.Println("Data:", data) - return nil, err - } - return jsonData, nil + return Shopify{store: store, apiKey: apiKey, pass: pass} } -// Creates a new Request to Shopify and returns -// the response as a map[string]interface{}. +// Request Creates a new Request to Shopify and returns the response as a map[string]interface{}. // method: GET/POST/PUT - string // url: target endpoint like "products" - string // data: content to be sent with the request // Usage: shopify.request("GET","products",nil) -func (shopify *Shopify) Request(method, endpoint string, data map[string]interface{}) ([]byte, []error) { - // fmt.Println("[request] Arguments: ", method, endpoint, data) - - jsonData, _ := getJsonBytesFromMap(data) - // fmt.Println("[request] data: ", string(jsonData)) - +func (shopify *Shopify) Request(method, endpoint string, data interface{}) ([]byte, []error) { + jsonData, _ := getJSONBytesFromMap(data) targetURL := shopify.createTargetURL(endpoint) - // fmt.Println("[request] targetUrl: ", targetURL) request := gorequest.New() request.Get(targetURL) @@ -79,39 +45,37 @@ func (shopify *Shopify) Request(method, endpoint string, data map[string]interfa _, body, errs := request.End() - return []byte(body), errs } -// Makes a GET request to shopify with the -// given endpoint. +// Get Makes a GET request to shopify with the given endpoint. // Usage: // shopify.Get("products/5.json") // shopify.Get("products/5/variants.json") func (shopify *Shopify) Get(endpoint string) ([]byte, []error) { + return shopify.GetWithParameters(endpoint, nil) +} - targetUrl := shopify.createTargetURL(endpoint) - +// GetWithParameters Makes a GET request to shopify with the given endpoint and given parameters +func (shopify *Shopify) GetWithParameters(endpoint string, parameters map[string]string) ([]byte, []error) { + targetURL := shopify.createTargetURLWithParameters(endpoint, parameters) request := gorequest.New() - _, body, errs := request.Get(targetUrl).End() + _, body, errs := request.Get(targetURL).End() return []byte(body), errs } -// Makes a POST request to shopify with the -// given endpoint and data. -// Usage: -// shopify.Post("products", map[string]interface{} = product data map) -func (shopify *Shopify) Post(endpoint string, data map[string]interface{}) ([]byte, []error) { - - targetUrl := shopify.createTargetURL(endpoint) - jsonData, err := getJsonBytesFromMap(data) +// Post Makes a POST request to shopify with the given endpoint and data. +// Usage: shopify.Post("products", map[string]interface{} = product data map) +func (shopify *Shopify) Post(endpoint string, data interface{}) ([]byte, []error) { + targetURL := shopify.createTargetURL(endpoint) + jsonData, err := getJSONBytesFromMap(data) if err != nil { return nil, []error{err} } request := gorequest.New() - request.Post(targetUrl) + request.Post(targetURL) if jsonData != nil && data != nil { request.Send(string(jsonData)) } @@ -120,20 +84,17 @@ func (shopify *Shopify) Post(endpoint string, data map[string]interface{}) ([]by return []byte(body), errs } -// Makes a PUT request to shopify with the -// given endpoint and data. -// Usage: -// shopify.Put("products", map[string]interface{} = product data map) -func (shopify *Shopify) Put(endpoint string, data map[string]interface{}) ([]byte, []error) { - - targetUrl := shopify.createTargetURL(endpoint) - jsonData, err := getJsonBytesFromMap(data) +// Put Makes a PUT request to shopify with the given endpoint and data. +// Usage: shopify.Put("products", map[string]interface{} = product data map) +func (shopify *Shopify) Put(endpoint string, data interface{}) ([]byte, []error) { + targetURL := shopify.createTargetURL(endpoint) + jsonData, err := getJSONBytesFromMap(data) if err != nil { return nil, []error{err} } request := gorequest.New() - request.Put(targetUrl) + request.Put(targetURL) if jsonData != nil && data != nil { request.Send(string(jsonData)) } @@ -142,16 +103,30 @@ func (shopify *Shopify) Put(endpoint string, data map[string]interface{}) ([]byt return []byte(body), errs } -// Makes a DELETE request to shopify with the -// given endpoint. -// Usage: -// shopify.Delete("products/5.json") +// Delete Makes a DELETE request to shopify with the given endpoint. +// Usage: shopify.Delete("products/5.json") func (shopify *Shopify) Delete(endpoint string) ([]byte, []error) { - - targetUrl := shopify.createTargetURL(endpoint) + targetURL := shopify.createTargetURL(endpoint) request := gorequest.New() - _, body, errs := request.Delete(targetUrl).End() + _, body, errs := request.Delete(targetURL).End() return []byte(body), errs } + +// Creates target URL for making a Shopify Request to a given endpoint +func (shopify *Shopify) createTargetURL(endpoint string) string { + return shopify.createTargetURLWithParameters(endpoint, nil) +} + +// Creates target URL for making a Shopify Request to a given endpoint with the given parameters +func (shopify *Shopify) createTargetURLWithParameters(endpoint string, parameters map[string]string) string { + var parametersString = "" + if parameters != nil && len(parameters) > 0 { + parametersString = "?" + for k := range parameters { + parametersString = fmt.Sprintf("%v%v=%v&", parametersString, k, parameters[k]) + } + } + return fmt.Sprintf("https://%s:%s@%s%s/%s.json%s", shopify.apiKey, shopify.pass, shopify.store, domain, endpoint, parametersString) +} diff --git a/shopify/shopify_test.go b/shopify/shopify_test.go index 0f87cd0..78fcd69 100755 --- a/shopify/shopify_test.go +++ b/shopify/shopify_test.go @@ -2,30 +2,31 @@ package shopify // Import Testing frameworks needed import ( - "testing" + "encoding/json" "fmt" - "github.com/bmizerany/assert" + "os" + "testing" + simplejson "github.com/bitly/go-simplejson" - "encoding/json" + "github.com/bmizerany/assert" ) // Create out store variables for easy access -const ( - store = "your-store-domain-name-here" - apiKey = "your-api-key-here" - pass = "your-secret-pass-here" +var ( + store = os.Getenv("SHOPIFY_STORE_TEST") + apiKey = os.Getenv("SHOPIFY_API_KEY_TEST") + pass = os.Getenv("SHOPIFY_PASSWORD_TEST") ) // We declare out shop here just to reuse // it later on. var shop = New(store, apiKey, pass) -var objIdToDelete int64 +var objIDToDelete int64 // Should create a new Store. func TestNew(t *testing.T) { - if shop.store != store || shop.apiKey != apiKey || shop.pass != pass { - t.Errorf("Error creating client, was suppposed to have store:$v apiKey:$v pass:$v", store, apiKey, pass) + t.Errorf("Error creating client, was suppposed to have store:%v apiKey:%v pass:%v", store, apiKey, pass) } } @@ -48,28 +49,22 @@ func TestGet(t *testing.T) { fmt.Println(js) fmt.Println(err) - assert.T(t, errors == nil) assert.T(t, products != nil) - // product := products["products"].([]interface{}) // fmt.Println(product[0]["vendor"]) // fmt.Println(products) - - } // Should make a new Post Request func TestPost(t *testing.T) { - str := ` {"product": {"title": "MyProduct","body_html": "Good snowboard!","vendor": "Burton","product_type": "Snowboard","variants": [ { "option1": "First", "price": "10.00", "sku": 123 }, { "option1": "Second", "price": "20.00", "sku": "123" }]}} ` var data map[string]interface{} json.Unmarshal([]byte(str), &data) result, errors := shop.Post("products", data) - js, err := simplejson.NewJson(result) fmt.Println(js) @@ -83,7 +78,7 @@ func TestPost(t *testing.T) { assert.T(t, title == "MyProduct") id, _ := js.Get("product").Get("id").Int64() - objIdToDelete = id + objIDToDelete = id } // Should make a new Put Request @@ -93,7 +88,7 @@ func TestPut(t *testing.T) { var data map[string]interface{} json.Unmarshal([]byte(str), &data) - endpoint := fmt.Sprintf("products/%v", objIdToDelete) + endpoint := fmt.Sprintf("products/%v", objIDToDelete) result, errors := shop.Put(endpoint, data) js, err := simplejson.NewJson(result) @@ -111,8 +106,7 @@ func TestPut(t *testing.T) { // Should make a new Delete Request func TestDelete(t *testing.T) { - - endpoint := fmt.Sprintf("products/%v", objIdToDelete) + endpoint := fmt.Sprintf("products/%v", objIDToDelete) result, error := shop.Delete(endpoint) assert.T(t, error == nil, "should be null") @@ -126,6 +120,3 @@ func TestCreateTargetURL(t *testing.T) { test := fmt.Sprintf("https://%s:%s@%s%s/%s.json", apiKey, pass, store, domain, endpoint) assert.Equal(t, result, test) } - - - diff --git a/shopify/utils.go b/shopify/utils.go new file mode 100755 index 0000000..aa34c88 --- /dev/null +++ b/shopify/utils.go @@ -0,0 +1,22 @@ +package shopify + +import "encoding/json" + +// getJSONBytesFromMap Extracts Json Bytes from map[string]interface +func getJSONBytesFromMap(data interface{}) ([]byte, error) { + jsonData, err := json.Marshal(data) + if err != nil { + return nil, err + } + return jsonData, nil +} + +func unmarshal(responseData []byte, responseErrors []error, output interface{}) []error { + if len(responseErrors) > 0 { + return responseErrors + } + if err := json.Unmarshal(responseData, output); err != nil { + return []error{err} + } + return nil +}