Example #1
0
            /// <summary>
            /// Given all relevant transaction info, this method will calculate the charges
            /// which should be put on the given transaction.
            /// </summary>
            /// <param name="context">The request context.</param>
            /// <param name="customerId">The customer account number to search for transaction charges by.</param>
            /// <param name="customerGroup">The customer charge group id to search for transaction charges by.</param>
            /// <param name="deliveryMode">The delivery mode code to search transaction charges by.</param>
            /// <param name="deliveryModeGroup">The delivery mode charge group id to search transactions charges by.</param>
            /// <param name="transaction">The transaction which will potentially have charges.</param>
            /// <returns>Collection of charges which apply to this transaction.</returns>
            private static IEnumerable <ChargeLine> CalculateTransactionCharges(RequestContext context, string customerId, string customerGroup, string deliveryMode, string deliveryModeGroup, SalesTransaction transaction)
            {
                GetSalesParametersDataRequest getSalesParametersDataRequest = new GetSalesParametersDataRequest(QueryResultSettings.SingleRecord);
                var salesParameters = context.Execute <SingleEntityDataServiceResponse <SalesParameters> >(getSalesParametersDataRequest).Entity;

                // return empty if we're not calculating transaction charges
                if (!salesParameters.UseHeaderCharges)
                {
                    return(new Collection <ChargeLine>());
                }

                // generate all applicable combinations of account, item, and delivery type for header auto-charges
                //   we'll iterate through these to create the header filters for finding auto-charge configurations
                var allCombinations = GetAllHeaderChargeCombinations();

                var processorArgs = new ChargeProcessorArguments
                {
                    CombinationsToTry   = allCombinations,
                    ChargeType          = ChargeLevel.Header,
                    CustomerId          = customerId,
                    CustomerChargeGroup = customerGroup,
                    ItemId                  = string.Empty,
                    ItemChargeGroup         = string.Empty,
                    DeliveryModeId          = deliveryMode,
                    DeliveryModeChargeGroup = deliveryModeGroup,
                };

                return(ApplyAutoCharges(context, transaction, processorArgs));
            }
Example #2
0
            /// <summary>
            /// Given all relevant transaction/line info, this will calculate the charges
            /// which should be put on the given sales line.
            /// </summary>
            /// <param name="context">The request context.</param>
            /// <param name="customerId">The customer account number to use for searching.</param>
            /// <param name="customerGroup">The customer charge group id to use for searching.</param>
            /// <param name="deliveryMode">The delivery mode code to use for searching.</param>
            /// <param name="deliveryModeGroup">The delivery mode charge group id to use for searching.</param>
            /// <param name="line">The sales line that would get the charge. Null if not applying to sales line.</param>
            /// <param name="transaction">The sales transaction that will have this charge.</param>
            /// <returns>Collection of charges which apply to this line.</returns>
            private static IEnumerable <ChargeLine> CalculateLineCharges(RequestContext context, string customerId, string customerGroup, string deliveryMode, string deliveryModeGroup, SalesLine line, SalesTransaction transaction)
            {
                GetSalesParametersDataRequest getSalesParametersDataRequest = new GetSalesParametersDataRequest(QueryResultSettings.SingleRecord);
                var salesParameters = context.Execute <SingleEntityDataServiceResponse <SalesParameters> >(getSalesParametersDataRequest).Entity;

                // return empty if we're not calculating line charges
                if (!salesParameters.UseLineCharges)
                {
                    return(new Collection <ChargeLine>());
                }

                var getItemsRequest = new GetItemsDataRequest(new string[] { line.ItemId });

                getItemsRequest.QueryResultSettings = new QueryResultSettings(new ColumnSet("ITEMID", "MARKUPGROUPID"), PagingInfo.AllRecords);
                var getItemsResponse = context.Execute <GetItemsDataResponse>(getItemsRequest);

                Item item = getItemsResponse.Items.SingleOrDefault();

                if (item == null)
                {
                    return(new Collection <ChargeLine>());
                }

                // generate all applicable combinations of account, item, and delivery type for line auto-charges
                //   we'll iterate through these below to create the header filters for finding auto-charge configurations
                var allCombinations = GetAllLineChargeCombinations();
                var processorArgs   = new ChargeProcessorArguments
                {
                    CombinationsToTry   = allCombinations,
                    ChargeType          = ChargeLevel.Line,
                    CustomerId          = customerId,
                    CustomerChargeGroup = customerGroup,
                    ItemId                  = item.ItemId,
                    ItemChargeGroup         = item.ChargeGroup,
                    DeliveryModeId          = deliveryMode,
                    DeliveryModeChargeGroup = deliveryModeGroup,
                };

                return(ApplyAutoCharges(context, transaction, processorArgs));
            }
            private SingleEntityDataServiceResponse <SalesParameters> GetSalesParameters(GetSalesParametersDataRequest request)
            {
                ThrowIf.Null(request, "request");
                ThrowIf.Null(request.QueryResultSettings, "request.QueryResultSettings");

                ChargeL2CacheDataStoreAccessor level2CacheDataAccessor = this.GetChargeL2CacheDataStoreAccessor(request.RequestContext);
                bool            found;
                bool            updateL2Cache;
                string          dataAreaId = request.RequestContext.GetChannelConfiguration().InventLocationDataAreaId;
                SalesParameters result     = DataManager.GetDataFromCache(() => level2CacheDataAccessor.GetSalesParameters(dataAreaId, request.QueryResultSettings.ColumnSet), out found, out updateL2Cache);

                if (!found)
                {
                    var query = new SqlPagedQuery(QueryResultSettings.SingleRecord)
                    {
                        Select = request.QueryResultSettings.ColumnSet,
                        From   = SalesParametersViewName,
                        Where  = "DATAAREAID = @DataAreaId"
                    };

                    query.Parameters["@DataAreaId"] = dataAreaId;

                    using (DatabaseContext databaseContext = new DatabaseContext(request.RequestContext))
                    {
                        result = databaseContext.ReadEntity <SalesParameters>(query).SingleOrDefault();
                    }

                    updateL2Cache &= result != null;
                }

                if (updateL2Cache)
                {
                    level2CacheDataAccessor.PutSalesParameters(dataAreaId, request.QueryResultSettings.ColumnSet, result);
                }

                return(new SingleEntityDataServiceResponse <SalesParameters>(result));
            }