/// <summary>
/// Associates a new product defined in the master catalog with a specific catalog.
/// </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="productInCatalogInfoIn">Properties of the product to define for the specific catalog association.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductInCatalogInfo"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddProductInCatalog(dataViewMode, productInCatalogInfoIn, productCode);
/// var productInCatalogInfoClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductInCatalogInfo> AddProductInCatalogClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductInCatalogInfo productInCatalogInfoIn, string productCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.ProductUrl.AddProductInCatalogUrl(productCode);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductInCatalogInfo>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.ProductInCatalogInfo>(productInCatalogInfoIn) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteDocumentDrafts(dataViewMode, documentIds, documentLists);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteDocumentDraftsClient(DataViewMode dataViewMode, List<string> documentIds, string documentLists = null)
{
var url = Mozu.Api.Urls.Content.DocumentDraftSummaryUrl.DeleteDocumentDraftsUrl(documentLists);
const string verb = "POST";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody(documentIds) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteOption(dataViewMode, productTypeId, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteOptionClient(DataViewMode dataViewMode, int productTypeId, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionUrl.DeleteOptionUrl(attributeFQN, productTypeId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Retrieves a document based on its document list and folder path in the document hierarchy.
/// </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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.Document"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetTreeDocument(dataViewMode, documentListName, documentName);
/// var documentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Content.Document> GetTreeDocumentClient(DataViewMode dataViewMode, string documentListName, string documentName)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentTree.DocumentTreeUrl.GetTreeDocumentUrl(documentListName, documentName);
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;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariation"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductVariation(dataViewMode, productCode, variationKey);
/// var productVariationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariation> GetProductVariationClient(DataViewMode dataViewMode, string productCode, string variationKey)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.GetProductVariationUrl(productCode, variationKey);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariation>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Deletes the facet specified by its unique identifier.
/// </summary>
/// <param name="facetId">Unique identifier of the facet to delete.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteFacetById(dataViewMode, facetId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteFacetByIdClient(DataViewMode dataViewMode, int facetId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.FacetUrl.DeleteFacetByIdUrl(facetId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=PublishDrafts(dataViewMode, publishScope);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient PublishDraftsClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.PublishingScope publishScope)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.PublishingScopeUrl.PublishDraftsUrl();
const string verb = "POST";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.PublishingScope>(publishScope) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.AttributeInProductType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddOption(dataViewMode, attributeInProductType, productTypeId);
/// var attributeInProductTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> AddOptionClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.AttributeInProductType attributeInProductType, int productTypeId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionUrl.AddOptionUrl(productTypeId);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeInProductType>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.AttributeInProductType>(attributeInProductType) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Category"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddCategory(dataViewMode, category, incrementSequence);
/// var categoryClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.Category> AddCategoryClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Category category, bool? incrementSequence = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.CategoryUrl.AddCategoryUrl(incrementSequence);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.Category>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.Category>(category) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Modifies properties of the discount target, for example, the dollar amount, or precentage off the price.
/// </summary>
/// <param name="discountId">Unique identifier of the discount. System-supplied and read-only.</param>
/// <param name="discountTarget">Properties of the discount target to modify. Required properties: Target.Type. Any unspecified properties are set to null and boolean variables to false.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.DiscountTarget"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateDiscountTarget(dataViewMode, discountTarget, discountId);
/// var discountTargetClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.DiscountTarget> UpdateDiscountTargetClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.DiscountTarget discountTarget, int discountId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Discounts.DiscountTargetUrl.UpdateDiscountTargetUrl(discountId);
const string verb = "PUT";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.DiscountTarget>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.DiscountTarget>(discountTarget) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.Facet"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddFacet(dataViewMode, facet);
/// var facetClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.Facet> AddFacetClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.Facet facet)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.FacetUrl.AddFacetUrl();
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.Facet>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.Facet>(facet) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Creates a new location inventory definition for the product code specified in the request.
/// </summary>
/// <param name="performUpserts"></param>
/// <param name="productCode">ProductCodeBase</param>
/// <param name="locationInventoryList">Array list of the location inventory definitions associated with the product code specified in the request. For each location, you must define the locationCode value and the stockOnHand value. All other properties in the array are system-supplied and read only.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.LocationInventory"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddLocationInventory(dataViewMode, locationInventoryList, productCode, 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 productCode, bool? performUpserts = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.LocationInventory.LocationInventoryUrl.AddLocationInventoryUrl(performUpserts, productCode);
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>
///
/// </summary>
/// <param name="skipInventoryCheck"></param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="productReservations"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductReservation"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddProductReservations(dataViewMode, productReservations, skipInventoryCheck);
/// var productReservationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<List<Mozu.Api.Contracts.ProductAdmin.ProductReservation>> AddProductReservationsClient(DataViewMode dataViewMode, List<Mozu.Api.Contracts.ProductAdmin.ProductReservation> productReservations, bool? skipInventoryCheck = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.ProductReservationUrl.AddProductReservationsUrl(skipInventoryCheck);
const string verb = "POST";
var mozuClient = new MozuClient<List<Mozu.Api.Contracts.ProductAdmin.ProductReservation>>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<List<Mozu.Api.Contracts.ProductAdmin.ProductReservation>>(productReservations) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GenerateProductVariations(dataViewMode, productOptionsIn, productTypeId, productCode, startIndex, pageSize, sortBy, filter);
/// var productVariationPagedCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection> GenerateProductVariationsClient(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)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeVariationUrl.GenerateProductVariationsUrl(filter, pageSize, productCode, productTypeId, sortBy, startIndex);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<List<Mozu.Api.Contracts.ProductAdmin.ProductOption>>(productOptionsIn) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="propertyTypeName"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.PropertyType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetPropertyType(dataViewMode, propertyTypeName);
/// var propertyTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Content.PropertyType> GetPropertyTypeClient(DataViewMode dataViewMode, string propertyTypeName)
{
var url = Mozu.Api.Urls.Content.PropertyTypeUrl.GetPropertyTypeUrl(propertyTypeName);
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>
/// 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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteProperty(dataViewMode, productCode, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeletePropertyClient(DataViewMode dataViewMode, string productCode, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductPropertyUrl.DeletePropertyUrl(attributeFQN, productCode);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetAttributeTypeRules(dataViewMode, startIndex, pageSize, sortBy, filter);
/// var attributeTypeRuleCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection> GetAttributeTypeRulesClient(DataViewMode dataViewMode, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Attributes.AttributeTypeRuleUrl.GetAttributeTypeRulesUrl(filter, pageSize, sortBy, startIndex);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeTypeRuleCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Deletes an attribute's vocabulary value.
/// </summary>
/// <param name="attributeFQN">The fully qualified name of the attribute, which is a user defined attribute identifier.</param>
/// <param name="value">The actual unique value of the attribute vocabulary to delete. A single attribute must have a unique value and match the attribute's data type. If a string value returns null, the system will generate a value. The actual string content displayed shoud be stored as "Content" and actual content is required for string values.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteAttributeVocabularyValue(dataViewMode, attributeFQN, value);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteAttributeVocabularyValueClient(DataViewMode dataViewMode, string attributeFQN, string value)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Attributes.AttributeVocabularyValueUrl.DeleteAttributeVocabularyValueUrl(attributeFQN, value);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Adds a new attribute vocabulary value.
/// </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>
/// <param name="attributeVocabularyValue">The predefined vocabulary value to add to the attribute content.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.AttributeVocabularyValue"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddAttributeVocabularyValue(dataViewMode, attributeVocabularyValue, attributeFQN);
/// var attributeVocabularyValueClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeVocabularyValue> AddAttributeVocabularyValueClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.AttributeVocabularyValue attributeVocabularyValue, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Attributes.AttributeVocabularyValueUrl.AddAttributeVocabularyValueUrl(attributeFQN);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.AttributeVocabularyValue>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.ProductAdmin.AttributeVocabularyValue>(attributeVocabularyValue) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteDocument(dataViewMode, documentListName, documentId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteDocumentClient(DataViewMode dataViewMode, string documentListName, string documentId)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentUrl.DeleteDocumentUrl(documentId, documentListName);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Retrieve the details of the master catalog specified in the request.
/// </summary>
/// <param name="masterCatalogId"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.MasterCatalog"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetMasterCatalog(dataViewMode, masterCatalogId);
/// var masterCatalogClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalog> GetMasterCatalogClient(DataViewMode dataViewMode, int masterCatalogId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.MasterCatalogUrl.GetMasterCatalogUrl(masterCatalogId);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.MasterCatalog>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="documentListName">Name of content documentListName to delete</param>
/// <param name="documentName">The name of the document in the site.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="System.IO.Stream"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetTreeDocumentContent(dataViewMode, documentListName, documentName);
/// var streamClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <System.IO.Stream> GetTreeDocumentContentClient(DataViewMode dataViewMode, string documentListName, string documentName)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentTreeUrl.GetTreeDocumentContentUrl(documentListName, documentName);
const string verb = "GET";
var mozuClient = new MozuClient <System.IO.Stream>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <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="responseFields">Use this field to include those fields which are not included by default.</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.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariation"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductVariation(dataViewMode, productCode, variationKey, responseFields);
/// var productVariationClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductVariation> GetProductVariationClient(DataViewMode dataViewMode, string productCode, string variationKey, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.GetProductVariationUrl(productCode, variationKey, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductVariation>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves a collection of the localized delta price values for a product variation. Localized delta prices are deltas between two differing monetary conversion amounts between countries, such as US Dollar vs Euro.
/// </summary>
/// <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="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductVariationLocalizedDeltaPrices(dataViewMode, productCode, variationKey);
/// var productVariationDeltaPriceClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice> > GetProductVariationLocalizedDeltaPricesClient(DataViewMode dataViewMode, string productCode, string variationKey)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.GetProductVariationLocalizedDeltaPricesUrl(productCode, variationKey);
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice> >()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Gets a documentListType.
/// </summary>
/// <param name="documentListTypeFQN"></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.DocumentListType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDocumentListType(dataViewMode, documentListTypeFQN, responseFields);
/// var documentListTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.DocumentListType> GetDocumentListTypeClient(DataViewMode dataViewMode, string documentListTypeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.DocumentListTypeUrl.GetDocumentListTypeUrl(documentListTypeFQN, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.DocumentListType>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Deletes the property value for localized content. This content is set by the locale code.
/// </summary>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <param name="localeCode">Language used for the entity. Currently, only "en-US" is supported.</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="value">The value string to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeletePropertyValueLocalizedContent(dataViewMode, productCode, attributeFQN, value, localeCode);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeletePropertyValueLocalizedContentClient(DataViewMode dataViewMode, string productCode, string attributeFQN, string value, string localeCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductPropertyUrl.DeletePropertyValueLocalizedContentUrl(productCode, attributeFQN, value, localeCode);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Creates a new documentListType
/// </summary>
/// <param name="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="list">Properties for the document list type. Document lists contain documents with an associated document type, such as web pages.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.DocumentListType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=CreateDocumentListType(dataViewMode, list, responseFields);
/// var documentListTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.Content.DocumentListType> CreateDocumentListTypeClient(DataViewMode dataViewMode, Mozu.Api.Contracts.Content.DocumentListType list, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.DocumentListTypeUrl.CreateDocumentListTypeUrl(responseFields);
const string verb = "POST";
var mozuClient = new MozuClient<Mozu.Api.Contracts.Content.DocumentListType>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody<Mozu.Api.Contracts.Content.DocumentListType>(list) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="acceptVariantProductCode">Specifies whether to accept a product variant's code as the .When you set this parameter to , you can pass in a product variant's code in the GetProduct call to retrieve the product variant details that are associated with the base product.</param>
/// <param name="allowInactive">If true, allow inactive categories to be retrieved in the category list response. If false, the categories retrieved will not include ones marked inactive.</param>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout to reference and associate to a product.</param>
/// <param name="purchaseLocation">The location where the order item(s) was purchased.</param>
/// <param name="quantity">The number of cart items in the shopper's active cart.</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="skipInventoryCheck">If true, skip the process to validate inventory when creating this product reservation.</param>
/// <param name="supressOutOfStock404">Specifies whether to supress the 404 error when the product is out of stock.</param>
/// <param name="variationProductCode">Merchant-created code associated with a specific product variation. Variation product codes maintain an association with the base product code.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.Product"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProduct(dataViewMode, productCode, variationProductCode, allowInactive, skipInventoryCheck, supressOutOfStock404, quantity, acceptVariantProductCode, purchaseLocation, responseFields);
/// var productClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.Product> GetProductClient(DataViewMode dataViewMode, string productCode, string variationProductCode = null, bool?allowInactive = null, bool?skipInventoryCheck = null, bool?supressOutOfStock404 = null, int?quantity = null, bool?acceptVariantProductCode = null, string purchaseLocation = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductUrl(productCode, variationProductCode, allowInactive, skipInventoryCheck, supressOutOfStock404, quantity, acceptVariantProductCode, purchaseLocation, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.Product>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Deletes the configuration of an option 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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteOption(dataViewMode, productCode, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteOptionClient(DataViewMode dataViewMode, string productCode, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductOptionUrl.DeleteOptionUrl(productCode, attributeFQN);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <param name="productTypeId">Identifier of the product type.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteExtra(dataViewMode, productTypeId, attributeFQN);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteExtraClient(DataViewMode dataViewMode, int productTypeId, string attributeFQN)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeExtraUrl.DeleteExtraUrl(productTypeId, attributeFQN);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </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 to reference and associate to a product.</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="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>
///
/// </summary>
/// <param name="productSortDefinitionId">Unique identifier of the product sort definition.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteProductSortDefinition(dataViewMode, productSortDefinitionId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteProductSortDefinitionClient(DataViewMode dataViewMode, int productSortDefinitionId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.ProductSortDefinitionUrl.DeleteProductSortDefinitionUrl(productSortDefinitionId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="catalogId">Unique identifier for a catalog.</param>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout to reference and associate to a product.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteProductInCatalog(dataViewMode, productCode, catalogId);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteProductInCatalogClient(DataViewMode dataViewMode, string productCode, int catalogId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.ProductUrl.DeleteProductInCatalogUrl(productCode, catalogId);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout to reference and associate to a product.</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="lastModifiedDate">The date when the product was last updated.</param>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout to reference and associate to a product.</param>
/// <param name="productVersion">The product version.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.Product"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductForIndexing(dataViewMode, productCode, productVersion, lastModifiedDate, responseFields);
/// var productClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.Product> GetProductForIndexingClient(DataViewMode dataViewMode, string productCode, long?productVersion = null, DateTime?lastModifiedDate = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductForIndexingUrl(productCode, productVersion, lastModifiedDate, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.Product>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves a collection of property values for localized content. This content is set by the locale code.
/// </summary>
/// <param name="attributeFQN">Fully qualified name for an attribute.</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="value">The value string to create.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetPropertyValueLocalizedContents(dataViewMode, productCode, attributeFQN, value);
/// var productPropertyValueLocalizedContentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent> > GetPropertyValueLocalizedContentsClient(DataViewMode dataViewMode, string productCode, string attributeFQN, string value)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductPropertyUrl.GetPropertyValueLocalizedContentsUrl(productCode, attributeFQN, value);
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent> >()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the details of the product type specified in the request.
/// </summary>
/// <param name="productTypeId">Identifier of the product type to retrieve.</param>
/// <param name="responseFields"></param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductType(dataViewMode, productTypeId, responseFields);
/// var productTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductType> GetProductTypeClient(DataViewMode dataViewMode, int productTypeId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.ProductTypeUrl.GetProductTypeUrl(productTypeId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductType>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
///
/// </summary>
/// <param name="cursorMark">In your first deep paged request, set this parameter to . Then, in all subsequent requests, set this parameter to the subsequent values of that's returned in each response to continue paging through the results. Continue this pattern until is null, which signifies the end of the paged results.</param>
/// <param name="filter">A set of filter expressions representing the search parameters for a query. This parameter is optional. Refer to [Sorting and Filtering](../../../../Developer/api-guides/sorting-filtering.htm) for a list of supported filters.</param>
/// <param name="pageSize">When creating paged results from a query, this value indicates the zero-based offset in the complete result set where the returned entities begin. For example, with this parameter set to 25, to get the 51st through the 75th items, set startIndex to 50.</param>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <param name="responseOptions">Options you can specify for the response. This parameter is null by default.You can primarily use this parameter to return volume price band information in product details, which you can then display on category pages and search results depanding on your theme configuration. To return volume price band information, set this parameter to .</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.ProductRuntime.ProductCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProducts(dataViewMode, filter, startIndex, pageSize, sortBy, responseOptions, cursorMark, responseFields);
/// var productCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.ProductCollection> GetProductsClient(DataViewMode dataViewMode, string filter = null, int?startIndex = null, int?pageSize = null, string sortBy = null, string responseOptions = null, string cursorMark = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductsUrl(filter, startIndex, pageSize, sortBy, responseOptions, cursorMark, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.ProductCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves a list of all product inventory definitions for the location code specified 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="filterFunctions"></param>
/// <param name="locationCode">The unique, user-defined code that identifies a location. </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="responseFields">Use this field to include those fields which are not included by default.</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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetLocationInventories(dataViewMode, locationCode, startIndex, pageSize, sortBy, filter, filterFunctions, responseFields);
/// var locationInventoryCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection> GetLocationInventoriesClient(DataViewMode dataViewMode, string locationCode, int? startIndex = null, int? pageSize = null, string sortBy = null, string filter = null, string filterFunctions = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.LocationInventoryUrl.GetLocationInventoriesUrl(locationCode, startIndex, pageSize, sortBy, filter, filterFunctions, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.LocationInventoryCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Retrieves a list of product handling fee rules and their details.
/// </summary>
/// <param name="profilecode">The unique, user-defined code of the profile with which the product handling fee rule is associated.</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="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ShippingAdmin.Profile.HandlingFeeRuleCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductHandlingFeeRules(dataViewMode, profilecode, responseFields);
/// var handlingFeeRuleCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ShippingAdmin.Profile.HandlingFeeRuleCollection> GetProductHandlingFeeRulesClient(DataViewMode dataViewMode, string profilecode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Shipping.Admin.Profiles.HandlingFeeRuleUrl.GetProductHandlingFeeRulesUrl(profilecode, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ShippingAdmin.Profile.HandlingFeeRuleCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the details of an option attribute configuration for the specified product.
/// </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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductOption"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetOption(dataViewMode, productCode, attributeFQN, responseFields);
/// var productOptionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductOption> GetOptionClient(DataViewMode dataViewMode, string productCode, string attributeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductOptionUrl.GetOptionUrl(productCode, attributeFQN, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductOption>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Retrieves the details of an option attribute defined 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="responseFields">Use this field to include those fields which are not included by default.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.AttributeInProductType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetOption(dataViewMode, productTypeId, attributeFQN, responseFields);
/// var attributeInProductTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> GetOptionClient(DataViewMode dataViewMode, int productTypeId, string attributeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypeOptionUrl.GetOptionUrl(productTypeId, attributeFQN, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.AttributeInProductType>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the localized content specified for the specified discount.
/// </summary>
/// <param name="discountId">Unique identifier of the discount. System-supplied and read only.</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.ProductAdmin.DiscountLocalizedContent"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDiscountContent(dataViewMode, discountId, responseFields);
/// var discountLocalizedContentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.DiscountLocalizedContent> GetDiscountContentClient(DataViewMode dataViewMode, int discountId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.DiscountUrl.GetDiscountContentUrl(discountId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.DiscountLocalizedContent>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Deletes the specified product handling fee rule.
/// </summary>
/// <param name="id">Unique identifier of the customer segment to retrieve.</param>
/// <param name="profilecode">The unique, user-defined code of the profile with which the product handling fee rule is associated.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteProductHandlingFeeRule(dataViewMode, profilecode, id);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteProductHandlingFeeRuleClient(DataViewMode dataViewMode, string profilecode, string id)
{
var url = Mozu.Api.Urls.Commerce.Shipping.Admin.Profiles.HandlingFeeRuleUrl.DeleteProductHandlingFeeRuleUrl(profilecode, id);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the list of product categories that appear on the storefront organized in a hierarchical format. Hidden categories do not appear in the list.
/// </summary>
/// <param name="responseFields">Filtering syntax appended to an API call to increase or decrease the amount of data returned inside a JSON object. This parameter should only be used to retrieve data. Attempting to update data using this parameter may cause data loss.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.CategoryCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetCategoryTree(dataViewMode, responseFields);
/// var categoryCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.CategoryCollection> GetCategoryTreeClient(DataViewMode dataViewMode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.CategoryUrl.GetCategoryTreeUrl(responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.CategoryCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="catalogId">Unique identifier for a catalog.</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="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.DiscountSettings"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDiscountSettings(dataViewMode, catalogId, responseFields);
/// var discountSettingsClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.DiscountSettings> GetDiscountSettingsClient(DataViewMode dataViewMode, int catalogId, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.DiscountSettingsUrl.GetDiscountSettingsUrl(catalogId, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.DiscountSettings>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the localized delta price value for a product variation. Localized delta prices are deltas between two differing monetary conversion amounts between countries, such as US Dollar vs Euro.
/// </summary>
/// <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="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductVariationLocalizedDeltaPrice(dataViewMode, productCode, variationKey, currencyCode, responseFields);
/// var productVariationDeltaPriceClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice> GetProductVariationLocalizedDeltaPriceClient(DataViewMode dataViewMode, string productCode, string variationKey, string currencyCode, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.GetProductVariationLocalizedDeltaPriceUrl(productCode, variationKey, currencyCode, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductAdmin.ProductVariationDeltaPrice>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Deletes the localized delta price value for a product variation. Localized delta prices are deltas between two differing monetary conversion amounts between countries, such as US Dollar vs Euro.
/// </summary>
/// <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="variationKey">System-generated key that represents the attribute values that uniquely identify a specific product variation.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteProductVariationLocalizedDeltaPrice(dataViewMode, productCode, variationKey, currencyCode);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteProductVariationLocalizedDeltaPriceClient(DataViewMode dataViewMode, string productCode, string variationKey, string currencyCode)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.DeleteProductVariationLocalizedDeltaPriceUrl(productCode, variationKey, currencyCode);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves a list of the product variations configured for the specified product code.
/// </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">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="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>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductVariations(dataViewMode, productCode, startIndex, pageSize, sortBy, filter, responseFields);
/// var productVariationPagedCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection> GetProductVariationsClient(DataViewMode dataViewMode, string productCode, int?startIndex = null, int?pageSize = null, string sortBy = null, string filter = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductVariationUrl.GetProductVariationsUrl(productCode, startIndex, pageSize, sortBy, filter, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductVariationPagedCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Gets all the available documentListTypes.
/// </summary>
/// <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="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.DocumentListTypeCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetDocumentListTypes(dataViewMode, pageSize, startIndex, responseFields);
/// var documentListTypeCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.DocumentListTypeCollection> GetDocumentListTypesClient(DataViewMode dataViewMode, int?pageSize = null, int?startIndex = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.DocumentListTypeUrl.GetDocumentListTypesUrl(pageSize, startIndex, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.DocumentListTypeCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="documentListName">Name of content documentListName to delete</param>
/// <param name="documentName">The name of the document in the site.</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=GetTreeDocument(dataViewMode, documentListName, documentName, includeInactive, responseFields);
/// var documentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.Document> GetTreeDocumentClient(DataViewMode dataViewMode, string documentListName, string documentName, bool?includeInactive = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentTreeUrl.GetTreeDocumentUrl(documentListName, documentName, 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);
}
/// <summary>
/// Retrieves a list of products that appear on the storefront according to any specified filter criteria and sort options.
/// </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="responseFields"></param>
/// <param name="sortBy"></param>
/// <param name="startIndex"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.ProductCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProducts(dataViewMode, filter, startIndex, pageSize, sortBy, responseFields);
/// var productCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductRuntime.ProductCollection> GetProductsClient(DataViewMode dataViewMode, string filter = null, int? startIndex = null, int? pageSize = null, string sortBy = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductsUrl(filter, startIndex, pageSize, sortBy, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductRuntime.ProductCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <summary>
/// Retrieves a list of product property attributes defined for a product type.
/// </summary>
/// <param name="productTypeId">Identifier of the product type.</param>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{List{<see cref="Mozu.Api.Contracts.ProductAdmin.AttributeInProductType"/>}}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProperties(dataViewMode, productTypeId);
/// var attributeInProductTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <List <Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> > GetPropertiesClient(DataViewMode dataViewMode, int productTypeId)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Attributedefinition.Producttypes.ProductTypePropertyUrl.GetPropertiesUrl(productTypeId);
const string verb = "GET";
var mozuClient = new MozuClient <List <Mozu.Api.Contracts.ProductAdmin.AttributeInProductType> >()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves the active inventory level information associated with the product or location specified in the request.
/// </summary>
/// <param name="locationCodes">Array of location codes for which to retrieve product inventory information.</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"></param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductInventory(dataViewMode, productCode, locationCodes, responseFields);
/// var locationInventoryCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient<Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection> GetProductInventoryClient(DataViewMode dataViewMode, string productCode, string locationCodes = null, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductInventoryUrl(productCode, locationCodes, responseFields);
const string verb = "GET";
var mozuClient = new MozuClient<Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
;
return mozuClient;
}
/// <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>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DeleteTreeDocumentContent(dataViewMode, stream, documentListName, documentName, contentType);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DeleteTreeDocumentContentClient(DataViewMode dataViewMode, System.IO.Stream stream, string documentListName, string documentName, String contentType= null)
{
var url = Mozu.Api.Urls.Content.Documentlists.DocumentTree.DocumentTreeUrl.DeleteTreeDocumentContentUrl(documentListName, documentName);
const string verb = "DELETE";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody(stream) .WithHeader(Headers.X_VOL_DATAVIEW_MODE ,dataViewMode.ToString())
.WithHeader(Headers.CONTENT_TYPE ,contentType)
;
return mozuClient;
}
/// <summary>
/// Deletes the draft version of product changes (pending product changes) for each product code specified in the request.
/// </summary>
/// <param name="dataViewMode">{<see cref="Mozu.Api.DataViewMode"/>}</param>
/// <param name="publishScope">Describes the scope of the product publishing update, which can include individual product codes or all pending changes.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />
/// </returns>
/// <example>
/// <code>
/// var mozuClient=DiscardDrafts(dataViewMode, publishScope);
///mozuClient.WithBaseAddress(url).Execute();
/// </code>
/// </example>
public static MozuClient DiscardDraftsClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.PublishingScope publishScope)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.PublishingScopeUrl.DiscardDraftsUrl();
const string verb = "POST";
var mozuClient = new MozuClient()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.PublishingScope>(publishScope).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
///
/// </summary>
/// <param name="propertyTypeName">The name of the property type.</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="propertyType">Property type available for content. Property types are like templates that can be reused.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.Content.PropertyType"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdatePropertyType(dataViewMode, propertyType, propertyTypeName, responseFields);
/// var propertyTypeClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.Content.PropertyType> UpdatePropertyTypeClient(DataViewMode dataViewMode, Mozu.Api.Contracts.Content.PropertyType propertyType, string propertyTypeName, string responseFields = null)
{
var url = Mozu.Api.Urls.Content.PropertyTypeUrl.UpdatePropertyTypeUrl(propertyTypeName, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.Content.PropertyType>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.Content.PropertyType>(propertyType).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Retrieves product inventories for the storefront displayed products.
/// </summary>
/// <param name="responseFields">A list or array of fields returned for a call. These fields may be customized and may be used for various types of data calls in Mozu. For example, responseFields are returned for retrieving or updating attributes, carts, and messages in Mozu.</param>
/// <param name="query">Properties for the product location inventory provided for queries to locate products by their location.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=GetProductInventories(dataViewMode, query, responseFields);
/// var locationInventoryCollectionClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection> GetProductInventoriesClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductRuntime.LocationInventoryQuery query, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Storefront.ProductUrl.GetProductInventoriesUrl(responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductRuntime.LocationInventoryCollection>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductRuntime.LocationInventoryQuery>(query).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Update one or more details of a property attribute configuration 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">The unique, user-defined product code of a product, used throughout 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="productProperty">Details of a property defined for a product.</param>
/// <returns>
/// <see cref="Mozu.Api.MozuClient" />{<see cref="Mozu.Api.Contracts.ProductAdmin.ProductProperty"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=UpdateProperty(dataViewMode, productProperty, productCode, attributeFQN, responseFields);
/// var productPropertyClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductProperty> UpdatePropertyClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductProperty productProperty, string productCode, string attributeFQN, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductPropertyUrl.UpdatePropertyUrl(productCode, attributeFQN, responseFields);
const string verb = "PUT";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductProperty>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.ProductProperty>(productProperty).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}
/// <summary>
/// Adds a property value for localized content. This content is set by the locale code.
/// </summary>
/// <param name="attributeFQN">Fully qualified name for an attribute.</param>
/// <param name="productCode">The unique, user-defined product code of a product, used throughout 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>
/// <param name="localizedContent">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.ProductAdmin.ProductPropertyValueLocalizedContent"/>}
/// </returns>
/// <example>
/// <code>
/// var mozuClient=AddPropertyValueLocalizedContent(dataViewMode, localizedContent, productCode, attributeFQN, value, responseFields);
/// var productPropertyValueLocalizedContentClient = mozuClient.WithBaseAddress(url).Execute().Result();
/// </code>
/// </example>
public static MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent> AddPropertyValueLocalizedContentClient(DataViewMode dataViewMode, Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent localizedContent, string productCode, string attributeFQN, string value, string responseFields = null)
{
var url = Mozu.Api.Urls.Commerce.Catalog.Admin.Products.ProductPropertyUrl.AddPropertyValueLocalizedContentUrl(productCode, attributeFQN, value, responseFields);
const string verb = "POST";
var mozuClient = new MozuClient <Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent>()
.WithVerb(verb).WithResourceUrl(url)
.WithBody <Mozu.Api.Contracts.ProductAdmin.ProductPropertyValueLocalizedContent>(localizedContent).WithHeader(Headers.X_VOL_DATAVIEW_MODE, dataViewMode.ToString())
;
return(mozuClient);
}