/// <summary> /// Returns the shop's <see cref="ShopifyShop"/> information. /// </summary> /// <returns></returns> public virtual async Task <ShopifyShop> GetAsync() { IRestRequest request = RequestEngine.CreateRequest("shop.json", Method.GET, "shop"); //Make request return(await RequestEngine.ExecuteRequestAsync <ShopifyShop>(_RestClient, request)); }
/// <summary> /// Creates a <see cref="ShopifyUsageCharge"/>. /// </summary> /// <param name="recurringChargeId">The id of the <see cref="ShopifyUsageCharge"/> that this usage charge belongs to.</param> /// <param name="description">The name or description of the usage charge.</param> /// <param name="price">The price of the usage charge.</param> /// <returns>The new <see cref="ShopifyUsageCharge"/>.</returns> public async Task <ShopifyUsageCharge> CreateAsync(long recurringChargeId, string description, double price) { var req = RequestEngine.CreateRequest($"recurring_application_charges/{recurringChargeId}/usage_charges.json", Method.POST, "usage_charge"); req.AddJsonBody(new { usage_charge = new { description = description, price = price } }); return(await RequestEngine.ExecuteRequestAsync <ShopifyUsageCharge>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyPage"/>. Id must not be null. /// </summary> /// <param name="page">The <see cref="ShopifyPage"/> to update.</param> /// <returns>The updated <see cref="ShopifyPage"/>.</returns> public virtual async Task <ShopifyPage> UpdateAsync(ShopifyPage page) { IRestRequest req = RequestEngine.CreateRequest($"pages/{page.Id.Value}.json", Method.PUT, "page"); req.AddJsonBody(new { page }); return(await RequestEngine.ExecuteRequestAsync <ShopifyPage>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyProductImage"/>. Id must not be null. /// </summary> /// <param name="productId">The id of the product that counted images belong to.</param> /// <param name="image">The <see cref="ShopifyProductImage"/> to update.</param> /// <returns>The updated <see cref="ShopifyProductImage"/>.</returns> public virtual async Task <ShopifyProductImage> UpdateAsync(long productId, ShopifyProductImage image) { var req = RequestEngine.CreateRequest($"products/{productId}/images/{image.Id.Value}.json", Method.PUT, "image"); req.AddJsonBody(new { image }); return(await RequestEngine.ExecuteRequestAsync <ShopifyProductImage>(_RestClient, req)); }
/// <summary> /// Gets a count of all of the shop's customers. /// </summary> /// <returns>The count of all customers for the shop.</returns> public async Task <int> CountAsync() { IRestRequest req = RequestEngine.CreateRequest("customers/count.json", Method.GET); JToken responseObject = await RequestEngine.ExecuteRequestAsync(_RestClient, req); //Response looks like { "count" : 123 }. Does not warrant its own class. return(responseObject.Value <int>("count")); }
/// <summary> /// Creates a <see cref="ShopifyCharge"/>. /// </summary> /// <param name="charge">The <see cref="ShopifyCharge"/> to create.</param> /// <returns>The new <see cref="ShopifyCharge"/>.</returns> public async Task <ShopifyCharge> CreateAsync(ShopifyCharge charge) { IRestRequest req = RequestEngine.CreateRequest("application_charges.json", Method.POST, "application_charge"); req.AddJsonBody(new { application_charge = charge }); return(await RequestEngine.ExecuteRequestAsync <ShopifyCharge>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyWebhook"/>. Id must not be null. /// </summary> /// <param name="webhook">The <see cref="ShopifyWebhook"/> to update.</param> /// <returns>The updated <see cref="ShopifyWebhook"/>.</returns> public virtual async Task <ShopifyWebhook> UpdateAsync(ShopifyWebhook webhook) { IRestRequest req = RequestEngine.CreateRequest($"webhooks/{webhook.Id.Value}.json", Method.PUT, "webhook"); req.AddJsonBody(new { webhook }); return(await RequestEngine.ExecuteRequestAsync <ShopifyWebhook>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyMetaField"/>. Id must not be null. /// </summary> /// <param name="metafield">The <see cref="ShopifyMetaField"/> to update.</param> /// <returns>The updated <see cref="ShopifyMetaField"/>.</returns> public async Task <ShopifyMetaField> UpdateAsync(ShopifyMetaField metafield) { IRestRequest req = RequestEngine.CreateRequest($"metafields/{metafield.Id.Value}.json", Method.PUT, "metafield"); req.AddJsonBody(new { metafield }); return(await RequestEngine.ExecuteRequestAsync <ShopifyMetaField>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifySmartCollection"/>. Id must not be null. /// </summary> /// <param name="collection">The smart collection to update.</param> public virtual async Task <ShopifySmartCollection> UpdateAsync(ShopifySmartCollection collection) { var req = RequestEngine.CreateRequest($"smart_collections/{collection.Id.Value}.json", Method.PUT, "smart_collection"); req.AddJsonBody(new { smart_collection = collection }); return(await RequestEngine.ExecuteRequestAsync <ShopifySmartCollection>(_RestClient, req)); }
/// <summary> /// Creates a new <see cref="ShopifyTransaction"/> of the given kind. /// </summary> /// <param name="orderId">The order id to which the fulfillments belong.</param> /// <param name="transaction">The transaction.</param> /// <returns>The new <see cref="ShopifyTransaction"/>.</returns> public virtual async Task <ShopifyTransaction> CreateAsync(long orderId, ShopifyTransaction transaction) { var req = RequestEngine.CreateRequest($"orders/{orderId}/transactions.json", Method.POST, "transaction"); req.AddJsonBody(new { transaction = transaction }); return(await RequestEngine.ExecuteRequestAsync <ShopifyTransaction>(_RestClient, req)); }
/// <summary> /// Gets a count of all of the shop's transactions. /// </summary> /// <param name="orderId">The order id to which the fulfillments belong.</param> /// <returns>The count of all fulfillments for the shop.</returns> public virtual async Task <int> CountAsync(long orderId) { var req = RequestEngine.CreateRequest($"orders/{orderId}/transactions/count.json", Method.GET); var responseObject = await RequestEngine.ExecuteRequestAsync(_RestClient, req); //Response looks like { "count" : 123 }. Does not warrant its own class. return(responseObject.Value <int>("count")); }
/// <summary> /// Updates the given <see cref="ShopifyProductVariant"/>. Id must not be null. /// </summary> /// <param name="variant">The variant to update.</param> public async Task <ShopifyProductVariant> UpdateAsync(ShopifyProductVariant variant) { var req = RequestEngine.CreateRequest($"variants/{variant.Id.Value}.json", Method.PUT, "variant"); req.AddJsonBody(new { variant }); return(await RequestEngine.ExecuteRequestAsync <ShopifyProductVariant>(_RestClient, req)); }
/// <summary> /// Creates a new <see cref="ShopifyProductVariant"/>. /// </summary> /// <param name="productId">The product that the new variant will belong to.</param> /// <param name="variant">A new <see cref="ShopifyProductVariant"/>. Id should be set to null.</param> public async Task <ShopifyProductVariant> CreateAsync(long productId, ShopifyProductVariant variant) { var req = RequestEngine.CreateRequest($"products/{productId}/variants.json", Method.POST, "variant"); req.AddJsonBody(new { variant }); return(await RequestEngine.ExecuteRequestAsync <ShopifyProductVariant>(_RestClient, req)); }
/// <summary> /// Creates a new <see cref="ShopifySmartCollection"/>. /// </summary> /// <param name="collection">A new <see cref="ShopifySmartCollection"/>. Id should be set to null.</param> public async Task <ShopifySmartCollection> CreateAsync(ShopifySmartCollection collection) { var req = RequestEngine.CreateRequest($"smart_collections.json", Method.POST, "smart_collection"); req.AddJsonBody(new { smart_collection = collection }); return(await RequestEngine.ExecuteRequestAsync <ShopifySmartCollection>(_RestClient, req)); }
/// <summary> /// Cancels an order. /// </summary> /// <param name="orderId">The order's id.</param> /// <returns>The cancelled <see cref="ShopifyOrder"/>.</returns> public virtual async Task CancelAsync(long orderId, ShopifyOrderCancelOptions options = null) { IRestRequest req = RequestEngine.CreateRequest($"orders/{orderId}/cancel.json", Method.POST); req.AddJsonBody(options); await RequestEngine.ExecuteRequestAsync(_RestClient, req); }
/// <summary> /// Updates the given <see cref="ShopifyProduct"/>. Id must not be null. /// </summary> /// <param name="product">The <see cref="ShopifyProduct"/> to update.</param> /// <returns>The updated <see cref="ShopifyProduct"/>.</returns> public virtual async Task <ShopifyProduct> UpdateAsync(ShopifyProduct product) { IRestRequest req = RequestEngine.CreateRequest($"products/{product.Id.Value}.json", Method.PUT, "product"); req.AddJsonBody(new { product }); return(await RequestEngine.ExecuteRequestAsync <ShopifyProduct>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyOrderRisk"/>. Id must not be null. /// </summary> /// <param name="orderId">The order the risk belongs to.</param> /// <param name="risk">The risk to update.</param> public virtual async Task <ShopifyOrderRisk> UpdateAsync(long orderId, ShopifyOrderRisk risk) { var req = RequestEngine.CreateRequest($"orders/{orderId}/risks/{risk.Id.Value}.json", Method.PUT, "risk"); req.AddJsonBody(new { risk }); return(await RequestEngine.ExecuteRequestAsync <ShopifyOrderRisk>(_RestClient, req)); }
/// <summary> /// Creates a new <see cref="ShopifyRedirect"/> on the store. The redirect always starts out with a role of /// "unpublished." If the redirect has a different role, it will be assigned that only after all of its /// files have been extracted and stored by Shopify (which might take a couple of minutes). /// </summary> /// <param name="redirect">The new <see cref="ShopifyRedirect"/>.</param> /// <returns>The new <see cref="ShopifyRedirect"/>.</returns> public async Task <ShopifyRedirect> CreateAsync(ShopifyRedirect redirect) { IRestRequest req = RequestEngine.CreateRequest("redirects.json", Method.POST, "redirect"); req.AddJsonBody(new { redirect }); return(await RequestEngine.ExecuteRequestAsync <ShopifyRedirect>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyFulfillment"/>. Id must not be null. /// </summary> /// <param name="orderId">The order id to which the fulfillments belong.</param> /// <param name="fulfillment">The <see cref="ShopifyFulfillment"/> to update.</param> /// <returns>The updated <see cref="ShopifyFulfillment"/>.</returns> public async Task <ShopifyFulfillment> UpdateAsync(long orderId, ShopifyFulfillment fulfillment) { var req = RequestEngine.CreateRequest($"orders/{orderId}/fulfillments/{fulfillment.Id.Value}.json", Method.PUT, "fulfillment"); req.AddJsonBody(new { fulfillment }); return(await RequestEngine.ExecuteRequestAsync <ShopifyFulfillment>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyRedirect"/>. Id must not be null. /// </summary> /// <param name="redirect">The <see cref="ShopifyRedirect"/> to update.</param> /// <returns>The updated <see cref="ShopifyRedirect"/>.</returns> public async Task <ShopifyRedirect> UpdateAsync(ShopifyRedirect redirect) { IRestRequest req = RequestEngine.CreateRequest("redirects/{0}.json".FormatWith(redirect.Id.Value), Method.PUT, "redirect"); req.AddJsonBody(new { redirect }); return(await RequestEngine.ExecuteRequestAsync <ShopifyRedirect>(_RestClient, req)); }
/// <summary> /// Creates a new <see cref="ShopifyApplicationCredit"/>. /// </summary> /// <param name="credit">A new <see cref="ShopifyApplicationCredit"/>. Id should be set to null.</param> public virtual async Task <ShopifyApplicationCredit> CreateAsync(ShopifyApplicationCredit credit) { var req = RequestEngine.CreateRequest($"application_credits.json", Method.POST, "application_credit"); req.AddJsonBody(new { application_credit = credit }); return(await RequestEngine.ExecuteRequestAsync <ShopifyApplicationCredit>(_RestClient, req)); }
/// <summary> /// Creates or updates a <see cref="ShopifyAsset"/>. Both tasks use the same method due to the /// way Shopify API handles assets. If an asset has a unique <see cref="ShopifyAsset.Key"/> value, /// it will be created. If not, it will be updated. Copy an asset by setting the /// <see cref="ShopifyAsset.SourceKey"/> to the target's <see cref="ShopifyAsset.Key"/> value. /// Note: This will not return the asset's <see cref="ShopifyAsset.Value"/> property. You should /// use <see cref="GetAsync(long, string, string)"/> to refresh the value after creating or updating. /// </summary> /// <param name="themeId">The id of the theme that the asset belongs to.</param> /// <param name="asset">The asset.</param> /// <returns>The created or updated asset.</returns> public async Task <ShopifyAsset> CreateOrUpdateAsync(long themeId, ShopifyAsset asset) { IRestRequest req = RequestEngine.CreateRequest("themes/{0}/assets.json".FormatWith(themeId), Method.PUT, "asset"); req.AddJsonBody(new { asset = asset }); return(await RequestEngine.ExecuteRequestAsync <ShopifyAsset>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyCustomer"/>. Id must not be null. /// </summary> /// <param name="customer">The <see cref="ShopifyCustomer"/> to update.</param> /// <returns>The updated <see cref="ShopifyCustomer"/>.</returns> public async Task <ShopifyCustomer> UpdateAsync(ShopifyCustomer customer) { IRestRequest req = RequestEngine.CreateRequest("customers/{0}.json".FormatWith(customer.Id.Value), Method.PUT, "customer"); req.AddJsonBody(new { customer }); return(await RequestEngine.ExecuteRequestAsync <ShopifyCustomer>(_RestClient, req)); }
/// <summary> /// Deletes a <see cref="ShopifyAsset"/> with the given key. /// </summary> /// <param name="themeId">The id of the theme that the asset belongs to.</param> /// <param name="key">The key value of the asset, e.g. 'templates/index.liquid' or 'assets/bg-body.gif'.</param> public async Task DeleteAsync(long themeId, string key) { IRestRequest req = RequestEngine.CreateRequest("themes/{0}/assets.json".FormatWith(themeId), Method.DELETE); req = SetAssetQuerystring(req, key, themeId); await RequestEngine.ExecuteRequestAsync(_RestClient, req); }
/// <summary> /// Updates the given <see cref="ShopifyOrder"/>. Id must not be null. /// </summary> /// <param name="order">The <see cref="ShopifyOrder"/> to update.</param> /// <returns>The updated <see cref="ShopifyOrder"/>.</returns> public async Task <ShopifyOrder> UpdateAsync(ShopifyOrder order) { IRestRequest req = RequestEngine.CreateRequest($"orders/{order.Id.Value}.json", Method.PUT, "order"); req.AddJsonBody(new { order }); return(await RequestEngine.ExecuteRequestAsync <ShopifyOrder>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyScriptTag"/>. Id must not be null. /// </summary> /// <param name="tag">The <see cref="ShopifyScriptTag"/> to update.</param> /// <returns>The updated <see cref="ShopifyScriptTag"/>.</returns> public async Task <ShopifyScriptTag> UpdateAsync(ShopifyScriptTag tag) { IRestRequest req = RequestEngine.CreateRequest("script_tags/{0}.json".FormatWith(tag.Id.Value), Method.PUT, "script_tag"); req.AddJsonBody(new { script_tag = tag }); return(await RequestEngine.ExecuteRequestAsync <ShopifyScriptTag>(_RestClient, req)); }
/// <summary> /// Updates the given <see cref="ShopifyTheme"/>. Id must not be null. /// </summary> /// <param name="theme">The <see cref="ShopifyTheme"/> to update.</param> /// <returns>The updated <see cref="ShopifyTheme"/>.</returns> public async Task <ShopifyTheme> UpdateAsync(ShopifyTheme theme) { IRestRequest req = RequestEngine.CreateRequest($"themes/{theme.Id.Value}.json", Method.PUT, "theme"); req.AddJsonBody(new { theme }); return(await RequestEngine.ExecuteRequestAsync <ShopifyTheme>(_RestClient, req)); }
/// <summary> /// Deletes a <see cref="ShopifyAsset"/> with the given key. /// </summary> /// <param name="themeId">The id of the theme that the asset belongs to.</param> /// <param name="key">The key value of the asset, e.g. 'templates/index.liquid' or 'assets/bg-body.gif'.</param> public virtual async Task DeleteAsync(long themeId, string key) { IRestRequest req = RequestEngine.CreateRequest($"themes/{themeId}/assets.json", Method.DELETE); req = SetAssetQuerystring(req, key, themeId); await RequestEngine.ExecuteRequestAsync(_RestClient, req); }
/// <summary> /// Creates a new <see cref="ShopifyWebhook"/> on the store. /// </summary> /// <param name="webhook">A new <see cref="ShopifyWebhook"/>. Id should be set to null.</param> /// <returns>The new <see cref="ShopifyWebhook"/>.</returns> public virtual async Task <ShopifyWebhook> CreateAsync(ShopifyWebhook webhook) { IRestRequest req = RequestEngine.CreateRequest("webhooks.json", Method.POST, "webhook"); //Build the request body req.AddJsonBody(new { webhook }); return(await RequestEngine.ExecuteRequestAsync <ShopifyWebhook>(_RestClient, req)); }
/// <summary> /// Retrieves the <see cref="ShopifyTheme"/> with the given id. /// </summary> /// <param name="themeId">The id of the theme to retrieve.</param> /// <param name="fields">A comma-separated list of fields to return.</param> /// <returns>The <see cref="ShopifyTheme"/>.</returns> public async Task <ShopifyTheme> GetAsync(long themeId, string fields = null) { IRestRequest req = RequestEngine.CreateRequest($"themes/{themeId}.json", Method.GET, "theme"); if (string.IsNullOrEmpty(fields) == false) { req.AddParameter("fields", fields); } return(await RequestEngine.ExecuteRequestAsync <ShopifyTheme>(_RestClient, req)); }