/// <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.
/// <example>
/// <code>
/// var result = ProductFactory.ConfiguredProduct(handler : handler, productOptionSelections : productOptionSelections, productCode : productCode, includeOptionDetails : includeOptionDetails, skipInventoryCheck : skipInventoryCheck, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<ConfiguredProduct/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct ConfiguredProduct(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.ProductRuntime.ProductOptionSelections productOptionSelections, string productCode, bool? includeOptionDetails = null, bool? skipInventoryCheck = null,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.Catalog.Storefront.ProductClient.ConfiguredProductClient(
productOptionSelections : productOptionSelections, productCode : productCode, includeOptionDetails : includeOptionDetails, skipInventoryCheck : skipInventoryCheck );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
///
/// <example>
/// <code>
/// var result = OrderTaxContextFactory.EstimateTaxes(handler : handler, taxableOrder : taxableOrder, responseFields : responseFields, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<OrderTaxContext/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.PricingRuntime.OrderTaxContext EstimateTaxes(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.PricingRuntime.TaxableOrder taxableOrder, string responseFields = null,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.Catalog.Storefront.OrderTaxContextClient.EstimateTaxesClient(
taxableOrder : taxableOrder, responseFields : responseFields );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
///
/// <example>
/// <code>
/// var result = ApplicationFactory.UpdateApplication(handler : handler, application : application, appId : appId, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<Application/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.InstalledApplications.Application UpdateApplication(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.InstalledApplications.Application application, string appId,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Platform.ApplicationClient.UpdateApplicationClient(
application : application, appId : appId );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
///
/// <example>
/// <code>
/// var result = CredentialStoreEntryFactory.StoreCredentials(handler : handler, credentials : credentials, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<void/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static void StoreCredentials(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.InstalledApplications.CredentialStoreEntry credentials,
HttpStatusCode expectedCode = HttpStatusCode.NoContent, HttpStatusCode successCode = HttpStatusCode.NoContent)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Platform.Extensions.CredentialStoreEntryClient.StoreCredentialsClient(
credentials : credentials );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
}
var noResponse = ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Assigns or associates an existing discount to a specified coupon set. Use the couponSetCode parameter to specify the coupon set.
/// <example>
/// <code>
/// var result = AssignedDiscountFactory.AssignDiscount(handler : handler, assignedDiscount : assignedDiscount, couponSetCode : couponSetCode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<void/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static void AssignDiscount(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.ProductAdmin.AssignedDiscount assignedDiscount, string couponSetCode,
HttpStatusCode expectedCode = HttpStatusCode.NoContent, HttpStatusCode successCode = HttpStatusCode.NoContent)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.Couponsets.AssignedDiscountClient.AssignDiscountClient(
assignedDiscount : assignedDiscount, couponSetCode : couponSetCode );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
}
var noResponse = ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Applies a price adjustment to the specified order.
/// <example>
/// <code>
/// var result = AdjustmentFactory.ApplyAdjustment(handler : handler, adjustment : adjustment, orderId : orderId, updateMode : updateMode, version : version, responseFields : responseFields, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<Order/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.CommerceRuntime.Orders.Order ApplyAdjustment(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.CommerceRuntime.Commerce.Adjustment adjustment, string orderId, string updateMode = null, string version = null, string responseFields = null,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.Orders.AdjustmentClient.ApplyAdjustmentClient(
adjustment : adjustment, orderId : orderId, updateMode : updateMode, version : version, responseFields : responseFields );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
///
/// <example>
/// <code>
/// var result = DocumentListTypeFactory.UpdateDocumentListType(handler : handler, list : list, documentListTypeFQN : documentListTypeFQN, responseFields : responseFields, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<DocumentListType/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.Content.DocumentListType UpdateDocumentListType(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.Content.DocumentListType list, string documentListTypeFQN, string responseFields = null,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Content.DocumentListTypeClient.UpdateDocumentListTypeClient(
list : list, documentListTypeFQN : documentListTypeFQN, responseFields : responseFields );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Creates a new channel that defines a new logical business division to use for financial reporting.
/// <example>
/// <code>
/// var result = ChannelFactory.CreateChannel(handler : handler, channel : channel, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<Channel/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.CommerceRuntime.Channels.Channel CreateChannel(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.CommerceRuntime.Channels.Channel channel,
HttpStatusCode expectedCode = HttpStatusCode.Created, HttpStatusCode successCode = HttpStatusCode.Created)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.ChannelClient.CreateChannelClient(
channel : channel );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Publishes the draft version of product changes for each product code specified in the request, and changes the product publish state to "live".
/// </summary>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="publishScope">Properties of the pending product changes to include in this operation.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var publishingscope = new PublishingScope();
/// publishingscope.PublishDrafts(dataViewMode, publishScope);
/// </code>
/// </example>
public virtual void PublishDrafts(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.PublishingScope publishScope)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.PublishingScopeClient.PublishDraftsClient(dataViewMode, publishScope);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Configures a property attribute for the product specified in the request.
/// <example>
/// <code>
/// var result = ProductPropertyFactory.AddProperty(handler : handler, productProperty : productProperty, productCode : productCode, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<ProductProperty/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductAdmin.ProductProperty AddProperty(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.ProductAdmin.ProductProperty productProperty, string productCode, DataViewMode dataViewMode= DataViewMode.Live,
HttpStatusCode expectedCode = HttpStatusCode.Created, HttpStatusCode successCode = HttpStatusCode.Created)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.AddPropertyClient(
productProperty : productProperty, productCode : productCode, dataViewMode: dataViewMode );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Generates a new developer account authentication ticket for the specified tenant by supplying the defined refresh token information.
/// <example>
/// <code>
/// var result = PublicDeveloperAdminAuthTicketFactory.RefreshDeveloperAuthTicket(handler : handler, existingAuthTicket : existingAuthTicket, developerAccountId : developerAccountId, responseFields : responseFields, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<DeveloperAdminUserAuthTicket/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket RefreshDeveloperAuthTicket(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket existingAuthTicket, int? developerAccountId = null, string responseFields = null,
HttpStatusCode expectedCode = HttpStatusCode.OK, HttpStatusCode successCode = HttpStatusCode.OK)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Platform.Developer.DeveloperAdminUserAuthTicketClient.RefreshDeveloperAuthTicketClient(
existingAuthTicket : existingAuthTicket, developerAccountId : developerAccountId, responseFields : responseFields );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Creates an authentication ticket for the supplied user to specify in API requests associated with the supplied tenant.
/// <example>
/// <code>
/// var result = TenantAdminUserAuthTicketFactory.CreateUserAuthTicket(handler : handler, userAuthInfo : userAuthInfo, tenantId : tenantId, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<TenantAdminUserAuthTicket/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.AdminUser.TenantAdminUserAuthTicket CreateUserAuthTicket(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int? tenantId = null,
HttpStatusCode expectedCode = HttpStatusCode.Created, HttpStatusCode successCode = HttpStatusCode.Created)
{
SetSdKparameters();
var currentClassName = System.Reflection.MethodInfo.GetCurrentMethod().DeclaringType.Name;
var currentMethodName = System.Reflection.MethodBase.GetCurrentMethod().Name;
Debug.WriteLine(currentMethodName + '.' + currentMethodName );
var apiClient = Mozu.Api.Clients.Platform.Adminuser.TenantAdminUserAuthTicketClient.CreateUserAuthTicketClient(
userAuthInfo : userAuthInfo, tenantId : tenantId );
try
{
apiClient.WithContext(handler.ApiContext).Execute();
}
catch (ApiException ex)
{
// Custom error handling for test cases can be placed here
Exception customException = TestFailException.GetCustomTestException(ex, currentClassName, currentMethodName, expectedCode);
if (customException != null)
throw customException;
return null;
}
return ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Creates a new customer account based on the information specified in the request.
/// </summary>
/// <param name="account">Properties of the customer account to update.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Customer.CustomerAccount"/>
/// </returns>
/// <example>
/// <code>
/// var customeraccount = new CustomerAccount();
/// var customerAccount = customeraccount.AddAccount( account);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Customer.CustomerAccount AddAccount(Mozu.Api.Contracts.Customer.CustomerAccount account)
{
MozuClient<Mozu.Api.Contracts.Customer.CustomerAccount> response;
var client = Mozu.Api.Clients.Commerce.Customer.CustomerAccountClient.AddAccountClient( account);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="orderId"></param>
/// <param name="validationResult"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult"/>
/// </returns>
/// <example>
/// <code>
/// var ordervalidationresult = new OrderValidationResult();
/// var orderValidationResult = ordervalidationresult.AddValidationResult( validationResult, orderId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult AddValidationResult(Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult validationResult, string orderId)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.OrderValidationResult> response;
var client = Mozu.Api.Clients.Commerce.Orders.OrderValidationResultClient.AddValidationResultClient( validationResult, orderId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="userAuthInfo"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>
/// </returns>
/// <example>
/// <code>
/// var customerauthticket = new CustomerAuthTicket();
/// var customerAuthTicket = customerauthticket.CreateUserAuthTicket( userAuthInfo);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Customer.CustomerAuthTicket CreateUserAuthTicket(Mozu.Api.Contracts.Customer.CustomerUserAuthInfo userAuthInfo)
{
MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> response;
var client = Mozu.Api.Clients.Commerce.Customer.CustomerAuthTicketClient.CreateUserAuthTicketClient( userAuthInfo);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new payment transaction for the specified order and performs the specified action.
/// </summary>
/// <param name="orderId">Unique identifier of the order for which to apply the payment.</param>
/// <param name="action">To action to perform for the newly created payment. Possible values are AuthAndCapture, AuthorizePayment, CapturePayment, VoidPayment, CreditPayment, RequestCheck, ApplyCheck, DeclineCheck.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.Order"/>
/// </returns>
/// <example>
/// <code>
/// var payment = new Payment();
/// var order = payment.CreatePaymentAction( action, orderId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.Order CreatePaymentAction(Mozu.Api.Contracts.CommerceRuntime.Payments.PaymentAction action, string orderId)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.Order> response;
var client = Mozu.Api.Clients.Commerce.Orders.PaymentClient.CreatePaymentActionClient( action, orderId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Assigns an option attribute to the product type based on the information supplied in the request.
/// </summary>
/// <param name="productTypeId">Identifier of the product type.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="attributeInProductType">Properties of the option attribute to define for the specified product type.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.AttributeInProductType"/>
/// </returns>
/// <example>
/// <code>
/// var producttypeoption = new ProductTypeOption();
/// var attributeInProductType = producttypeoption.AddOption(dataViewMode, attributeInProductType, productTypeId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.AttributeInProductType AddOption(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.AttributeInProductType attributeInProductType, int productTypeId)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionClient.AddOptionClient(dataViewMode, attributeInProductType, productTypeId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <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.Contracts.CommerceRuntime.Returns.Return"/>
/// </returns>
/// <example>
/// <code>
/// var return = new Return();
/// var return = return.CreateReturn( ret);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Returns.Return CreateReturn(Mozu.Api.Contracts.CommerceRuntime.Returns.Return ret)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> response;
var client = Mozu.Api.Clients.Commerce.ReturnClient.CreateReturnClient( ret);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="locationType"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Location.LocationType"/>
/// </returns>
/// <example>
/// <code>
/// var locationtype = new LocationType();
/// var locationType = locationtype.AddLocationType( locationType);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Location.LocationType AddLocationType(Mozu.Api.Contracts.Location.LocationType locationType)
{
MozuClient<Mozu.Api.Contracts.Location.LocationType> response;
var client = Mozu.Api.Clients.Commerce.Admin.LocationTypeClient.AddLocationTypeClient( locationType);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Configures a property attribute for the product specified in the request.
/// </summary>
/// <param name="productCode"></param>
/// <param name="productProperty">Properties of the property attribute to configure for a product.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.ProductProperty"/>
/// </returns>
/// <example>
/// <code>
/// var productproperty = new ProductProperty();
/// var productProperty = productproperty.AddProperty(dataViewMode, productProperty, productCode);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.ProductProperty AddProperty(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductProperty productProperty, string productCode)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductProperty> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.AddPropertyClient(dataViewMode, productProperty, productCode);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new document in an existing list.
/// </summary>
/// <param name="documentListName">The descriptive alphanumeric document list name being created.</param>
/// <param name="document">The descriptive name of the newly created document.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Content.Document"/>
/// </returns>
/// <example>
/// <code>
/// var document = new Document();
/// var document = document.CreateDocument(dataViewMode, document, documentListName);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Content.Document CreateDocument(DataViewMode dataViewMode, Mozu.Api.Contracts.Content.Document document, string documentListName)
{
MozuClient<Mozu.Api.Contracts.Content.Document> response;
var client = Mozu.Api.Clients.Content.Documentlists.DocumentClient.CreateDocumentClient(dataViewMode, document, documentListName);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="appId"></param>
/// <param name="application"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.InstalledApplications.Application"/>
/// </returns>
/// <example>
/// <code>
/// var application = new Application();
/// var application = application.UpdateApplication( application, appId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.InstalledApplications.Application UpdateApplication(Mozu.Api.Contracts.InstalledApplications.Application application, string appId)
{
MozuClient<Mozu.Api.Contracts.InstalledApplications.Application> response;
var client = Mozu.Api.Clients.Platform.ApplicationClient.UpdateApplicationClient( application, appId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="accountAndAuthInfo"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Customer.CustomerAuthTicket"/>
/// </returns>
/// <example>
/// <code>
/// var customeraccount = new CustomerAccount();
/// var customerAuthTicket = customeraccount.AddAccountAndLogin( accountAndAuthInfo);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Customer.CustomerAuthTicket AddAccountAndLogin(Mozu.Api.Contracts.Customer.CustomerAccountAndAuthInfo accountAndAuthInfo)
{
MozuClient<Mozu.Api.Contracts.Customer.CustomerAuthTicket> response;
var client = Mozu.Api.Clients.Commerce.Customer.CustomerAccountClient.AddAccountAndLoginClient( accountAndAuthInfo);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Generate an authentication ticket for a developer account.
/// </summary>
/// <param name="developerAccountId">Unique identifier of the developer account.</param>
/// <param name="userAuthInfo">The user authentication information required to generate the developer account user authentication ticket, which consists of a user name and password.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket"/>
/// </returns>
/// <example>
/// <code>
/// var developeradminuserauthticket = new DeveloperAdminUserAuthTicket();
/// var developerAdminUserAuthTicket = developeradminuserauthticket.CreateDeveloperUserAuthTicket( userAuthInfo, developerAccountId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket CreateDeveloperUserAuthTicket(Mozu.Api.Contracts.Core.UserAuthInfo userAuthInfo, int? developerAccountId = null)
{
MozuClient<Mozu.Api.Contracts.AdminUser.DeveloperAdminUserAuthTicket> response;
var client = Mozu.Api.Clients.Platform.Developer.DeveloperAdminUserAuthTicketClient.CreateDeveloperUserAuthTicketClient( userAuthInfo, developerAccountId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <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.Contracts.ProductRuntime.ConfiguredProduct"/>
/// </returns>
/// <example>
/// <code>
/// var product = new Product();
/// var configuredProduct = product.ConfiguredProduct( productOptionSelections, productCode, includeOptionDetails, skipInventoryCheck);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct ConfiguredProduct(Mozu.Api.Contracts.ProductRuntime.ProductOptionSelections productOptionSelections, string productCode, bool? includeOptionDetails = null, bool? skipInventoryCheck = null)
{
MozuClient<Mozu.Api.Contracts.ProductRuntime.ConfiguredProduct> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Storefront.ProductClient.ConfiguredProductClient( productOptionSelections, productCode, includeOptionDetails, skipInventoryCheck);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Applies a price adjustment to the specified order.
/// </summary>
/// <param name="orderId">Unique identifier of the order for which to apply the adjustment.</param>
/// <param name="updateMode">Specifies whether to apply the adjustment by updating the original order, updating the order in draft mode, or updating the order in draft mode and then committing the changes to the original. Draft mode enables users to make incremental order changes before committing the changes to the original order. Valid values are "ApplyToOriginal," "ApplyToDraft," or "ApplyAndCommit."</param>
/// <param name="version">System-supplied integer that represents the current version of the order, which prevents users from unintentionally overriding changes to the order. When a user performs an operation for a defined order, the system validates that the version of the updated order matches the version of the order on the server. After the operation completes successfully, the system increments the version number by one.</param>
/// <param name="adjustment">Properties of the price adjustment to apply to the order.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.Order"/>
/// </returns>
/// <example>
/// <code>
/// var adjustment = new Adjustment();
/// var order = adjustment.ApplyAdjustment( adjustment, orderId, updateMode, version);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.Order ApplyAdjustment(Mozu.Api.Contracts.CommerceRuntime.Commerce.Adjustment adjustment, string orderId, string updateMode = null, string version = null)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.Order> response;
var client = Mozu.Api.Clients.Commerce.Orders.AdjustmentClient.ApplyAdjustmentClient( adjustment, orderId, updateMode, version);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <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.Contracts.CommerceRuntime.Returns.Return"/>
/// </returns>
/// <example>
/// <code>
/// var return = new Return();
/// var return = return.CreatePaymentActionForReturn( action, returnId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Returns.Return CreatePaymentActionForReturn(Mozu.Api.Contracts.CommerceRuntime.Payments.PaymentAction action, string returnId)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Returns.Return> response;
var client = Mozu.Api.Clients.Commerce.ReturnClient.CreatePaymentActionForReturnClient( action, returnId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new territory for which to calculate sales tax.
/// </summary>
/// <param name="taxableTerritory">Properties of the taxable territory to create.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.SiteSettings.General.TaxableTerritory"/>
/// </returns>
/// <example>
/// <code>
/// var taxableterritory = new TaxableTerritory();
/// var taxableTerritory = taxableterritory.AddTaxableTerritory( taxableTerritory);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.SiteSettings.General.TaxableTerritory AddTaxableTerritory(Mozu.Api.Contracts.SiteSettings.General.TaxableTerritory taxableTerritory)
{
MozuClient<Mozu.Api.Contracts.SiteSettings.General.TaxableTerritory> response;
var client = Mozu.Api.Clients.Commerce.Settings.General.TaxableTerritoryClient.AddTaxableTerritoryClient( taxableTerritory);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new order for no-cart quick-ordering scenarios.
/// </summary>
/// <param name="order">All properties of the order to place.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.CommerceRuntime.Orders.Order"/>
/// </returns>
/// <example>
/// <code>
/// var order = new Order();
/// var order = order.CreateOrder( order);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.CommerceRuntime.Orders.Order CreateOrder(Mozu.Api.Contracts.CommerceRuntime.Orders.Order order)
{
MozuClient<Mozu.Api.Contracts.CommerceRuntime.Orders.Order> response;
var client = Mozu.Api.Clients.Commerce.OrderClient.CreateOrderClient( order);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new transaction and updates the amount of a store credit or gift card.
/// </summary>
/// <param name="code">User-defined code that identifies the customer credit to update.</param>
/// <param name="creditTransaction">Properties of the transaction to create for the customer credit.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Customer.Credit.CreditTransaction"/>
/// </returns>
/// <example>
/// <code>
/// var credittransaction = new CreditTransaction();
/// var creditTransaction = credittransaction.AddTransaction( creditTransaction, code);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Customer.Credit.CreditTransaction AddTransaction(Mozu.Api.Contracts.Customer.Credit.CreditTransaction creditTransaction, string code)
{
MozuClient<Mozu.Api.Contracts.Customer.Credit.CreditTransaction> response;
var client = Mozu.Api.Clients.Commerce.Customer.Credits.CreditTransactionClient.AddTransactionClient( creditTransaction, code);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
