public async Task <Summary> GetById(Guid importNotificationId)
{
await authorization.EnsureAccessAsync(importNotificationId);
var status =
(await
context.ImportNotificationAssessments.SingleAsync(
n => n.NotificationApplicationId == importNotificationId)).Status;
var notificationInfo = await context.ImportNotifications.SingleAsync(n => n.Id == importNotificationId);
var totalMovements = await context.ImportMovements.Where(m => m.NotificationId == importNotificationId).CountAsync();
var shipment = await context.Shipments.Where(s => s.ImportNotificationId == importNotificationId).SingleAsync();
var received = await TotalQuantityReceived(importNotificationId, shipment);
var averageShipmentInfo = AveragePerShipment(shipment);
return(new Summary
{
IntendedShipments = shipment.NumberOfShipments,
UsedShipments = totalMovements,
DisplayUnit = shipment.Quantity.Units,
QuantityReceivedTotal = received.Quantity,
QuantityRemainingTotal = shipment.Quantity.Quantity - received.Quantity,
Id = importNotificationId,
NotificationStatus = status,
NotificationType = notificationInfo.NotificationType,
NotificationNumber = notificationInfo.NotificationNumber,
AverageTonnage = averageShipmentInfo.Quantity,
AverageDataUnit = averageShipmentInfo.Units
});
}
public async Task <NumberOfShipmentsHistory> GetOriginalNumberOfShipments(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.NumberOfShipmentsHistories.Where(x => x.ImportNotificationId == notificationId)
.OrderBy(x => x.DateChanged)
.FirstOrDefaultAsync());
}
public async Task <Shipment> GetByNotificationIdOrDefault(Guid notificationId)
{
var shipment = await context.Shipments.SingleOrDefaultAsync(s => s.ImportNotificationId == notificationId);
if (shipment != null)
{
await authorization.EnsureAccessAsync(notificationId);
}
return(shipment);
}
public async Task <ImportMovement> Get(Guid id)
{
var movement = await context.ImportMovements.SingleAsync(m => m.Id == id);
await notificationAuthorization.EnsureAccessAsync(movement.NotificationId);
return(movement);
}
public async Task <IEnumerable <MovementTableData> > GetById(Guid importNotificationId, int pageNumber, int pageSize)
{
await authorization.EnsureAccessAsync(importNotificationId);
var movements = context.ImportMovements
.Where(movement => movement.NotificationId == importNotificationId)
.OrderByDescending(m => m.Number)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize);
var result = GetMovementTableData(movements);
return(result.OrderByDescending(m => m.Number));
}
public async Task <Consultation> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context
.Consultations
.SingleOrDefaultAsync(c => c.NotificationId == notificationId));
}
public async Task <IEnumerable <ImportNotificationTransaction> > GetTransactions(Guid importNotificationId)
{
await authorization.EnsureAccessAsync(importNotificationId);
return
(await
context.ImportNotificationTransactions.Where(t => t.NotificationId == importNotificationId)
.ToListAsync());
}
public async Task <IList <NotificationAssessmentDecision> > GetByImportNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
var assessment = await context.ImportNotificationAssessments.SingleOrDefaultAsync(n => n.NotificationApplicationId == notificationId);
var withdrawals = await context.ImportWithdrawals.SingleOrDefaultAsync(n => n.NotificationId == notificationId);
var objections = await context.ImportObjections.SingleOrDefaultAsync(n => n.NotificationId == notificationId);
var consent = await context.ImportConsents.SingleOrDefaultAsync(n => n.NotificationId == notificationId);
var result = new List <NotificationAssessmentDecision>();
if (assessment.Dates.ConsentedDate != null)
{
result.Add(new NotificationAssessmentDecision(notificationId,
assessment.Dates.ConsentedDate.GetValueOrDefault(),
consent.ConsentRange.From,
consent.ConsentRange.To,
NotificationStatus.Consented));
}
if (withdrawals != null)
{
result.Add(new NotificationAssessmentDecision(notificationId,
withdrawals.Date,
null,
null,
NotificationStatus.Withdrawn));
}
if (objections != null)
{
result.Add(new NotificationAssessmentDecision(notificationId,
objections.Date,
null,
null,
NotificationStatus.Objected));
}
if (assessment.Dates.ConsentWithdrawnDate != null)
{
result.Add(new NotificationAssessmentDecision(notificationId,
assessment.Dates.ConsentWithdrawnDate.GetValueOrDefault(),
null,
null,
NotificationStatus.ConsentWithdrawn));
}
return(result.OrderByDescending(r => r.Date).ToList());
}
public async Task <ImportNotificationOverview> Get(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
var notification =
await context.ImportNotifications.SingleOrDefaultAsync(x => x.Id == notificationId);
var assessments =
await
context.ImportNotificationAssessments.SingleOrDefaultAsync(
x => x.NotificationApplicationId == notificationId);
var exporter = await context.Exporters.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var importer = await context.Importers.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var producer = await context.Producers.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var facilities =
await context.Facilities.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var shipment = await context.Shipments.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var transportRoute =
await context.TransportRoutes.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var operationCode =
await context.OperationCodes.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
var wasteType =
await context.WasteTypes.SingleOrDefaultAsync(x => x.ImportNotificationId == notificationId);
return(ImportNotificationOverview.Load(notification,
assessments,
exporter,
importer,
producer,
facilities,
shipment,
transportRoute,
operationCode,
wasteType));
}
public async Task <Importer> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.Importers.SingleAsync(i => i.ImportNotificationId == notificationId));
}
public async Task <FacilityCollection> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.Facilities.SingleOrDefaultAsync(f => f.ImportNotificationId == notificationId));
}
public async Task <ImportFinancialGuarantee> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.ImportFinancialGuarantees.SingleAsync(f => f.ImportNotificationId == notificationId));
}
public async Task <ImportNotification> Get(Guid id)
{
await authorization.EnsureAccessAsync(id);
return(await context.ImportNotifications.SingleAsync(n => n.Id == id));
}
public async Task <ImportWithdrawn> GetByNotificationIdOrDefault(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.ImportWithdrawals.SingleOrDefaultAsync(w => w.NotificationId == notificationId));
}
public async Task <TransportRoute> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.TransportRoutes.SingleAsync(t => t.ImportNotificationId == notificationId));
}
public async Task <WasteOperation> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.OperationCodes.SingleAsync(o => o.ImportNotificationId == notificationId));
}
public async Task EnsureAccessAsync(Guid movementId)
{
var notificationId = (await repository.Get(movementId)).NotificationId;
await authorization.EnsureAccessAsync(notificationId);
}
public async Task Add(ImportMovementAudit audit)
{
await authorization.EnsureAccessAsync(audit.NotificationId);
context.ImportMovementAudits.Add(audit);
}
public async Task <ImportObjection> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.ImportObjections.SingleAsync(o => o.NotificationId == notificationId));
}
public async Task <WasteType> GetByNotificationId(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.WasteTypes.SingleAsync(wt => wt.ImportNotificationId == notificationId));
}
public async Task <ImportNotificationAssessment> GetByNotification(Guid notificationId)
{
await authorization.EnsureAccessAsync(notificationId);
return(await context.ImportNotificationAssessments.SingleAsync(na => na.NotificationApplicationId == notificationId));
}
