Exemple #1
0
            /// <summary>
            /// Calculates the specific reason code on an entity like sales line, tender line etc.
            /// </summary>
            /// <param name="request">The request.</param>
            /// <param name="sourceId">The source identifier.</param>
            /// <param name="tableRefType">The table identifier for the specific reason code.</param>
            /// <param name="refRelation">The first reference relation key corresponding to the entity and table.</param>
            /// <param name="refRelation2">The second reference relation key corresponding to the entity and table.</param>
            /// <param name="refRelation3">The third reference relation key corresponding to the entity and table.</param>
            /// <param name="requiredReasonCodes">The collection to which required reason codes are added.</param>
            /// <param name="reasonCodeRequirements">The required specific reason codes map.</param>
            /// <param name="presentReasonCodeLines">The collection with the already present reason code lines.</param>
            /// <param name="salesLine">The sales line when applicable.</param>
            private static void CalculateReasonCodesSpecificToEntity(
                CalculateRequiredReasonCodesServiceRequest request,
                string sourceId,
                ReasonCodeTableRefType tableRefType,
                string refRelation,
                string refRelation2,
                string refRelation3,
                IDictionary <string, ReasonCode> requiredReasonCodes,
                HashSet <ReasonCodeRequirement> reasonCodeRequirements,
                IEnumerable <ReasonCodeLine> presentReasonCodeLines,
                SalesLine salesLine)
            {
                GetReasonCodesByTableRefTypeDataRequest getReasonCodesByTableRefTypeDataRequest = new GetReasonCodesByTableRefTypeDataRequest(tableRefType, refRelation, refRelation2, refRelation3, QueryResultSettings.AllRecords);
                IEnumerable <ReasonCode> reasonCodes = request.RequestContext.Runtime.Execute <EntityDataServiceResponse <ReasonCode> >(getReasonCodesByTableRefTypeDataRequest, request.RequestContext).PagedEntityCollection.Results;

                reasonCodes = AddLinkedReasonCodes(reasonCodes, request.RequestContext);

                var triggeredReasonCodes = CalculateTriggeredReasonCodes(reasonCodes, presentReasonCodeLines, request.RequestContext);

                reasonCodes = reasonCodes.Union(triggeredReasonCodes).Distinct();

                reasonCodes = AddLinkedReasonCodes(reasonCodes, request.RequestContext);

                foreach (var reasonCode in reasonCodes)
                {
                    if (presentReasonCodeLines.Any(rc => string.Equals(rc.ReasonCodeId, reasonCode.ReasonCodeId, StringComparison.OrdinalIgnoreCase)))
                    {
                        continue;
                    }

                    bool entitySpecificApplicability = true;

                    switch (tableRefType)
                    {
                    case ReasonCodeTableRefType.Item:
                        entitySpecificApplicability = HasSalesLineSpecificApplicability(reasonCode, salesLine);
                        break;
                    }

                    if (entitySpecificApplicability &&
                        ShouldReasonCodeBeApplied(reasonCode, request.SalesTransaction))
                    {
                        var reasonCodeRequirement = new ReasonCodeRequirement()
                        {
                            ReasonCodeId      = reasonCode.ReasonCodeId,
                            SourceId          = sourceId,
                            TableRefTypeValue = (int)tableRefType,
                        };

                        reasonCodeRequirements.Add(reasonCodeRequirement);
                        requiredReasonCodes[reasonCode.ReasonCodeId] = reasonCode;
                    }
                }
            }
