private async Task <Result> SaveAccommodationManualCorrection(string htAccommodationId,
AccommodationManualCorrectionRequest accommodationManualCorrectionRequest, CancellationToken cancellationToken)
{
var(_, isFailure, accommodationId, error) = AccommodationIdRetriever.RetrieveId(htAccommodationId);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodation = await _context.Accommodations.SingleOrDefaultAsync(ac => ac.Id == accommodationId, cancellationToken);
if (accommodation == default)
{
return(Result.Failure($"Accommodation with {nameof(htAccommodationId)} {htAccommodationId} does not exist."));
}
accommodation.AccommodationWithManualCorrections = MultilingualAccommodationConverter.Convert(accommodationManualCorrectionRequest);
accommodation.Modified = DateTimeOffset.UtcNow;
accommodation.IsCorrected = false;
_context.Update(accommodation);
await _context.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
public async Task <Result> Deactivate(AccommodationsDeactivationRequest request, CancellationToken cancellationToken = default)
{
if (!request.HtAccommodationIds.Any())
{
return(Result.Failure("Accommodation ids must be specified"));
}
if (request.Reason == DeactivationReasons.None)
{
return(Result.Failure("Deactivation reason must be specified"));
}
var(_, isFailure, accommodationIds, error) = AccommodationIdRetriever.RetrieveIds(request.HtAccommodationIds);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodationsToDeactivate =
await _context.Accommodations.Where(a => accommodationIds.Contains(a.Id) && a.IsActive).ToListAsync(cancellationToken);
if (!accommodationsToDeactivate.Any())
{
return(Result.Success());
}
return(await DeactivateAccommodations(accommodationsToDeactivate)
.Tap(Unpublish)
.Tap(AddDeactivationEvents));
async Task <Result <List <RichAccommodationDetails> > > DeactivateAccommodations(List <RichAccommodationDetails> accommodations)
{
var dateTime = DateTimeOffset.UtcNow;
foreach (var accommodation in accommodations)
{
accommodation.IsActive = false;
accommodation.DeactivationReason = request.Reason;
accommodation.DeactivationReasonDescription = request.DeactivationReasonDescription;
accommodation.Modified = dateTime;
}
_context.UpdateRange(accommodations);
await _context.SaveChangesAsync(cancellationToken);
return(accommodations);
}
Task Unpublish(List <RichAccommodationDetails> accommodations)
{
var ids = accommodations.Select(a => a.Id).ToList();
return(_accommodationChangePublisher.PublishRemoved(ids));
}
Task AddDeactivationEvents()
=> _accommodationChangeLogService.AddDeactivationEvents(accommodationIds !, AccommodationChangeEventSources.Api, request.Reason,
request.DeactivationReasonDescription);
}
public async Task <Result> AddSuppliersPriority(string htAccommodationId, Dictionary <AccommodationDataTypes, List <string> > suppliersPriority,
CancellationToken cancellationToken = default)
{
var(_, isFailure, accommodationId, error) = AccommodationIdRetriever.RetrieveId(htAccommodationId);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodation = await _context.Accommodations.SingleOrDefaultAsync(ac => ac.Id == accommodationId, cancellationToken);
if (accommodation == default)
{
return(Result.Failure($"Accommodation with {nameof(htAccommodationId)} {htAccommodationId} does not exist."));
}
accommodation.SuppliersPriority = suppliersPriority;
accommodation.IsCorrected = false;
accommodation.Modified = DateTimeOffset.UtcNow;
_context.Update(accommodation);
await _context.SaveChangesAsync(cancellationToken);
return(Result.Success());
}
public async Task <Result> Activate(string htAccommodationId, DeactivationReasons deactivationReasonToCheck = default,
CancellationToken cancellationToken = default)
{
var(_, isFailure, accommodationId, error) = AccommodationIdRetriever.RetrieveId(htAccommodationId);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodationToActivate = await _context.Accommodations.SingleOrDefaultAsync(a => a.Id == accommodationId, cancellationToken);
if (accommodationToActivate is null)
{
return(Result.Failure <RichAccommodationDetails>($"Accommodation with htId {htAccommodationId} doesn't exist"));
}
if (deactivationReasonToCheck != default && accommodationToActivate.DeactivationReason != deactivationReasonToCheck)
{
return(Result.Failure <RichAccommodationDetails>(
$"Accommodation with htId {htAccommodationId} must have {deactivationReasonToCheck.ToString()} deactivation reason."));
}
if (accommodationToActivate.IsActive)
{
return(Result.Success());
}
return(await ActivateAccommodation(accommodationToActivate)
.Tap(Publish)
.Tap(AddActivationEvent));
async Task <Result <RichAccommodationDetails> > ActivateAccommodation(RichAccommodationDetails accommodation)
{
accommodation.IsActive = true;
accommodation.DeactivationReason = DeactivationReasons.None;
accommodation.DeactivationReasonDescription = string.Empty;
accommodation.Modified = DateTimeOffset.UtcNow;
_context.Update(accommodation);
await _context.SaveChangesAsync(cancellationToken);
return(accommodation);
}
Task Publish(RichAccommodationDetails accommodation)
{
return(_accommodationChangePublisher.PublishAdded(AccommodationDataForPublicationConverter.Convert(accommodation), accommodation.LocalityId ?? default));
}
Task AddActivationEvent()
=> _accommodationChangeLogService.AddActivationEvent(accommodationId, AccommodationChangeEventSources.Api,
accommodationToActivate.DeactivationReason);
}
public async Task <Result> Deactivate(string htAccommodationId, DeactivationReasons reason, string deactivationReasonDescription,
CancellationToken cancellationToken = default)
{
var(_, isFailure, accommodationId, error) = AccommodationIdRetriever.RetrieveId(htAccommodationId);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodationToDeactivate = await _context.Accommodations.SingleOrDefaultAsync(a => a.Id == accommodationId, cancellationToken);
if (accommodationToDeactivate is null)
{
return(Result.Failure($"Accommodation with id {accommodationId} doesn't exist"));
}
if (reason == DeactivationReasons.None)
{
return(Result.Failure("Deactivation reason must be specified"));
}
if (accommodationToDeactivate.IsActive == false && accommodationToDeactivate.DeactivationReason == reason)
{
return(Result.Success());
}
return(await DeactivateAccommodation(accommodationToDeactivate)
.Tap(Unpublish)
.Tap(AddDeactivationEvent));
async Task <Result <RichAccommodationDetails> > DeactivateAccommodation(RichAccommodationDetails accommodation)
{
accommodation.IsActive = false;
accommodation.DeactivationReason = reason;
accommodation.DeactivationReasonDescription = deactivationReasonDescription;
accommodation.Modified = DateTimeOffset.UtcNow;
_context.Update(accommodation);
await _context.SaveChangesAsync(cancellationToken);
return(accommodation);
}
Task Unpublish(RichAccommodationDetails accommodation) => _accommodationChangePublisher.PublishRemoved(accommodation.Id);
Task AddDeactivationEvent()
=> _accommodationChangeLogService.AddDeactivationEvent(accommodationId, AccommodationChangeEventSources.Api, reason,
deactivationReasonDescription);
}
/// <summary>
/// Combines accommodation to the accommodation with baseHtAccommodationId.
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <Result> Merge(AccommodationsMergeRequest request, CancellationToken cancellationToken = default)
{
var baseHtAccommodationId = request.BaseHtAccommodationId;
var htAccommodationIdToMerge = request.HtAccommodationIdToMerge;
var baseAccommodationIdResult = AccommodationIdRetriever.RetrieveId(baseHtAccommodationId);
if (baseAccommodationIdResult.IsFailure)
{
return(Result.Failure(baseAccommodationIdResult.Error));
}
var accommodationIdToMergeResult = AccommodationIdRetriever.RetrieveId(htAccommodationIdToMerge);
if (accommodationIdToMergeResult.IsFailure)
{
return(Result.Failure(accommodationIdToMergeResult.Error));
}
var baseAccommodationId = baseAccommodationIdResult.Value;
var accommodationIdToMerge = accommodationIdToMergeResult.Value;
var(_, isFailure, error) = await Merge(baseAccommodationId, accommodationIdToMerge);
if (isFailure)
{
return(Result.Failure(error));
}
await AddOrUpdateMappings(baseAccommodationId, accommodationIdToMerge);
var uncertainMatch = await _context.AccommodationUncertainMatches
.Where(um => um.IsActive && (um.SourceHtId == baseAccommodationId && um.HtIdToMerge == accommodationIdToMerge ||
um.HtIdToMerge == baseAccommodationId && um.SourceHtId == accommodationIdToMerge))
.FirstOrDefaultAsync(cancellationToken);
if (uncertainMatch != default)
{
uncertainMatch.IsActive = false;
_context.Update(uncertainMatch);
}
await _context.SaveChangesAsync(cancellationToken);
await _accommodationChangePublisher.PublishRemoved(accommodationIdToMerge);
await _accommodationChangeLogCollectorService.SaveCollectedEventLogs(cancellationToken);
return(Result.Success());
}
public async Task <Result> Activate(AccommodationsActivationRequest request, CancellationToken cancellationToken = default)
{
if (!request.HtAccommodationIds.Any())
{
return(Result.Failure("Accommodation htIds must be specified"));
}
var(_, isFailure, accommodationIds, error) = AccommodationIdRetriever.RetrieveIds(request.HtAccommodationIds);
if (isFailure)
{
return(Result.Failure(error));
}
var accommodationsToActivate = await _context.Accommodations.Where(a => accommodationIds.Contains(a.Id) && !a.IsActive)
.ToListAsync(cancellationToken);
if (!accommodationsToActivate.Any())
{
return(Result.Success());
}
return(await ActivateAccommodations(accommodationsToActivate)
.Tap(Publish));
async Task <Result <List <RichAccommodationDetails> > > ActivateAccommodations(List <RichAccommodationDetails> accommodations)
{
var dateTime = DateTimeOffset.UtcNow;
foreach (var accommodation in accommodations)
{
_accommodationChangeLogCollectorService.CollectActivationEvent(accommodation.Id, AccommodationChangeEventSources.Api,
accommodation.DeactivationReason);
accommodation.IsActive = true;
accommodation.DeactivationReason = DeactivationReasons.None;
accommodation.DeactivationReasonDescription = string.Empty;
accommodation.IsCorrected = false;
accommodation.Modified = dateTime;
}
_context.UpdateRange(accommodations);
await _context.SaveChangesAsync(cancellationToken);
await _accommodationChangeLogCollectorService.SaveCollectedEventLogs(cancellationToken);
return(accommodations);
}
Task Publish(List <RichAccommodationDetails> richAccommodationsData)
{
var accommodationsToPublish = new List <(AccommodationDataForPublication accommodation, int localityId)>(richAccommodationsData.Count);
foreach (var richAccommodationData in richAccommodationsData)
{
var accommodation = AccommodationDataForPublicationConverter.Convert(richAccommodationData);
accommodationsToPublish.Add((accommodation, richAccommodationData.LocalityId ?? default));
}
return(_accommodationChangePublisher.PublishAdded(accommodationsToPublish));
}
}
