C# DataViewMode.ToString方法代码示例

 /// <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>
 /// 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>
 /// 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>
 /// 
 /// </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>
 /// 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>
 /// 
 /// </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>
 /// 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>
 /// 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>
 /// 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>
 /// 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>
 /// 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>
 /// 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>
 /// 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>
 /// 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;
 }