/// <summary>
/// Creates a new channel that defines a new logical business division to use for financial reporting.
/// </summary>
/// <param name="channel">Properties of the channel to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Channels.Channel"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateChannel( channel);
/// var channelClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Channels.Channel> CreateChannelClient(Mozu.Api.Contracts.CommerceRuntime.Channels.Channel channel)
{
var url = Mozu.Api.Urls.Commerce.ChannelUrl.CreateChannelUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Channels.Channel>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.CommerceRuntime.Channels.Channel>(channel);
return mozuClient;
}
/// <summary>
/// Retrieves a list of the fulfillment information for the specified order.
/// </summary>
/// <param name="draft">If true, retrieve the draft version of the order's fulfillment information, which might include uncommitted changes.</param>
/// <param name="orderId">Unique identifier of the order.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Fulfillment.FulfillmentInfo"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetFulfillmentInfo( orderId, draft);
/// var fulfillmentInfoClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.FulfillmentInfo> GetFulfillmentInfoClient(string orderId, bool? draft = null)
{
var url = Mozu.Api.Urls.Commerce.Orders.FulfillmentInfo.FulfillmentInfoUrl.GetFulfillmentInfoUrl(draft, orderId);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.FulfillmentInfo>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Retrieves a list of the Mozu tenants or development stores for which the specified user has an assigned role.
/// </summary>
/// <param name="userId">Unique identifier of the user whose tenant scopes you want to retrieve.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Tenant.TenantCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetTenantScopesForUser( userId);
/// var tenantCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Tenant.TenantCollection> GetTenantScopesForUserClient(string userId)
{
var url = Mozu.Api.Urls.Platform.Adminuser.AdminUserUrl.GetTenantScopesForUserUrl(userId);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Tenant.TenantCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Deletes a defined channel for the tenant and removes the defined site associations. After deleting this channel, assign its associated sites to another channel.
/// </summary>
/// <param name="code">User-defined code that identifies the channel to delete.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteChannel( code);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteChannelClient(string code)
{
var url = Mozu.Api.Urls.Commerce.ChannelUrl.DeleteChannelUrl(code);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Retrieves the details of the specified administrator user account.
/// </summary>
/// <param name="userId">Unique identifier of the administrator account to retrieve.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Core.User"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetUser( userId);
/// var userClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Core.User> GetUserClient(string userId)
{
var url = Mozu.Api.Urls.Platform.Adminuser.AdminUserUrl.GetUserUrl(userId);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Core.User>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Creates a new payment for a return that results in a refund to the customer.
/// </summary>
/// <param name="returnId">Unique identifier of the return associated with the payment action.</param>
/// <param name="action">The payment action to perform for the customer return.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Returns.Return"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreatePaymentActionForReturn( action, returnId);
/// var returnClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> CreatePaymentActionForReturnClient(Mozu.Api.Contracts.CommerceRuntime.Payments.PaymentAction action, string returnId)
{
var url = Mozu.Api.Urls.Commerce.ReturnUrl.CreatePaymentActionForReturnUrl(returnId);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.CommerceRuntime.Payments.PaymentAction>(action);
return mozuClient;
}
/// <summary>
/// Creates a return for previously fulfilled items. Each return must either be associated with an original order or a product definition to represent each returned item.
/// </summary>
/// <param name="ret">Wrapper for the properties of the return to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Returns.Return"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateReturn( ret);
/// var returnClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> CreateReturnClient(Mozu.Api.Contracts.CommerceRuntime.Returns.Return ret)
{
var url = Mozu.Api.Urls.Commerce.ReturnUrl.CreateReturnUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.CommerceRuntime.Returns.Return>(ret);
return mozuClient;
}
/// <summary>
/// Creates a new record in the Mozu database based on the information supplied in the request.
/// </summary>
/// <param name="dbEntryQuery">The database entry string to create.</param>
/// <param name="value">The value string to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateDBValue( value, dbEntryQuery);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient CreateDBValueClient(string value, string dbEntryQuery)
{
var url = Mozu.Api.Urls.Platform.UserData.UserDataUrl.CreateDBValueUrl(dbEntryQuery);
const string verb = "POST";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody(value);
return mozuClient;
}
/// <summary>
/// Removes a previously defined record in the Mozu database.
/// </summary>
/// <param name="dbEntryQuery">The database entry string to delete.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteDBValue( dbEntryQuery);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteDBValueClient(string dbEntryQuery)
{
var url = Mozu.Api.Urls.Platform.UserData.UserDataUrl.DeleteDBValueUrl(dbEntryQuery);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="appId"></param>
/// <param name="application"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.InstalledApplications.Application"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateApplication( application, appId);
/// var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.InstalledApplications.Application> UpdateApplicationClient(Mozu.Api.Contracts.InstalledApplications.Application application, string appId)
{
var url = Mozu.Api.Urls.Platform.ApplicationUrl.UpdateApplicationUrl(appId);
const string verb = "PUT";
var mozuClient = new MozuClient<Mozu.Api.Contracts.InstalledApplications.Application>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.InstalledApplications.Application>(application);
return mozuClient;
}
/// <summary>
/// Creates a new development or release package for the application version specified in the request.
/// </summary>
/// <param name="applicationVersionId">Unique identifier of the application version. Application version IDs are unique across all applications associated with the developer account.</param>
/// <param name="package">Properties of the development or release package to define.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AppDev.Package"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddPackage( pkg, applicationVersionId);
/// var packageClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.AppDev.Package> AddPackageClient(Mozu.Api.Contracts.AppDev.Package pkg, int applicationVersionId)
{
var url = Mozu.Api.Urls.Platform.Developer.ApplicationVersionUrl.AddPackageUrl(applicationVersionId);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.AppDev.Package>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.AppDev.Package>(pkg);
return mozuClient;
}
/// <summary>
/// Deletes the shipment specified in the request.
/// </summary>
/// <param name="orderId">Unique identifier of the order to cancel shipment.</param>
/// <param name="shipmentId">Unique identifier of the shipment to cancel.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteShipment( orderId, shipmentId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteShipmentClient(string orderId, string shipmentId)
{
var url = Mozu.Api.Urls.Commerce.Orders.ShipmentUrl.DeleteShipmentUrl(orderId, shipmentId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="appId"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.InstalledApplications.Application"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetApplication( appId);
/// var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.InstalledApplications.Application> GetApplicationClient(string appId)
{
var url = Mozu.Api.Urls.Platform.ApplicationUrl.GetApplicationUrl(appId);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.InstalledApplications.Application>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Deletes the shopper wish list specified in the request and all items associated with it.
/// </summary>
/// <param name="wishlistId">Unique identifier of the wish list to delete.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteWishlist( wishlistId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteWishlistClient(string wishlistId)
{
var url = Mozu.Api.Urls.Commerce.WishlistUrl.DeleteWishlistUrl(wishlistId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Creates a shipment from one or more package associated with an order and assign a label and tracking number to an order shipment.
/// </summary>
/// <param name="orderId">Unique identifier of the order for this shipment.</param>
/// <param name="packageIds">List of unique identifiers for each package associated with this shipment. Not all packages must belong to the same shipment.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreatePackageShipments( packageIds, orderId);
/// var packageClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<List<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package>> CreatePackageShipmentsClient(List<string> packageIds, string orderId)
{
var url = Mozu.Api.Urls.Commerce.Orders.ShipmentUrl.CreatePackageShipmentsUrl(orderId);
const string verb = "POST";
var mozuClient = new MozuClient<List<Mozu.Api.Contracts.CommerceRuntime.Fulfillment.Package>>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody(packageIds);
return mozuClient;
}
/// <summary>
/// Creates a new product selection. A create occurs each time a shopper selects a product option as they configure a product. Once all the required product options are configured, the product can be added to a cart.
/// </summary>
/// <param name="includeOptionDetails">If true, the response returns details about the product. If false, returns a product summary such as the product name, price, and sale price.</param>
/// <param name="productCode">Merchant-created code that uniquely identifies the product such as a SKU or item number. Once created, the product code is read-only.</param>
/// <param name="skipInventoryCheck"></param>
/// <param name="productOptionSelections">For a product with shopper-configurable options, the properties of the product options selected by the shopper.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=ConfiguredProduct( productOptionSelections, productCode, includeOptionDetails, skipInventoryCheck);
/// var configuredProductClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct> ConfiguredProductClient(Mozu.Api.Contracts.ProductRuntime.ProductOptionSelections productOptionSelections, string productCode, bool? includeOptionDetails = null, bool? skipInventoryCheck = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.ConfiguredProductUrl(includeOptionDetails, productCode, skipInventoryCheck);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductRuntime.ProductOptionSelections>(productOptionSelections);
return mozuClient;
}
/// <summary>
/// Creates a new shopper wish list for the associated customer account. Although customer accounts are maintained at the tenant level, the system stores wish lists at the site level. Newly created wish lists do not have any items.
/// </summary>
/// <param name="wishlist">Properties of the wish list to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateWishlist( wishlist);
/// var wishlistClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist> CreateWishlistClient(Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist wishlist)
{
var url = Mozu.Api.Urls.Commerce.WishlistUrl.CreateWishlistUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.CommerceRuntime.Wishlists.Wishlist>(wishlist);
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="System.IO.Stream"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateAnonymousShopperAuthTicket();
/// var streamClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<System.IO.Stream> CreateAnonymousShopperAuthTicketClient()
{
var url = Mozu.Api.Urls.Commerce.Customer.CustomerAuthTicketUrl.CreateAnonymousShopperAuthTicketUrl();
const string verb = "GET";
var mozuClient = new MozuClient<System.IO.Stream>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="userAuthInfo"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateUserAuthTicket( userAuthInfo);
/// var customerAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> CreateUserAuthTicketClient(Mozu.Api.Contracts.Customer.CustomerUserAuthInfo userAuthInfo)
{
var url = Mozu.Api.Urls.Commerce.Customer.CustomerAuthTicketUrl.CreateUserAuthTicketUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Customer.CustomerUserAuthInfo>(userAuthInfo);
return mozuClient;
}
/// <summary>
/// Creates an authentication ticket for the supplied user to specify in API requests associated with the supplied tenant.
/// </summary>
/// <param name="tenantId">Unique identifier of the development or production tenant for which to generate the user authentication ticket.</param>
/// <param name="userAuthInfo">The user authentication information required to generate the user authentication ticket, which consists of a user name and password.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateUserAuthTicket( userAuthInfo, tenantId);
/// var tenantAdminUserAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket> CreateUserAuthTicketClient(Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int? tenantId = null)
{
var url = Mozu.Api.Urls.Platform.Adminuser.TenantAdminUserAuthTicketUrl.CreateUserAuthTicketUrl(tenantId);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Core.UserAuthInfo>(userAuthInfo);
return mozuClient;
}
/// <summary>
/// Retrieves the configured site location usages for the location usage code specified in the request.
/// </summary>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Location.LocationUsageCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetLocationUsages();
/// var locationUsageCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Location.LocationUsageCollection> GetLocationUsagesClient()
{
var url = Mozu.Api.Urls.Commerce.Settings.LocationUsageUrl.GetLocationUsagesUrl();
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Location.LocationUsageCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="location"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Location.Location"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddLocation( location);
/// var locationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Location.Location> AddLocationClient(Mozu.Api.Contracts.Location.Location location)
{
var url = Mozu.Api.Urls.Commerce.Admin.LocationUrl.AddLocationUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Location.Location>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Location.Location>(location);
return mozuClient;
}
/// <summary>
/// Applies a defined attribute to the customer account specified in the request and assigns a value to the customer attribute.
/// </summary>
/// <param name="accountId">Unique identifier of the customer account.</param>
/// <param name="attribute"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAttribute"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddAccountAttribute( attribute, accountId);
/// var customerAttributeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Customer.CustomerAttribute> AddAccountAttributeClient(Mozu.Api.Contracts.Customer.CustomerAttribute attribute, int accountId)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.AddAccountAttributeUrl(accountId);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.CustomerAttribute>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Customer.CustomerAttribute>(attribute);
return mozuClient;
}
/// <summary>
/// Creates a new store credit for the customer account specified in the request.
/// </summary>
/// <param name="credit">Properties of the store credit to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.Credit.Credit"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddCredit( credit);
/// var creditClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit> AddCreditClient(Mozu.Api.Contracts.Customer.Credit.Credit credit)
{
var url = Mozu.Api.Urls.Commerce.Customer.CreditUrl.AddCreditUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Customer.Credit.Credit>(credit);
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="code"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.Credit.Credit"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AssociateCreditToShopper( code);
/// var creditClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit> AssociateCreditToShopperClient(string code)
{
var url = Mozu.Api.Urls.Commerce.Customer.CreditUrl.AssociateCreditToShopperUrl(code);
const string verb = "PUT";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.Credit.Credit>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="accountAndAuthInfo"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddAccountAndLogin( accountAndAuthInfo);
/// var customerAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> AddAccountAndLoginClient(Mozu.Api.Contracts.Customer.CustomerAccountAndAuthInfo accountAndAuthInfo)
{
var url = Mozu.Api.Urls.Commerce.Customer.CustomerAccountUrl.AddAccountAndLoginUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Customer.CustomerAccountAndAuthInfo>(accountAndAuthInfo);
return mozuClient;
}
/// <summary>
/// Retrieve the details of all master catalog associated with a tenant.
/// </summary>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetMasterCatalogs();
/// var masterCatalogCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection> GetMasterCatalogsClient()
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.MasterCatalogUrl.GetMasterCatalogsUrl();
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalogCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="accountId"></param>
/// <param name="attributeFQN"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteAccountAttribute( accountId, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteAccountAttributeClient(int accountId, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.DeleteAccountAttributeUrl(accountId, attributeFQN);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Initializes an application with the necessary configured settings.
/// </summary>
/// <param name="application">Properties of the application to update.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.SiteSettings.Application.Application"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=ThirdPartyUpdateApplication( application);
/// var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.SiteSettings.Application.Application> ThirdPartyUpdateApplicationClient(Mozu.Api.Contracts.SiteSettings.Application.Application application)
{
var url = Mozu.Api.Urls.Commerce.Settings.ApplicationUrl.ThirdPartyUpdateApplicationUrl();
const string verb = "PUT";
var mozuClient = new MozuClient<Mozu.Api.Contracts.SiteSettings.Application.Application>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.SiteSettings.Application.Application>(application);
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="locationCode"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteLocation( locationCode);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteLocationClient(string locationCode)
{
var url = Mozu.Api.Urls.Commerce.Admin.LocationUrl.DeleteLocationUrl(locationCode);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return mozuClient;
}
/// <summary>
/// Retrieves a list of the validation results associated with the order.
/// </summary>
/// <param name="orderId">Unique identifier of the order.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetValidationResults( orderId);
/// var orderValidationResultClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult> > GetValidationResultsClient(string orderId)
{
var url = Mozu.Api.Urls.Commerce.Orders.OrderValidationResultUrl.GetValidationResultsUrl(orderId);
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult> >()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="masterCatalogId">Unique identifier for the master catalog. The master catalog contains all products accessible per catalogs and the site/tenant.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.MasterCatalog"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetMasterCatalog( masterCatalogId, responseFields);
/// var masterCatalogClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.MasterCatalog> GetMasterCatalogClient(int masterCatalogId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.MasterCatalogUrl.GetMasterCatalogUrl(masterCatalogId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.MasterCatalog>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="carrierId">The unique identifier of the carrier.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="carrierConfiguration">Properties of a carrier configured in the shipping admin.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ShippingAdmin.CarrierConfiguration"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateConfiguration( carrierConfiguration, carrierId, responseFields);
/// var carrierConfigurationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ShippingAdmin.CarrierConfiguration> CreateConfigurationClient(Mozu.Api.Contracts.ShippingAdmin.CarrierConfiguration carrierConfiguration, string carrierId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Shipping.Admin.CarrierConfigurationUrl.CreateConfigurationUrl(carrierId, responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ShippingAdmin.CarrierConfiguration>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ShippingAdmin.CarrierConfiguration>(carrierConfiguration);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="filter">A set of filter expressions representing the search parameters for a query. This parameter is optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for a list of supported filters.</param>
/// <param name="pageSize">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with this parameter set to 25, to get the 51st through the 75th items, set startIndex to 50.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="sortBy">The element to sort the results by and the channel in which the results appear. Either ascending (a-z) or descending (z-a) channel. Optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for more information.</param>
/// <param name="startIndex">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with pageSize set to 25, to get the 51st through the 75th items, set this parameter to 50.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ShippingAdmin.CarrierConfigurationCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetConfigurations( startIndex, pageSize, sortBy, filter, responseFields);
/// var carrierConfigurationCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ShippingAdmin.CarrierConfigurationCollection> GetConfigurationsClient(int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Shipping.Admin.CarrierConfigurationUrl.GetConfigurationsUrl(startIndex, pageSize, sortBy, filter, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ShippingAdmin.CarrierConfigurationCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="carrierId">The unique identifier of the carrier configuration.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteConfiguration( carrierId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteConfigurationClient(string carrierId)
{
var url = Mozu.Api.Urls.Commerce.Shipping.Admin.CarrierConfigurationUrl.DeleteConfigurationUrl(carrierId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="appId">appId parameter description DOCUMENT_HERE </param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="application">Properties of an app installed in a tenant.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.InstalledApplications.Application"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateApplication( application, appId, responseFields);
/// var applicationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.InstalledApplications.Application> UpdateApplicationClient(Mozu.Api.Contracts.InstalledApplications.Application application, string appId, string responseFields = null)
{
var url = Mozu.Api.Urls.Platform.InstalledApplicationsUrl.UpdateApplicationUrl(appId, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.InstalledApplications.Application>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.InstalledApplications.Application>(application);
return(mozuClient);
}
/// <summary>
/// Add a new order validation result to a submitted order.
/// </summary>
/// <param name="orderId">Unique identifier of the order.</param>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="validationResult">Properties of the resulting order validation performed by an order validation capability.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddValidationResult( validationResult, orderId, responseFields);
/// var orderValidationResultClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult> AddValidationResultClient(Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult validationResult, string orderId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Orders.OrderValidationResultUrl.AddValidationResultUrl(orderId, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult>(validationResult);
return(mozuClient);
}
/// <summary>
/// Retrieves the details of the specified price list.
/// </summary>
/// <param name="priceListCode">The unique code of the price list for which you want to retrieve the details.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.PriceList"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetPriceList( priceListCode, responseFields);
/// var priceListClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.PriceList> GetPriceListClient(string priceListCode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.PriceListUrl.GetPriceListUrl(priceListCode, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.PriceList>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="accountId">Unique identifier of the customer account.</param>
/// <param name="filter">A set of filter expressions representing the search parameters for a query. This parameter is optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for a list of supported filters.</param>
/// <param name="pageSize">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with this parameter set to 25, to get the 51st through the 75th items, set startIndex to 50.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="sortBy">The element to sort the results by and the channel in which the results appear. Either ascending (a-z) or descending (z-a) channel. Optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for more information.</param>
/// <param name="startIndex">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with pageSize set to 25, to get the 51st through the 75th items, set this parameter to 50.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAttributeCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetAccountAttributes( accountId, startIndex, pageSize, sortBy, filter, responseFields);
/// var customerAttributeCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Customer.CustomerAttributeCollection> GetAccountAttributesClient(int accountId, int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.GetAccountAttributesUrl(accountId, startIndex, pageSize, sortBy, filter, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Customer.CustomerAttributeCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
/// Retrieves the details of a price list to which the specified customer resolves. This is primarly used when creating an offline order for a shopper.You can use this operation alongside custom Arc.js actions to alter the price list to which a shopper resolves.
/// </summary>
/// <param name="customerAccountId">The unique identifier of the customer account for which to retrieve wish lists.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.ResolvedPriceList"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetResolvedPriceList( customerAccountId, responseFields);
/// var resolvedPriceListClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.ResolvedPriceList> GetResolvedPriceListClient(int?customerAccountId = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.PriceListUrl.GetResolvedPriceListUrl(customerAccountId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.ResolvedPriceList>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="accountId">Unique identifier of the customer account.</param>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteAccountAttribute( accountId, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteAccountAttributeClient(int accountId, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.DeleteAccountAttributeUrl(accountId, attributeFQN);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="accountId">Unique identifier of the customer account.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="attribute">Properties of an attribute associated with a customer account.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAttribute"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddAccountAttribute( attribute, accountId, responseFields);
/// var customerAttributeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Customer.CustomerAttribute> AddAccountAttributeClient(Mozu.Api.Contracts.Customer.CustomerAttribute attribute, int accountId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.AddAccountAttributeUrl(accountId, responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Customer.CustomerAttribute>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.Customer.CustomerAttribute>(attribute);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="developerAccountId">Unique identifier of the developer account.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="existingAuthTicket">Properties of the authentication ticket to be used in developer account claims with the API.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=RefreshDeveloperAuthTicket( existingAuthTicket, developerAccountId, responseFields);
/// var developerAdminUserAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket> RefreshDeveloperAuthTicketClient(Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket existingAuthTicket, int?developerAccountId = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Platform.Developer.DeveloperAdminUserAuthTicketUrl.RefreshDeveloperAuthTicketUrl(developerAccountId, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket>(existingAuthTicket);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="accountId">Unique identifier of the customer account.</param>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Customer.CustomerAttribute"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetAccountAttribute( accountId, attributeFQN, responseFields);
/// var customerAttributeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Customer.CustomerAttribute> GetAccountAttributeClient(int accountId, string attributeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Customer.Accounts.CustomerAttributeUrl.GetAccountAttributeUrl(accountId, attributeFQN, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Customer.CustomerAttribute>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleSortFields"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetSearchTuningRuleSortFields( responseFields);
/// var searchTuningRuleSortFieldsClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleSortFields> GetSearchTuningRuleSortFieldsClient(string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.GetSearchTuningRuleSortFieldsUrl(responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleSortFields>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="refreshToken">Alphanumeric string used for access tokens. This token refreshes access for accounts by generating a new developer or application account authentication ticket after an access token expires.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteUserAuthTicket( refreshToken);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteUserAuthTicketClient(string refreshToken)
{
var url = Mozu.Api.Urls.Platform.Developer.DeveloperAdminUserAuthTicketUrl.DeleteUserAuthTicketUrl(refreshToken);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="synonymId">The unique identifier of the synonym definition.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteSynonymDefinition( synonymId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteSynonymDefinitionClient(int synonymId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.DeleteSynonymDefinitionUrl(synonymId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="developerAccountId">Unique identifier of the developer account.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="userAuthInfo">Information required to authenticate a user.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateDeveloperUserAuthTicket( userAuthInfo, developerAccountId, responseFields);
/// var developerAdminUserAuthTicketClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket> CreateDeveloperUserAuthTicketClient(Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int?developerAccountId = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Platform.Developer.DeveloperAdminUserAuthTicketUrl.CreateDeveloperUserAuthTicketUrl(developerAccountId, responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.Core.UserAuthInfo>(userAuthInfo);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="synonymId">The unique identifier of the synonym definition.</param>
/// <param name="synonymDefinition">The updated synonym definition details.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinition"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateSynonymDefinition( synonymDefinition, synonymId, responseFields);
/// var synonymDefinitionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinition> UpdateSynonymDefinitionClient(Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinition synonymDefinition, int synonymId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.UpdateSynonymDefinitionUrl(synonymId, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinition>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinition>(synonymDefinition);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="filter">A set of filter expressions representing the search parameters for a query. This parameter is optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for a list of supported filters.</param>
/// <param name="pageSize">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with this parameter set to 25, to get the 51st through the 75th items, set startIndex to 50.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="sortBy">The element to sort the results by and the channel in which the results appear. Either ascending (a-z) or descending (z-a) channel. Optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for more information.</param>
/// <param name="startIndex">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with pageSize set to 25, to get the 51st through the 75th items, set this parameter to 50.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetSearchTuningRules( startIndex, pageSize, sortBy, filter, responseFields);
/// var searchTuningRuleCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleCollection> GetSearchTuningRulesClient(int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.GetSearchTuningRulesUrl(startIndex, pageSize, sortBy, filter, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRuleCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="searchTuningRuleCode">The unique identifier of the search tuning rule.</param>
/// <param name="searchTuningRuleIn">The details of the updated search tuning rule.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRule"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateSearchTuningRule( searchTuningRuleIn, searchTuningRuleCode, responseFields);
/// var searchTuningRuleClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRule> UpdateSearchTuningRuleClient(Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRule searchTuningRuleIn, string searchTuningRuleCode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.UpdateSearchTuningRuleUrl(searchTuningRuleCode, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRule>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.Search.SearchTuningRule>(searchTuningRuleIn);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="searchTuningRuleCode">The unique identifier of the search tuning rule.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteSearchTuningRule( searchTuningRuleCode);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteSearchTuningRuleClient(string searchTuningRuleCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.DeleteSearchTuningRuleUrl(searchTuningRuleCode);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="definition">Properties of an external payment processing workflow defined for the site. At this time, only PayPal Express is supported.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddThirdPartyPaymentWorkflow( definition);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient AddThirdPartyPaymentWorkflowClient(Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition definition)
{
var url = Mozu.Api.Urls.Commerce.Settings.Checkout.PaymentSettingsUrl.AddThirdPartyPaymentWorkflowUrl();
const string verb = "PUT";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition>(definition);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="settings">The search settings to update.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.SearchSettings"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateSettings( settings, responseFields);
/// var searchSettingsClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.SearchSettings> UpdateSettingsClient(Mozu.Api.Contracts.ProductAdmin.SearchSettings settings, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.UpdateSettingsUrl(responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.SearchSettings>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.SearchSettings>(settings);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="fullyQualifiedName">Fully qualified name of the attribute for the third-party payment workflow.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetThirdPartyPaymentWorkflowWithValues( fullyQualifiedName, responseFields);
/// var externalPaymentWorkflowDefinitionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition> GetThirdPartyPaymentWorkflowWithValuesClient(string fullyQualifiedName, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Settings.Checkout.PaymentSettingsUrl.GetThirdPartyPaymentWorkflowWithValuesUrl(fullyQualifiedName, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="localeCode">The two character country code that sets the locale, such as US for United States. Sites, tenants, and catalogs use locale codes for localizing content, such as translated product text per supported country.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinitionCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetSynonymDefinitionCollection( localeCode, responseFields);
/// var synonymDefinitionCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinitionCollection> GetSynonymDefinitionCollectionClient(string localeCode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.SearchUrl.GetSynonymDefinitionCollectionUrl(localeCode, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Search.SynonymDefinitionCollection>()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="key">Key used for metadata defined for objects, including extensible attributes, custom attributes associated with a shipping provider, and search synonyms definitions. This content may be user-defined depending on the object and usage.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="upsert">Any set of key value pairs to be stored in the extended properties of a cart.</param>
/// <param name="extendedProperty">The details of the updated extended property.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateExtendedProperty( extendedProperty, key, upsert, responseFields);
/// var extendedPropertyClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty> UpdateExtendedPropertyClient(Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty extendedProperty, string key, bool?upsert = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Carts.ExtendedPropertyUrl.UpdateExtendedPropertyUrl(key, upsert, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty>(extendedProperty);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetThirdPartyPaymentWorkflows();
/// var externalPaymentWorkflowDefinitionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition> > GetThirdPartyPaymentWorkflowsClient()
{
var url = Mozu.Api.Urls.Commerce.Settings.Checkout.PaymentSettingsUrl.GetThirdPartyPaymentWorkflowsUrl();
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.SiteSettings.Order.ExternalPaymentWorkflowDefinition> >()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="extendedProperties">The details of the new extended property.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddExtendedProperties( extendedProperties);
/// var extendedPropertyClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty> > AddExtendedPropertiesClient(List <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty> extendedProperties)
{
var url = Mozu.Api.Urls.Commerce.Carts.ExtendedPropertyUrl.AddExtendedPropertiesUrl();
const string verb = "POST";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty> >()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <List <Mozu.Api.Contracts.CommerceRuntime.Commerce.ExtendedProperty> >(extendedProperties);
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="fullyQualifiedName">Fully qualified name of the attribute for the third-party payment workflow.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteThirdPartyPaymentWorkflow( fullyQualifiedName);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteThirdPartyPaymentWorkflowClient(string fullyQualifiedName)
{
var url = Mozu.Api.Urls.Commerce.Settings.Checkout.PaymentSettingsUrl.DeleteThirdPartyPaymentWorkflowUrl(fullyQualifiedName);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
;
return(mozuClient);
}
