Introduction
Welcome to the Proxy Cart for Proxy Engine Docs! Proxy Engine is an Open Source Node.js Framework created by the team at Cali Style Technologies.
What is Proxy Cart?
Proxy Cart is the eCommerce component for Proxy Engine. Connect your own Merchant Processor, Shipping Provider, Fulfillment Service, Tax Provider, and import your products. Attach it to Proxy Engine and you have an REST API based eCommerce solution!
Dependencies
Proxy Engine
Repo | Build Status (edge) |
---|---|
trailpack-proxy-engine |
Proxy Permissions
Repo | Build Status (edge) |
---|---|
trailpack-proxy-permissions |
Proxy Passport
Repo | Build Status (edge) |
---|---|
trailpack-proxy-passport |
Proxy Notifications
Repo | Build Status (edge) |
---|---|
trailpack-proxy-notifications |
Supported ORMs
Repo | Build Status (edge) |
---|---|
trailpack-proxy-sequelize |
Supported Webserver
Repo | Build Status (edge) |
---|---|
trailpack-express |
Installation
To install Proxy Generics:
$ npm install trailpack-proxy-generics
If you are using Trail's yo generator:
$ yo trails:trailpack trailpack-proxy-generics
Configuration
To configure Proxy Cart is simple, there are only 3 files to create/modify:
- config/main.js
- config/web.js
- config/proxyCart.js
config/main.js
config/main.js
module.exports = {
packs: [
// ... other trailpacks
require('trailpack-proxy-cart')
// ... other proxy-packs
]
}
Like all Trails' trailpacks, it must be included in the config/main.js
file.
config/web.js
config/web.js
module.exports = {
/**
* Middlewares to load (in order)
* Add the Proxy Cart middleware after the passport middleware
*/
middlewares: {
//middlewares loading order
order: [
// ... other middleware
'session',
'passportInit', // <-- Handles Passport
'passportSession', // <-- Handles Passport Session
'proxyCartInit', // <-- Handles Cart Middleware start
'proxyCartSession', // <-- Handles Session
'proxyCartSessionCart', // <-- Handles Cart Session
'proxyCartSessionCustomer', // <-- Handles Customer Session
// ... trailing middleware
]
}
}
This adds the correct middleware to express.
config/proxyCart.js
config/proxyCart.js
module.exports = {
// The default Shop address (Nexus)
nexus: {
name: '<name>',
host: '<host>',
email: '<email>',
address: {
address_1: '<address 1>',
address_2: '',
address_3: '',
company: '<company>',
city: '<city>',
province: '<full name of state/province>',
country: '<full name of country>',
postal_code: '<postal code>'
}
},
// Allow certain events
allow: {
// Allows a product to be destroyed, Recommended false
destroy_product: false,
// Allows a product variant to be destroyed, Recommended false
destroy_variant: false
},
// The default currency used
default_currency: 'USD',
// The countries to load by default
default_countries: ['USA'],
// Emails to send
emails: {
orderCreated: false,
orderUpdated: false,
orderPaid: false,
orderFulfilled: false,
orderRefunded: false,
orderCancelled: false,
sourceExpired: false,
sourceWillExpire: false,
sourceUpdated: false,
subscriptionCreated: false,
subscriptionUpdated: false,
subscriptionActivated: false,
subscriptionDeactivated: false,
subscriptionCancelled: false,
subscriptionWillRenew: false,
subscriptionRenewed: false,
transactionFailed: false
},
// Orders
orders: {
// Restock default for refunded order items
refund_restock: false,
// The default function for an automatic order payment: manual, immediate
payment_kind: 'immediate',
// the default function for transaction kind: authorize, sale
transaction_kind: 'authorize',
// The default function for an automatic order fulfillment: manual, immediate
fulfillment_kind: 'manual',
// The amount of times a Order will retry failed transactions
retry_attempts: 5,
// The amount of days before a Order will cancel from failed transactions
grace_period_days: 5
},
// Subscriptions
subscriptions: {
// The amount of times a Subscription will retry failed transactions
retry_attempts: 5,
// The amount of days before a Subscription will cancel from failed transactions
grace_period_days: 5
},
// Transactions
transactions: {
// The amount of times a Transaction will retry failed
retry_attempts: 5,
// The amount of days before a Transaction will cancel from failed
authorization_exp_days: 5
}
}
Also, Proxy Cart takes it's own config in the config/proxyCart.js
file.
Config Parameters
Parameter | Type | Default | Description |
---|
Definitions
Shops
A shop represents a physical location that sells a product. When taxes and shipping are calculated per product, they are calculated by the nearest shop to the destination of an order. This means that the same product can be sold in multiple stores and shipped from different locations which may effect shipping and tax rates. They also track on hand inventory and inventory lead time.
Products
A Product is a Physical or Digital item.
Product Variants
A Product Variant is a variation of a product denoted by a unique Stock Keeping Unit (SKU)
Product Association
A Product Association is a product that is associated to another product beyond the levels of a collection or tag.
Product Images
A Product Image is an image that is associated directly with a product and sometimes a product variant.
Product Reviews
A Product Review is input from a customer with a history of purchasing a product.
Metadata
A Metadata is additional information about a product, customer, or review that is not constrained by the parent model.
Collections
A Collection is a grouping of like items, such as products, customers, and shipping zones and can apply collection discounts, shipping overrides, and tax overrides.
Tags
A Tag is a searching marker for a customer, product, or order.
Customers
A Customer represents an account of one more users or guests.
Users
A User is a registered user account with an username/email and password with given permission roles. Multiple users can share a single Customer account.
Accounts
An Account is a 3rd party payment provider that the customer belongs to such as Stripe or Authorize.net, each customer can have multiple accounts
Sources
A Source is a payment method used by the customer at checkout that belongs to a customer and a 3rd party Account.
Carts
A Cart is a bucket that holds products and data until an order is placed.
Orders
An Order is a bucket that holds products and data and the transactions of purchases and fulfillment.
Fulfillment
A Fulfillment is a shipping transaction for an order.
Fulfillment Event
A Fulfillment Event is the progress of a Fulfillment.
Transactions
A Transaction is a representation of a purchasing event.
Refunds
A Refund represents a transaction that has been completely or partially refunded.
Gift Cards
A Gift Card is an alternate payment method that acts as a customer source.
Discounts
A Discount is a value or percent off of a product, shipping cost, or total order applied by meeting criteria.
Subscriptions
A Subscription is the reoccurring of an order based on time period.
Shipping Zones
A Shipping Zone is a geographical area that may override shipping and tax costs.
Shipping Restrictions
A Shipping Restriction is a geographical restriction on the shipping of certain products.
Vendors
Vendors are companies that distribute a product. In the case of drop shipping, the taxes and shipping are calculated from the vendor address to the customer.
Events
Proxy Cart publishes many subscribable events using Proxy Engine's pub/sub.
Published Events
Proxy Cart uses Proxy Engine's event publisher to publish events.
Customer Events
Events published and saved during customer actions.
customer.checkout
customer.updated
customer.account.created
customer.account.updated
customer.account_balance.updated
customer.source.created
customer.source.updated
customer.source.removed
customer.subscription.subscribed
customer.subscription.updated
customer.subscription.cancelled
customer.subscription.activated
customer.subscription.deactivated
customer.subscription.items_added
customer.subscription.items_removed
customer.subscription.renewed
Order Events
Order events published and saved during order operations.
order.created.*{pending|success|failure|error}
order.transaction.sale.*{pending|success|failure|error}
order.transaction.authorize.*{pending|success|failure|error}
order.transaction.capture.*{pending|success|failure|error}
order.transaction.void.*{pending|success|failure|error}
order.transaction.refund.*{pending|success|failure|error}
order.fulfillment.create.*{pending|success|failure|error}
API: Endpoints
API: Models
Proxy Cart creates many models and extends models from Proxy Engine and Proxy Permissions
Account
Address
Cart
City
Collection
CollectionUpload
Country
County
Coupon
Customer
CustomerAccount
CustomerCart
CustomerOrder
CustomerSource
CustomerUpload
CustomerUser
Discount
Fulfillment
FulfillmentEvent
GiftCard
ItemAddress
ItemCollection
Join table to handle collection children
ItemDiscount
Join table to handle discount children
ItemImage
ItemRefund
ItemShippingZone
ItemTag
Metadata
Order
OrderItem
OrderRisk
OrderSource
OrderUpload
Product
id: number;
The Id of the Product, can not be modified.
handle: string;
A 'ka-ba-ab' style string, can not be modified once set.
title: string;
The selling title of the of the product.
body: string;
The information or description of the product in either markdown, html, or both.
html: string;
The rendered version of the product body.
vendors: string[];
The name of each Vendor of the product.
type: string;
The lowest level description of a product.
tags: string[];
The name of each tag that the product is associated to.
collections: Collection[];
A list of Collections this product is in.
associations: Product[];
A list of products that this product is associated with.
metadata: Metadata.data
The metadata associated to the product, an object that contains data in JSON in the Metadata table.
weight: number;
The weight as a number.
weight_unit: string;
THe weight unit of the product expressed in either grams (g), kilograms (kg), ounces (oz), pounds (lb).
images: Image[];
A list of images associated with a product.
variants: ProductVariant[];
A list of product variants associated with a product.
seo_title: string;
A special title used for SEO purposes.
seo_description: string;
A special description used for SEO purposes.
tax_code: string;
The code that the product uses for tax purposes.
price: number;
The price of the product in whole numbers eg. ($1.00) = 100.
calculated_price: number;
The price of the product after discounts in whole numbers eg. ($1.00) = 100.
currency: string;
The currency the prices are in.
total_discounts: number;
The total amount of discounts applied to the product at the time it's displated in whole numbers eg. ($1.00) = 100.
discounted_lines: [{price: number, name: string, line: number}]
A list of discounts applied to the product.
published_scope: string;
A container for where the product is displayable.
published: boolean;
A boolean if the product is published.
published_at: string;
When the product was published.
unpublished_at: string;
When the product was unpublished.
options: string[]
The options generated by the product variants.
review_score: number;
The score of the product based on reviews.
total_reviews: number;
The total amount of reviews the product has.
total_variants: number;
The total amount of variants the product has.
The google shopping attributes
g_product_category: string;
g_gender: string;
g_age_group: string;
g_mpn: string;
g_adwords_grouping: string;
g_adwords_label: string;
g_condition: string;
g_custom_product: string;
g_custom_label_0: string;
g_custom_label_1: string;
g_custom_label_2: string;
g_custom_label_3: string;
g_custom_label_4: string;
amazon
The amazon shopping attributes
live_mode: boolean;
If the product was created in a live environment.
created_at: string;
When the product was created.
updated_at: string;
When the product was last updated.
ProductAssociation
ProductAssociationUpload
ProductImage
ProductMetaUpload
ProductReview
ProductVariant
id: number;
The Variant's ID
product_id: number;
The product ID this variant belongs to
sku: string;
The Stock Keeping Unit (sku) for this variant
title: string;
The Title of the variant
option: {: }
An Object of options that this variant is
barcode: string;
The Barcode associated to the variant
price: number;
The Price of the variant
compare_at_price: number;
A comparative price of the variant
currency: string;
The currency of the prices
fulfillment_service: string;
The service to be used to fulfill this variant
position: number;
The position of this variant in context to other variants
published: boolean;
If this variant is published
published_at: string;
When this variant was published
requires_shipping: boolean;
If this variant requires shipping
requires_tax: boolean;
If this variant requires taxes
requires_subscription: boolean;
If this variant requires a subscription
subscription_interval: string;
The interval of the required subscription
subscription_unit: string;
The interval unit of the required subscription
inventory_management: string;
The service that manages the inventory
inventory_policy: string;
The policy that effects wether this variant can be purchased
inventory_quantity: string;
The amount of inventory total of this variant
inventory_lead_time: string;
The amount of time to get more of this variant
tax_code: string;
The US tax code this variant belongs to
weight: number;
The weight of this variant
weight_unit: string;
The weight unit of this variant
images: Image[];
Images that belong to this variant
live_mode: boolean;
If this variant was created in a live environment
created_at: string;
When this variant was first created
updated_at: string;
When this variant was last updated.
Province
Refund
ShippingRestriction
ShippingZone
Shop
ShopProduct
Source
Subscription
SubscriptionUpload
Tag
Transaction
User
Vendor
VendorProduct
VendorUpload
API: Controllers
CustomerController
Handles Customer operations
CustomerController.create
Creates a Customer
POST
/customer
{}
Returns the created Customer
{}
CustomerController.update
Updates a Customer
POST
/customer/:id
Returns updated customer
{}
CustomerController.findOne
Find a Customer by id
GET
/customer/:id Returns customer
{}
CustomerController.session
Get the current customer in session
GET
/customer/session
Returns customer
{}
CustomerController.search
GET
/customer/search
Returns customers
[]
CustomerController.uploadCSV
Upload a Customer CSV
POST
/customer/uploadCSV
//
Returns details
{}
CustomerController.processUpload
Process Uploaded Customer CSV
POST
/customer/processUpload/:id
//
Returns details
{}
CustomerController.exportCustomers
Exports customers as a CSV
CartController
Handles Cart operations
CartController.create
Creates a new cart and can add items at the start. Some interesting features:
- Specify a
product_id
,variant_id
, orproduct_variant_id
which is an alias of 'variant_id' - Specify a quantity
- Specify properties, useful for custom specifics to an order
- Checks if the product inventory is available according to inventory policy
- Checks for geographic restrictions
- Checks for Product and Customer Discounts
- Checks and validates Coupons
POST
/cart
{
line_items: [
{
variant_id: 1,
properties: [
{ custom_engraving: 'Hello World' }
]
},
{
product_variant_id: 1
},
{
product_id: 1,
quantity: 2
}
]
}
Returns a Cart Object
CartController.checkout
From cart to checkout is easy and there are some special features to note: - You can supply multiple payment methods - You can override the the shipping and billing address - You can process payments immediately - You can send to fulfillment immediately
payment_kind
: the type of payment to be made, 'immediate', 'manual'
transaction_kind
: The type of transaction to create, 'authorize', 'capture', 'sale', or 'manual'
payment_details
: an array of payment information, requires a 'gateway' attribute and normally a 'token' or a 'source'
fulfillment_kind
: the type of fulfillment to perform, 'immediate', 'manual', null or blank
billing_address
: an address object or you can leave null if cart has a customer with address
shipping_address
: an address object or you can leave null if cart has a customer with address
shop_id
: an id, provide a shop ID if you want to require calculations be based on a shop location
POST
/cart/:id/checkout || /cart/checkout (If cart in session)
{
payment_kind: 'immediate',
transaction_kind: 'sale',
payment_details: [
{
gateway: 'payment_processor',
token: '123'
}
],
fulfillment_kind: 'immediate'
}
Returns the placed Order and a new Cart object, and if Customer was provided/created a Customer Object
{
order: {},
cart: {},
customer: {}
}
CartController.addItems
Add Items to an open cart. Some interesting things to note:
- You can add an existing item to a cart and it will increase the quantity
- Checks if the product inventory is available according to inventory policy
- Checks for geographic restrictions
- Checks for Product, Collections, and Customer Discounts
- Checks for Account Balance
- Checks and validates Coupons
POST
/cart/:id/addItems || /cart/addItems (if cart in session)
{
line_items: [
{
variant_id: 1,
properties: [
{ custom_engraving: 'Hello World' }
]
},
{
product_variant_id: 1
},
{
product_id: 1,
quantity: 2
}
]
}
Returns the cart with new values
{}
CartController.removeItems
Remove Items from an open cart. Some interesting things to note:
- If you specify just an id form, it will only reduce the quantity in the cart by 1.
- If you specify a quantity, it will reduce the quantity in the cart by that number
POST
/cart/:id/removeItems || /cart/removeItems (if cart in session)
{
line_items: [
{
variant_id: 1,
},
{
product_variant_id: 1
},
{
product_id: 1,
quantity: 2
}
]
}
Returns updated Cart
{}
CartController.clear
Removes all items from an open cart
POST
/cart/:id/clear || /cart/clear (if cart in session)
{}
Returns updated Cart
{}
CollectionController
Handles Collection operations
CollectionController.create
Creates a new Collection. Some interesting things to note:
- A collection has many products associated to it. In addition, it can have a discount that applies to the products which is reflected in their calculated price. This is different then the discount object (which effects an individual product). For the collection, you can have the discount be ignored for certain product types. Put those product type strings in the discount_product_exclude
array. But let’s say that the product types you want to discount is shorter then the product types you don’t want to discount, in which case, you would use the discount_product_include
. You would never want to use both. If the discount_product_exclude
's length is greater than 0, discount_product_include
will be ignored.
POST
<api>/collection
{
handle: "customer-discount-test",
title: "Customer Discount",
body: "# Customer Discount",
published: true,
sort_order: "price-desc",
discount_type: "fixed",
discount_scope: "global",
discount_rate: 100,
primary_purpose: "discount",
discount_product_exclude: [
"subscription"
],
collections: [
// Add an existing sub collection
"existing-collection-handle",
// Create a new collection
{
handle: 'new-collection-handle',
title: 'New Collection'
}
]
}
Returns created collection
{}
CollectionController.update
Updates a Collection
POST
<api>/collection/:id
{}
Returns updated collection
{}
CollectionController.add
Adds a Collection to a collection
POST
/collection/:id/add/:collection
{}
Returns updated collection
{}
CollectionController.remove
Remove a Collection from a collection
POST
/collection/:id/remove/:collection
{}
Returns updated collection
{}
CollectionController.addProduct
Add a product to a Collection
POST
/collection/:id/addProduct/:product
{}
Returns updated collection
{}
CollectionController.removeProduct
Removes a product from a Collection
POST
/collection/:id/removeProduct/:product
{}
Returns updated collection
{}
CollectionController.addCustomer
Add a customer to a Collection
POST
/collection/:id/addCustomer/:customer
{}
Returns updated collection
{}
CollectionController.removeCustomer
Removes a customer from a Collection
POST
/collection/:id/removeCustomer/:customer
{}
Returns updated collection
{}
CustomerController.uploadCSV
Uploads a Customer CSV using a template and makes it ready to process
POST
/customer/uploadCSV name: csv
Returns statistics of the upload
{}
CustomerController.processUpload
Processes Uploaded CSV
POST
/customer/processUpload/:uploadID
{}
Returns statistics of the processed upload
{}
FulfillmentController
Handles Fulfillment operations
ProductController
Handles Product operations
ProductController.findOne
Find a Product by id
GET
/product/:id Returns the product
{}
ProductController.findAll
Find a Products by query
GET
/products Returns paginated products with pagination
x-headers
[]
ProductController.findByTag
Find a Products by tag name with query
GET
/products/tag/:tag Returns paginated products with pagination
x-headers
[]
ProductController.findByCollection
Find a Products by collection handle with query
/products/collection/:handle Returns paginated products with pagination
x-headers
[]
ProductController.addProduct
Adds a new product. Some interesting things to note: - If you do not supply a currency, it will use the your configs default currency (USD) - Prices are all in whole numbers a their base level eg. $1.00 = 100 - If a collection is not found in the list, it will be created. - If a tag is not found in the list, it will be created. - If you do not provide any variants, a default variant will be created if there is provided SKU.
POST
/product || POST /product/add
{
handle: 'snowboard',
title: 'Burton Custom Freestyle 151',
body: '<strong>Good snowboard!</strong>',
vendors: [
'Burton'
],
type: 'Snowboard',
price: '10000',
published: true,
tags: [
'snow',
'equipment',
'outdoor'
],
collections: [
'fire sale'
],
metadata: {
test: 'value'
},
sku: 'board-m-123',
weight: '20',
weight_unit: 'lb',
images: [
{
src: 'https://placeholdit.imgix.net/~text?txtsize=33&txt=350%C3%97150&w=350&h=150',
alt: 'Hello World'
}
],
variants: [
{
title: 'Women\'s Burton Custom Freestyle 151',
price: '10001',
sku: 'board-w-123',
images: [
{
src: 'https://placeholdit.imgix.net/~text?txtsize=33&txt=350%C3%97150&w=350&h=150',
alt: 'Hello World 2'
}
]
}
]
}
Returns Created Product
{}
ProductController.addProducts
Adds new products
POST
/product/addProducts || /products
[]
Returns Created Products
[]
ProductController.updateProduct
Updates a product. updateProduct can update a product, add new variants and update existing ones, and add/update images all in one step.
Some interesting things to note:
- Updating the metadata will override the original metadata completely
- Supplying a list of collection's will override the original collections list.
- You can supply a completely new collection in the collection list and one will be created.
- Supplying a list of tags will override original tags list.
- You can supply a completely new tag in the tag list and one will be created.
- If you supply a title and there is no original SEO title, an SEO title will be created.
- If you supply a body, the html attribute will be updated.
- You can not modify the html attribute, instead, use the body to write new markdown/html or a mixture of both.
- Supplying a list of Images will only add new images to the product or modify existing ones by supplying an image id
. IT DOES NOT REMOVE ANY IMAGES
- Supplying a list of variants will only add new variants to the product or modify existing ones by supplying a variant id
. IT DOES NOT REMOVE ANY VARIANTS
POST
/product/:id/update
{
id: 123,
// Updates Title
title: 'Burton Custom Freestyle 151 Gen 2',
// Updates Metdata
metadata: {
test: 'new value'
},
// Alters collections
collections: [
// Existing Collection
'free-shipping',
// A completely new collection
{
handle: 'merorial-day-sale',
title: 'Memorial Day Sale',
discount_type: "fixed",
discount_scope: "global",
discount_rate: 100,
primary_purpose: "discount",
published: true
}
],
tags: [
'new tag'
],
images: [
// Updates existing Image alt
{
id: 123,
alt: 'Hello World 2 Updated'
},
// Creates new Image
{
src: 'https://placeholdit.imgix.net/~text?txtsize=33&txt=350%C3%97150&w=350&h=150',
alt: 'Hello World 3'
}
],
variants: [
// Updates Variant
{
id: 123,
// Updates the Title
title: 'Women\'s Burton Custom Freestyle 151 Updated',
// Updates the Variants position
position: 1,
// Updates existing Image alt
images: [
{
id: 1234,
alt: 'Image Updated'
},
// Add a new Image
{
src: 'https://placeholdit.imgix.net/~text?txtsize=33&txt=350%C3%97150&w=350&h=150',
alt: 'Hello World 5'
}
]
},
// Creates new Variant
{
title: 'Youth Burton Custom Freestyle 151',
sku: 'board-y-123',
images: [
{
src: 'https://placeholdit.imgix.net/~text?txtsize=33&txt=350%C3%97150&w=350&h=150',
alt: 'Hello World 4'
}
]
}
]
}
Returns the updated Product
{}
ProductController.updateProducts
Updates multiple products at once.
PUT
/products || POST /product/updateProducts
[]
Returns the updated Products
[]
ProductController.removeProduct
Removes a product (does not delete unless configured too)
POST
/product/:id/remove || DELETE /product/:id
{}
Returns the removed product
{}
ProductController.removeProducts
Removes multiple products (does not delete unless configured too)
POST
/product/removeProducts
[]
Returns the removed products
[]
ProductController.createVariant
Creates a variant. Some interesting things to note: - Any attributes not defined, will be inherited from the parent product - Any new options provided will be added to the product options array eg. Price, weight, currency, etc.
POST
/product/:id/variant
{
sku: 'new-sku',
title: 'Awesome SKU',
option: {'Option 1': 'This is Option 1', 'Option 2': 'This is Option 2' },
price: 10000,
currecny: 'USD'
}
Returns created Variant
{}
ProductController.updateVariant
Updates a variant. Some interesting things to note: - Any new options provided will be added to the product options array eg. Price, weight, currency, etc. - You can not update the SKU on an already created variant!
POST
/product/:id/variant/:variant
{
title: 'Awesome SKU',
option: {'Option 3': 'This is Option 3', 'Option 4': 'This is Option 4' }
}
Returns updated Variant
{}
ProductController.removeVariant
Removes a product variant (does not delete unless configured too)
POST
/product/:id/variant/:variant/remove || DELETE /product/:id/variant/:variant
{}
Returns the removed variant
{}
ProductController.removeVariants
Removes multiple product variants (does not delete unless configured too) // TODO
ProductController.removeImage
Removes a product image
POST
/product/:id/image/:image/remove || DELETE /product/:id/image/:image
{}
Returns the deleted images
[]
ProductController.addTag
Adds a tag to a product
POST
/product/:id/addTag/:tag
{}
Returns Updated Product
{}
ProductController.removeTag
Removes a tag from a product
POST
/product/:id/removeTag/:tag || DELETE /product/:id/tag/:tag
{}
Returns Updated Product
{}
ProductController.addCollection
Adds a product to a collection
POST
/product/:id/addCollection/:collection
{}
Returns Updated Product
{}
ProductController.removeCollection
Removes a product from a collection
POST
/product/:id/addCollection/:collection
{}
Returns Updated Product
{}
ProductController.addVendor
Adds a Vendor to a product
POST
/product/:id/addVendor/:vendor
{}
Returns Updated Product
{}
ProductController.removeVendor
Removes a Vendor from a product
POST
/product/:id/removeVendor/:vendor
{}
Returns Updated Product
{}
ProductController.uploadCSV
Uploads a Product CSV using a template and makes it ready to process
//POST
/product/uploadCSV name: csv
{}
Returns statistics of the upload
{}
ProductController.processUpload
Processes Uploaded CSV
POST
product/processUpload/:uploadID
{}
Returns statistics of the processed upload
{}
ProductController.uploadMetaCSV
Uploads a Metadata CSV using a template and makes it ready to process
POST
product/uploadMetaCSV name csv
{}
Returns statistics of the upload
{}
ProductController.processMetaUpload
Processes Uploaded Metadata CSV
POST
product/processMetaUpload/:uploadMetaID javascript {}
Returns statistics of the processed upload
{}
ProductController.exportProducts
Exports products as a CSV (TODO)
POST
product/exportProducts
{}
Returns a CSV
OrderController
Handles Order operations
OrderController.exportOrders
Exports orders as a CSV (TODO)
POST
/order/exportOrders
{}
Returns a CSV
ProxyCartController
Handles ProxyCart operations
ReviewController
Handles Review operations
ShopController
Handles Shop operations
ShopController.create
Creates a new Shop
POST
/shop
{}
Returns the created Shop
{}
ShopController.update
Updates a Shop
POST
/shop/:id
{}
Returns the updated Shop
{}
SubscriptionController
Handles Subscription operations
TagController
Handles Tag operations
TransactionController
Handles Transaction operations
UserController
Handles User operations
API: Services
Proxy Cart creates many services to handle operations
AccountService
CartService
CollectionService
CollectionCsvService
CountryService
CouponService
CustomerService
CustomerCsvService
DiscountService
FulfillmentService
GiftCardService
OrderService
OrderCsvService
PaymentService
ProductService
ProductCsvService
ProductCsvService
ProxyCartService
ReviewService
ShippingService
ShopService
SubscriptionService
SubscriptionCsvService
TagService
TaxService
TransactionService
VendorService
VendorCsvService
API: Crons
AccountsCron
CartsCron
DiscountsCron
OrdersCron
SubscriptionsCron
TransactionsCron
API: Emails
Customer
Order
Source
Subscription
API: Templates
Customer
Order
Source
Subscription
API: Sitemaps
API: Generics
fulfillmentProvider
geolocationProvider
imageProvider
shippingProvider
taxProvider
API: Analytics
API: Tasks
Errors
The Proxy Engine API uses the following error codes:
Error Code | Meaning |
---|---|
400 | Bad Request -- Your request sucks. |
401 | Unauthorized -- Your API key is wrong. |
403 | Forbidden -- The requested is hidden for administrators only. |
404 | Not Found -- The specified could not be found. |
405 | Method Not Allowed -- You tried to access a kitten with an invalid method. |
406 | Not Acceptable -- You requested a format that isn't json. |
410 | Gone -- The requested has been removed from our servers. |
418 | I'm a teapot. |
429 | Too Many Requests -- You're requesting too often! Slow down! |
500 | Internal Server Error -- We had a problem with our server. Try again later. |
503 | Service Unavailable -- We're temporarily offline for maintenance. Please try again later. |