private async Task <FWTObjectID> GetBestMatchingAsync(FWTObjectBriefDetails[] individualResults, Customer customer)
        {
            FWTIndividual bestMatch            = null;
            FWTObjectID   bestMatchingObjectID = null;
            var           bestMatchScore       = 0;

            var tasks = new List <Task <retrieveIndividualResponse> >();

            _logger.LogDebug($"IndividualService.GetBestMatchingAsync:{customer.Surname}: Retrieving results for {individualResults.Count()} results");

            foreach (var individualResult in individualResults)
            {
                tasks.Add(Task.Run(async() =>
                {
                    _logger.LogDebug($"IndividualService.GetBestMatchingAsync:{customer.Surname}: Retrievingindividual");
                    return(await _verintConnection.retrieveIndividualAsync(individualResult.ObjectID));
                }));
            }

            var results = await Task.WhenAll(tasks);

            _logger.LogDebug($"IndividualService.GetBestMatchingAsync:{customer.Surname}: Retrieved all search result objects");

            results.ToList().ForEach(result =>
            {
                var individual = result.FWTIndividual;
                var score      = 0;

                _individualWeightings.ToList().ForEach(_ => score += _.Calculate(individual, customer));

                if (score > bestMatchScore)
                {
                    bestMatchScore = score;
                    bestMatch      = individual;
                }
            });

            if (bestMatch != null && bestMatchScore >= 1)
            {
                _logger.LogDebug($"IndividualService.GetBestMatchingAsync:{customer.Surname}: Match found, score: {bestMatchScore}");
                await UpdateIndividual(bestMatch, customer);

                bestMatchingObjectID = bestMatch.BriefDetails.ObjectID;
            }

            return(bestMatchingObjectID);
        }
Beispiel #2
0
        public async Task <StockportGovUK.NetStandard.Models.Verint.Case> GetCase(string caseId)
        {
            if (string.IsNullOrWhiteSpace(caseId))
            {
                throw new Exception("Null or empty references are not allowed");
            }

            var caseRequest = new FWTCaseFullDetailsRequest
            {
                CaseReference = caseId.Trim(),
                Option        = new[] { "all" }
            };

            var response = await _verintConnection.retrieveCaseDetailsAsync(caseRequest);

            var caseDetails = response.FWTCaseFullDetails.MapToCase();

            if (response.FWTCaseFullDetails.CoreDetails.AssociatedObject != null)
            {
                if (response.FWTCaseFullDetails.CoreDetails.AssociatedObject.ObjectID.ObjectType ==
                    VerintConstants.OrganisationObjectType)
                {
                    var organisation = await _verintConnection.retrieveOrganisationAsync(response.FWTCaseFullDetails.CoreDetails.AssociatedObject.ObjectID);

                    if (organisation != null)
                    {
                        caseDetails.Organisation = organisation.FWTOrganisation.Map();
                    }
                }

                if (!string.IsNullOrWhiteSpace(response.FWTCaseFullDetails.Interactions[0]?.PartyID?.ObjectReference[0]) &&
                    response.FWTCaseFullDetails.Interactions[0]?.PartyID?.ObjectType == "C1")
                {
                    var individual = await _verintConnection.retrieveIndividualAsync(response.FWTCaseFullDetails.Interactions[0].PartyID);

                    if (individual != null)
                    {
                        caseDetails.Customer = individual.FWTIndividual.MapToCustomer();
                    }
                }
            }

            return(caseDetails);
        }