public CancellationPolicyManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
DirectContractsDbContext dbContext)
{
_dbContext = dbContext;
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
}
public static void DetachEntries <T>(this DirectContractsDbContext dbContext, IEnumerable <T> items)
{
foreach (var item in items)
{
DetachEntry(dbContext, item);
}
}
private static Task <TResult> WithTransactionScope <TResult>(DirectContractsDbContext context, Func <Task <TResult> > operation)
where TResult : IResult
{
var strategy = context.Database.CreateExecutionStrategy();
return(strategy.ExecuteAsync((object)null,
async(dbContext, state, cancellationToken) =>
{
// Nested transaction support. We can commit only on a top-level
var transaction = dbContext.Database.CurrentTransaction is null
? await dbContext.Database.BeginTransactionAsync(cancellationToken)
: null;
try
{
var result = await operation();
if (result.IsSuccess)
{
transaction?.Commit();
}
return result;
}
finally
{
transaction?.Dispose();
}
},
// This delegate is not used in NpgSql.
null));
}
public BookingManagementService(IManagerContextService managerContextService, DirectContracts.Services.IBookingService bookingService, IBookingWebhookService bookingWebhookService, DirectContractsDbContext dbContext)
{
_managerContext = managerContextService;
_bookingService = bookingService;
_bookingWebhookService = bookingWebhookService;
_dbContext = dbContext;
}
public PromotionalOfferManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
DirectContractsDbContext dbContext)
{
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
_dbContext = dbContext;
}
public RateManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
DirectContractsDbContext dbContext)
{
_dbContext = dbContext;
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
}
public BookingService(IAvailabilityDataStorage availabilityDataStorage, IAvailabilityService availabilityService, IDateTimeProvider dateTimeProvider, DirectContractsDbContext dbContext)
{
_availabilityDataStorage = availabilityDataStorage;
_availabilityService = availabilityService;
_dateTimeProvider = dateTimeProvider;
_dbContext = dbContext;
}
public SeasonManagementService(DirectContractsDbContext dbContext, IManagerContextService managerContextService,
IServiceSupplierContextService serviceSupplierContextService)
{
_dbContext = dbContext;
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
}
public AvailabilityRestrictionsManagementService(DirectContractsDbContext dbContext, IManagerContextService managerContextService,
IServiceSupplierContextService serviceSupplierContextService)
{
_dbContext = dbContext;
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
}
public static async Task <Result> CheckIfRoomsBelongToContract(this DirectContractsDbContext dbContext, int contractId, int serviceSupplierId, List <int> roomIds)
{
if (!roomIds.Any())
{
return(Result.Success());
}
var availableRoomIds = await dbContext.Rooms
.Join(dbContext.Accommodations, room => room.AccommodationId, accommodation => accommodation.Id, (room, accommodation) => new
{
room,
accommodation
})
.Join(dbContext.ContractAccommodationRelations, roomAndAccommodation => roomAndAccommodation.accommodation.Id, relation => relation.AccommodationId, (roomAndAccommodation, relation)
=> new { roomAndAccommodation.accommodation, roomAndAccommodation.room, relation })
.Join(dbContext.Contracts, accommodationAndRoomAndRelation => accommodationAndRoomAndRelation.relation.ContractId, contract => contract.Id,
(accommodationAndRoomAndRelation, contract) => new
{
accommodationAndRoomAndRelation.accommodation,
accommodationAndRoomAndRelation.room,
accommodationAndRoomAndRelation.relation,
contract
})
.Where(accommodationAndRoomAndRelationAndContract => accommodationAndRoomAndRelationAndContract.contract.Id == contractId &&
roomIds.Contains(accommodationAndRoomAndRelationAndContract.room.Id) &&
accommodationAndRoomAndRelationAndContract.contract.ServiceSupplierId == serviceSupplierId)
.Select(accommodationAndRoomAndRelationAndContract => accommodationAndRoomAndRelationAndContract.room.Id)
.ToListAsync();
var notBelongIds = roomIds.Except(availableRoomIds).ToList();
return(notBelongIds.Any()
? Result.Failure($"Invalid room ids: {string.Join(", ", notBelongIds)}")
: Result.Success());
}
public AllocationRequirementManagementService(DirectContractsDbContext dbContext,
IManagerContextService managerContextService,
IServiceSupplierContextService serviceSupplierContextService)
{
_dbContext = dbContext;
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
}
public AvailabilityService(IRoomAvailabilityService roomAvailabilityService, IRateAvailabilityService rateAvailabilityService, IAvailabilityDataStorage availabilityDataStorage, IAvailabilityHashGenerator availabilityHashGenerator, IRateDetailsSetGenerator rateDetailsSetGenerator, DirectContractsDbContext dbContext)
{
_roomAvailabilityService = roomAvailabilityService;
_rateAvailabilityService = rateAvailabilityService;
_availabilityDataStorage = availabilityDataStorage;
_availabilityHashGenerator = availabilityHashGenerator;
_rateDetailsSetGenerator = rateDetailsSetGenerator;
_dbContext = dbContext;
}
public static IQueryable <Accommodation> GetContractedAccommodations(this DirectContractsDbContext dbContext, int contractId, int serviceSupplierId)
=> dbContext.Accommodations
.Join(dbContext.ContractAccommodationRelations, accommodation => accommodation.Id, relation => relation.AccommodationId,
(accommodation, relation) => new { accommodation, relation })
.Join(dbContext.Contracts, accommodationAndRelation => accommodationAndRelation.relation.ContractId, contract => contract.Id,
(accommodationAndRelation, contract) => new { accommodationAndRelation, contract })
.Where(accommodationAndRelationAndContract => accommodationAndRelationAndContract.contract.ServiceSupplierId == serviceSupplierId &&
accommodationAndRelationAndContract.contract.Id == contractId)
.Select(accommodationAndRelationAndContract => accommodationAndRelationAndContract.accommodationAndRelation.accommodation);
public ContractManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
IDocumentManagementService documentManagementService,
DirectContractsDbContext dbContext, IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
_documentManagementService = documentManagementService;
_dbContext = dbContext;
_dateTimeProvider = dateTimeProvider;
}
public ManagerRegistrationService(IManagerContextService managerContextService, IManagerInvitationService managerInvitationService,
INotificationService notificationService, DirectContractsDbContext dbContext, ILogger <ManagerRegistrationService> logger,
IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_managerInvitationService = managerInvitationService;
_notificationService = notificationService;
_dbContext = dbContext;
_logger = logger;
_dateTimeProvider = dateTimeProvider;
}
public DocumentManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
DirectContractsDbContext dbContext, IAmazonS3ClientService amazonS3ClientService, IOptions <DocumentManagementServiceOptions> options,
IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
_dbContext = dbContext;
_amazonS3ClientService = amazonS3ClientService;
_bucketName = options.Value.AmazonS3Bucket;
_dateTimeProvider = dateTimeProvider;
}
public static async Task <Result> CheckIfSeasonsBelongToContract(this DirectContractsDbContext dbContext, int contractId, List <int> seasonIds)
{
var availableSeasonIds =
await dbContext.Seasons.Where(s => seasonIds.Contains(s.Id) && s.ContractId == contractId).Select(s => s.Id).ToListAsync();
var notBelongIds = seasonIds.Except(availableSeasonIds).ToList();
return(notBelongIds.Any()
? Result.Failure($"Season ids {string.Join(", ", notBelongIds)} do not belong to the contract manager")
: Result.Success());
}
public static Task <Result <T> > BindWithTransaction <T>(
this Result target,
DirectContractsDbContext context,
Func <Task <Result <T> > > f)
{
var(_, isFailure, error) = target;
if (isFailure)
{
return(Task.FromResult(Result.Failure <T>(error)));
}
return(WithTransactionScope(context, f));
}
public static async Task <Result> BindWithTransaction <T>(
this Result <T> target,
DirectContractsDbContext context,
Func <T, Task <Result> > f)
{
var(_, isFailure, result, error) = target;
if (isFailure)
{
return(Result.Failure(error));
}
return(await WithTransactionScope(context, () => f(result)));
}
public ImageManagementService(IManagerContextService managerContextService, IServiceSupplierContextService serviceSupplierContextService,
DirectContractsDbContext dbContext, IAmazonS3ClientService amazonS3ClientService, IOptions <ImageManagementServiceOptions> options,
IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
_dbContext = dbContext;
_amazonS3ClientService = amazonS3ClientService;
_bucketName = options.Value.AmazonS3Bucket;
var amazonS3RegionEndpoint = options.Value.AmazonS3RegionEndpoint;
_basePathToAmazon = $"https://{_bucketName}.s3-{amazonS3RegionEndpoint}.amazonaws.com";
_dateTimeProvider = dateTimeProvider;
}
public static async Task <Result> CheckIfSeasonRangesBelongToContract(this DirectContractsDbContext dbContext, int contractId, List <int> seasonRangeIds)
{
var allContractRangeIds = (await dbContext.GetSeasons()
.Where(season => season.ContractId == contractId)
.Select(season => season.SeasonRanges)
.ToListAsync())
.SelectMany(season => season)
.Select(seasonRange => seasonRange.Id).ToList();
var notBelongIds = seasonRangeIds.Except(allContractRangeIds).ToList();
return(notBelongIds.Any()
? Result.Failure($"Season range ids {string.Join(", ", notBelongIds)} do not belong to the contract manager")
: Result.Success());
}
public AccommodationManagementService(IManagerContextService managerContextService,
IServiceSupplierContextService serviceSupplierContextService,
IImageManagementService imageManagementService,
IAmenityService amenityService,
DirectContractsDbContext dbContext,
GeometryFactory geometryFactory,
IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_serviceSupplierContext = serviceSupplierContextService;
_imageManagementService = imageManagementService;
_amenityService = amenityService;
_geometryFactory = geometryFactory;
_dbContext = dbContext;
_dateTimeProvider = dateTimeProvider;
}
public static void DetachEntry <T>(this DirectContractsDbContext dbContext, T item)
{
var entry = dbContext.Entry(item);
entry.State = EntityState.Detached;
}
public static async Task <bool> DoesAccommodationBelongToServiceSupplier(this DirectContractsDbContext dbContext, int accommodationId, int serviceSupplierId) => await dbContext.Accommodations.AnyAsync(a => a.ServiceSupplierId == serviceSupplierId && a.Id == accommodationId);
public LocationManagementService(DirectContractsDbContext dbContext, ILocationNameNormalizer locationNameNormalizer)
{
_dbContext = dbContext;
_locationNameNormalizer = locationNameNormalizer;
}
public static IIncludableQueryable <Season, List <SeasonRange> > GetSeasons(this DirectContractsDbContext dbContext) => dbContext.Seasons.Include(season => season.SeasonRanges);
public ManagerContextService(DirectContractsDbContext dbContext, ITokenInfoAccessor tokenInfoAccessor, ISha256HashGenerator sha256HashGenerator)
{
_dbContext = dbContext;
_tokenInfoAccessor = tokenInfoAccessor;
_sha256HashGenerator = sha256HashGenerator;
}
public static async Task <bool> DoesContractBelongToServiceSupplier(this DirectContractsDbContext dbContext, int contractId, int serviceSupplierId) => await dbContext.Contracts.AnyAsync(c => c.ServiceSupplierId == serviceSupplierId && c.Id == contractId);
public AmenityService(DirectContractsDbContext dbContext)
{
_dbContext = dbContext;
}
public ManagerManagementService(IManagerContextService managerContextService, DirectContractsDbContext dbContext, IDateTimeProvider dateTimeProvider)
{
_managerContext = managerContextService;
_dbContext = dbContext;
_dateTimeProvider = dateTimeProvider;
}
