public async Task <ExecutionResult> Execute(ExecuteContext <EmptyParameters> context)
{
var result = await _busPublisher.SendRequest <ICreateUser, IIdentifierResult>(new CreateUser
{
EmailAddress = "*****@*****.**",
FullName = "Default Administrator Account",
Id = Guid.NewGuid(),
IsAdministrator = true,
IsActive = true
});
if (!result.Successful)
{
throw result.ToException();
}
var userId = result.Id.Value;
return(context.CompletedWithVariables(new GuidLog {
Id = userId
}, new UserIdParameters()
{
UserId = userId
}));
}
public async Task <ExecutionResult> Execute(ExecuteContext <UserIdParameters> context)
{
var result = await _busPublisher.SendRequest <ICreateAuthenticationMeans, IIdentifierResult>(
new CreateAuthenticationMeans
{
Id = Guid.NewGuid(),
Method = "password",
ValidSince = DateTimeOffset.UtcNow,
Value = "AQAAAAEAACcQAAAAEMBltRflZWAQYQiGzPsZ6Hp4x10Pv4d4uJP1GSr5DOdwYuhqXzUmTyAX8FgUuPssig=="
}
);
if (!result.Successful)
{
throw result.ToException();
}
var meansId = result.Id.Value;
return(context.CompletedWithVariables(new GuidLog {
Id = meansId
}, new UserIdMeansIdParameters
{
UserId = context.Arguments.UserId,
MeansId = meansId
}));
}
public async Task <ExecutionResult> Execute(ExecuteContext <CreationActivityParameters> context)
{
var result = await _busPublisher.SendRequest <ICreatePointOfSale, IIdentifierResult>(
new CreatePointOfSale(context.Arguments.Id, context.Arguments.DisplayName, context.Arguments.ParentAccountingGroupId, context.Arguments.SaleStrategyId, context.Arguments.Features)
);
return(result.Successful ? context.Completed(new IdentifierLogEntry(result.Id.Value)) : context.Faulted(result.ToException()));
}
protected async Task <(Guid, Guid)> RetrieveMeansIdAndUserId(string authMeansMethod, string authMeansValue)
{
var meansIdResolution = await _busPublisher.SendRequest <IResolveAuthenticationMeans, IIdentifierResult>(new ResolveAuthenticationMeans(authMeansMethod, authMeansValue));
if (!meansIdResolution.Successful)
{
throw meansIdResolution.ToException();
}
else if (!meansIdResolution.Id.HasValue)
{
throw new BaristaException("means_id_resolution_failed", "Could not resolve ID of located authentication means");
}
var meansId = meansIdResolution.Id.Value;
var userIdResolution = await _busPublisher.SendRequest <IResolveAuthenticationMeansUserId, IUserIdResolutionResult>(new ResolveAuthenticationMeansUserId(meansId, false));
if (!userIdResolution.Successful)
{
throw new BaristaException("invalid_means", $"Authentication means with ID '{meansId}' is not currently assigned to an user.");
}
else if (!userIdResolution.AssignmentId.HasValue)
{
throw new BaristaException("assignment_to_user_resolution_failed", $"Could not resolve ID of assignment to user from means '{meansId}'.");
}
else if (!userIdResolution.UserId.HasValue)
{
throw new BaristaException("user_id_resolution_failed", $"Could not resolve user ID from means '{meansId}'.");
}
var assignment = await _idSvc.GetAssignmentToUser(userIdResolution.AssignmentId.Value);
if (assignment is null)
{
throw new BaristaException("invalid_means_assignment_id", $"The user assignment with ID '{userIdResolution.AssignmentId}' (resolved from means with ID '{meansId}') was not found.");
}
var now = DateTimeOffset.UtcNow;
var spendingLimitChecks = assignment.SpendingLimits.ToDictionary(
sl => sl,
sl => _acSvc.GetSpendingOfMeans(assignment.Means, sl.Interval == TimeSpan.Zero ? DateTimeOffset.MinValue : now.Subtract(sl.Interval))
);
await Task.WhenAll(spendingLimitChecks.Values);
foreach (var(spendingLimit, actualSpendingTask) in spendingLimitChecks)
{
var actualSpending = actualSpendingTask.Result;
if (actualSpending > spendingLimit.Value)
{
throw new BaristaException("spending_limit_exceeded", $"The swipe was forbidden by the spending limit '{assignment.Id}/{spendingLimit.Id}' with value {spendingLimit.Value} per {spendingLimit.Interval}, current spending in this interval is {actualSpending}");
}
}
return(meansId, userIdResolution.UserId.Value);
}
public async Task <IOperationResult> HandleAsync(IConfirmSwipe command, ICorrelationContext correlationContext)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var sale = await _accountingService.GetSale(command.SaleId);
if (sale is null)
{
throw new BaristaException("sale_not_found", $"Could not find sale with ID '{command.SaleId}'");
}
if (sale.PointOfSaleId != command.PointOfSaleId)
{
throw new BaristaException("unauthorized_point_of_sale", $"The sale with ID '{command.SaleId}' was not created by the requesting PoS with ID '{command.PointOfSaleId}'");
}
var opResult = await _busPublisher.SendRequest <ChangeSaleStateToConfirmed, IOperationResult>(
new ChangeSaleStateToConfirmed(command.SaleId, Guid.NewGuid(), "PoS", command.PointOfSaleId)
);
if (opResult.Successful)
{
return(OperationResult.Ok());
}
else
{
throw opResult.ToException();
}
}
public async Task HandleAsync(ISaleConfirmationTimeoutExpired @event, ICorrelationContext correlationContext)
{
var sale = await _accSvc.GetSale(@event.SaleId);
if (sale is null)
{
_logger.LogDebug($"The sale {@event.SaleId} does not exist.");
return;
}
else if (sale.State == "Confirmed" || sale.State == "Cancelled")
{
_logger.LogDebug($"The sale {@event.SaleId} is already in a permitted state of {sale.State}.");
return;
}
_logger.LogInformation($"The sale {@event.SaleId} is in a non-final state of {sale.State}, requesting its cancellation.");
var deletionResult = await _busPublisher.SendRequest(new CancelTimedOutSale(@event.SaleId));
if (deletionResult.Successful)
{
_logger.LogDebug($"The sale {@event.SaleId} was cancelled successfully due to timing out.");
}
else
{
_logger.LogInformation(deletionResult.ToException(), $"The sale {@event.SaleId} was not cancelled due to timing out.");
}
}
public async Task <ExecutionResult> Execute(ExecuteContext <OwnershipAssignmentParameters> context)
{
var result = await _busPublisher.SendRequest <CreateAccountingGroupOwnership, IParentChildIdentifierResult>(
new CreateAccountingGroupOwnership(context.Arguments.AccountingGroupId, context.Arguments.OwnerUserId)
);
return(result.Successful ? context.Completed() : context.Faulted(new Exception(result.ErrorCode)));
}
public async Task <ExecutionResult> Execute(ExecuteContext <OwnershipAssignmentParameters> context)
{
var result = await _busPublisher.SendRequest <ICreatePointOfSaleUserAuthorization, IParentChildIdentifierResult>(
new CreatePointOfSaleOwnership(context.Arguments.PointOfSaleId, context.Arguments.OwnerUserId)
);
return(result.Successful ? context.Completed() : context.Faulted(result.ToException()));
}
protected override async Task HandleAsync(Guid posId, JObject messagePayload)
{
var cardId = messagePayload[MessageKey].Value <string>();
var offersPage = await _offersService.BrowseOffers(new BrowseOffers { AtPointOfSaleId = posId, ValidAt = DateTime.UtcNow, ResultsPerPage = 1 });
if (offersPage.TotalResults != 1)
{
Logger.LogError("The point of sale {posId} must have exactly one valid offer, else swipes cannot be processed", posId);
return;
}
if (!(offersPage.Items?.SingleOrDefault() is Offer offer))
{
Logger.LogError("A single offer was expected in the offers result set");
return;
}
var command = new ProcessSwipe(AuthenticationMeansType, cardId, posId, offer.Id, 1);
var processResult = await _busPublisher.SendRequest <IProcessSwipe, IIdentifierResult>(command);
if (!processResult.Successful)
{
Logger.LogError(processResult.ToException(), "Could not process swipe");
return;
}
else if (!processResult.Id.HasValue)
{
Logger.LogError("Swipe process was successful but did not yield a sale identifier");
return;
}
var dispenseResult = await _busPublisher.SendRequest(new Commands.DispenseProduct(posId, offer.ProductId));
var confirmResult = await _busPublisher.SendRequest <IConfirmSwipe>(new ConfirmSwipe(posId, processResult.Id.Value));
if (!confirmResult.Successful)
{
Logger.LogError(confirmResult.ToException(), "Could not confirm swipe");
return;
}
Logger.LogInformation($"Successfully handled sale with ID {processResult.Id.Value}");
}
protected async Task EnsureRemovalOfSaleBasedOp(Guid saleId)
{
var sale = await _accountingService.GetSale(saleId);
if (sale is null)
{
throw new BaristaException("sale_not_found", $"Error retrieving sale with ID {saleId} that supposedly changed state.");
}
var offer = await _offersService.GetOffer(sale.OfferId);
if (offer is null)
{
_logger.LogInformation($"The sale {saleId} changed state to cancelled but its offer could not be found");
return;
}
if (!(offer.StockItemId is Guid stockItemId))
{
return;
}
var autoStockOps = await _stockOperationsService.BrowseSaleBasedStockOperations(new BrowseSaleBasedStockOperations { StockItemId = new Guid[] { stockItemId }, SaleId = sale.Id });
if (autoStockOps.TotalResults == 0)
{
return;
}
else if (autoStockOps.TotalResults > 1)
{
throw new BaristaException("multiple_stock_ops_per_one_sale", $"Multiple stock operations yielded by query of stockItemId={stockItemId} and saleId={sale.Id}");
}
var autoStockOp = autoStockOps.Items.Single();
var removalOpResult = await _busPublisher.SendRequest(new DeleteSaleBasedStockOperation(autoStockOp.Id));
if (!removalOpResult.Successful)
{
throw removalOpResult.ToException();
}
}
public async Task <ActionResult> Honk()
{
var result =
await _busPublisher.SendRequest <CreateAccountingGroup, IIdentifierResult>(
new CreateAccountingGroup(Guid.NewGuid(), "ControllerTest", Guid.Empty));
if (result.Successful)
{
return(new OkObjectResult(result.Id.Value));
}
else
{
return(BadRequest(result.ErrorCode));
}
}
public async Task <ExecutionResult> Execute(ExecuteContext <UserIdMeansIdParameters> context)
{
var result = await _busPublisher.SendRequest <ICreateAssignmentToUser, IIdentifierResult>(new CreateAssignmentToUser
{
Id = Guid.NewGuid(),
IsShared = false,
MeansId = context.Arguments.MeansId,
UserId = context.Arguments.UserId,
ValidSince = DateTimeOffset.UtcNow
});
if (!result.Successful)
{
throw result.ToException();
}
return(context.Completed());
}
public async Task <IOperationResult> HandleAsync(ICancelTimedOutSale command, ICorrelationContext correlationContext)
{
var sale = await _queryDispatcher.QueryAsync(new GetSale(command.SaleId));
if (sale is null)
{
return(new OperationResult("sale_not_found", $"Could not find sale with ID '{command.SaleId}'"));
}
if (sale.State != SaleState.FundsReserved.ToString())
{
return(new OperationResult("sale_not_in_appropriate_state", $"The sale with ID '{command.SaleId}' is in the state '{sale.State}', cancellation can only happen in the {nameof(SaleState.FundsReserved)}"));
}
var newSaleStateChange = await _busPublisher.SendRequest <ICreateSaleStateChange, IIdentifierResult>(
new CreateSaleStateChange(command.SaleId, Guid.NewGuid(), "Timeout", "Cancelled", null, null)
);
return(newSaleStateChange);
}
protected override async Task <IOperationResult> RemedyAsync(PointOfSaleIdParameters args, Guid inconsistentEntityId) => await _busPublisher.SendRequest(new DeleteOffer(inconsistentEntityId));
protected override async Task <IOperationResult> RemedyAsync(AccountingGroupIdParameters args, Guid userId) => (await _busPublisher.SendRequest(new DeleteAccountingGroupUserAuthorization(args.AccountingGroupId, userId)));
protected async Task UpdateHashedPasswordAsync(Guid passwordMeansId, string newHashedApiKey) => await _busPublisher.SendRequest <UpdateAuthenticationMeansValue, IOperationResult>(new UpdateAuthenticationMeansValue(passwordMeansId, newHashedApiKey));
protected override async Task <IOperationResult> RemedyAsync(StockItemIdParameters args, Guid inconsistentEntityId) => await _busPublisher.SendRequest(new DeleteManualStockOperation(inconsistentEntityId));
protected override async Task <IOperationResult> RemedyAsync(UserIdParameters args, Guid inconsistentEntityId) => await _busPublisher.SendRequest(new DeleteAccountingGroupUserAuthorization(inconsistentEntityId, args.UserId));
protected override async Task HandleAsync(Guid posId, JObject messagePayload) => await _busPublisher.SendRequest(new SetPointOfSaleKeyValue(posId, MessageKey, messagePayload[MessageKey].Value <string>()));
protected override async Task UpdateHashedPasswordAsync(AuthenticationMeansWithValue passwordContainer, string newHashedApiKey) => await _busPublisher.SendRequest <UpdateAuthenticationMeansValue, IOperationResult>(new UpdateAuthenticationMeansValue(passwordContainer.Id, newHashedApiKey));
protected override async Task <IOperationResult> RemedyAsync(AuthenticationMeansIdParameters args, Guid inconsistentEntityId) => await _busPublisher.SendRequest(new DeleteAssignmentToUser(inconsistentEntityId));
protected override async Task <IOperationResult> RemedyAsync(StockItemIdParameters args, Guid inconsistentEntityId) => await _busPublisher.SendRequest(new UnsetOfferStockItemReference(inconsistentEntityId, args.StockItemId));
