public async Task <ISpiderCheckResult> AddAsync(ISpiderCheckResult entity)
{
var newEntity = SpiderCheckResultEntity.Create(entity);
await _tableStorage.InsertOrReplaceAsync(newEntity);
return(newEntity);
}
private async Task <ISpiderCheckResult> GetCheckResult(string clientId, ISpiderCheckResult spiderResult)
{
if (spiderResult != null)
{
return(await _checkResultRepository.AddAsync(spiderResult));
}
return(await _spiderCheckService.CheckAsync(clientId));
}
public static SpiderCheckResultEntity Create(ISpiderCheckResult src)
{
var entity = Mapper.Map <SpiderCheckResultEntity>(src);
entity.PersonProfiles = Mapper.Map <SpiderProfile[]>(src.PersonProfiles);
entity.PartitionKey = GeneratePartitionKey(src.CustomerId);
entity.RowKey = GenerateRowKey(src.ResultId);
return(entity);
}
private static ISpiderCheckResultDiff ComputeDiffWithEmpty(ISpiderCheckResult result, Func <string, bool> categoryPredicate)
{
var filteredProfiles = FilterByCategory(result.PersonProfiles, categoryPredicate);
return(new SpiderCheckResultDiff
{
AddedProfiles = filteredProfiles.Select(Mapper.Map <SpiderProfile>).ToArray(),
ChangedProfiles = Array.Empty <SpiderProfilePair>(),
RemovedProfiles = Array.Empty <SpiderProfile>()
});
}
private static ISpiderCheckResultDiff ComputeDiffByCategory
(
ISpiderCheckResult current,
ISpiderCheckResult previous,
Func <string, bool> categoryPredicate
)
{
var(oldProfiles, newProfiles) = RemoveIntersection(
FilterByCategory(previous.PersonProfiles, categoryPredicate),
FilterByCategory(current.PersonProfiles, categoryPredicate), ResultComparer);
var oldProfileIds = oldProfiles.Select(x => x.ProfileId);
var newProfileIds = oldProfiles.Select(x => x.ProfileId);
var changedIds = oldProfileIds
.Intersect(newProfileIds)
.ToHashSet();
var changedProfiles = oldProfiles
.Join(newProfiles,
x => x.ProfileId,
y => y.ProfileId,
(x, y) => new SpiderProfilePair
{
Previous = Mapper.Map <SpiderProfile>(x),
Current = Mapper.Map <SpiderProfile>(y)
})
.Where(p => changedIds.Contains(p.Previous.ProfileId))
.ToArray();
var removedProfiles = oldProfiles
.Where(x => !changedIds.Contains(x.ProfileId))
.Select(Mapper.Map <SpiderProfile>)
.ToArray();
var addedProfiles = newProfiles
.Where(x => !changedIds.Contains(x.ProfileId))
.Select(Mapper.Map <SpiderProfile>)
.ToArray();
return(new SpiderCheckResultDiff
{
ChangedProfiles = changedProfiles,
RemovedProfiles = removedProfiles,
AddedProfiles = addedProfiles
});
}
private async Task SaveCustomerChecksInfo(ISpiderCheckResult result, SpiderDocumentAutoStatusGroup checksInfo)
{
var clientId = result.CustomerId;
var checkId = result.ResultId;
await _customerChecksRepository.AddAsync(new CustomerChecksInfo
{
CustomerId = clientId,
LatestPepCheckId = checkId,
LatestCrimeCheckId = checkId,
LatestSanctionCheckId = checkId,
IsPepCheckRequired = checksInfo.Pep.IsAutoApproved,
IsCrimeCheckRequired = checksInfo.Crime.IsAutoApproved,
IsSanctionCheckRequired = checksInfo.Sanction.IsAutoApproved
});
}
private async Task <SpiderDocumentAutoStatusGroup> SaveDocuments(ISpiderCheckResult result)
{
var pepDiff = _diffService.ComputeDiffWithEmptyByPep(result);
var crimeDiff = _diffService.ComputeDiffWithEmptyByCrime(result);
var sanctionDiff = _diffService.ComputeDiffWithEmptyBySanction(result);
var clientId = result.CustomerId;
var checkId = result.ResultId;
var pepTask = SaveDocument(clientId, pepDiff, PepSpiderCheck.ApiType, checkId, result.CheckDateTime);
var crimeTask = SaveDocument(clientId, crimeDiff, CrimeSpiderCheck.ApiType, checkId, result.CheckDateTime);
var sanctionTask = SaveDocument(clientId, sanctionDiff, SanctionSpiderCheck.ApiType, checkId, result.CheckDateTime);
return(new SpiderDocumentAutoStatusGroup
{
Pep = await pepTask,
Crime = await crimeTask,
Sanction = await sanctionTask
});
}
public ISpiderCheckResultDiff ComputeDiffWithEmptyBySanction(ISpiderCheckResult result)
{
return(ComputeDiffWithEmpty(result, SanctionCategoryPredicate));
}
public ISpiderCheckResultDiff ComputeDiffWithEmptyByCrime(ISpiderCheckResult result)
{
return(ComputeDiffWithEmpty(result, CrimeCategoryPredicate));
}
public ISpiderCheckResultDiff ComputeDiffBySanction(ISpiderCheckResult current, ISpiderCheckResult previous)
{
return(ComputeDiffByCategory(current, previous, SanctionCategoryPredicate));
}
public ISpiderCheckResultDiff ComputeDiffByCrime(ISpiderCheckResult current, ISpiderCheckResult previous)
{
return(ComputeDiffByCategory(current, previous, CrimeCategoryPredicate));
}
public Task <SpiderDocumentAutoStatusGroup> MoveFirstCheckAsync(string clientId, ISpiderCheckResult spiderResult)
{
return(SpiderManageApi.MoveFirstCheckAsync(clientId, spiderResult));
}
public async Task <SpiderDocumentAutoStatusGroup> PerformFirstCheckAsync(string clientId, ISpiderCheckResult spiderResult = null)
{
_log.Info($"Stated first spider check for {clientId}");
var checkResult = await GetCheckResult(clientId, spiderResult);
var checksInfo = await SaveDocuments(checkResult);
await SaveCustomerChecksInfo(checkResult, checksInfo);
_log.Info($"Finished first spider check for {clientId}");
return(checksInfo);
}
public static ISpiderCheckResultDiff ComputeDiff(this ICheckPersonResultDiffService service, string apiType, ISpiderCheckResult current, ISpiderCheckResult previous)
{
switch (apiType)
{
case PepSpiderCheck.ApiType:
return(service.ComputeDiffByPep(current, previous));
case CrimeSpiderCheck.ApiType:
return(service.ComputeDiffByCrime(current, previous));
case SanctionSpiderCheck.ApiType:
return(service.ComputeDiffBySanction(current, previous));
default:
throw new InvalidOperationException();
}
}
private async Task <CheckSummary> CheckCustomerByType(string apiType, ICustomerChecksInfo customer, ISpiderCheckResult currentResult)
{
if (!customer.GetIsCheckRequired(apiType))
{
return(CheckSummary.Empty);
}
var clientId = customer.CustomerId;
var previousResultId = customer.GetLatestCheckId(apiType);
var previousResult = await _spiderCheckResultRepository.GetAsync(clientId, previousResultId);
var diff = _diffService.ComputeDiff(apiType, currentResult, previousResult);
var summary = CheckSummary.FromDiff(diff);
if (summary.IsSuspected)
{
var document = await _spiderCheckProcessingService.UploadSpiderCheck(clientId, apiType, UploadRequest);
await _spiderDocumentInfoRepository.AddOrUpdateAsync(new SpiderDocumentInfo
{
CustomerId = clientId,
DocumentId = document.DocumentId,
CheckDiff = Mapper.Map <SpiderCheckResultDiff>(diff),
CurrentCheckId = currentResult.ResultId,
PreviousCheckId = previousResultId
});
await _customerChecksInfoRepository.UpdateCheckStatesAsync(clientId, apiType, false);
}
await _customerChecksInfoRepository.UpdateLatestCheckIdAsync(clientId, apiType, currentResult.ResultId);
return(summary);
}
