/// <summary>
/// Creates the contract.
/// </summary>
/// <param name="contractId">The contract identifier.</param>
/// <param name="estateId">The estate identifier.</param>
/// <param name="operatorId">The operator identifier.</param>
/// <param name="description">The description.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.InvalidOperationException">
/// Unable to create a contract for an estate that is not created
/// or
/// Unable to create a contract for an operator that is not setup on estate [{estate.Name}]
/// or
/// Contract Id [{contractId}] already created for estate [{estate.Name}]
/// </exception>
public async Task CreateContract(Guid contractId,
Guid estateId,
Guid operatorId,
String description,
CancellationToken cancellationToken)
{
// Validate the estate
EstateAggregate estateAggregate = await this.EstateAggregateRepository.GetLatestVersion(estateId, cancellationToken);
if (estateAggregate.IsCreated == false)
{
throw new InvalidOperationException("Unable to create a contract for an estate that is not created");
}
// Validate the operator
Estate estate = estateAggregate.GetEstate();
if (estate.Operators == null || estate.Operators.Any(o => o.OperatorId == operatorId) == false)
{
throw new InvalidOperationException($"Unable to create a contract for an operator that is not setup on estate [{estate.Name}]");
}
// Get the contract aggregate
ContractAggregate contractAggregate = await this.ContractAggregateRepository.GetLatestVersion(contractId, cancellationToken);
// Check for a duplicate
if (contractAggregate.IsCreated)
{
throw new InvalidOperationException($"Contract Id [{contractId}] already created for estate [{estate.Name}]");
}
contractAggregate.Create(estateId, operatorId, description);
await this.ContractAggregateRepository.SaveChanges(contractAggregate, cancellationToken);
}
public async Task AssignOperatorToMerchant(Guid estateId,
Guid merchantId,
Guid operatorId,
String merchantNumber,
String terminalNumber,
CancellationToken cancellationToken)
{
MerchantAggregate merchantAggregate = await this.MerchantAggregateRepository.GetLatestVersion(merchantId, cancellationToken);
// Check merchant has been created
if (merchantAggregate.IsCreated == false)
{
throw new InvalidOperationException($"Merchant Id {merchantId} has not been created");
}
// Estate Id is a valid estate
EstateAggregate estateAggregate = await this.EstateAggregateRepository.GetLatestVersion(estateId, cancellationToken);
if (estateAggregate.IsCreated == false)
{
throw new InvalidOperationException($"Estate Id {estateId} has not been created");
}
// Is the operator valid for this estate
Estate estate = estateAggregate.GetEstate();
Operator @operator = estate.Operators?.SingleOrDefault(o => o.OperatorId == operatorId);
if (@operator == null)
{
throw new InvalidOperationException($"Operator Id {operatorId} is not supported on Estate [{estate.Name}]");
}
// Operator has been validated, now check the rules of the operator against the passed in data
if (@operator.RequireCustomMerchantNumber)
{
// requested addition must have a merchant number supplied
if (String.IsNullOrEmpty(merchantNumber))
{
throw new InvalidOperationException($"Operator Id {operatorId} requires that a merchant number is provided");
}
}
if (@operator.RequireCustomTerminalNumber)
{
// requested addition must have a terminal number supplied
if (String.IsNullOrEmpty(terminalNumber))
{
throw new InvalidOperationException($"Operator Id {operatorId} requires that a terminal number is provided");
}
}
// Assign the operator
merchantAggregate.AssignOperator(operatorId, @operator.Name, merchantNumber, terminalNumber);
await this.MerchantAggregateRepository.SaveChanges(merchantAggregate, cancellationToken);
}
public void EstateAggregate_GetEstate_NoOperators_EstateIsReturned()
{
EstateAggregate aggregate = EstateAggregate.Create(TestData.EstateId);
aggregate.Create(TestData.EstateName);
Estate model = aggregate.GetEstate();
model.EstateId.ShouldBe(TestData.EstateId);
model.Name.ShouldBe(TestData.EstateName);
model.Operators.ShouldBeNull();
}
public void EstateAggregate_GetEstate_WithASecurityUser_EstateIsReturned()
{
EstateAggregate aggregate = EstateAggregate.Create(TestData.EstateId);
aggregate.Create(TestData.EstateName);
aggregate.AddSecurityUser(TestData.SecurityUserId, TestData.EstateUserEmailAddress);
Estate model = aggregate.GetEstate();
model.EstateId.ShouldBe(TestData.EstateId);
model.Name.ShouldBe(TestData.EstateName);
model.SecurityUsers.ShouldHaveSingleItem();
SecurityUser securityUser = model.SecurityUsers.Single();
securityUser.SecurityUserId.ShouldBe(TestData.SecurityUserId);
securityUser.EmailAddress.ShouldBe(TestData.EstateUserEmailAddress);
}
public void EstateAggregate_GetEstate_WithAnOperator_EstateIsReturned()
{
EstateAggregate aggregate = EstateAggregate.Create(TestData.EstateId);
aggregate.Create(TestData.EstateName);
aggregate.AddOperator(TestData.OperatorId, TestData.OperatorName, TestData.RequireCustomMerchantNumberFalse, TestData.RequireCustomTerminalNumberFalse);
Estate model = aggregate.GetEstate();
model.EstateId.ShouldBe(TestData.EstateId);
model.Name.ShouldBe(TestData.EstateName);
model.Operators.ShouldHaveSingleItem();
Operator @operator = model.Operators.Single();
@operator.OperatorId.ShouldBe(TestData.OperatorId);
@operator.Name.ShouldBe(TestData.OperatorName);
@operator.RequireCustomMerchantNumber.ShouldBe(TestData.RequireCustomMerchantNumberFalse);
@operator.RequireCustomTerminalNumber.ShouldBe(TestData.RequireCustomTerminalNumberFalse);
}