public Task <PagedResult <Category> > GetChildren(long channelId, long categoryId, QueryResultSettings queryResultSettings) { return(Task.Run(() => ChannelManager.Create(CommerceRuntimeManager.Runtime).GetDirectChildCategories(channelId, categoryId, queryResultSettings))); }
/// <summary> /// Loads the specified listing page, and returns true if a full page was loaded. /// </summary> /// <param name="productsSearchCriteria">The search criteria.</param> /// <param name="querySettings">The query settings.</param> /// <returns>Returns changed products.</returns> private ChangedProductsSearchResult LoadChangedProducts(ChangedProductsSearchCriteria productsSearchCriteria, QueryResultSettings querySettings) { Stopwatch watch = Stopwatch.StartNew(); ChangedProductsSearchResult results; results = this.productManager.GetChangedProducts(productsSearchCriteria, querySettings); watch.Stop(); int numberOfReadProducts = results.Results.Count; this.LogTimingMessage(Resources.NumberOfReadProductsInPage, numberOfReadProducts, watch.Elapsed); return(results); }
/// <summary> /// Gets terminal entity by identifier. /// </summary> /// <param name="context">The request context.</param> /// <param name="terminalId">The terminal identifier.</param> /// <param name="settings">The query result settings to retrieve the terminal.</param> /// <returns>The terminal object.</returns> private Terminal GetTerminalById(RequestContext context, string terminalId, QueryResultSettings settings) { ThrowIf.NullOrWhiteSpace(terminalId, "terminalId"); ThrowIf.Null(settings, "settings"); Terminal terminal; var query = new SqlPagedQuery(settings) { From = TerminalDatabaseAccessor.TerminalsViewName, Where = "TERMINALID = @id" }; query.Parameters["@id"] = terminalId; using (var databaseContext = new DatabaseContext(context)) { terminal = databaseContext.ReadEntity <Terminal>(query).Results.SingleOrDefault(); } return(terminal); }
public Task <PagedResult <PurchaseOrder> > ReadAll(QueryResultSettings queryResultSettings) { return(Task.Run(() => InventoryManager.Create(CommerceRuntimeManager.Runtime).GetPurchaseOrder(null))); }
private PagedResult <GlobalCustomer> SearchCustomersSproc(string keyword, bool onlyCurrentCompany, QueryResultSettings settings) { using (SqliteDatabaseContext databaseContext = new SqliteDatabaseContext(this.Context)) { // Use the "LIKE" to search for customer related table fields // Based on the pre-populated materialized view crt_CUSTOMERSEARCHABLEFIELDSVIEW string queryText = @"WITH UNIQUEPARTYIDS AS ( SELECT DISTINCT csfv.PARTY FROM crt_CUSTOMERSEARCHABLEFIELDSVIEW csfv INNER JOIN ( SELECT PARTY, ADDRESSBOOK FROM AX_DIRADDRESSBOOKPARTY WHERE PARTY NOT IN (SELECT RECID FROM AX_OMINTERNALORGANIZATION)) dap ON csfv.PARTY = dap.PARTY INNER JOIN AX_RETAILSTOREADDRESSBOOK rsab ON dap.ADDRESSBOOK = rsab.ADDRESSBOOK WHERE rsab.STORERECID = @bi_ChannelId AND csfv.FIELD LIKE @nvc_SearchCondition ) SELECT PARTYNUMBER, CASE WHEN gcv.DATAAREAID <> '' THEN gcv.ACCOUNTNUMBER ELSE '' END AS ACCOUNTNUMBER, NAME, FULLADDRESS, PHONE, EMAIL, INSTANCERELATIONTYPE as CUSTOMERTYPE, ORGID, RECORDID FROM CRT_GLOBALCUSTOMERSVIEW gcv INNER JOIN UNIQUEPARTYIDS pid ON gcv.RECORDID = pid.PARTY WHERE (@b_SearchCrossCompany <> 1 AND ACCOUNTNUMBER != '' AND gcv.DATAAREAID = @nvc_DataAreaId) OR (@b_SearchCrossCompany = 1) LIMIT @i_Top, @i_Skip;"; var parameters = new ParameterSet(); parameters["@bi_ChannelId"] = databaseContext.ChannelId; parameters["@nvc_DataAreaId"] = databaseContext.DataAreaId; parameters["@nvc_SearchCondition"] = string.Format("%{0}%", keyword); parameters["@b_SearchCrossCompany"] = Convert.ToInt32(onlyCurrentCompany); parameters["@i_Top"] = settings.Paging.Top; parameters["@i_Skip"] = settings.Paging.Skip; var query = new SqlQuery(queryText, parameters); PagedResult <GlobalCustomer> customers = databaseContext.ReadEntity <GlobalCustomer>(query); return(customers); } }
/// <summary> /// Initializes a new instance of the <see cref="SqlServerDatabaseContext"/> class. /// </summary> /// <param name="request">The data request.</param> public SqlServerDatabaseContext(Request request) : base(request.RequestContext) { this.settings = request.QueryResultSettings; }
/// <summary> /// Gets the order delivery options for shipping. /// </summary> /// <param name="shipToAddress">The ship to address.</param> /// <param name="queryResultSettings">The query result settings.</param> /// <returns>The service response containing the available delivery options.</returns> public async Task <ActionResult> GetOrderDeliveryOptionsForShipping(Address shipToAddress, QueryResultSettings queryResultSettings) { EcommerceContext ecommerceContext = ServiceUtilities.GetEcommerceContext(this.HttpContext); CartOperationsHandler cartOperationsHandler = new CartOperationsHandler(ecommerceContext); SessionType sessionType = ServiceUtilities.GetSessionType(this.HttpContext, isCheckoutSession: true); string cartId = ServiceUtilities.GetCartIdFromRequestCookie(this.HttpContext, sessionType); PagedResult <DeliveryOption> deliveryOptions = await cartOperationsHandler.GetOrderDeliveryOptionsForShipping(cartId, shipToAddress, queryResultSettings); return(this.Json(deliveryOptions)); }
public async Task <PagedResult <ProductSearchResult> > SearchByText(string searchText, long catalogId, QueryResultSettings queryResultSettings) { if (string.IsNullOrEmpty(searchText)) { throw new ArgumentNullException(nameof(searchText)); } ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IProductManager productManager = managerFactory.GetManager <IProductManager>(); long channelId = await Utilities.GetChannelId(this.EcommerceContext); PagedResult <ProductSearchResult> productSearchResults = await productManager.SearchByText(channelId, catalogId, searchText, queryResultSettings); return(productSearchResults); }
public virtual async Task <PagedResult <ProductAvailableQuantity> > GetProductAvailability(IEnumerable <long> productIds, long channelId, QueryResultSettings queryResultSettings) { if (productIds == null) { throw new ArgumentNullException(nameof(productIds)); } ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IProductManager productManager = managerFactory.GetManager <IProductManager>(); PagedResult <ProductAvailableQuantity> productAvailableQuantities = await productManager.GetProductAvailabilities(productIds, 0, queryResultSettings); return(productAvailableQuantities); }
public Task <PagedResult <ProductCatalog> > GetCatalogs(long channelId, bool activeOnly, QueryResultSettings queryResultSettings) { return(Task.Run(() => Runtime.Client.ProductManager.Create(CommerceRuntimeManager.Runtime).GetProductCatalogs(channelId, activeOnly, queryResultSettings))); }
public async Task <PagedResult <ProductPrice> > GetActivePrices(IEnumerable <long> productIds, long?catalogId, IEnumerable <long> affiliationLoyaltyTierIds, QueryResultSettings queryResultSettings) { IProductManager manager = Utilities.GetManagerFactory(this.EcommerceContext).GetManager <IProductManager>(); long channelId = await Utilities.GetChannelId(this.EcommerceContext); ProjectionDomain projectionDomain = new ProjectionDomain { ChannelId = channelId, CatalogId = catalogId }; IList <AffiliationLoyaltyTier> tiers = null; if (affiliationLoyaltyTierIds != null) { tiers = new List <AffiliationLoyaltyTier>(); foreach (long affiliationLoyaltyTierId in affiliationLoyaltyTierIds) { tiers.Add(new AffiliationLoyaltyTier { AffiliationId = affiliationLoyaltyTierId }); } } PagedResult <ProductPrice> productPrices = await manager.GetActivePrices(projectionDomain, productIds, DateTimeOffset.UtcNow, null, tiers, queryResultSettings); return(productPrices); }
public Task <PagedResult <ProductCatalog> > ReadAll(QueryResultSettings queryResultSettings) { throw new NotSupportedException(); }
/// <summary> /// Gets the sales order. /// </summary> /// <param name="salesOrderSearchCriteria">The sales order search criteria.</param> /// <param name="queryResultSettings">The query result settings.</param> /// <returns>A response containing the sales orders inquired for.</returns> public async Task <ActionResult> GetSalesOrder(SalesOrderSearchCriteria salesOrderSearchCriteria, QueryResultSettings queryResultSettings) { EcommerceContext ecommerceContext = ServiceUtilities.GetEcommerceContext(this.HttpContext); SalesOrderOperationsHandler salesOrderOperationHandler = new SalesOrderOperationsHandler(ecommerceContext); PagedResult <SalesOrder> salesOrders = await salesOrderOperationHandler.GetSalesOrder(salesOrderSearchCriteria, queryResultSettings); return(this.Json(salesOrders.Results)); }
public EntityDataServiceResponse <Shift> Execute(QueryResultSettings queryResultSettings) { SqlPagedQuery query = new SqlPagedQuery(queryResultSettings) { From = ShiftsView, OrderBy = "SHIFTID", }; IList <string> whereClauses = new List <string>(); // Builds where clauses for query. if (this.request.Criteria.ChannelId != null) { whereClauses.Add("CHANNEL = @ChannelId"); } if (this.request.Criteria.Status != null) { whereClauses.Add("STATUS = @Status"); } if (!string.IsNullOrEmpty(this.request.Criteria.StaffId)) { if (this.request.Criteria.SearchByStaffId && this.request.Criteria.SearchByCurrentStaffId) { whereClauses.Add("(STAFFID = @StaffId OR CURRENTSTAFFID = @StaffId)"); } if (this.request.Criteria.SearchByStaffId && !this.request.Criteria.SearchByCurrentStaffId) { whereClauses.Add("STAFFID = @StaffId"); } if (!this.request.Criteria.SearchByStaffId && this.request.Criteria.SearchByCurrentStaffId) { whereClauses.Add("CURRENTSTAFFID = @StaffId"); } } if (!string.IsNullOrEmpty(this.request.Criteria.TerminalId)) { if (this.request.Criteria.SearchByTerminalId && this.request.Criteria.SearchByCurrentTerminalId) { whereClauses.Add("(TERMINALID = @TerminalId OR CURRENTTERMINALID = @TerminalId)"); } if (this.request.Criteria.SearchByTerminalId && !this.request.Criteria.SearchByCurrentTerminalId) { whereClauses.Add("TERMINALID = @TerminalId"); } if (!this.request.Criteria.SearchByTerminalId && this.request.Criteria.SearchByCurrentTerminalId) { whereClauses.Add("CURRENTTERMINALID = @TerminalId"); } } if (this.request.Criteria.ShiftId != null) { whereClauses.Add("SHIFTID = @ShiftId"); } query.Where = string.Join(" AND ", whereClauses); // Build query for shared shifts. if (!this.request.Criteria.IncludeSharedShifts) { query.Where += " AND (ISSHARED IS NULL OR ISSHARED <> 1)"; } // Sets query parameters. if (this.request.Criteria.ChannelId != null) { query.Parameters.Add("@ChannelId", this.request.Criteria.ChannelId); } if (this.request.Criteria.Status != null) { query.Parameters.Add("@Status", this.request.Criteria.Status); } if (!string.IsNullOrEmpty(this.request.Criteria.StaffId)) { query.Parameters.Add("@StaffId", this.request.Criteria.StaffId); } if (!string.IsNullOrEmpty(this.request.Criteria.TerminalId)) { query.Parameters.Add("@TerminalId", this.request.Criteria.TerminalId); } if (this.request.Criteria.ShiftId != null) { query.Parameters.Add("@ShiftId", this.request.Criteria.ShiftId); } PagedResult <Shift> shifts = this.databaseContext.ReadEntity <Shift>(query); return(new EntityDataServiceResponse <Shift>(shifts)); }
/// <summary> /// Executes the operation asynchronous with paged results. /// </summary> /// <typeparam name="T">The type of of entity.</typeparam> /// <param name="entitySet">The entity set.</param> /// <param name="entitySetTypeName">Type name of the entity set.</param> /// <param name="operation">The operation name.</param> /// <param name="isAction">True, if the operation is an action; false, if the operation is a function.</param> /// <param name="queryResultSettings">The query result settings.</param> /// <param name="expandProperties">The navigation properties to be expanded.</param> /// <param name="operationParameters">The operation parameters.</param> /// <returns>The paged results of objects.</returns> public async Task <PagedResult <T> > ExecuteOperationAsync <T>(string entitySet, string entitySetTypeName, string operation, bool isAction, QueryResultSettings queryResultSettings, ICollection <string> expandProperties, params OperationParameter[] operationParameters) { if (BatchHelper.IsInBatchMode(this.batchId)) { if (isAction) { throw new NotSupportedException("Action is not supported in batch mode, only Read, ReadAll, and Functions are supported."); } else { Guid localBatchId = this.batchId.Value; TaskCompletionSource <object> taskCompletionSource = this.parametersCache.PutParameters <T>(localBatchId, entitySet, entitySetTypeName, operation, queryResultSettings, expandProperties, operationParameters); return(await taskCompletionSource.Task.ContinueWith <PagedResult <T> >(this.GetPagedResult <T>)); } } else { string result = await Task.Run(async() => await AdaptorCaller.ExecuteAsync(GetRequestUri(entitySetTypeName, operation, queryResultSettings, operationParameters))); result = AdaptorCaller.RemoveCommerceRuntimePrefix(result); TryThrowAsCommerceException(result); PagedResult <T> pagedResult = result.DeserializeJsonObject <PagedResult <T> >(); return(pagedResult); } }
public virtual async Task <PagedResult <Product> > SearchProducts(ProductSearchCriteria productSearchCriteria, IEnumerable <long> catalogIds, QueryResultSettings queryResultSettings) { if (productSearchCriteria == null) { throw new ArgumentNullException(nameof(productSearchCriteria)); } if (catalogIds == null || !catalogIds.Any()) { throw new ArgumentNullException(nameof(catalogIds)); } if (Utilities.AreNonCataloguedProductsIncludedByDefault() || catalogIds.Contains(0)) { // Override the list of catalog Ids to zero, because query for zero will automatically included products from all catalogs. catalogIds = new long[] { 0 }; } ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IOrgUnitManager orgUnitManager = managerFactory.GetManager <IOrgUnitManager>(); long channelId = await Utilities.GetChannelId(this.EcommerceContext); List <Product> productsFromAllCatalogs = new List <Product>(); IProductManager productManager = managerFactory.GetManager <IProductManager>(); foreach (long catalogId in catalogIds.Distinct()) { productSearchCriteria.Context = new ProjectionDomain() { ChannelId = channelId, CatalogId = catalogId }; PagedResult <Product> products = await productManager.Search(productSearchCriteria, queryResultSettings); productsFromAllCatalogs.AddRange(products.Results); } PagedResult <Product> allProducts = new PagedResult <Product>(productsFromAllCatalogs); return(allProducts); }
/// <summary> /// Reads all entities of type T. /// </summary> /// <typeparam name="T">The type of of entity.</typeparam> /// <param name="entitySet">The entity set.</param> /// <param name="expandProperties">The navigation properties to be expanded.</param> /// <param name="queryResultSettings">The query result settings.</param> /// <returns> /// Collection of objects. /// </returns> public async Task <RetailProxy.PagedResult <T> > ReadAll <T>(string entitySet, ICollection <string> expandProperties, QueryResultSettings queryResultSettings) where T : ICommerceEntity { return(await this.ExecuteOperationAsync <T>(entitySet, typeof(T).Name, ActionNames.ReadAll, false, queryResultSettings, expandProperties)); }
public virtual async Task <PagedResult <StateProvinceInfo> > GetStateProvinces(string countryCode, QueryResultSettings queryResultSettings) { ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IStoreOperationsManager storeOperationsManager = managerFactory.GetManager <IStoreOperationsManager>(); PagedResult <StateProvinceInfo> stateProvinceInfoCollection = await storeOperationsManager.GetStateProvinces(countryCode, queryResultSettings); return(stateProvinceInfoCollection); }
/// <summary> /// Initializes a new instance of the <see cref="SqlServerDatabaseContext"/> class. /// </summary> /// <param name="context">The data request context.</param> /// <param name="requestSettings">The request settings.</param> public SqlServerDatabaseContext(RequestContext context, QueryResultSettings requestSettings) : base(context) { this.settings = requestSettings; }
public virtual async Task <PagedResult <LoyaltyCardTransaction> > GetLoyaltyCardTransactions(string loyaltyCardNumber, string rewardPointId, QueryResultSettings queryResultSettings) { ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IStoreOperationsManager storeOperationsManager = managerFactory.GetManager <IStoreOperationsManager>(); PagedResult <LoyaltyCardTransaction> loyaltyCardTransactions = await storeOperationsManager.GetLoyaltyCardTransactions(loyaltyCardNumber, rewardPointId, queryResultSettings); return(loyaltyCardTransactions); }
/// <summary> /// Gets the line delivery options for shipping. /// </summary> /// <param name="lineShippingAddresses">The line shipping addresses.</param> /// <param name="queryResultSettings">The query result settings.</param> /// <returns> /// The service response containing the available delivery options for the specified lines. /// </returns> public async Task <ActionResult> GetLineDeliveryOptionsForShipping(IEnumerable <LineShippingAddress> lineShippingAddresses, QueryResultSettings queryResultSettings) { EcommerceContext ecommerceContext = ServiceUtilities.GetEcommerceContext(this.HttpContext); CartOperationsHandler cartOperationsHandler = new CartOperationsHandler(ecommerceContext); SessionType sessionType = ServiceUtilities.GetSessionType(this.HttpContext, isCheckoutSession: true); string cartId = ServiceUtilities.GetCartIdFromRequestCookie(this.HttpContext, sessionType); PagedResult <SalesLineDeliveryOption> lineDeliveryOptions = await cartOperationsHandler.GetLineDeliveryOptionsForShipping(cartId, lineShippingAddresses, queryResultSettings); return(this.Json(lineDeliveryOptions.Results)); }
public virtual async Task <PagedResult <CountryRegionInfo> > GetCountryRegionInfo(string languageId, QueryResultSettings queryResultSettings) { ManagerFactory managerFactory = Utilities.GetManagerFactory(this.EcommerceContext); IStoreOperationsManager storeOperationsManager = managerFactory.GetManager <IStoreOperationsManager>(); PagedResult <CountryRegionInfo> countryRegionInfoCollection = await storeOperationsManager.GetCountryRegionsByLanguageId(languageId, queryResultSettings); return(countryRegionInfoCollection); }
/// <summary> /// Gets the customers. /// </summary> /// <param name="keyword">Optional record identifier of the customer to retrieve.</param> /// <param name="onlyCurrentCompany">If set to <c>true</c> [only current company].</param> /// <param name="settings">The query result settings.</param> /// <returns> /// A collection of customers. /// </returns> public PagedResult <GlobalCustomer> SearchCustomers(string keyword, bool onlyCurrentCompany, QueryResultSettings settings) { ThrowIf.Null(settings, "settings"); ThrowIf.Null(keyword, "keyword"); PagedResult <GlobalCustomer> customers = this.SearchCustomersSproc(keyword, onlyCurrentCompany, settings); return(customers); }
/// <summary> /// Retrieves terminal and device association information data from headquarters. /// </summary> /// <param name="orgUnitNumber">The store number.</param> /// <param name="deviceType">The device type value.</param> /// <param name="settings">The query result settings.</param> /// <returns>The paged results of terminal info of the given store.</returns> internal PagedResult <Microsoft.Dynamics.Commerce.Runtime.DataModel.TerminalInfo> GetTerminalInfo(string orgUnitNumber, int deviceType, QueryResultSettings settings) { ThrowIf.NullOrWhiteSpace(orgUnitNumber, "orgUnitNumber"); ThrowIf.Null(settings, "settings"); ThrowIf.Null(settings.Paging, "settings.Paging"); var terminalInfoList = new List <Microsoft.Dynamics.Commerce.Runtime.DataModel.TerminalInfo>(); var data = this.InvokeMethodAllowNullResponse( GetAvailableTerminalsMethodName, new object[] { orgUnitNumber, deviceType, settings.Paging.NumberOfRecordsToFetch, settings.Paging.Skip }); if (data != null) { var xmlTerminalInfoList = (string)data[0]; var availableTerminalInfo = SerializationHelper.DeserializeObjectDataContractFromXml <Serialization.TerminalInfo[]>(xmlTerminalInfoList); if (availableTerminalInfo != null) { terminalInfoList = availableTerminalInfo.Select(terminalInfo => new Microsoft.Dynamics.Commerce.Runtime.DataModel.TerminalInfo() { TerminalId = terminalInfo.TerminalId, DeviceNumber = terminalInfo.DeviceNumber, Name = terminalInfo.Name, DeviceType = terminalInfo.DeviceType, ActivationStatusValue = terminalInfo.ActivationStatusValue }).ToList(); } } return(new PagedResult <Microsoft.Dynamics.Commerce.Runtime.DataModel.TerminalInfo>(terminalInfoList.AsReadOnly(), settings.Paging)); }
/// <summary> /// Initiates a catalog publishing. /// </summary> /// <param name="catalogPublisher">Instance of the object which implements ICatalogPublisher.</param> /// <returns>True if changed products were found in CRT, False otherwise.</returns> /// <remarks>Retrieves the channel's catalogs from CRT and then checks whether CRT contains changed products for each of the catalogs. If changed products are found then /// ICatalogPublisher's callbacks are executed to let the caller's code process changed products.</remarks> public bool PublishCatalog(ICatalogPublisher catalogPublisher) { if (catalogPublisher == null) { throw new ArgumentNullException(nameof(catalogPublisher)); } List <long> productCatalogIds = new List <long>(1); // If catalogs were published to this channel, a given product will be published into SP for each catalog // in which it appears, so catalogless publishing would not yield different results for those products. // If, however, a product was published directly from the assortment, that product will only be detected // and published to SP if the ForceCataloglessPublishing flag is set to 'true' (1) in the job configuration file. // The semantics of forcing catalogless publishing as strict, in that catalog-less products will be published // if and only if the flag is set. That means, for instance, that if the flag is not set and there are no // catalogs published to this channel, the SP job will not detect/publish any products to SP. if (this.publishingConfig.ForceNoCatalogPublishing) { NetTracer.Information(Resources.ProductCatalogToPublish, 0, "unspecified", "(not a proper catalog)"); productCatalogIds.Add(0); } IReadOnlyCollection <ProductCatalog> productCatalogs = this.GetCatalogs(); bool deletesFound = this.DeleteProducts(productCatalogs, catalogPublisher); foreach (ProductCatalog productCatalog in productCatalogs) { productCatalogIds.Add(productCatalog.RecordId); } ChangedProductsSearchCriteria searchCriteria = new ChangedProductsSearchCriteria { DataLevel = CommerceEntityDataLevel.Complete }; searchCriteria.Context.ChannelId = this.onlineChannel.RecordId; bool isInitialSync; QueryResultSettings productsQuerySettings = this.CreateGetListingsCriteria( this.onlineChannel.ChannelProperties, searchCriteria, out isInitialSync); bool changesFound = false; try { Stopwatch readChangedProductsWatch = Stopwatch.StartNew(); searchCriteria.Session = this.productManager.BeginReadChangedProducts(searchCriteria); readChangedProductsWatch.Stop(); this.LogTimingMessage(Resources.Duration_ReadChangedProducts, readChangedProductsWatch.Elapsed, searchCriteria.Session.TotalNumberOfProducts); if (searchCriteria.Session.TotalNumberOfProducts > 0) { changesFound = true; int totalProductsCount = 0; Stopwatch timerCummulativeListingRetrieval = new Stopwatch(); // loop through the product catalogs, retrieving products. foreach (long productCatalogId in productCatalogIds) { NetTracer.Information(Resources.StartReadProductsFromCatalog, productCatalogId); // set the catalog id on the search criteria searchCriteria.Context.CatalogId = productCatalogId; searchCriteria.Session.ResetNumberOfProductsRead(); int pageNumberForCatalog = 0; int catalogProductsCount = 0; // inner loop: load changes, page by page, up to catalog max size do { timerCummulativeListingRetrieval.Start(); ChangedProductsSearchResult getProductsResults = this.LoadChangedProducts(searchCriteria, productsQuerySettings); timerCummulativeListingRetrieval.Stop(); int numberOfReadProducts = getProductsResults.Results.Count; totalProductsCount += numberOfReadProducts; catalogProductsCount += numberOfReadProducts; this.LogTimingMessage(Resources.NumberOfReadProductsInPageSummary, productCatalogId, catalogProductsCount, totalProductsCount, timerCummulativeListingRetrieval.Elapsed); catalogPublisher.OnChangedProductsFound(getProductsResults, pageNumberForCatalog, productCatalogId); pageNumberForCatalog++; }while (searchCriteria.Session.NumberOfProductsRead < searchCriteria.Session.TotalNumberOfProducts); this.LogTimingMessage(Resources.CatalogReadCompleted, productCatalogId, catalogProductsCount, totalProductsCount, timerCummulativeListingRetrieval.Elapsed); catalogPublisher.OnCatalogReadCompleted(productCatalogId, this); } // for each product catalog this.LogTimingMessage(Resources.AllCatalogsReadCompleted, totalProductsCount, timerCummulativeListingRetrieval.Elapsed); } // if changed products were found } finally { this.productManager.EndReadChangedProducts(searchCriteria.Session); } ChannelProperty channelProperty = new ChannelProperty { Name = KeySyncAnchor, Value = new string(searchCriteria.Session.NextSynchronizationToken) }; this.channelManager.UpdateChannelProperties(new ChannelProperty[] { channelProperty }); return(changesFound || deletesFound); }
/// <summary> /// Retrieves devices available for activation from headquarters. /// </summary> /// <param name="deviceType">The device type value.</param> /// <param name="settings">The query result settings.</param> /// <returns>The paged results of devices matches the given device type.</returns> internal PagedResult <Microsoft.Dynamics.Commerce.Runtime.DataModel.Device> GetAvailableDevices(int deviceType, QueryResultSettings settings) { ThrowIf.Null(settings, "settings"); ThrowIf.Null(settings.Paging, "settings.Paging"); var devices = new List <Microsoft.Dynamics.Commerce.Runtime.DataModel.Device>(); var data = this.InvokeMethodAllowNullResponse( GetAvailableDevicesMethodName, new object[] { deviceType, settings.Paging.NumberOfRecordsToFetch, settings.Paging.Skip }); if (data != null) { var xmlDevices = (string)data[0]; var availableDevices = SerializationHelper.DeserializeObjectDataContractFromXml <Serialization.Device[]>(xmlDevices); if (availableDevices != null) { devices = availableDevices.Select(device => new Microsoft.Dynamics.Commerce.Runtime.DataModel.Device() { DeviceNumber = device.DeviceNumber, DeviceType = device.DeviceType, ActivationStatusValue = device.ActivationStatusValue }).ToList(); } } return(new PagedResult <Microsoft.Dynamics.Commerce.Runtime.DataModel.Device>(devices.AsReadOnly(), settings.Paging)); }
/// <summary> /// Gets the product search results using the specified category identifier. /// </summary> /// <param name="currentChannelId">The identifier of the channel that the request is originating from.</param> /// <param name="searchText">The search text that the result should be relevant to.</param> /// <param name="targetChannelId">The identifier of the channel to which the resultant product representatives must belong to.</param> /// <param name="targetCatalogId">The identifier of the catalog to which the resultant product representatives must belong to.</param> /// <param name="attributeIdCollectionString">The attribute values to retrieve along with the result set.</param> /// <param name="settings">The settings to use while processing this request.</param> /// <returns>A collection of product search results representing products in the requested category or its sub-categories.</returns> internal ReadOnlyCollection <ProductSearchResult> SearchProductsByText(long currentChannelId, string searchText, long targetChannelId, long targetCatalogId, string attributeIdCollectionString, QueryResultSettings settings) { CP.RetailTransactionServiceResponse transactionServiceResponse = this.GetResponseFromMethod( GetProductsByKeywordMethodName, currentChannelId, searchText, settings.Paging.Skip + 1, // 1-based in AX settings.Paging.NumberOfRecordsToFetch, settings.Sorting == null ? RecordIdAttributeName : settings.Sorting.ToString(), // order by settings.Sorting == null || !settings.Sorting.IsSpecified ? (settings.Sorting.Columns.First().IsDescending ? 1 : 0) : 0, // sort order: Ascending by default false, // return total count string.Empty, // language targetChannelId, targetCatalogId, attributeIdCollectionString); // Check result if (!transactionServiceResponse.Success) { throw new CommunicationException( CommunicationErrors.Microsoft_Dynamics_Commerce_Runtime_HeadquarterCommunicationFailure, string.Format("Invoke method {0} failed: {1}", GetProductsByCategoryMethodName, transactionServiceResponse.Message)); } // Throw if service response does not contain any data. if (transactionServiceResponse.Data == null || transactionServiceResponse.Data.Length == 0) { throw new CommunicationException(CommunicationErrors.Microsoft_Dynamics_Commerce_Runtime_HeadquarterResponseParsingError, "Service response does not contain any data."); } string searchResultsXml = (string)transactionServiceResponse.Data[0]; var results = this.GetResultsFromXml(searchResultsXml); return(results); }
public TaskCompletionSource <object> PutParameters <T>(Guid batchId, string entitySet, string entitySetType, string functionName, QueryResultSettings settings, ICollection <string> expandProperties, params OperationParameter[] operationParameters) { if (!this.IsThreadRegistered(batchId)) { throw new InvalidOperationException("The calling thread is trying to cache tasks for batch operation, but the thread has not been registered on this cache."); } else { ParametersGroup prametersGroup = new ParametersGroup(entitySet, entitySetType, functionName, typeof(T), settings, expandProperties, operationParameters); this.requestsCache[batchId.ToString()].Add(prametersGroup); TaskCompletionSource <object> taskCompletionSource = new TaskCompletionSource <object>(); this.tasksCache[batchId.ToString()].Add(taskCompletionSource); return(taskCompletionSource); } }
public void OnExecuting(Request request) { SaveCartRequest saveCartRequest = request as SaveCartRequest; SalesTransaction salesTransaction = saveCartRequest.SalesTransaction; Dictionary <string, bool> checkDict = new Dictionary <string, bool>(); if (saveCartRequest.Cart.CartType == CartType.CustomerOrder && saveCartRequest.Cart.CustomerOrderMode == CustomerOrderMode.CustomerOrderCreateOrEdit) { if (salesTransaction == null) { salesTransaction = CartWorkflowHelper.LoadSalesTransaction(saveCartRequest.RequestContext, saveCartRequest.Cart.Id, saveCartRequest.Cart.Version); } if (salesTransaction != null && salesTransaction.CartType == CartType.CustomerOrder && salesTransaction.CustomerOrderMode == CustomerOrderMode.CustomerOrderCreateOrEdit && (!String.IsNullOrEmpty(saveCartRequest.Cart.DeliveryMode))) { bool DeliveryOnhandCheck = saveCartRequest.Cart.DeliveryMode == "99" ? true : false; if (DeliveryOnhandCheck == true) { InventoryManager inventoryManager = InventoryManager.Create(request.RequestContext.Runtime); foreach (SalesLine salesLine in salesTransaction.InventorySalesLines) { PagingInfo pagingInfo = new PagingInfo(30, 0); SortingInfo sortingInfo = new SortingInfo(); var settings = new QueryResultSettings(pagingInfo, sortingInfo); PagedResult <OrgUnitAvailability> orgUnitAvailabilities = inventoryManager.SearchAvailableInventory(salesLine.ProductId, null, settings); foreach (OrgUnitAvailability orgUnitAvailability in orgUnitAvailabilities) { if (checkDict.ContainsKey(salesLine.LineId)) { break; } foreach (ItemAvailability itemAvailability in orgUnitAvailability.ItemAvailabilities) { if (itemAvailability.ProductId == salesLine.ProductId && (itemAvailability.InventoryLocationId == salesLine.InventoryLocationId || string.IsNullOrEmpty(salesLine.InventoryLocationId)) // && itemAvailability.VariantInventoryDimensionId == salesLine.InventoryDimensionId && itemAvailability.AvailableQuantity >= salesLine.Quantity) { checkDict.Add(salesLine.LineId, true); break; } } } if (!checkDict.ContainsKey(salesLine.LineId)) { checkDict.Add(salesLine.LineId, false); } } if (checkDict.ContainsValue(false)) { throw new CartValidationException(DataValidationErrors.Microsoft_Dynamics_Commerce_Runtime_InvalidDeliveryMode, String.Format("Delivery mode {0} is not applicable since some product are out stock", salesTransaction.DeliveryMode)); } } } } }
public Task <PagedResult <Category> > GetCategories(long channelId, QueryResultSettings queryResultSettings) { return(Task.Run(() => ChannelManager.Create(CommerceRuntimeManager.Runtime).GetChannelCategoryHierarchy(channelId, queryResultSettings))); }