public static IOutcome <List <PlayerMod> > GetModsFromIdList(ZelusDbContext db, List <int> modIds)
{
//Only allow saving of exactly 6 mods for a modset
if (modIds.IsNull() || modIds.Count != 6)
{
return(Outcomes.Failure <List <PlayerMod> >()
.WithMessage("Can only save 6 mods to a mod set."));
}
var mods = db.PlayerMods
.Where(pm => modIds.Contains(pm.Id))
.ToList();
//Only allow 1 of each slot of mods
if (mods.Count(pm => pm.SlotId == (int)ModSlots.Square) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Arrow) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Diamond) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Triangle) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Circle) != 1 ||
mods.Count(pm => pm.SlotId == (int)ModSlots.Cross) != 1)
{
return(Outcomes.Failure <List <PlayerMod> >()
.WithMessage("Can only save 1 mod per slot."));
}
return(Outcomes.Success <List <PlayerMod> >()
.WithValue(mods));
}
public Task <IOutcome> Handle(SetDriverForOrderCommandRequest request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
try
{
var driver = GetDriver(request.DriverId);
if (driver == null)
{
throw new NullReferenceException("Назначаемый водитель не найден");
}
SetDriverForOrder(request.OrderId, driver.Id);
var successMessage = $"На заказ № {request.OrderId} назначен водитель: {driver.FullName}";
_logger.LogInformation(
$"{successMessage} (ID = {driver.Id})");
return (IOutcome)Outcomes.Success().WithMessage(successMessage);
}
catch (Exception ex)
{
var errorBaseMessage = $"$При назначении водителя на заказ № {request.OrderId} возникла ошибка";
var errorBuilder = new StringBuilder();
errorBuilder.Append($"{errorBaseMessage}: ");
errorBuilder.AppendLine();
errorBuilder.Append(ex.Message);
_logger.LogError(errorBuilder.ToString());
return Outcomes.Failure().WithMessage(errorBuilder.ToString());
}
}, cancellationToken));
}
public IOutcome Execute()
{
try
{
CategorizeUnits();
if (_newUnits.Count > 0)
{
_db.Units.AddRange(_newUnits);
}
foreach (var unitToUpdate in _unitsToUpdate)
{
_db.Units.AddOrUpdate(unitToUpdate);
}
_db.SaveChanges();
return(Outcomes.Success());
}
catch (Exception ex)
{
return(Outcomes.Failure()
.WithMessage(ex.ToString()));
}
}
public async Task Handle__CreateNewOrderIsFail__SendMethodOfINotifierWasNotCalled()
{
// Arrange
var notifier = Substitute.For <INotifier>();
var dbContext = Substitute.For <OrderContext>();
var appSettings = AppSettingsFake.Generate();
var commandRequest = GenerateCommandRequest();
#region DbContextFactory
var dbContextFactory = Substitute.For <IDbContextFactory <OrderContext> >();
dbContextFactory.Create(appSettings.ConnectionStrings.OrdersDb).Returns(dbContext);
#endregion
var handler = CreateTestedComponent(appSettings, dbContextFactory, notifier);
#region CreateNewOrderCommand
var createNewOrderCommand = Substitute.For <CreateNewOrderCommand>(dbContext);
createNewOrderCommand.Execute(Arg.Any <CreateNewOrderCommand.Context>())
.Returns(Outcomes.Failure <Order>().WithMessage("test-error"));
var createNewOrderCommandFactory = Substitute.For <CreateNewOrderCommand.Factory>();
createNewOrderCommandFactory.Create(dbContext).Returns(createNewOrderCommand);
handler.SetCreateNewOrderCommandFactory(createNewOrderCommandFactory);
#endregion
// Act
await handler.Handle(commandRequest, CancellationToken.None);
// Assert
notifier.Received(0).Send(Arg.Any <Notification>());
}
public void Failure_StatusCode_WithStatusCode_Works()
{
var outcome = Outcomes.Failure()
.WithStatusCode(200);
Assert.True(outcome.StatusCode == 200);
}
public IOutcome Execute()
{
try
{
CategorizePlayerCharacters();
if (_newPlayerCharacters.Count > 0)
{
_db.PlayerCharacters.AddRange(_newPlayerCharacters);
}
foreach (var playerCharacterToUpdate in _playerCharactersToUpdate)
{
_db.PlayerCharacters.AddOrUpdate(playerCharacterToUpdate);
}
foreach (var playerToSync in _players)
{
playerToSync.LastCollectionSync = DateTime.UtcNow;
_db.Players.AddOrUpdate(playerToSync);
}
_db.SaveChanges();
return(Outcomes.Success());
}
catch (Exception ex)
{
return(Outcomes.Failure()
.WithMessage(ex.ToString()));
}
}
public IOutcome Execute()
{
try
{
CategorizePlayers();
if (_newPlayers.Count > 0)
{
_db.Players.AddRange(_newPlayers);
}
foreach (var playerToUpdate in _playersToUpdate)
{
_db.Players.AddOrUpdate(playerToUpdate);
}
if (_playersToRemove.Count > 0)
{
_db.Players.RemoveRange(_playersToRemove);
}
_db.SaveChanges();
return(Outcomes.Success());
}
catch (Exception ex)
{
return(Outcomes.Failure()
.WithMessage(ex.ToString()));
}
}
public Task <IOutcome> Handle(FinishOrderCommandRequest request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
using (var dbContext = _dbContextFactory.Create(_appSettings.ConnectionStrings.OrdersDb))
{
try
{
var foundOrder = dbContext.Orders.FirstOrDefault(e => e.Id == request.OrderId);
if (foundOrder == null)
{
return Outcomes.Failure().WithMessage($"Заказ № {request.OrderId} не найден");
}
foundOrder.Status = StatusEnum.Finished;
foundOrder.FinishDateTime = DateTime.Now;
dbContext.SaveChanges();
return (IOutcome)Outcomes.Success();
}
catch (Exception ex)
{
var logMessage = $"При закрытии заказа № {request.OrderId} возникли ошибки";
_logger.LogError(ex, logMessage);
return Outcomes.Failure().WithMessage(logMessage);
}
}
}, cancellationToken));
}
public Task <IOutcome> Handle(MakeOrderCommandRequest request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
_logger.LogInformation($"Начато формирование заказа на такси для клиента {request.Phone}");
// 1. Создать новый заказ со статусом "В обработке"
var createOrderResult = CreateNewOrder(request);
if (createOrderResult.Failure)
{
return createOrderResult;
}
// 2. Отправить клиенту СМС с номером заказа
var createdOrder = createOrderResult.Value;
var sendResult = SendNotification(createdOrder);
if (sendResult.Failure)
{
var errorBuilder = new StringBuilder();
errorBuilder.Append($"Заказ № {createdOrder.Id} создан, но отправка емайл-уведомления");
errorBuilder.Append(" завершилась с ошибкой:");
errorBuilder.AppendLine();
errorBuilder.AppendLine(sendResult.ToMultiLine());
return (IOutcome)Outcomes.Failure().WithMessage(errorBuilder.ToString());
}
var successMessage = $"Заказ № {createdOrder.Id} создан. Статус - \"{createdOrder.Status}\"";
_logger.LogInformation(successMessage);
return Outcomes.Success().WithMessage(successMessage);
}, cancellationToken));
}
private async Task <IOutcome> SendOverMultipleSmtpServersAsync(EmailMessage message)
{
var errors = new List <string>();
var smtpServerConfigurations = _mailSettingsConfig.Smtp.Servers;
var wasSentSuccessfully = false;
foreach (var smtpServerConfiguration in smtpServerConfigurations)
{
try
{
if (wasSentSuccessfully)
{
continue;
}
var createRequest = new MailMessageCreateRequest()
{
EmailMessage = message,
SmtpServerConfig = smtpServerConfiguration,
IsReadSenderFromConfig = true,
RequiredRecipients = _mailSettingsConfig.Smtp.RequiredRecipients,
};
var mailMessage = await _mailMessageFactory.CreateAsync(createRequest);
using (var smtpClient = _smtpClientFactory.Create(smtpServerConfiguration))
{
await smtpClient.SendAsync(mailMessage);
wasSentSuccessfully = true;
}
}
catch (Exception ex)
{
wasSentSuccessfully = false;
var error = ex.Message;
if (ex.InnerException != null)
{
var innerEx = ex.InnerException;
while (innerEx.InnerException != null)
{
innerEx = innerEx.InnerException;
}
error = innerEx.Message;
}
errors.Add($"SMTP {smtpServerConfiguration.Host} throw an error: {error}");
}
}
if (wasSentSuccessfully)
{
return(Outcomes.Success());
}
return(Outcomes.Failure().WithMessagesFrom(errors.Distinct()));
}
public IOutcome Accept(NewPaymentCommand payment)
{
if (payment.CreditCard.ExpireDate > DateTime.Now)
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Credit card invalid, it´s expired since {payment.CreditCard.ExpireDate}."));
}
public IOutcome Accept(Payment payment)
{
if (Math.Floor(Math.Log10(payment.CreditCardNotMasked.CVV) + 1) == 3)
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Credit card CVV is invalid."));
}
public IOutcome Accept(Payment payment)
{
if (payment.CreditCardNotMasked.Number.Length == 16)
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Credit card number is invalid {payment.CreditCard.Number}. It must have 16 characters"));
}
public void Failure_Keys_WithKey_Works()
{
var outcome = Outcomes.Failure()
.WithKey("test1", "value1")
.WithKey("test2", "value2");
Assert.True(outcome.Keys["test1"].ToString() == "value1");
Assert.True(outcome.Keys["test2"].ToString() == "value2");
}
public void Failure_OfT_Messages_Not_Null_By_Default()
{
IOutcome <int> outcome = Outcomes.Failure <int>();
Assert.False(outcome.Success);
Assert.NotNull(outcome.Messages);
Assert.True(outcome.Value == 0);
Assert.True(outcome.ToString() == string.Empty);
}
public IOutcome Accept(Payment payment)
{
if (payment.Amount.Value > 0)
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"The payment amount must be greater than 0."));
}
public void Failure_FromException_Works()
{
var exception = new InvalidOperationException("test message");
var outcome = Outcomes.Failure().FromException(exception);
Assert.False(outcome.Success);
Assert.True(outcome.Messages.Count == 1);
Assert.True(outcome.ToMultiLine("<br>") == "System.InvalidOperationException: test message<br>");
}
public IOutcome Accept(PaymentCommand payment)
{
var merchantExists = FindMerchantByID(payment.MerchantID).GetAwaiter();
if (merchantExists.GetResult())
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Merchant not found to process the payment."));
}
public void Failure_WithValue_Works()
{
var outcome = Outcomes.Failure <Decimal>()
.WithValue(23123.32M);
Assert.True(!outcome.Success);
Assert.True(outcome.Messages.Count == 0);
Assert.True(outcome.Value == 23123.32M);
Assert.True(outcome.ToString() == string.Empty);
Assert.True(outcome.ToMultiLine("<br>") == string.Empty);
}
/// <summary>
/// Creates a new <see cref="TimeFrame"/> instance with the given times.
/// </summary>
/// <param name="earliestTime">The earliest time for delivery.</param>
/// <param name="latestTime">The latest time for delivery.</param>
/// <returns>An <see cref="Outcome"/> indicating the outcome of the create method.</returns>
public static Outcome <TimeFrame> Create(DateTime earliestTime, DateTime latestTime)
{
var error = Exceptions.WhenOutOfRange(latestTime, earliestTime, nameof(latestTime));
if (error == null)
{
return(Outcomes.Success(new TimeFrame(earliestTime, latestTime)));
}
return(Outcomes.Failure <TimeFrame>(error));
}
/// <summary>
/// Creates a new <see cref="Email"/> instance with a specified <paramref name="value"/>.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>An <see cref="Outcome"/> indicating the outcome of the create method.</returns>
public static Outcome <Email> Create(string value)
{
var error = ValidateValue(value);
if (error == null)
{
return(Outcomes.Success(new Email(value)));
}
return(Outcomes.Failure <Email>(error));
}
public Task <IOutcome> NotifyAsync(EmailMessage message)
{
try
{
return(SendOverMultipleSmtpServersAsync(message));
}
catch (Exception ex)
{
return(Task.FromResult((IOutcome)Outcomes.Failure().WithMessage(ex.Message)));
}
}
public IOutcome Accept(PaymentCommand payment)
{
var shopperExists = FindShopperByID(payment.ShopperID).GetAwaiter();
if (shopperExists.GetResult())
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Shopper not found to process the payment."));
}
public void Failure_FromException_Chaining_Works()
{
var exception = new InvalidOperationException("test");
var outcome = Outcomes.Failure().WithMessage("prefix")
.FromException(exception)
.WithMessage("suffix");
Assert.False(outcome.Success);
Assert.True(outcome.Messages.Count == 3);
Assert.True(outcome.ToMultiLine("<br>") == "prefix<br>System.InvalidOperationException: test<br>suffix<br>");
}
public void Failure_FromOutcome_Chaining_Works()
{
var previousOutcome = Outcomes.Failure().WithMessage("test");
var outcome = Outcomes.Failure().WithMessage("prefix")
.FromOutcome(previousOutcome)
.WithMessage("suffix");
Assert.False(outcome.Success);
Assert.True(outcome.Messages.Count == 3);
Assert.True(outcome.ToMultiLine("<br>") == "prefix<br>test<br>suffix<br>");
}
public void Failure_WithKeysFrom_Works()
{
var outcome1 = Outcomes.Failure()
.WithKey("test", 35);
var outcome2 = Outcomes.Failure().WithKeysFrom(outcome1);
var outcome3 = Outcomes.Failure().FromOutcome(outcome1);
Assert.True(outcome1.Keys["test"].Equals(35));
Assert.True(outcome2.Keys["test"].Equals(35));
Assert.True(outcome3.Keys["test"].Equals(35));
}
public void Failure_Messages_Not_Null_By_Default()
{
IOutcome outcome = Outcomes.Failure();
Assert.False(outcome.Success);
Assert.NotNull(outcome.Messages);
Assert.True(outcome.ToString() == string.Empty);
//This should also work.
IOutcome <object> o = (IOutcome <object>)outcome;
Assert.Null(o.Value);
}
public IOutcome Accept(MerchantCommand newEntity)
{
var result = this.findMerchantRepository.GetAsync(newEntity.Id).GetAwaiter();
var merchant = result.GetResult();
if (merchant is null)
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Merchant ID is alredy in use!"));
}
public void Failure_Chaining_Syntactic_Sugar_Works()
{
var previousOutcome = Outcomes.Failure().WithMessage("test");
var outcome = Outcomes.Failure().WithStatusCode(201)
.WithMessage("prefix")
.WithMessagesFrom(previousOutcome)
.WithMessage("suffix");
Assert.False(outcome.Success);
Assert.True(outcome.Messages.Count == 3);
Assert.True(outcome.ToMultiLine("<br>") == "prefix<br>test<br>suffix<br>");
}
public IOutcome Accept(Merchant newEntity)
{
var findMerchantQuery = new FindMerchantQuery(newEntity.Name);
var task = this.findMerchantQueryHandler.GetAllAsync(findMerchantQuery).GetAwaiter();
IEnumerable <Merchant> merchant = task.GetResult();
if (merchant is null || !merchant.Any())
{
return(Outcomes.Success());
}
return(Outcomes.Failure <int[]>().WithMessage($"Merchant name is alredy in use!"));
}