Exemple #2
0
            /// <summary>
            /// Calculates the required reason codes given the source type.
            /// </summary>
            /// <param name="request">The request.</param>
            /// <param name="requiredReasonCodes">The collection to which required reason codes are added.</param>
            /// <param name="transactionRequiredReasonCodeIds">The identifiers of reason codes required at transaction level.</param>
            /// <param name="reasonCodeRequirements">The collection of reason code requirements.</param>
            private static void CalculateRequiredReasonCodesBySourceType(
                CalculateRequiredReasonCodesServiceRequest request,
                Dictionary <string, ReasonCode> requiredReasonCodes,
                HashSet <string> transactionRequiredReasonCodeIds,
                HashSet <ReasonCodeRequirement> reasonCodeRequirements)
            {
                // Look up operation level reason codes if available.
                if (request.SourceType != ReasonCodeSourceType.None)
                {
                    ReasonCodeSettings settingsDictionary = GetReasonCodeSettings(request.RequestContext);
                    string             reasonCodeId       = settingsDictionary[request.SourceType];

                    if (!string.IsNullOrWhiteSpace(reasonCodeId))
                    {
                        GetReasonCodesDataRequest getReasonCodeRequest = new GetReasonCodesDataRequest(QueryResultSettings.AllRecords, new string[] { reasonCodeId });
                        IEnumerable <ReasonCode>  reasonCodes          = request.RequestContext.Execute <EntityDataServiceResponse <ReasonCode> >(getReasonCodeRequest).PagedEntityCollection.Results;

                        foreach (var reasonCode in reasonCodes)
                        {
                            if (IsTransactionSourceType(request.SourceType) &&
                                ShouldReasonCodeBeApplied(reasonCode, request.SalesTransaction))
                            {
                                if (!ContainsReasonCode(request.SalesTransaction.ReasonCodeLines, reasonCode.ReasonCodeId))
                                {
                                    requiredReasonCodes[reasonCode.ReasonCodeId] = reasonCode;
                                    transactionRequiredReasonCodeIds.Add(reasonCode.ReasonCodeId);
                                }

                                var triggeredReasonCodes = CalculateTriggeredReasonCodes(
                                    new ReasonCode[] { reasonCode }, request.SalesTransaction.ReasonCodeLines, request.RequestContext);

                                if (triggeredReasonCodes.Any())
                                {
                                    requiredReasonCodes.AddRange(triggeredReasonCodes.ToDictionary(rc => rc.ReasonCodeId, rc => rc));
                                    transactionRequiredReasonCodeIds.AddRange(triggeredReasonCodes.Select(rc => rc.ReasonCodeId));
                                }
                            }
                            else
                            {
                                foreach (var salesLine in request.SalesLines)
                                {
                                    if (ShouldReasonCodeBeApplied(reasonCode, request.SalesTransaction))
                                    {
                                        if (!ContainsReasonCode(salesLine.ReasonCodeLines, reasonCode.ReasonCodeId))
                                        {
                                            var reasonCodeRequirement = new ReasonCodeRequirement()
                                            {
                                                ReasonCodeId      = reasonCode.ReasonCodeId,
                                                SourceId          = salesLine.ProductId.ToString(CultureInfo.InvariantCulture),
                                                TableRefTypeValue = (int)ReasonCodeTableRefType.Item,
                                            };

                                            reasonCodeRequirements.Add(reasonCodeRequirement);
                                            requiredReasonCodes[reasonCode.ReasonCodeId] = reasonCode;
                                        }

                                        var triggeredReasonCodes = CalculateTriggeredReasonCodes(
                                            new ReasonCode[] { reasonCode }, salesLine.ReasonCodeLines, request.RequestContext);

                                        if (triggeredReasonCodes.Any())
                                        {
                                            requiredReasonCodes.AddRange(triggeredReasonCodes.ToDictionary(rc => rc.ReasonCodeId, rc => rc));
                                            reasonCodeRequirements.AddRange(triggeredReasonCodes.Select(rc => new ReasonCodeRequirement()
                                            {
                                                ReasonCodeId      = rc.ReasonCodeId,
                                                SourceId          = salesLine.ProductId.ToString(CultureInfo.InvariantCulture),
                                                TableRefTypeValue = (int)ReasonCodeTableRefType.Item,
                                            }));
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }