/// <summary>
/// Adds the specified model.
/// </summary>
/// <param name="model">The model.</param>
public void Add(AddNewCustomerViewModel model)
{
var createCustomerCommand = _mapper.Map <CreateCustomerCommand>(model);
// TODO Get password by MD5 enscript
_commandDispatcher.Send(createCustomerCommand);
}
public Task CreateAsync(ApplicationRole role)
{
_commandDispatcher.Send(new AddRoleCommand
{
Name = role?.Details.Name,
Description = role?.Details.Description,
RoleType = role.Details == null ? null : role.Details.RoleType,
});
return(Task.FromResult(0));
}
public async Task <IActionResult> Edit(CategoryEditModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _commands.Send(new CreateCategoryCommand { Id = model.Id, Name = model.Name });
return(RedirectToAction("Index", new { id = model.Id }));
}
/// <summary>
/// Adds the specified model.
/// </summary>
/// <param name="model">The model.</param>
public void Add(AddNewCustomerViewModel model)
{
const int saltLength = 64;
var createCustomerCommand = _mapper.Map <CreateCustomerCommand>(model);
var passwordResult = PasswordWithSaltHasher.ActionEncrypt(model.Password, saltLength);
createCustomerCommand.SecurityStamp = passwordResult.Salt;
createCustomerCommand.PasswordHash = passwordResult.Digest;
_commandDispatcher.Send(createCustomerCommand);
}
public async Task <IActionResult> Create(PodcastCreateModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var id = Guid.NewGuid();
await _commands.Send(new CreatePodcastCommand { Id = id, Link = model.Link, CategoryId = model.CategoryId });
return(RedirectToAction("ForPodcastCreation", "Wait", new { Id = id }));
}
public ActionResult <RentalModelResult> PostRental([FromBody] CreateRentCommand createRentCommand)
{
Guid rentId = Guid.Empty;
_commandDispatcher.Send(createRentCommand, out rentId);
var modelToReturn = _mapper.Map <RentalModelResult>(createRentCommand);
modelToReturn.RentalId = rentId;
return(CreatedAtRoute("GetRent", new { rentId = rentId }, modelToReturn));
}
public ActionResult Edit(TravellerModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_commandDispatcher.Send(new ChangeTravellerName(model.Id, model.Firstname, model.Lastname));
_commandDispatcher.Send(new ChangeTravellerCountry(model.Id, model.Country));
this.FlashSuccess(string.Format("Traveller '{0} {1}' updated", model.Firstname, model.Lastname));
return(RedirectToAction("Edit", new { id = model.Id }));
}
public async Task Set([ActivityTrigger] SetSuccessfulLearnerMatchInput input)
{
_logger.LogInformation("Setting SuccessfulLearnerMatch for apprenticeship incentive id {apprenticeshipIncentiveId}, ULN {uln}, Succeeded: {succeeded}", input.ApprenticeshipIncentiveId, input.Uln, input.Succeeded);
await _commandDispatcher.Send(new SetSuccessfulLearnerMatchCommand(input.ApprenticeshipIncentiveId, input.Uln, input.Succeeded));
_logger.LogInformation("Set SuccessfulLearnerMatch for apprenticeship incentive id {apprenticeshipIncentiveId}, ULN {uln}, Succeeded: {succeeded}", input.ApprenticeshipIncentiveId, input.Uln, input.Succeeded);
}
public async Task Update([ActivityTrigger] LearnerChangeOfCircumstanceInput input)
{
_logger.LogInformation("Calling Learner Change of Circumstance for apprenticeship incentive id {apprenticeshipIncentiveId}, uln {uln}", input.ApprenticeshipIncentiveId, input.Uln);
await _commandDispatcher.Send(new LearnerChangeOfCircumstanceCommand(input.ApprenticeshipIncentiveId));
_logger.LogInformation("Called Learner Change of Circumstance for apprenticeship incentive id {apprenticeshipIncentiveId}, uln {uln}", input.ApprenticeshipIncentiveId, input.Uln);
}
public async Task Create([ActivityTrigger] LearnerMatchInput input)
{
_logger.LogInformation("Creating Learner Match record for apprenticeship incentive id {apprenticeshipIncentiveId}", input.ApprenticeshipIncentiveId);
await _commandDispatcher.Send(new RefreshLearnerCommand(input.ApprenticeshipIncentiveId));
_logger.LogInformation("Created Learner Match record for apprenticeship incentive id {apprenticeshipIncentiveId}", input.ApprenticeshipIncentiveId);
}
public async Task Handle(AccountVrfCaseStatusRemindersCommand command, CancellationToken cancellationToken = default)
{
var accountsWithoutVrfStatus = await _accountDataRepository.GetByVrfCaseStatus(null);
foreach (var account in accountsWithoutVrfStatus)
{
var applications = new List <ApprenticeApplicationDto>();
foreach (var legalEntity in account.LegalEntities)
{
var applicationsForLegalEntity = await _applicationDataRepository.GetList(account.AccountId, legalEntity.AccountLegalEntityId);
applications.AddRange(applicationsForLegalEntity);
}
var submittedApplications = applications.Where(x => x.ApplicationDate < command.ApplicationCutOffDate)
.OrderBy(x => x.ApplicationDate);
if (submittedApplications.Any())
{
var application = submittedApplications.First();
var firstSubmittedApplicationId = await _applicationDataRepository.GetFirstSubmittedApplicationId(application.AccountLegalEntityId);
var sendRepeatReminderEmailCommand = new SendBankDetailsRepeatReminderEmailCommand(application.AccountId,
application.AccountLegalEntityId,
firstSubmittedApplicationId.Value,
application.SubmittedByEmail);
await _commandDispatcher.Send(sendRepeatReminderEmailCommand);
}
}
}
public async Task Create([ActivityTrigger] CalculateDaysInLearningInput input)
{
_logger.LogInformation("Calculating DaysinLearning for apprenticeship incentive id {apprenticeshipIncentiveId}, active period {activePeriod}", input.ApprenticeshipIncentiveId, input.ActivePeriod);
await _commandDispatcher.Send(new CalculateDaysInLearningCommand(input.ApprenticeshipIncentiveId, input.ActivePeriod.Period, input.ActivePeriod.Year ));
_logger.LogInformation("Calculated DaysinLearning for apprenticeship incentive id {apprenticeshipIncentiveId}, active period {activePeriod}", input.ApprenticeshipIncentiveId, input.ActivePeriod);
}
public async Task Create([ActivityTrigger] CreatePaymentInput input)
{
_logger.LogInformation("Creating Payment for apprenticeship incentive id {apprenticeshipIncentiveId}, pending payment id {pendingPaymentId}, collection period {collectionPeriod}", input.ApprenticeshipIncentiveId, input.PendingPaymentId, input.CollectionPeriod);
await _commandDispatcher.Send(new CreatePaymentCommand(input.ApprenticeshipIncentiveId, input.PendingPaymentId, input.CollectionPeriod.Year, input.CollectionPeriod.Period));
_logger.LogInformation("Created Payment for apprenticeship incentive id {apprenticeshipIncentiveId}, pending payment id {pendingPaymentId}, collection period {collectionPeriod}", input.ApprenticeshipIncentiveId, input.PendingPaymentId, input.CollectionPeriod);
}
public IActionResult PostDriver([FromBody] CreateDriverCommand createDriverCommand)
{
if (createDriverCommand == null)
{
return(BadRequest());
}
Guid driverId = Guid.Empty;
_commandDispatcher.Send(createDriverCommand, out driverId);
var driverToReturn = _mapper.Map <DriverResult>(createDriverCommand);
driverToReturn.DriverId = driverId;
return(CreatedAtRoute("GetDriver", new { driverId = driverId }, driverToReturn));
}
public async Task Update([ActivityTrigger] object input)
{
_logger.LogInformation("Setting active collection period to in progress");
await _commandDispatcher.Send(new SetActivePeriodToInProgressCommand());
_logger.LogInformation("Active collection period set to in progress");
}
public async Task Update([ActivityTrigger] CalculateEarningsInput input)
{
_logger.LogInformation("Calculating Earnings for apprenticeship incentive id {apprenticeshipIncentiveId}, uln {uln}", input.ApprenticeshipIncentiveId, input.Uln);
await _commandDispatcher.Send(new CalculateEarningsCommand(input.ApprenticeshipIncentiveId));
_logger.LogInformation("Calculated Earnings for apprenticeship incentive id {apprenticeshipIncentiveId}, uln {uln}", input.ApprenticeshipIncentiveId, input.Uln);
}
public async Task Complete([ActivityTrigger] CompletePaymentProcessInput input)
{
_logger.LogInformation("Completing payment process");
await _commandDispatcher.Send(new CompleteCommand(input.CompletionDateTime, new Domain.ValueObjects.CollectionPeriod(input.CollectionPeriod.Period, input.CollectionPeriod.Year)));
_logger.LogInformation("Payment process completed for collection period {collectionPeriod}", input.CollectionPeriod);
}
private void CompleteIfPossible(ICommandDispatcher dispatcher)
{
if (status == Status.ReadyToComplete)
{
ApplyChanges(new OrderDelivered(this.id));
dispatcher.Send(new CompleteOrder(this.id)); //todo this is wierd should do it after events have been persisted
}
}
public IActionResult Post([FromBody] CreateCarCommand createCarCommand)
{
if (createCarCommand == null)
{
return(BadRequest());
}
Guid carId = Guid.Empty;
_commandDispatcher.Send(createCarCommand, out carId);
var carToReturn = _mapper.Map <CarResult>(createCarCommand);
carToReturn.CarId = carId;
return(CreatedAtRoute("GetCar", new { carId }, carToReturn));
}
public async Task <bool> Send([ActivityTrigger] AccountLegalEntityCollectionPeriod accountLegalEntityCollectionPeriod)
{
var collectionPeriod = accountLegalEntityCollectionPeriod.CollectionPeriod;
var accountLegalEntityId = accountLegalEntityCollectionPeriod.AccountLegalEntityId;
_logger.LogInformation("[SendPaymentRequestsForAccountLegalEntity] Publish SendPaymentRequestsCommand for account legal entity {accountLegalEntityId}, collection period {collectionPeriod}", accountLegalEntityId, collectionPeriod);
await _commandDispatcher.Send(new SendPaymentRequestsCommand(accountLegalEntityId, DateTime.UtcNow));
_logger.LogInformation("[SendPaymentRequestsForAccountLegalEntity] Published SendPaymentRequestsCommand for account legal entity {accountLegalEntityId}, collection period {collectionPeriod}", accountLegalEntityId, collectionPeriod);
return(true);
}
public void ConsumeCommand(string sender, Parcel parcel)
{
if (_messageInboxItemRepository.AllowReceive(parcel.MessageId, sender))
{
var mapToClass = _messageTypeMap[parcel.Route];
var commandType = Type.GetType(mapToClass);
dynamic command = _jsonSerializer.Deserialize(parcel.MessageBody, commandType);
_commandDispatcher.Send(command);
_messageInboxItemRepository.Receive(parcel.MessageId, sender);
}
}
public async Task Validate([ActivityTrigger] ValidatePendingPaymentData payment)
{
_logger.LogInformation("Validating Pending Payment [PendingPaymentId={pendingPaymentId}], [collection period={year}/{period}], [ApprenticeshipIncentiveId={apprenticeshipIncentiveId}]",
payment.PendingPaymentId, payment.Year, payment.Period, payment.ApprenticeshipIncentiveId);
try
{
await _commandDispatcher.Send(new ValidatePendingPaymentCommand(payment.ApprenticeshipIncentiveId,
payment.PendingPaymentId, payment.Year, payment.Period));
}
catch (Exception ex)
{
throw new ValidatePendingPaymentException(payment.ApprenticeshipIncentiveId, payment.PendingPaymentId, ex);
}
}
public async Task Send <TCommand>(TCommand command, CancellationToken cancellationToken = default) where TCommand : ICommand
{
if (_hook != null)
{
try
{
if (_hook?.OnReceived != null)
{
_hook.OnReceived(command);
}
await _commandDispatcher.Send(command);
if (_hook?.OnProcessed != null)
{
_hook.OnProcessed(command);
}
}
catch (Exception ex)
{
bool suppressError = false;
if (_hook?.OnErrored != null)
{
suppressError = _hook.OnErrored(ex, command);
}
if (!suppressError)
{
throw;
}
}
}
else
{
await _commandDispatcher.Send(command);
}
}
public async Task <Result <T> > Send <T>(ICommand <T> command, CancellationToken cancellationToken = default)
{
_logger.Sending(command.GetType(), command.CorrelationId);
var result = await _bus.Send(command, cancellationToken);
if (result is Ok <T> )
{
_logger.Success(command.CorrelationId);
}
else if (result is Error <T> error)
{
_logger.Error(command.CorrelationId, error.Message);
}
return(result);
}
public async Task Send <T>(T command, CancellationToken cancellationToken = default) where T : ICommand
{
var log = _logfactory.CreateLogger <T>();
var domainLog = (command is ILogWriter) ? (command as ILogWriter).Log : new Log();
try
{
if (domainLog.OnProcessing == null)
{
log.LogInformation($"Start dispatch '{typeof(T)}' command");
}
else
{
log.LogInformation($"Start dispatch '{typeof(T)}' command : {domainLog.OnProcessing.Invoke()}");
}
await _dispatcher.Send(command, cancellationToken);
if (domainLog.OnProcessed == null)
{
log.LogInformation($"End dispatch '{typeof(T)}' command");
}
else
{
log.LogInformation($"End dispatch '{typeof(T)}' command : {domainLog.OnProcessed.Invoke()}");
}
}
catch (Exception ex)
{
if (domainLog.OnError == null)
{
log.LogError(ex, $"Error dispatching '{typeof(T)}' command");
}
else
{
log.LogError(ex, $"Error dispatching '{typeof(T)}' command : {domainLog.OnError.Invoke()}");
}
throw;
}
}
public async Task Execute(CreatePodcastCommand command)
{
using (var work = _factory.Begin())
{
if (work.Podcasts.Exists(command.Id))
{
return;
}
var Podcast = new Podcast {
Id = command.Id,
Link = command.Link,
CategoryId = command.CategoryId
};
work.Podcasts.Save(Podcast);
work.Commit();
}
await _command.Send(new RetrievePodcastCommand { Id = command.Id, Link = command.Link });
}
public async Task <IActionResult> PausePayments([FromBody] PausePaymentsRequest request)
{
try
{
await _commandDispatcher.Send(new PausePaymentsCommand(request.ULN, request.AccountLegalEntityId, request.ServiceRequest?.TaskId, request.ServiceRequest?.DecisionReference, request.ServiceRequest?.TaskCreatedDate, request.Action));
return(new OkObjectResult(new { Message = $"Payments have been successfully {request.Action}d" }));
}
catch (InvalidRequestException e)
{
return(new BadRequestObjectResult(e.Message));
}
catch (KeyNotFoundException e)
{
return(new NotFoundObjectResult(new { e.Message }));
}
catch (PausePaymentsException e)
{
return(new BadRequestObjectResult(new { e.Message }));
}
}
public async Task <Result <T> > Send <T>(ICommand <T> command, CancellationToken cancellationToken = default)
{
try
{
_logger.Debug("Exception to result: Send");
return(await _bus.Send(command, cancellationToken));
}
catch (DomainException dex)
{
_logger.Information(dex, "Domain error processing command {Id}", command.CorrelationId);
return(command.Error(dex.Message));
}
catch (Exception ex)
{
_logger.Error(ex, "Error processing command {Id}", command.CorrelationId);
return(command.Error($"An error occurred processing command {command.CorrelationId}"));
}
finally
{
_logger.Debug("Exception to result: End");
}
}
protected Task SendCommandAsync <TCommand>(TCommand command) where TCommand : ICommand
{
return(_commandDispatcher.Send(command));
}
public async Task <Result <T> > Send <T>(ICommand <T> command, CancellationToken cancellationToken = default)
{
var result = await _bus.Send(command, cancellationToken);
return(result);
}