/// <summary>
/// Deletes the content associated with a document, such as a product image or PDF specifications file.
/// </summary>
/// <param name="documentListName">The name of the document list associated with the document.</param>
/// <param name="documentName">The name of the document, which is unique within its folder.</param>
/// <param name="stream"></param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var documenttree = new DocumentTree();
/// documenttree.DeleteTreeDocumentContent(dataViewMode, stream, documentListName, documentName, contentType);
/// </code>
/// </example>
public virtual void DeleteTreeDocumentContent(DataViewMode dataViewMode, System.IO.Stream stream, string documentListName, string documentName, String contentType= null)
{
MozuClient response;
var client = Mozu.Api.Clients.Content.Documentlists.DocumentTree.DocumentTreeClient.DeleteTreeDocumentContentClient(dataViewMode, stream, documentListName, documentName, contentType);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
///
/// <example>
/// <code>
/// var result = DocumentTypeFactory.GetDocumentTypes(handler : handler, pageSize : pageSize, startIndex : startIndex, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<DocumentTypeCollection/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.Content.DocumentTypeCollection GetDocumentTypes(ServiceClientMessageHandler handler,
int? pageSize = null, int? startIndex = null, DataViewMode dataViewMode= DataViewMode.Live,
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.DocumentTypeClient.GetDocumentTypesClient(
pageSize : pageSize, startIndex : startIndex, 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>
/// Deletes a defined product attribute. You cannot delete an attribute assigned a value for a product.
/// </summary>
/// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var attribute = new Attribute();
/// attribute.DeleteAttribute(dataViewMode, attributeFQN);
/// </code>
/// </example>
public virtual void DeleteAttribute(DataViewMode dataViewMode, string attributeFQN)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.AttributeClient.DeleteAttributeClient(dataViewMode, attributeFQN);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Retrieves the details of an extra attribute definition for the specified product type.
/// <example>
/// <code>
/// var result = ProductTypeExtraFactory.GetExtra(handler : handler, productTypeId : productTypeId, attributeFQN : attributeFQN, responseFields : responseFields, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<AttributeInProductType/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductAdmin.AttributeInProductType GetExtra(ServiceClientMessageHandler handler,
int productTypeId, string attributeFQN, string responseFields = null, DataViewMode dataViewMode= DataViewMode.Live,
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.Admin.Attributedefinition.Producttypes.ProductTypeExtraClient.GetExtraClient(
productTypeId : productTypeId, attributeFQN : attributeFQN, responseFields : responseFields, 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>
/// Deletes the configuration of a property attribute for the product specified in the request.
/// </summary>
/// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
/// <param name="productCode"></param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var productproperty = new ProductProperty();
/// productproperty.DeleteProperty(dataViewMode, productCode, attributeFQN);
/// </code>
/// </example>
public virtual void DeleteProperty(DataViewMode dataViewMode, string productCode, string attributeFQN)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductPropertyClient.DeletePropertyClient(dataViewMode, productCode, attributeFQN);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Deletes a discount specified by its discount ID.
/// <example>
/// <code>
/// var result = DiscountFactory.DeleteDiscount(handler : handler, discountId : discountId, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<void/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static void DeleteDiscount(ServiceClientMessageHandler handler,
int discountId, DataViewMode dataViewMode= DataViewMode.Live,
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.DiscountClient.DeleteDiscountClient(
discountId : discountId, 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;
}
var noResponse = ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
/// <summary>
/// Deletes the drafts of the specified documents. Published documents cannot be deleted.
/// </summary>
/// <param name="documentLists">List of document lists that contain documents to delete.</param>
/// <param name="documentIds">Unique identifiers of the documents to delete.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var documentdraftsummary = new DocumentDraftSummary();
/// documentdraftsummary.DeleteDocumentDrafts(dataViewMode, documentIds, documentLists);
/// </code>
/// </example>
public virtual void DeleteDocumentDrafts(DataViewMode dataViewMode, List<string> documentIds, string documentLists = null)
{
MozuClient response;
var client = Mozu.Api.Clients.Content.DocumentDraftSummaryClient.DeleteDocumentDraftsClient(dataViewMode, documentIds, documentLists);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Retrieves a list of all product inventory definitions for the location code specified in the request.
/// <example>
/// <code>
/// var result = LocationInventoryFactory.GetLocationInventories(handler : handler, locationCode : locationCode, startIndex : startIndex, pageSize : pageSize, sortBy : sortBy, filter : filter, filterFunctions : filterFunctions, responseFields : responseFields, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<LocationInventoryCollection/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection GetLocationInventories(ServiceClientMessageHandler handler,
string locationCode, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null, string filterFunctions = null, string responseFields = null, DataViewMode dataViewMode= DataViewMode.Live,
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.Admin.LocationInventoryClient.GetLocationInventoriesClient(
locationCode : locationCode, startIndex : startIndex, pageSize : pageSize, sortBy : sortBy, filter : filter, filterFunctions : filterFunctions, responseFields : responseFields, 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>
/// Removes an option attribute definition for the specified product type.
/// </summary>
/// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
/// <param name="productTypeId">Identifier of the product type.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var producttypeoption = new ProductTypeOption();
/// producttypeoption.DeleteOption(dataViewMode, productTypeId, attributeFQN);
/// </code>
/// </example>
public virtual void DeleteOption(DataViewMode dataViewMode, int productTypeId, string attributeFQN)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionClient.DeleteOptionClient(dataViewMode, productTypeId, attributeFQN);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Deletes a variation, based on the supplied variation key, for the specified product code.
/// </summary>
/// <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="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var productvariation = new ProductVariation();
/// productvariation.DeleteProductVariation(dataViewMode, productCode, variationKey);
/// </code>
/// </example>
public virtual void DeleteProductVariation(DataViewMode dataViewMode, string productCode, string variationKey)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductVariationClient.DeleteProductVariationClient(dataViewMode, productCode, variationKey);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <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>
/// Deletes a discount specified by its discount ID.
/// </summary>
/// <param name="discountId">Unique identifier of the discount. System-supplied and read-only.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var discount = new Discount();
/// discount.DeleteDiscount(dataViewMode, discountId);
/// </code>
/// </example>
public virtual void DeleteDiscount(DataViewMode dataViewMode, int discountId)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.DiscountClient.DeleteDiscountClient(dataViewMode, discountId);
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>
/// Deletes a specific document based on the specified document ID.
/// </summary>
/// <param name="documentId">Identifier of the document being deleted.</param>
/// <param name="documentListName">The name of the document list associated with the document list being deleted.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var document = new Document();
/// document.DeleteDocument(dataViewMode, documentListName, documentId);
/// </code>
/// </example>
public virtual void DeleteDocument(DataViewMode dataViewMode, string documentListName, string documentId)
{
MozuClient response;
var client = Mozu.Api.Clients.Content.Documentlists.DocumentClient.DeleteDocumentClient(dataViewMode, documentListName, documentId);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Deletes the facet specified by its unique identifier.
/// </summary>
/// <param name="facetId">Unique identifier of the facet to delete.</param>
/// <returns>
///
/// </returns>
/// <example>
/// <code>
/// var facet = new Facet();
/// facet.DeleteFacetById(dataViewMode, facetId);
/// </code>
/// </example>
public virtual void DeleteFacetById(DataViewMode dataViewMode, int facetId)
{
MozuClient response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.FacetClient.DeleteFacetByIdClient(dataViewMode, facetId);
client.WithContext(_apiContext);
response= client.Execute();
}
/// <summary>
/// Retrieves the properties of facets that aid in indexing and searching.
/// </summary>
/// <param name="documentListName">The document list associated with the facets to retrieve.</param>
/// <param name="propertyName">The property name associated with the facets to retrieve.</param>
/// <returns>
/// List{<see cref="Mozu.Api.Contracts.Content.Facet"/>}
/// </returns>
/// <example>
/// <code>
/// var facet = new Facet();
/// var facet = facet.GetFacets(dataViewMode, documentListName, propertyName);
/// </code>
/// </example>
public virtual List<Mozu.Api.Contracts.Content.Facet> GetFacets(DataViewMode dataViewMode, string documentListName, string propertyName)
{
MozuClient<List<Mozu.Api.Contracts.Content.Facet>> response;
var client = Mozu.Api.Clients.Content.Documentlists.FacetClient.GetFacetsClient(dataViewMode, documentListName, propertyName);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new attribute to describe one aspect of a product such as color or size, based on its defined product type. The attribute name, attribute type, input type, and data type are required.
/// </summary>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="attribute">Properties of the new product attribute to create.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.Attribute"/>
/// </returns>
/// <example>
/// <code>
/// var attribute = new Attribute();
/// var attribute = attribute.AddAttribute(dataViewMode, attribute);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.Attribute AddAttribute(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Attribute attribute)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.Attribute> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.AttributeClient.AddAttributeClient(dataViewMode, attribute);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a discount.
/// </summary>
/// <param name="discount">Properties of the discount to create. Required properties: Content.Name, AmountType, StartDate, and Target.Type.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.Discount"/>
/// </returns>
/// <example>
/// <code>
/// var discount = new Discount();
/// var discount = discount.CreateDiscount(dataViewMode, discount);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.Discount CreateDiscount(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Discount discount)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.Discount> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.DiscountClient.CreateDiscountClient(dataViewMode, discount);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Adds a new category to the site's category hierarchy. Specify a ParentCategoryID to determine where to locate the category in the hierarchy. If a ParentCategoryID is not specified, the new category becomes a top-level category.
/// </summary>
/// <param name="incrementSequence"></param>
/// <param name="category">Properties of the new category. Required properties: ParentCategoryID and Content.Name.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.Category"/>
/// </returns>
/// <example>
/// <code>
/// var category = new Category();
/// var category = category.AddCategory(dataViewMode, category, incrementSequence);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.Category AddCategory(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Category category, bool? incrementSequence = null)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.Category> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.CategoryClient.AddCategoryClient(dataViewMode, category, incrementSequence);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates a new category, price, or attribute facet. Supply the category or attribute source to use for the facet values.
/// </summary>
/// <param name="facet">Properties of the new facet to create. Required properties: Source, FacetType, IsHidden, and CategoryId.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.Facet"/>
/// </returns>
/// <example>
/// <code>
/// var facet = new Facet();
/// var facet = facet.AddFacet(dataViewMode, facet);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.Facet AddFacet(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Facet facet)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.Facet> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.FacetClient.AddFacetClient(dataViewMode, facet);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Retrieve the details of the master catalog specified in the request.
/// </summary>
/// <param name="masterCatalogId"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.MasterCatalog"/>
/// </returns>
/// <example>
/// <code>
/// var mastercatalog = new MasterCatalog();
/// var masterCatalog = mastercatalog.GetMasterCatalog(dataViewMode, masterCatalogId);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.MasterCatalog GetMasterCatalog(DataViewMode dataViewMode, int masterCatalogId)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalog> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.MasterCatalogClient.GetMasterCatalogClient(dataViewMode, masterCatalogId);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Creates an array of product inventory definitions for the location specified in the request. When adding a new inventory definition, you must specify the productCode and stockOnHand value in each array you define. All other properties are system-supplied and read only.
/// </summary>
/// <param name="locationCode">User-defined code that uniquely identifies the location.</param>
/// <param name="performUpserts"></param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="locationInventoryList">Array list of product inventory definitions for all associated locations. For each location inventory in the list, define the productCode and stockOnHand values.</param>
/// <returns>
/// List{<see cref="Mozu.Api.Contracts.ProductAdmin.LocationInventory"/>}
/// </returns>
/// <example>
/// <code>
/// var locationinventory = new LocationInventory();
/// var locationInventory = locationinventory.AddLocationInventory(dataViewMode, locationInventoryList, locationCode, performUpserts);
/// </code>
/// </example>
public virtual List<Mozu.Api.Contracts.ProductAdmin.LocationInventory> AddLocationInventory(DataViewMode dataViewMode, List<Mozu.Api.Contracts.ProductAdmin.LocationInventory> locationInventoryList, string locationCode, bool? performUpserts = null)
{
MozuClient<List<Mozu.Api.Contracts.ProductAdmin.LocationInventory>> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.LocationInventory.LocationInventoryClient.AddLocationInventoryClient(dataViewMode, locationInventoryList, locationCode, performUpserts);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// </summary>
/// <param name="skipInventoryCheck"></param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="productReservations"></param>
/// <returns>
/// List{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductReservation"/>}
/// </returns>
/// <example>
/// <code>
/// var productreservation = new ProductReservation();
/// var productReservation = productreservation.AddProductReservations(dataViewMode, productReservations, skipInventoryCheck);
/// </code>
/// </example>
public virtual List<Mozu.Api.Contracts.ProductAdmin.ProductReservation> AddProductReservations(DataViewMode dataViewMode, List<Mozu.Api.Contracts.ProductAdmin.ProductReservation> productReservations, bool? skipInventoryCheck = null)
{
MozuClient<List<Mozu.Api.Contracts.ProductAdmin.ProductReservation>> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.ProductReservationClient.AddProductReservationsClient(dataViewMode, productReservations, skipInventoryCheck);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Generates the variations possible for a product associated with the product type based on the option values supplied in the request.
/// </summary>
/// <param name="filter">A set of expressions that consist of a field, operator, and value and represent search parameter syntax when filtering results of a query. Valid operators include equals (eq), does not equal (ne), greater than (gt), less than (lt), greater than or equal to (ge), less than or equal to (le), starts with (sw), or contains (cont). For example - "filter=IsDisplayed+eq+true"</param>
/// <param name="pageSize">The number of results to display on each page when creating paged results from a query. The maximum value is 200.</param>
/// <param name="productCode"></param>
/// <param name="productTypeId">Unique identifier of the product type.</param>
/// <param name="sortBy">The property by which to sort results and whether the results appear in ascending (a-z) order, represented by ASC or in descending (z-a) order, represented by DESC. The sortBy parameter follows an available property. For example: "sortBy=productCode+asc"</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 a PageSize of 25, to get the 51st through the 75th items, use startIndex=3.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="productOptionsIn">The product option attributes configured for this product type.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection"/>
/// </returns>
/// <example>
/// <code>
/// var producttypevariation = new ProductTypeVariation();
/// var productVariationPagedCollection = producttypevariation.GenerateProductVariations(dataViewMode, productOptionsIn, productTypeId, productCode, startIndex, pageSize, sortBy, filter);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection GenerateProductVariations(DataViewMode dataViewMode, List<Mozu.Api.Contracts.ProductAdmin.ProductOption> productOptionsIn, int productTypeId, string productCode = null, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeVariationClient.GenerateProductVariationsClient(dataViewMode, productOptionsIn, productTypeId, productCode, startIndex, pageSize, sortBy, filter);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Retrieves a list of attribute type rules according to optional filter criteria and sort options. Attribute type rules help drive the behavior of attributes on a storefront page.
/// </summary>
/// <param name="filter">A set of expressions that consist of a field, operator, and value and represent search parameter syntax when filtering results of a query. Valid operators include equals (eq), does not equal (ne), greater than (gt), less than (lt), greater than or equal to (ge), less than or equal to (le), starts with (sw), or contains (cont). For example - "filter=IsDisplayed+eq+true"</param>
/// <param name="pageSize">The number of results to display on each page when creating paged results from a query. The maximum value is 200.</param>
/// <param name="sortBy"></param>
/// <param name="startIndex"></param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection"/>
/// </returns>
/// <example>
/// <code>
/// var attributetyperule = new AttributeTypeRule();
/// var attributeTypeRuleCollection = attributetyperule.GetAttributeTypeRules(dataViewMode, startIndex, pageSize, sortBy, filter);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection GetAttributeTypeRules(DataViewMode dataViewMode, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Attributedefinition.Attributes.AttributeTypeRuleClient.GetAttributeTypeRulesClient(dataViewMode, startIndex, pageSize, sortBy, filter);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
/// Retrieves the details of a product variation based on the supplied product code and variation key.
/// </summary>
/// <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="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariation"/>
/// </returns>
/// <example>
/// <code>
/// var productvariation = new ProductVariation();
/// var productVariation = productvariation.GetProductVariation(dataViewMode, productCode, variationKey);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.ProductAdmin.ProductVariation GetProductVariation(DataViewMode dataViewMode, string productCode, string variationKey)
{
MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariation> response;
var client = Mozu.Api.Clients.Commerce.Catalog.Admin.Products.ProductVariationClient.GetProductVariationClient(dataViewMode, productCode, variationKey);
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>
/// 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 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="propertyTypeName"></param>
/// <returns>
/// <see cref="Mozu.Api.Contracts.Content.PropertyType"/>
/// </returns>
/// <example>
/// <code>
/// var propertytype = new PropertyType();
/// var propertyType = propertytype.GetPropertyType(dataViewMode, propertyTypeName);
/// </code>
/// </example>
public virtual Mozu.Api.Contracts.Content.PropertyType GetPropertyType(DataViewMode dataViewMode, string propertyTypeName)
{
MozuClient<Mozu.Api.Contracts.Content.PropertyType> response;
var client = Mozu.Api.Clients.Content.PropertyTypeClient.GetPropertyTypeClient(dataViewMode, propertyTypeName);
client.WithContext(_apiContext);
response= client.Execute();
return response.Result();
}
/// <summary>
///
/// <example>
/// <code>
/// var result = ProductPropertyFactory.AddProperty(handler : handler, productProperty : productProperty, productCode : productCode, responseFields : responseFields, 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, string responseFields = null, 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, responseFields: responseFields, dataViewMode: dataViewMode);
try
{
apiClient.WithContext(handler.ApiContext).ExecuteAsync(default(CancellationToken)).Wait();
}
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>
///
/// </summary>
/// <param name="categoryId">Unique identifier of the category to modify.</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.Category"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetCategory(dataViewMode, categoryId, responseFields);
/// var categoryClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.Category> GetCategoryClient(DataViewMode dataViewMode, int categoryId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.CategoryUrl.GetCategoryUrl(categoryId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.Category>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// <example>
/// <code>
/// var result = DocumentTypeFactory.GetDocumentTypes(handler : handler, pageSize : pageSize, startIndex : startIndex, responseFields : responseFields, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<DocumentTypeCollection/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.Content.DocumentTypeCollection GetDocumentTypes(ServiceClientMessageHandler handler,
int?pageSize = null, int?startIndex = null, string responseFields = null, DataViewMode dataViewMode = DataViewMode.Live,
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.DocumentTypeClient.GetDocumentTypesClient(
pageSize: pageSize, startIndex: startIndex, responseFields: responseFields, dataViewMode: dataViewMode);
try
{
apiClient.WithContext(handler.ApiContext).ExecuteAsync(default(CancellationToken)).Wait();
}
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>
/// Updates the configuration of an extra attribute for the product specified in the request.
/// </summary>
/// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</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="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="productExtra">Properties of an extra attribute to defined for a product that is associated with a product type that uses the extra. Setting up extras for a product enables shopper-entered information, such as initials for a monogram.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductExtra"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateExtra(dataViewMode, productExtra, productCode, attributeFQN, responseFields);
/// var productExtraClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductExtra> UpdateExtraClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductExtra productExtra, string productCode, string attributeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductExtraUrl.UpdateExtraUrl(productCode, attributeFQN, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductExtra>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.ProductExtra>(productExtra).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
public ProductExtraResource(IApiContext apiContext, DataViewMode dataViewMode)
{
_apiContext = apiContext;
_dataViewMode = dataViewMode;
}
/// <summary>
/// Creates an array of product inventory definitions for the location specified in the request. When adding a new inventory definition, you must specify the productCode and stockOnHand value in each array you define. All other properties are system-supplied and read only.
/// </summary>
/// <param name="locationCode">The unique, user-defined code that identifies a location. </param>
/// <param name="performUpserts">Query string parameter lets the service perform an update for a new or existing record. When run, the update occurs without throwing a conflict exception that the record exists. If true, the updates completes regardless of the record currently existing. By default, if no value is specified, the service assumes this value is false.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="locationInventoryList">Properties of an inventory definition that defines the level of inventory for a specific product at a given location.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.LocationInventory"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddLocationInventory(dataViewMode, locationInventoryList, locationCode, performUpserts);
/// var locationInventoryClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> > AddLocationInventoryClient(DataViewMode dataViewMode, List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> locationInventoryList, string locationCode, bool?performUpserts = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.LocationInventoryUrl.AddLocationInventoryUrl(locationCode, performUpserts);
const string verb = "POST";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> >()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> >(locationInventoryList).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the localized delta price value for a product extra. Localized delta prices are deltas between two differing monetary conversion amounts between countries, such as US Dollar vs Euro.
/// </summary>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <param name="currencyCode">The three character ISO currency code, such as USD for US Dollars.</param>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout Mozu to reference and associate to a product.</param>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="value">The value string to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductExtraValueDeltaPrice"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetExtraValueLocalizedDeltaPrice(dataViewMode, productCode, attributeFQN, value, currencyCode, responseFields);
/// var productExtraValueDeltaPriceClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductExtraValueDeltaPrice> GetExtraValueLocalizedDeltaPriceClient(DataViewMode dataViewMode, string productCode, string attributeFQN, string value, string currencyCode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductExtraUrl.GetExtraValueLocalizedDeltaPriceUrl(productCode, attributeFQN, value, currencyCode, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductExtraValueDeltaPrice>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves a list of the content property types.
/// </summary>
/// <param name="pageSize">The number of results to display on each page when creating paged results from a query. The maximum value is 200.</param>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</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 a PageSize of 25, to get the 51st through the 75th items, use startIndex=3.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.PropertyTypeCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetPropertyTypes(dataViewMode, pageSize, startIndex, responseFields);
/// var propertyTypeCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.PropertyTypeCollection> GetPropertyTypesClient(DataViewMode dataViewMode, int?pageSize = null, int?startIndex = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.PropertyTypeUrl.GetPropertyTypesUrl(pageSize, startIndex, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.PropertyTypeCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
public CategoryResource(IApiContext apiContext, DataViewMode dataViewMode)
{
_apiContext = apiContext;
_dataViewMode = dataViewMode;
}
public LocationInventoryResource(IApiContext apiContext, DataViewMode dataViewMode)
{
_apiContext = apiContext;
_dataViewMode = dataViewMode;
}
/// <summary>
/// Publishes the draft version of product changes (pending product changes) for each product code specified in the request, and changes the product publish state to "live".
/// <example>
/// <code>
/// var result = PublishingScopeFactory.PublishDrafts(handler : handler, publishScope : publishScope, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<void/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static void PublishDrafts(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.ProductAdmin.PublishingScope publishScope, DataViewMode dataViewMode = DataViewMode.Live,
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.PublishingScopeClient.PublishDraftsClient(
publishScope: publishScope, 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;
}
}
var noResponse = ResponseMessageFactory.CheckResponseCodes(apiClient.HttpResponse.StatusCode, expectedCode, successCode)
? (apiClient.Result())
: null;
}
public LocationInventoryResource(IApiContext apiContext)
{
_apiContext = apiContext;
_dataViewMode = DataViewMode.Live;
}
/// <summary>
/// Retrieves a list of all product inventory definitions for the location code specified in the request.
/// <example>
/// <code>
/// var result = LocationInventoryFactory.GetLocationInventories(handler : handler, locationCode : locationCode, startIndex : startIndex, pageSize : pageSize, sortBy : sortBy, filter : filter, responseFields : responseFields, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<LocationInventoryCollection/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection GetLocationInventories(ServiceClientMessageHandler handler,
string locationCode, int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null, DataViewMode dataViewMode = DataViewMode.Live,
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.Admin.LocationInventoryClient.GetLocationInventoriesClient(
locationCode: locationCode, startIndex: startIndex, pageSize: pageSize, sortBy: sortBy, filter: filter, responseFields: responseFields, 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>
/// Updates the active stock on hand inventory of products for the location code specified in the request.
/// <example>
/// <code>
/// var result = LocationInventoryFactory.UpdateLocationInventory(handler : handler, locationInventoryAdjustments : locationInventoryAdjustments, locationCode : locationCode, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<List<LocationInventory>/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> UpdateLocationInventory(ServiceClientMessageHandler handler,
List <Mozu.Api.Contracts.ProductAdmin.LocationInventoryAdjustment> locationInventoryAdjustments, string locationCode, DataViewMode dataViewMode = DataViewMode.Live,
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.Admin.LocationInventoryClient.UpdateLocationInventoryClient(
locationInventoryAdjustments: locationInventoryAdjustments, locationCode: locationCode, 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>
///
/// <example>
/// <code>
/// var result = ProductPropertyFactory.DeletePropertyValueLocalizedContent(handler : handler, productCode : productCode, attributeFQN : attributeFQN, value : value, localeCode : localeCode, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<void/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static void DeletePropertyValueLocalizedContent(ServiceClientMessageHandler handler,
string productCode, string attributeFQN, string value, string localeCode, DataViewMode dataViewMode = DataViewMode.Live,
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.Products.ProductPropertyClient.DeletePropertyValueLocalizedContentClient(
productCode: productCode, attributeFQN: attributeFQN, value: value, localeCode: localeCode, dataViewMode: dataViewMode);
try
{
apiClient.WithContext(handler.ApiContext).ExecuteAsync(default(CancellationToken)).Wait();
}
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;
}
public ProductReservationResource(IApiContext apiContext, DataViewMode dataViewMode)
{
_apiContext = apiContext;
_dataViewMode = dataViewMode;
}
public CategoryResource(IApiContext apiContext)
{
_apiContext = apiContext;
_dataViewMode = DataViewMode.Live;
}
public ProductExtraResource(IApiContext apiContext)
{
_apiContext = apiContext;
_dataViewMode = DataViewMode.Live;
}
/// <summary>
///
/// </summary>
/// <param name="documentId">Unique identifier for a document, used by content and document calls. Document IDs are associated with document types, document type lists, sites, and tenants.</param>
/// <param name="documentListName">Name of content documentListName to delete</param>
/// <param name="includeInactive">Include inactive content.</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.Content.Document"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDocument(dataViewMode, documentListName, documentId, includeInactive, responseFields);
/// var documentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.Document> GetDocumentClient(DataViewMode dataViewMode, string documentListName, string documentId, bool?includeInactive = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentUrl.GetDocumentUrl(documentListName, documentId, includeInactive, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.Document>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
public ProductReservationResource(IApiContext apiContext)
{
_apiContext = apiContext;
_dataViewMode = DataViewMode.Live;
}
/// <summary>
/// Retrieves the details of the content property type.
/// </summary>
/// <param name="propertyTypeName">The name of the property type.</param>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.PropertyType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetPropertyType(dataViewMode, propertyTypeName, responseFields);
/// var propertyTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.PropertyType> GetPropertyTypeClient(DataViewMode dataViewMode, string propertyTypeName, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.PropertyTypeUrl.GetPropertyTypeUrl(propertyTypeName, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.PropertyType>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Creates a new DocumentType
/// </summary>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="documentType">The type of documents used in the CMS such as "web_page" or "template" or "image_url".</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.DocumentType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateDocumentType(dataViewMode, documentType, responseFields);
/// var documentTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.DocumentType> CreateDocumentTypeClient(DataViewMode dataViewMode, Mozu.Api.Contracts.Content.DocumentType documentType, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.DocumentTypeUrl.CreateDocumentTypeUrl(responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.DocumentType>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.Content.DocumentType>(documentType).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieve the content associated with a document, such as a product image or PDF specifications file, by supplying the document ID.
/// <example>
/// <code>
/// var result = DocumentFactory.GetDocumentContent(handler : handler, documentListName : documentListName, documentId : documentId, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<Stream/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static System.IO.Stream GetDocumentContent(ServiceClientMessageHandler handler,
string documentListName, string documentId, DataViewMode dataViewMode = DataViewMode.Live,
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.Documentlists.DocumentClient.GetDocumentContentClient(
documentListName: documentListName, documentId: documentId, 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);
}
public PropertyTypeResource(IApiContext apiContext)
{
_apiContext = apiContext;
_dataViewMode = DataViewMode.Live;
}
/// <summary>
///
/// </summary>
/// <param name="documentListName">Name of content documentListName to delete</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="includeInactive">Include inactive content.</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.Content.DocumentCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDocuments(dataViewMode, documentListName, filter, sortBy, pageSize, startIndex, includeInactive, responseFields);
/// var documentCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.DocumentCollection> GetDocumentsClient(DataViewMode dataViewMode, string documentListName, string filter = null, string sortBy = null, int?pageSize = null, int?startIndex = null, bool?includeInactive = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentUrl.GetDocumentsUrl(documentListName, filter, sortBy, pageSize, startIndex, includeInactive, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.DocumentCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
public PropertyTypeResource(IApiContext apiContext, DataViewMode dataViewMode)
{
_apiContext = apiContext;
_dataViewMode = dataViewMode;
}
/// <summary>
/// Retrieves a list of extras configured for the product according to any defined filter and sort criteria.
/// </summary>
/// <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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductExtra"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetExtras(dataViewMode, productCode);
/// var productExtraClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductExtra> > GetExtrasClient(DataViewMode dataViewMode, string productCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductExtraUrl.GetExtrasUrl(productCode);
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductExtra> >()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
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.CategoryPagedCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetCategories(dataViewMode, startIndex, pageSize, sortBy, filter, responseFields);
/// var categoryPagedCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.CategoryPagedCollection> GetCategoriesClient(DataViewMode dataViewMode, int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.CategoryUrl.GetCategoriesUrl(startIndex, pageSize, sortBy, filter, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.CategoryPagedCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Updates the active stock on hand inventory of products for the location code specified in the request.
/// </summary>
/// <param name="locationCode">The unique, user-defined code that identifies a location. </param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="locationInventoryAdjustments">Properties of an adjustment to the active product inventory of a specific location.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.LocationInventory"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateLocationInventory(dataViewMode, locationInventoryAdjustments, locationCode);
/// var locationInventoryClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> > UpdateLocationInventoryClient(DataViewMode dataViewMode, List <Mozu.Api.Contracts.ProductAdmin.LocationInventoryAdjustment> locationInventoryAdjustments, string locationCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.LocationInventoryUrl.UpdateLocationInventoryUrl(locationCode);
const string verb = "PUT";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.LocationInventory> >()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <List <Mozu.Api.Contracts.ProductAdmin.LocationInventoryAdjustment> >(locationInventoryAdjustments).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Updates the localized price value for a product variation and a specific localized currency.
/// <example>
/// <code>
/// var result = ProductVariationFactory.UpdateProductVariationLocalizedPrice(handler : handler, localizedPrice : localizedPrice, productCode : productCode, variationKey : variationKey, currencyCode : currencyCode, responseFields : responseFields, dataViewMode: dataViewMode, expectedCode: expectedCode, successCode: successCode);
/// var optionalCasting = ConvertClass<ProductVariationFixedPrice/>(result);
/// return optionalCasting;
/// </code>
/// </example>
/// </summary>
public static Mozu.Api.Contracts.ProductAdmin.ProductVariationFixedPrice UpdateProductVariationLocalizedPrice(ServiceClientMessageHandler handler,
Mozu.Api.Contracts.ProductAdmin.ProductVariationFixedPrice localizedPrice, string productCode, string variationKey, string currencyCode, string responseFields = null, DataViewMode dataViewMode = DataViewMode.Live,
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.Admin.Products.ProductVariationClient.UpdateProductVariationLocalizedPriceClient(
localizedPrice: localizedPrice, productCode: productCode, variationKey: variationKey, currencyCode: currencyCode, responseFields: responseFields, 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);
}
