public ImportMovementReceipt(Guid movementId, ShipmentQuantity quantity, DateTime date)
{
MovementId = movementId;
Quantity = quantity.Quantity;
Unit = quantity.Units;
Date = date;
}
public AcceptedTriggerParameters(Guid fileId, DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
FileId = fileId;
DateReceived = dateReceived;
CreatedBy = createdBy;
Quantity = quantity;
}
internal MovementReceipt(Guid fileId, DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
FileId = fileId;
Date = dateReceived;
QuantityReceived = quantity;
CreatedBy = createdBy.ToString();
}
private ShipmentInfo CreateShipmentInfo(int maxNumberOfMovements)
{
var anyShipmentPeriod = new ShipmentPeriod(new DateTime(2015, 3, 1), new DateTime(2016, 1, 1), true);
var anyQuantity = new ShipmentQuantity(5m, Core.Shared.ShipmentQuantityUnits.Tonnes);
return(new ShipmentInfo(NotificationId, anyShipmentPeriod, maxNumberOfMovements, anyQuantity));
}
public static NotificationMovementsSummary Load(Guid notificationId,
string notificationNumber,
NotificationType notificationType,
int intendedTotalShipments,
int currentTotalShipments,
int activeLoadsPermitted,
int currentActiveLoads,
decimal intendedQuantity,
decimal quantityReceived,
ShipmentQuantityUnits units,
FinancialGuaranteeStatus financialGuaranteeStatus,
UKCompetentAuthority competentAuthority,
NotificationStatus notificationStatus,
ShipmentQuantity averageTonnageInfo)
{
return(new NotificationMovementsSummary
{
NotificationId = notificationId,
NotificationNumber = notificationNumber,
NotificationType = notificationType,
IntendedTotalShipments = intendedTotalShipments,
CurrentTotalShipments = currentTotalShipments,
ActiveLoadsPermitted = activeLoadsPermitted,
CurrentActiveLoads = currentActiveLoads,
IntendedQuantity = intendedQuantity,
QuantityReceived = quantityReceived,
Units = units,
FinancialGuaranteeStatus = financialGuaranteeStatus,
CompetentAuthority = competentAuthority,
NotificationStatus = notificationStatus,
AverageDataUnit = averageTonnageInfo.Units,
AverageTonnage = averageTonnageInfo.Quantity
});
}
internal MovementReceipt(DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
Date = dateReceived;
QuantityReceived = quantity;
CreatedBy = createdBy.ToString();
CreatedOnDate = SystemTime.UtcNow;
}
private ShipmentInfo GetTestShipmentInfo(ShipmentQuantityUnits unit)
{
var shipmentPeriod = new ShipmentPeriod(DateTime.Now, DateTime.Now.AddMonths(12), true);
var shipmentQuantity = new ShipmentQuantity(1.0m, unit);
return(new ShipmentInfo(notificationId, shipmentPeriod, 100, shipmentQuantity));
}
public ShipmentInfo(Guid notificationId, ShipmentPeriod shipmentPeriod, int numberOfShipments, ShipmentQuantity shipmentQuantity)
{
NotificationId = notificationId;
UpdateQuantity(shipmentQuantity);
UpdateShipmentPeriod(shipmentPeriod, NotificationStatus.NotSubmitted);
UpdateNumberOfShipments(numberOfShipments);
}
public ImportMovementReceipt(Guid movementId, ShipmentQuantity quantity, DateTime date)
{
MovementId = movementId;
Quantity = quantity.Quantity;
Unit = quantity.Units;
Date = date;
}
public void Receive(Guid fileId, DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
Guard.ArgumentNotDefaultValue(() => fileId, fileId);
Guard.ArgumentNotDefaultValue(() => dateReceived, dateReceived);
Guard.ArgumentNotDefaultValue(() => quantity, quantity);
stateMachine.Fire(acceptedTrigger, new AcceptedTriggerParameters(fileId, dateReceived, quantity, createdBy));
}
public async Task <ShipmentQuantity> Remaining(Guid notificationId)
{
var shipment = await shipmentRepository.GetByNotificationId(notificationId);
var shipmentQuantity = new ShipmentQuantity(shipment.Quantity, shipment.Units);
return(shipmentQuantity - await Received(notificationId));
}
public async Task<ShipmentQuantity> Remaining(Guid notificationId)
{
var shipment = await shipmentRepository.GetByNotificationId(notificationId);
var shipmentQuantity = new ShipmentQuantity(shipment.Quantity, shipment.Units);
return shipmentQuantity - await Received(notificationId);
}
public async Task <bool> HandleAsync(HasExceededConsentedQuantity message)
{
var remaining = await movementsQuantity.Remaining(message.NotificationId);
var quantity = new ShipmentQuantity(message.Quantity, message.Units);
return(quantity > remaining);
}
public void Add_SameUnitType_ReturnsExpected(ShipmentQuantityUnits unit)
{
var unit1 = new ShipmentQuantity(1, unit);
var unit2 = new ShipmentQuantity(2, unit);
var expected = new ShipmentQuantity(3, unit);
Assert.Equal(expected, unit1 + unit2);
}
public void Equals_SameQuantityAndUnit_ReturnsTrue(string quantity, ShipmentQuantityUnits unit)
{
var decimalQuantity = Convert.ToDecimal(quantity);
var unit1 = new ShipmentQuantity(decimalQuantity, unit);
var unit2 = new ShipmentQuantity(decimalQuantity, unit);
Assert.True(unit1.Equals(unit2));
}
public void Add_SameUnitType_ReturnsExpected(ShipmentQuantityUnits unit)
{
var unit1 = new ShipmentQuantity(1, unit);
var unit2 = new ShipmentQuantity(2, unit);
var expected = new ShipmentQuantity(3, unit);
Assert.Equal(expected, unit1 + unit2);
}
public void Equals_SameQuantityAndUnit_ReturnsTrue(string quantity, ShipmentQuantityUnits unit)
{
var decimalQuantity = Convert.ToDecimal(quantity);
var unit1 = new ShipmentQuantity(decimalQuantity, unit);
var unit2 = new ShipmentQuantity(decimalQuantity, unit);
Assert.True(unit1.Equals(unit2));
}
public async Task<ImportMovementReceipt> Receive(Guid movementId, ShipmentQuantity quantity, DateTime date)
{
var movement = await movementRepository.Get(movementId);
var receipt = movement.Receive(quantity, date);
receiptRepository.Add(receipt);
return receipt;
}
public void Equals_UnconvertableUnits_ReturnsFalse(string quantity1, ShipmentQuantityUnits unit1,
string quantity2, ShipmentQuantityUnits unit2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var shipmentUnit1 = new ShipmentQuantity(decimalQuantity1, unit1);
var shipmentUnit2 = new ShipmentQuantity(decimalQuantity2, unit2);
Assert.False(shipmentUnit1.Equals(shipmentUnit2));
}
public void Equals_EquivalentQuantity_ReturnsTrue(string quantity1, ShipmentQuantityUnits unit1,
string quantity2, ShipmentQuantityUnits unit2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var shipmentUnit1 = new ShipmentQuantity(decimalQuantity1, unit1);
var shipmentUnit2 = new ShipmentQuantity(decimalQuantity2, unit2);
Assert.True(shipmentUnit1.Equals(shipmentUnit2));
}
public void LessThanOrEquals_ConvertableUnitType_ReturnsTrue(string quantity1, ShipmentQuantityUnits units1,
string quantity2, ShipmentQuantityUnits units2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var unit1 = new ShipmentQuantity(decimalQuantity1, units1);
var unit2 = new ShipmentQuantity(decimalQuantity2, units2);
Assert.True(unit1 <= unit2);
}
public void Equals_EquivalentQuantity_ReturnsTrue(string quantity1, ShipmentQuantityUnits unit1,
string quantity2, ShipmentQuantityUnits unit2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var shipmentUnit1 = new ShipmentQuantity(decimalQuantity1, unit1);
var shipmentUnit2 = new ShipmentQuantity(decimalQuantity2, unit2);
Assert.True(shipmentUnit1.Equals(shipmentUnit2));
}
public void Equals_UnconvertableUnits_ReturnsFalse(string quantity1, ShipmentQuantityUnits unit1,
string quantity2, ShipmentQuantityUnits unit2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var shipmentUnit1 = new ShipmentQuantity(decimalQuantity1, unit1);
var shipmentUnit2 = new ShipmentQuantity(decimalQuantity2, unit2);
Assert.False(shipmentUnit1.Equals(shipmentUnit2));
}
public Shipment(Guid importNotificationId, ShipmentPeriod period, ShipmentQuantity quantity, int numberOfShipments)
{
Guard.ArgumentNotDefaultValue(() => importNotificationId, importNotificationId);
Guard.ArgumentNotNull(() => period, period);
Guard.ArgumentNotNull(() => quantity, quantity);
Guard.ArgumentNotZeroOrNegative(() => numberOfShipments, numberOfShipments);
ImportNotificationId = importNotificationId;
Period = period;
Quantity = quantity;
NumberOfShipments = numberOfShipments;
}
public void LastDateCantBeBeforeFirstDate()
{
var firstDate = new DateTime(2015, 01, 02);
var lastDate = new DateTime(2015, 01, 01);
var shipmentQuantity = new ShipmentQuantity(0.0001M, ShipmentQuantityUnits.Tonnes);
Action createShipmentInfo = () =>
new ShipmentInfo(AnyGuid, new ShipmentPeriod(firstDate, lastDate, true), 1, shipmentQuantity);
Assert.Throws<InvalidOperationException>(createShipmentInfo);
}
public void ReceiveInternally(DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
Guard.ArgumentNotDefaultValue(() => dateReceived, dateReceived);
Guard.ArgumentNotNull(() => quantity, quantity);
if (dateReceived > SystemTime.UtcNow.Date)
{
throw new InvalidOperationException("The when the waste was received date cannot be in the future.");
}
stateMachine.Fire(internallyAcceptedTrigger, new InternallyAcceptedTriggerParameters(dateReceived, quantity, createdBy));
}
public void NumberOfShipmentsCantBeZero()
{
var firstDate = new DateTime(2015, 01, 01);
var lastDate = new DateTime(2015, 12, 01);
var shipmentPeriod = new ShipmentPeriod(firstDate, lastDate, true);
var shipmentQuantity = new ShipmentQuantity(100, ShipmentQuantityUnits.Kilograms);
Action createShipmentInfo = () => new ShipmentInfo(AnyGuid, shipmentPeriod, 0, shipmentQuantity);
Assert.Throws<ArgumentOutOfRangeException>(createShipmentInfo);
}
public async Task<MovementDetails> Create(Movement movement, ShipmentQuantity shipmentQuantity, IEnumerable<PackagingInfo> packages)
{
var remaining = await movementsQuantity.Remaining(movement.NotificationId);
if (shipmentQuantity > remaining)
{
throw new InvalidOperationException(string.Format(
"Cannot create new movement details for movement {0} as the quantity exceeds what is remaining", movement.Id));
}
return new MovementDetails(movement.Id, shipmentQuantity, packages);
}
public void PreconsentedNotificationDatesCantBeOutside36Months()
{
var firstDate = new DateTime(2015, 01, 01);
var lastDate = new DateTime(2018, 01, 02);
var shipmentQuantity = new ShipmentQuantity(0.0001M, ShipmentQuantityUnits.Tonnes);
Action createShipmentInfo = () =>
new ShipmentInfo(AnyGuid, new ShipmentPeriod(firstDate, lastDate, true), 1, shipmentQuantity);
Assert.Throws <InvalidOperationException>(createShipmentInfo);
}
public void LastDateCantBeBeforeFirstDate()
{
var firstDate = new DateTime(2015, 01, 02);
var lastDate = new DateTime(2015, 01, 01);
var shipmentQuantity = new ShipmentQuantity(0.0001M, ShipmentQuantityUnits.Tonnes);
Action createShipmentInfo = () =>
new ShipmentInfo(AnyGuid, new ShipmentPeriod(firstDate, lastDate, true), 1, shipmentQuantity);
Assert.Throws <InvalidOperationException>(createShipmentInfo);
}
public Shipment(Guid importNotificationId, ShipmentPeriod period, ShipmentQuantity quantity, int numberOfShipments)
{
Guard.ArgumentNotDefaultValue(() => importNotificationId, importNotificationId);
Guard.ArgumentNotNull(() => period, period);
Guard.ArgumentNotNull(() => quantity, quantity);
Guard.ArgumentNotZeroOrNegative(() => numberOfShipments, numberOfShipments);
ImportNotificationId = importNotificationId;
Period = period;
Quantity = quantity;
NumberOfShipments = numberOfShipments;
}
public void NumberOfShipmentsCantBeNegative()
{
var firstDate = new DateTime(2015, 01, 01);
var lastDate = new DateTime(2015, 12, 01);
var shipmentPeriod = new ShipmentPeriod(firstDate, lastDate, true);
var shipmentQuantity = new ShipmentQuantity(100, ShipmentQuantityUnits.Kilograms);
Action createShipmentInfo = () => new ShipmentInfo(AnyGuid, shipmentPeriod, -5, shipmentQuantity);
Assert.Throws <ArgumentOutOfRangeException>(createShipmentInfo);
}
public async Task <MovementDetails> Create(Movement movement, ShipmentQuantity shipmentQuantity, IEnumerable <PackagingInfo> packages)
{
var remaining = await movementsQuantity.Remaining(movement.NotificationId);
if (shipmentQuantity > remaining)
{
throw new InvalidOperationException(string.Format(
"Cannot create new movement details for movement {0} as the quantity exceeds what is remaining", movement.Id));
}
return(new MovementDetails(movement.Id, shipmentQuantity, packages));
}
public void Add_ConvertableUnitType_ReturnsExpected(string quantity1, ShipmentQuantityUnits units1, string quantity2, ShipmentQuantityUnits units2, string expected)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var decimalExpected = Convert.ToDecimal(expected);
var unit1 = new ShipmentQuantity(decimalQuantity1, units1);
var unit2 = new ShipmentQuantity(decimalQuantity2, units2);
var expectedUnit = new ShipmentQuantity(decimalExpected, units1);
Assert.Equal(expectedUnit, unit1 + unit2);
}
private async Task SaveMovementDetails(Movement movement, DraftMovement draftMovement, NotificationApplication notification)
{
var shipmentQuantity = new ShipmentQuantity(draftMovement.Quantity, draftMovement.Units);
var packagingInfos = GetPackagingInfoFromDraft(draftMovement.PackagingInfos, notification);
var movementDetails = await movementDetailsFactory.Create(
movement,
shipmentQuantity,
packagingInfos);
context.MovementDetails.Add(movementDetails);
await context.SaveChangesAsync();
}
public async Task <Guid[]> HandleAsync(CreateMovements message)
{
var newIds = new List <Guid>();
using (var transaction = context.Database.BeginTransaction())
{
try
{
for (int i = 0; i < message.NumberToCreate; i++)
{
var movement = await movementFactory.Create(message.NotificationId, message.ActualMovementDate);
context.Movements.Add(movement);
await context.SaveChangesAsync();
var shipmentQuantity = new ShipmentQuantity(message.Quantity, message.Units);
var packagingInfos = await GetPackagingInfos(message.NotificationId, message.PackagingTypes);
var movementDetails = await movementDetailsFactory.Create(
movement,
shipmentQuantity,
packagingInfos);
context.MovementDetails.Add(movementDetails);
await context.SaveChangesAsync();
newIds.Add(movement.Id);
await movementAuditRepository.Add(new MovementAudit(movement.NotificationId, movement.Number,
userContext.UserId.ToString(), (int)MovementAuditType.Incomplete, SystemTime.Now));
await context.SaveChangesAsync();
}
}
catch
{
transaction.Rollback();
throw;
}
transaction.Commit();
}
return(newIds.ToArray());
}
public async Task <ImportMovementReceipt> Receive(Guid movementId, ShipmentQuantity quantity, DateTime date)
{
var movement = await movementRepository.Get(movementId);
if (date < movement.ActualShipmentDate)
{
throw new InvalidOperationException("The when the waste was received date cannot be before the actual date of shipment.");
}
if (date > SystemTime.UtcNow.Date)
{
throw new InvalidOperationException("The when the waste was received date cannot be in the future.");
}
var receipt = movement.Receive(quantity, date);
receiptRepository.Add(receipt);
return(receipt);
}
public async Task <QuantityReceivedTolerance> HandleAsync(DoesQuantityReceivedExceedTolerance message)
{
var movementDetails = await movementDetailsRepository.GetByMovementId(message.MovementId);
var shipmentQuantity = new ShipmentQuantity(message.Quantity, message.Units);
var intendedQuantity = movementDetails.ActualQuantity.Quantity;
var units = movementDetails.ActualQuantity.Units;
if (shipmentQuantity < new ShipmentQuantity(intendedQuantity * 0.5m, units))
{
return(QuantityReceivedTolerance.BelowTolerance);
}
if (shipmentQuantity > new ShipmentQuantity(intendedQuantity * 1.5m, units))
{
return(QuantityReceivedTolerance.AboveTolerance);
}
return(QuantityReceivedTolerance.WithinTolerance);
}
internal MovementDetails(Guid movementId,
ShipmentQuantity actualQuantity,
IEnumerable <PackagingInfo> packagingInfos)
{
Guard.ArgumentNotDefaultValue(() => movementId, movementId);
Guard.ArgumentNotNull(() => actualQuantity, actualQuantity);
Guard.ArgumentNotNull(() => packagingInfos, packagingInfos);
if (!packagingInfos.Any())
{
throw new ArgumentException("Packaging infos can not be empty.", "packagingInfos");
}
if (actualQuantity <= new ShipmentQuantity(0, actualQuantity.Units))
{
throw new ArgumentException("Actual quantity must be greater than zero", "actualQuantity");
}
MovementId = movementId;
ActualQuantity = actualQuantity;
PackagingInfosCollection = packagingInfos.ToList();
}
internal MovementDetails(Guid movementId,
ShipmentQuantity actualQuantity,
IEnumerable<PackagingInfo> packagingInfos)
{
Guard.ArgumentNotDefaultValue(() => movementId, movementId);
Guard.ArgumentNotNull(() => actualQuantity, actualQuantity);
Guard.ArgumentNotNull(() => packagingInfos, packagingInfos);
if (!packagingInfos.Any())
{
throw new ArgumentException("Packaging infos can not be empty.", "packagingInfos");
}
if (actualQuantity <= new ShipmentQuantity(0, actualQuantity.Units))
{
throw new ArgumentException("Actual quantity must be greater than zero", "actualQuantity");
}
MovementId = movementId;
ActualQuantity = actualQuantity;
PackagingInfosCollection = packagingInfos.ToList();
}
public async Task <Guid> HandleAsync(SetIntendedShipmentInfoForNotification command)
{
var facilityCollection = await facilityRepository.GetByNotificationId(command.NotificationId);
var shipmentInfo = await shipmentInfoRepository.GetByNotificationId(command.NotificationId);
var status = await assessmentRepository.GetStatusByNotificationId(command.NotificationId);
var shipmentPeriod = new ShipmentPeriod(
command.StartDate,
command.EndDate,
facilityCollection.AllFacilitiesPreconsented.GetValueOrDefault());
var shipmentQuantity = new ShipmentQuantity(
command.Quantity,
command.Units);
if (shipmentInfo == null)
{
shipmentInfo = new ShipmentInfo(command.NotificationId,
shipmentPeriod,
command.NumberOfShipments,
shipmentQuantity);
context.ShipmentInfos.Add(shipmentInfo);
}
else
{
shipmentInfo.UpdateNumberOfShipments(command.NumberOfShipments);
shipmentInfo.UpdateShipmentPeriod(shipmentPeriod, status);
shipmentInfo.UpdateQuantity(shipmentQuantity);
}
await context.SaveChangesAsync();
return(shipmentInfo.Id);
}
public ShipmentTests()
{
quantity = new ShipmentQuantity(50, ShipmentQuantityUnits.Tonnes);
period = new ShipmentPeriod(new DateTime(2016, 1, 1), new DateTime(2017, 1, 1), true);
}
public void PreconsentedNotificationDatesCantBeOutside36Months()
{
var firstDate = new DateTime(2015, 01, 01);
var lastDate = new DateTime(2018, 01, 02);
var shipmentQuantity = new ShipmentQuantity(0.0001M, ShipmentQuantityUnits.Tonnes);
Action createShipmentInfo = () =>
new ShipmentInfo(AnyGuid, new ShipmentPeriod(firstDate, lastDate, true), 1, shipmentQuantity);
Assert.Throws<InvalidOperationException>(createShipmentInfo);
}
public ImportMovementReceipt Receive(ShipmentQuantity quantity, DateTime date)
{
return new ImportMovementReceipt(Id, quantity, date);
}
public InternallyAcceptedTriggerParameters(DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
DateReceived = dateReceived;
CreatedBy = createdBy;
Quantity = quantity;
}
public void LessThanOrEquals_ConvertableUnitType_ReturnsTrue(string quantity1, ShipmentQuantityUnits units1,
string quantity2, ShipmentQuantityUnits units2)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var unit1 = new ShipmentQuantity(decimalQuantity1, units1);
var unit2 = new ShipmentQuantity(decimalQuantity2, units2);
Assert.True(unit1 <= unit2);
}
public AcceptedTriggerParameters(Guid fileId, DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
FileId = fileId;
DateReceived = dateReceived;
CreatedBy = createdBy;
Quantity = quantity;
}
public InternallyAcceptedTriggerParameters(DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
DateReceived = dateReceived;
CreatedBy = createdBy;
Quantity = quantity;
}
public void ReceiveInternally(DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
Guard.ArgumentNotDefaultValue(() => dateReceived, dateReceived);
Guard.ArgumentNotNull(() => quantity, quantity);
stateMachine.Fire(internallyAcceptedTrigger, new InternallyAcceptedTriggerParameters(dateReceived, quantity, createdBy));
}
public void Add_ConvertableUnitType_ReturnsExpected(string quantity1, ShipmentQuantityUnits units1, string quantity2, ShipmentQuantityUnits units2, string expected)
{
var decimalQuantity1 = Convert.ToDecimal(quantity1);
var decimalQuantity2 = Convert.ToDecimal(quantity2);
var decimalExpected = Convert.ToDecimal(expected);
var unit1 = new ShipmentQuantity(decimalQuantity1, units1);
var unit2 = new ShipmentQuantity(decimalQuantity2, units2);
var expectedUnit = new ShipmentQuantity(decimalExpected, units1);
Assert.Equal(expectedUnit, unit1 + unit2);
}
public ShipmentTests()
{
quantity = new ShipmentQuantity(50, ShipmentQuantityUnits.Tonnes);
period = new ShipmentPeriod(new DateTime(2016, 1, 1), new DateTime(2017, 1, 1), true);
}
public void Receive(Guid fileId, DateTime dateReceived, ShipmentQuantity quantity, Guid createdBy)
{
Guard.ArgumentNotDefaultValue(() => fileId, fileId);
Guard.ArgumentNotDefaultValue(() => dateReceived, dateReceived);
Guard.ArgumentNotDefaultValue(() => quantity, quantity);
stateMachine.Fire(acceptedTrigger, new AcceptedTriggerParameters(fileId, dateReceived, quantity, createdBy));
}
public void UpdateQuantity(ShipmentQuantity shipmentQuantity)
{
Quantity = shipmentQuantity.Quantity;
Units = shipmentQuantity.Units;
}
public ImportMovementReceipt Receive(ShipmentQuantity quantity, DateTime date)
{
return(new ImportMovementReceipt(Id, quantity, date));
}
private ShipmentInfo CreateShipmentInfo(int maxNumberOfMovements)
{
var anyShipmentPeriod = new ShipmentPeriod(new DateTime(2015, 3, 1), new DateTime(2016, 1, 1), true);
var anyQuantity = new ShipmentQuantity(5m, Core.Shared.ShipmentQuantityUnits.Tonnes);
return new ShipmentInfo(NotificationId, anyShipmentPeriod, maxNumberOfMovements, anyQuantity);
}
