public Tests()
{
_mediator = new Mock <IMediator>();
_emailMock = new Mock <IEmailService>();
_orderRepoMock = new Mock <IOrderRepository>();
_mockMediatr = new Mock <IMediator>();
_order = new Order()
{
UserName = "******"
};
_orders = new List <Order>()
{
new() {
UserName = "******"
}
};
_updateOrderCommand = new UpdateOrderCommand()
{
UserName = "******",
TotalPrice = 0
};
}
public async Task Handle_GivenValidRequest_ShouldReturnOrderId()
{
// Arrange
var command = new UpdateOrderCommand
{
Id = 1,
Description = "NewDesc",
Quantity = "321",
Status = "Tested",
};
var sut = new UpdateOrderCommandHandler(this.deletableEntityRepository);
// Act
var id = await sut.Handle(command, It.IsAny <CancellationToken>());
// Assert
var order = await this.dbContext.Orders.SingleOrDefaultAsync(x => x.Id == id);
order.ShouldNotBeNull();
order.Description.ShouldBe("NewDesc");
order.Quantity.ShouldBe(321);
order.Status.ShouldBe("Tested");
}
public async Task <ActionResult <bool> > UpdateOrder([FromBody] UpdateOrderCommand command)
{
bool status = await _mediator.Send(command);
return(Ok(status));
}
public async Task <ActionResult> UpdateOrder([FromBody] UpdateOrderCommand cmd)
{
await _mediator.Send(cmd);
return(Ok());
}
public async Task <IActionResult> UpdateOrder(UpdateOrderCommand command)
{
await _mediator.Send(command);
return(NoContent());
}
public async Task <ActionResult> UpdateOrder([FromBody] UpdateOrderCommand command)
{
await mediator.Send(command);
return(NoContent());
}
public void Description_not_empty_success()
{
var order = new UpdateOrderCommand(Guid.Empty, Guid.Empty, new DateTime(), "Description");
validator.ShouldNotHaveValidationErrorFor(p => p.Description, order);
}
public void Product_id_empty_fail()
{
var order = new UpdateOrderCommand(Guid.Empty, Guid.Empty, new DateTime(), string.Empty);
validator.ShouldHaveValidationErrorFor(p => p.ProductId, order);
}
public Task <int> Update(UpdateOrderCommand updateOrderCommand)
{
throw new NotImplementedException();
}
/// <summary>
/// 更新
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <Unit> Handle(UpdateOrderCommand request, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateOrderCommand command)
{
var response = await _mediator.Send(command);
return(Json(response));
}
public void Run(UpdateOrderCommand command)
{
_service.When(command);
}
public async Task ShouldUpdateOrder()
{
// Arrange
var accountId = await RunAsDefaultUserAsync();
var createCustomerCommand = new CreateCustomerCommand
{
AccountId = accountId,
ShopName = "Test Shop Name",
ShopAddress = "Test Shop address",
LocationOnMap = "Test LocationOnMap"
};
await SendAsync(createCustomerCommand);
// Create product brand
var brandCommand = new CreateBrandCommand {
Name = "Test Brand"
};
var brandId = await SendAsync(brandCommand);
// Create product category
var productCategoryCommand = new CreateProductCategoryCommand {
Name = "Test Product Category"
};
var productCategoryId = await SendAsync(productCategoryCommand);
// Create product
var createProductCommand = new CreateProductCommand
{
AvailableToSell = true,
// created brand id
BrandId = brandId,
// created product category id
ProductCategoryId = productCategoryId,
Name = "Test Product",
PhotoUrl = "Test Product",
Barcode = "Test Product"
};
var productId = await SendAsync(createProductCommand);
// Add first unit to product
var addFirstUnitCommand = new AddUnitCommand
{
ProductId = productId,
SellingPrice = 92,
ContentCount = 2,
Price = 33,
Count = 6,
IsAvailable = true,
Name = "Test First Unit",
Weight = 44
};
var firstUnitId = await SendAsync(addFirstUnitCommand);
// Add first unit to product
var addSecondUnitCommand = new AddUnitCommand
{
ProductId = productId,
SellingPrice = 342,
ContentCount = 24,
Price = 323,
Count = 64,
IsAvailable = true,
Name = "Test Second Unit",
Weight = 94
};
var secondUnitId = await SendAsync(addSecondUnitCommand);
// AddItem To Shopping Van
var addItemToVanCommand = new AddItemToVanCommand
{
ProductId = productId,
UnitId = firstUnitId
};
await SendAsync(addItemToVanCommand);
await SendAsync(addItemToVanCommand);
// Place Order Command
var placeOrderCommand = new PlaceOrderCommand();
var orderId = await SendAsync(placeOrderCommand);
// Get Order By Id Query
var orderByIdQuery = new OrderByIdQuery {
OrderId = orderId
};
var order = await SendAsync(orderByIdQuery);
// Act
var updateOrderCommand = new UpdateOrderCommand
{
OrderId = orderId,
OrderItemId = order.OrderItems.FirstOrDefault(x => x.UnitId == firstUnitId).Id,
UnitId = secondUnitId,
UnitCount = 10,
UnitName = addSecondUnitCommand.Name
};
await SendAsync(updateOrderCommand);
// Get Order By Id Query
var orderAfterUpdate = await SendAsync(orderByIdQuery);
// Assert
order.Should().NotBeNull();
order.OrderItems.Count.Should().Be(1);
order.OrderItems.FirstOrDefault(x => x.UnitId == firstUnitId).UnitName.Should().Be(addFirstUnitCommand.Name);
orderAfterUpdate.OrderItems.FirstOrDefault(x => x.UnitId == secondUnitId).UnitName.Should().Be(addSecondUnitCommand.Name);
}
public static Order ToEntity(this UpdateOrderCommand model, Order destination)
{
return(model.MapTo(destination));
}
partial void OnUpdatedOrder(IServiceRequestWithData <Cqrs.Authentication.ISingleSignOnToken, Entities.OrderEntity> serviceRequest, ref UpdateOrderCommand command, Entities.OrderEntity locatedItem, ref ServiceResponseStateType?serviceResponseStateType);
public Task <ActionResult> Update(UpdateOrderCommand command) => throw new NotImplementedException();
public async Task <OrderDTO> UpdateOrderAsync(OrderDTO orderDTO)
{
var query = new UpdateOrderCommand(orderDTO);
return(await _mediator.Send(query));
}
public async Task <UpdateOrderValidationResult> Validate(UpdateOrderCommand order, string subject)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (string.IsNullOrWhiteSpace(subject))
{
throw new ArgumentNullException(nameof(subject));
}
var record = await _orderRepository.Get(order.Id);
if (record == null)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheOrderDoesntExist));
}
if (record.Status == OrderAggregateStatus.Received) // Cannot update received order.
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheReceivedOrderCannotBeUpdated));
}
if (record.Status != OrderAggregateStatus.Created && record.Status == order.Status) // Confirmed & received order cannot be updated.
{
return(new UpdateOrderValidationResult(string.Format(ErrorDescriptions.TheOrderCannotBeUpdatedBecauseOfItsState, Enum.GetName(typeof(OrderAggregateStatus), order.Status))));
}
if (record.Status != order.Status)
{
if (record.Status == OrderAggregateStatus.Created && order.Status != OrderAggregateStatus.Confirmed) // created => confirmed.
{
return(new UpdateOrderValidationResult(string.Format(ErrorDescriptions.TheOrderStateCannotBeUpdated, Enum.GetName(typeof(OrderAggregateStatus), record.Status), Enum.GetName(typeof(OrderAggregateStatus), order))));
}
if (record.Status == OrderAggregateStatus.Confirmed && order.Status != OrderAggregateStatus.Received) // confirmed => received
{
return(new UpdateOrderValidationResult(string.Format(ErrorDescriptions.TheOrderStateCannotBeUpdated, Enum.GetName(typeof(OrderAggregateStatus), record.Status), Enum.GetName(typeof(OrderAggregateStatus), order))));
}
}
if (order.TransportMode == OrderTransportModes.Manual && order.Status == OrderAggregateStatus.Received && record.Subject != subject) // Only the creator can confirm the order.
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheOrderReceptionCanBeConfirmedOnlyByItsCreator));
}
IEnumerable <ProductAggregate> prods = null;
if (order.OrderLines != null && order.OrderLines.Any()) // Check the lines.
{
var productIds = order.OrderLines.Select(o => o.ProductId);
var products = await _productRepository.Search(new SearchProductsParameter { ProductIds = productIds });
if (products.Content.Count() != productIds.Count())
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheOrderLineProductIsInvalid));
}
if (order.OrderLines.Any(o => o.Quantity <= 0))
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheOrderLineQuantityIsInvalid));
}
foreach (var orderLine in order.OrderLines)
{
var product = products.Content.First(p => p.Id == orderLine.ProductId);
if (orderLine.Quantity > product.AvailableInStock && product.AvailableInStock.HasValue)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheOrderLineQuantityIsTooMuch));
}
}
prods = products.Content;
var discountCodes = order.OrderLines.Select(o => o.DiscountCode).Where(dc => !string.IsNullOrEmpty(dc));
if (discountCodes.Any()) // Check discounts.
{
var discounts = await _discountRepository.Search(new SearchDiscountsParameter
{
IsPagingEnabled = false,
DiscountCodes = discountCodes
});
if (discounts.Content == null || !discounts.Content.Any() || discounts.Content.Count() != discountCodes.Count())
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheDiscountCodesAreNotValid));
}
foreach (var orderLine in order.OrderLines)
{
if (string.IsNullOrWhiteSpace(orderLine.DiscountCode))
{
continue;
}
var discount = discounts.Content.First(c => c.Code == orderLine.DiscountCode);
if (discount.Products == null || !discount.Products.Any(p => p.ProductId == orderLine.ProductId)) // Check discount is valid for the product.
{
return(new UpdateOrderValidationResult(string.Format(ErrorDescriptions.TheDiscountCannotBeUsedForThisProduct, orderLine.ProductId)));
}
if (!discount.IsValid()) // Check discount is valid.
{
return(new UpdateOrderValidationResult(string.Format(ErrorDescriptions.TheProductDiscountIsInvalid, orderLine.DiscountCode)));
}
orderLine.DiscountId = discount.Id;
}
}
}
double shippingPrice = 0;
string payerEmail = string.Empty;
string sellerEmail = string.Empty;
if (order.Status == OrderAggregateStatus.Confirmed && order.TransportMode == OrderTransportModes.Packet)
{
if (order.OrderParcel == null)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheParcelDoesntExist));
}
var payer = await _openidClient.GetPublicClaims(_settingsProvider.GetBaseOpenidUrl(), subject);
if (payer == null)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.ThePayerPaypalAccountNotExist));
}
var seller = await _openidClient.GetPublicClaims(_settingsProvider.GetBaseOpenidUrl(), record.SellerId);
if (seller == null)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheSellerPaypalAccountNotExist));
}
var paypalBuyer = payer.Claims.FirstOrDefault(c => c.Type == "paypal_email");
var paypalSeller = seller.Claims.FirstOrDefault(c => c.Type == "paypal_email");
if (paypalBuyer == null || string.IsNullOrWhiteSpace(paypalBuyer.Value))
{
return(new UpdateOrderValidationResult(ErrorDescriptions.ThePayerPaypalAccountNotExist));
}
if (paypalSeller == null || string.IsNullOrWhiteSpace(paypalSeller.Value))
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheSellerPaypalAccountNotExist));
}
if (order.OrderParcel.Transporter == Transporters.Dhl)
{
return(new UpdateOrderValidationResult(ErrorDescriptions.TheTransporterDhlIsNotSupported));
}
if (order.OrderParcel.Transporter == Transporters.Ups)
{
var buyerName = payer.Claims.First(c => c.Type == SimpleIdentityServer.Core.Jwt.Constants.StandardResourceOwnerClaimNames.Name).Value;
var sellerName = seller.Claims.First(c => c.Type == SimpleIdentityServer.Core.Jwt.Constants.StandardResourceOwnerClaimNames.Name).Value;
var parameter = new GetUpsRatingsParameter
{
Credentials = new UpsCredentials
{
LicenseNumber = _settingsProvider.GetUpsLicenseNumber(),
Password = _settingsProvider.GetUpsPassword(),
UserName = _settingsProvider.GetUpsUsername()
},
Shipper = new UpsShipperParameter
{
Name = buyerName,
Address = new UpsAddressParameter
{
AddressLine = order.OrderParcel.BuyerAddressLine,
City = order.OrderParcel.BuyerCity,
Country = order.OrderParcel.BuyerCountryCode,
PostalCode = order.OrderParcel.BuyerPostalCode.ToString()
}
},
ShipFrom = new UpsShipParameter
{
Name = buyerName,
AttentionName = buyerName,
CompanyName = buyerName,
Address = new UpsAddressParameter
{
AddressLine = order.OrderParcel.BuyerAddressLine,
City = order.OrderParcel.BuyerCity,
Country = order.OrderParcel.BuyerCountryCode,
PostalCode = order.OrderParcel.BuyerPostalCode.ToString()
}
},
ShipTo = new UpsShipParameter
{
Name = sellerName,
AttentionName = sellerName,
CompanyName = sellerName,
Address = new UpsAddressParameter
{
AddressLine = order.OrderParcel.SellerAddressLine,
City = order.OrderParcel.SellerCity,
Country = order.OrderParcel.SellerCountryCode,
PostalCode = order.OrderParcel.SellerPostalCode.ToString()
}
},
Package = new UpsPackageParameter
{
Height = Constants.PackageInfo.Height,
Length = Constants.PackageInfo.Length,
Weight = Constants.PackageInfo.Weight,
Width = Constants.PackageInfo.Width
},
AlternateDeliveryAddress = new UpsAlternateDeliveryAddressParameter
{
Name = order.OrderParcel.ParcelShopName,
Address = new UpsAddressParameter
{
AddressLine = order.OrderParcel.ParcelShopAddressLine,
City = order.OrderParcel.ParcelShopCity,
Country = order.OrderParcel.ParcelShopCountryCode,
PostalCode = order.OrderParcel.ParcelShopPostalCode.ToString()
}
},
UpsService = CommonBuilder.MappingBothUpsServices.First(kvp => kvp.Key == order.OrderParcel.UpsServiceCode).Value
};
var ratingsResponse = await _upsClient.GetRatings(parameter);
if (ratingsResponse.Response.Error != null)
{
return(new UpdateOrderValidationResult(ratingsResponse.Response.Error.ErrorDescription));
}
shippingPrice = ratingsResponse.RatedShipment.TotalCharges.MonetaryValue;
payerEmail = paypalBuyer.Value;
sellerEmail = paypalSeller.Value;
}
}
return(new UpdateOrderValidationResult(record, prods, payerEmail, sellerEmail, shippingPrice));
}
public void Product_id_not_empty_success()
{
var order = new UpdateOrderCommand(Guid.Empty, Guid.NewGuid(), new DateTime(), string.Empty);
validator.ShouldNotHaveValidationErrorFor(p => p.ProductId, order);
}
public async Task UpdateOrder(UpdateOrderCommand command)
{
await CommandBus.Execute(command);
}
public void Order_date_not_empty_success()
{
var order = new UpdateOrderCommand(Guid.Empty, Guid.Empty, DateTime.Now, string.Empty);
validator.ShouldNotHaveValidationErrorFor(p => p.OrderDate, order);
}
public async Task <IActionResult> Index(RaffleOrderViewModel model)
{
RaffleOrder order = null;
var raffleEvent = raffleEventRepository.GetById(1);
if (DateTime.UtcNow >= raffleEvent.CloseDate)
{
return(RedirectToAction("Index"));
}
if (HttpContext.Request.Cookies.ContainsKey(CookieKeys.RaffleOrderId))
{
var orderId = int.Parse(HttpContext.Request.Cookies[CookieKeys.RaffleOrderId]);
order = (await mediator.Send(new GetRaffleOrderQuery {
OrderId = orderId
}));
}
if ((order != null && !order.Lines.Any(x => x.Count > 0)) &&
!model.RaffleItems.Any(x => x.Amount > 0))
{
var raffleItems = raffleItemRepository.GetAll()
.Select(x => new RaffleItemModel
{
Id = x.Id,
ItemNumber = x.ItemNumber,
Title = x.Title,
Description = x.Description,
Category = x.Category,
Sponsor = x.Sponsor,
Cost = x.Cost,
Value = x.ItemValue,
ForOver21 = x.ForOver21,
LocalPickupOnly = x.LocalPickupOnly,
NumberOfDraws = x.NumberOfDraws,
IsAvailable = x.IsAvailable,
TotalTicketsEntered = x.TotalTicketsEntered,
Pictures = x.ImageUrls
}).ToList();
model = new RaffleOrderViewModel
{
StartDate = raffleEvent.StartDate,
CloseDate = raffleEvent.CloseDate.Value.ToUniversalTime(),
Categories = raffleItemRepository.GetUsedCategories().OrderBy(x => x).ToList(),
RaffleItems = raffleItems,
ErrorMessage = "A raffle needs to be selected."
};
return(View(model));
}
if (ModelState.IsValid)
{
if (order != null)
{
var lineItems = order.Lines.Select(x => new UpdateOrderCommand.RaffleOrderItem
{
RaffleItemId = x.RaffleItemId,
Name = x.Name,
Price = x.Price,
Count = x.Count
}).ToList();
var newLineItems = model.RaffleItems
.Where(x => x.Amount > 0)
.Select(x => new UpdateOrderCommand.RaffleOrderItem
{
RaffleItemId = x.Id,
Name = $"#{x.ItemNumber} {x.Title}",
Price = x.Cost,
Count = x.Amount
}).ToList();
lineItems.AddRange(newLineItems.Where(x => !lineItems.Any(y => y.RaffleItemId == x.RaffleItemId)));
foreach (var item in lineItems)
{
var newItem = newLineItems.FirstOrDefault(x => x.RaffleItemId == item.RaffleItemId);
if (newItem == null)
{
continue;
}
item.Price = newItem.Price;
item.Count = newItem.Count;
}
var updateOrder = new UpdateOrderCommand
{
OrderId = order.Id,
ReplaceAll = true,
RaffleOrderItems = lineItems
};
await mediator.Publish(updateOrder);
}
else
{
var startRaffleOrder = new StartRaffleOrderQuery
{
RaffleOrderItems = model.RaffleItems
.Where(x => x.Amount > 0)
.Select(x => new StartRaffleOrderQuery.RaffleOrderItem
{
RaffleItemId = x.Id,
Name = $"#{x.ItemNumber} {x.Title}",
Price = x.Cost,
Count = x.Amount
}).ToList()
};
var orderId = (await mediator.Send(startRaffleOrder));
order = (await mediator.Send(new GetRaffleOrderQuery {
OrderId = orderId
}));
}
HttpContext.Response.Cookies.Append(
CookieKeys.RaffleOrderId,
order.Id.ToString(),
new CookieOptions
{
Secure = true,
SameSite = SameSiteMode.Strict,
Expires = new DateTimeOffset(DateTime.Now.AddDays(7))
});
return(RedirectToAction("CompleteRaffle", new { orderId = order.Id }));
}
return(View(model));
}
public void Description_empty_fail()
{
var order = new UpdateOrderCommand(Guid.Empty, Guid.Empty, new DateTime(), string.Empty);
validator.ShouldHaveValidationErrorFor(p => p.Description, order);
}
public async Task <IActionResult> Put([FromBody] UpdateOrderCommand command)
{
var result = await Mediator.Send(command);
return(Ok(result));
}
public Task <string> UpdateOrder(UpdateOrderCommand updateRequest)
{
return(Task.FromResult(updateOrderInDatabase(updateRequest)));
}
public async Task <ActionResult <Unit> > Update(UpdateOrderCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
