public ProductsController(ILogger <ProductsController> logger, IOptionsSnapshot <WingtipToysProductServiceOptions> options, GetProductCommand cmd1, GetProductsCommand cmd2,
[FromServices] IDistributedCache cache)
{
_logger = logger;
_options = options;
_cache = cache;
_getProductCommand = cmd1;
_getProductsCommand = cmd2;
}
public async Task <IActionResult> Get(int sku)
{
var command = new GetProductCommand
{
sku = sku
};
return(Ok(await _mediator.Send(command)));
}
public async Task ShouldGetProduct()
{
// Arrange
var getProductCommand = new GetProductCommand(2, WorkContext.WorkingLanguageId);
// Act
var result = await _getProductQueryHandler.Handle(getProductCommand);
// Assert
Assert.IsNotNull(result?.Object);
}
public async Task <IQueryable <ProductQuery> > Handle(GetProductCommand request, CancellationToken cancellationToken)
{
#region Persistence
var contragentsDomain = await _ProductRepository.Get(request.GraphFilters);
var response = contragentsDomain.Select(item =>
item.ToQueryModel <ProductQuery>(_Mapper));
#endregion
return(response);
}
private async Task <IActionResult> CreateProduct(GetProductCommand command)
{
var productDtoResult = await QueryProcessor.GetQueryHandler <GetProductCommand, ProductDto>(command);
if (productDtoResult.Failure)
{
return(BadRequest(productDtoResult.ErrorMessages));
}
var productDto = productDtoResult.Object;
return(Ok(productDto));
}
public async Task <IEnumerable <Infrastructure.Database.Query.Model.Product> > GetProducts(
Dictionary <string, GraphFilter> filters,
[Service] IServiceProvider serviceProvider,
CancellationToken cancellationToken)
{
var getProductCommand = new GetProductCommand
{
GraphFilters = filters
};
using (var scope = serviceProvider.CreateScope())
{
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
return((await mediator.Send(getProductCommand, cancellationToken)).ToList());
}
}
public ActionResult <ProductAvailabilityReadDto> GetProductFromWareHouse(GetProductCommand getProductCommand)
{
var productAvailabilityJson = _kubernetesClient.GetNamespacedCustomObject(
ProductAvailabilityEntity.CrdGroup,
ProductAvailabilityEntity.CrdApiVersion, Namespace,
ProductAvailabilityEntity.CrdPluralName, getProductCommand.ProductId) as JObject;
var productAvailability = productAvailabilityJson.ToObject <ProductAvailabilityEntity>();
if (productAvailability.Spec.AvailableQuantity >= getProductCommand.Quantity)
{
var x = new ProductAvailabilityEntity
{
ApiVersion = ProductAvailabilityEntity.CrdGroup + "/" + ProductAvailabilityEntity.CrdApiVersion,
Kind = ProductAvailabilityEntity.CrdKind,
Metadata =
{
Name = getProductCommand.ProductId,
ResourceVersion = productAvailability.Metadata.ResourceVersion
},
Spec =
{
LastUpdateTimeStamp = DateTime.UtcNow,
AvailableQuantity = productAvailability.Spec.AvailableQuantity - getProductCommand.Quantity
}
};
var body = JObject.FromObject(x, _camelCaseSerializer);
productAvailabilityJson = _kubernetesClient.ReplaceNamespacedCustomObject(body, ProductAvailabilityEntity.CrdGroup, ProductAvailabilityEntity.CrdApiVersion
, Namespace, ProductAvailabilityEntity.CrdPluralName, getProductCommand.ProductId) as JObject;
productAvailability = productAvailabilityJson.ToObject <ProductAvailabilityEntity>();
return(new ProductAvailabilityReadDto
{
AvailableQuantity = productAvailability.Spec.AvailableQuantity,
Id = productAvailability.Metadata.Name
});
}
return(BadRequest(new
{
Error =
$"There are only {productAvailability.Spec.AvailableQuantity} items for product {getProductCommand.ProductId}, {getProductCommand.Quantity} items cannot be requested"
}));
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="cart"></param>
/// <param name="getProductCommand"></param>
/// <param name="context"></param>
/// <returns></returns>
internal static decimal GetCartShippingRate(string name, Cart cart, GetProductCommand getProductCommand, CommercePipelineExecutionContext context)
{
var rates = GetCartShippingRates(cart, getProductCommand, context.GetPolicy <FedExClientPolicy>(), context.CommerceContext);
if (rates == null || !rates.Any())
{
return(0m);
}
try
{
return(rates.FirstOrDefault(x => x.Key == name.ToLower()).Value);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(0m);
}
public async Task <ActionResult> GetProduct(int id)
{
if (id < 0)
{
return(new BadRequestObjectResult("Invalid variable"));
}
var command = new GetProductCommand(id);
var result = await this._mediator.Send(command);
if (result.Status == CommandResultStatus.Success)
{
return(new OkObjectResult(result.Result));
}
else
{
return(new BadRequestObjectResult("Something went wrong"));
}
}
public async Task <IActionResult> GetProductById([FromQuery(Name = "productId")] string productId)
{
try
{
if (string.IsNullOrWhiteSpace(productId))
{
throw new Exception("Product Id is not valid");
}
var client = _bus.CreateRequestClient <IGetProductCommand, IProductRetrievedEvent>(_serviceAddress,
TimeSpan.FromSeconds(20));
var getCompanyCommand = new GetProductCommand(productId);
var response = await client.Request(getCompanyCommand);
return(Ok(response?.ProductDto));
}
catch (Exception e)
{
return(BadRequest($"Can't get the product: {e.Message}"));
}
}
public async Task <Result <ProductDto> > Handle(GetProductCommand request, CancellationToken cancellationToken)
{
var cacheKey = $"Product-{request.Id}";
var cache = await _cacheService.GetStringAsync(cacheKey);
ProductDto product;
if (cache.TryGetValue <Product>(out var cachedProduct))
{
product = _mapper.Map <ProductDto>(cachedProduct);
return(Result <ProductDto> .Success(product));
}
var productInDb = await _productRepository.GetAsync(p => p.Id == request.Id);
productInDb.CheckForNull();
await _cacheService.SetCacheAsync(cacheKey, productInDb, _productSettings);
product = _mapper.Map <ProductDto>(productInDb);
return(Result <ProductDto> .Success(product));
}
public void Must_return_product()
{
// Arrange
CreateProduct();
var product = CreateProduct(); // тестируемый продукт
CreateProduct();
Db.SaveChanges();
// Act
var cmd = new GetProductCommand(Db);
var result = cmd.Execute(product.Id);
// Assert
AssertSuccess(result);
Assert.AreEqual(product.Id, result.Value.Id, "Возвратился продукт с неверным Id");
Assert.IsNotNull(result.Value.Category, "Продукт вернулся без категории");
Assert.AreEqual(product.Name, result.Value.Name, "Неверное имя продукта");
Assert.IsNotNull(result.Value.Params, "Продукт вернулся без параметров");
Assert.AreEqual(product.Params.Count, result.Value.Params.Count, "Проукт вернулся с неверным числом параметров");
}
public async Task <IActionResult> Create(string url)
{
url = url?.TrimStart('/') ?? "";
var urlPath = url.Split('?').First();
if (Regex.IsMatch(urlPath.Split('/').Last(), @"^\d+$"))
{
urlPath = urlPath.Substring(0, urlPath.LastIndexOf("/"));
}
var routeDtoResult = await QueryProcessor.GetQueryHandler <GetRouteByUrlCommand, RouteDto>(new GetRouteByUrlCommand(urlPath, WorkContext.WorkingLanguageId));
if (routeDtoResult.Failure)
{
return(BadRequest(routeDtoResult.ErrorMessages));
}
var currentRouteDto = routeDtoResult.Object;
if (currentRouteDto == null)
{
// TODO: 404
return(NotFound());
}
if (currentRouteDto.AngularComponent != AngularComponents.ProductComponent)
{
var getCategoryCommand = new GetCategoryCommand(currentRouteDto.ItemId.Value, WorkContext.WorkingLanguageId);
return(await CreateCategory(getCategoryCommand));
}
else
{
var getProductCommand = new GetProductCommand(currentRouteDto.ItemId.Value, WorkContext.WorkingLanguageId);
return(await CreateProduct(getProductCommand));
}
}
internal static List <KeyValuePair <string, decimal> > GetCartShippingRates(Cart cart,
GetProductCommand getProductCommand, FedExClientPolicy fedExClientPolicy, CommerceContext commerceContext)
{
var input = new FedexReqestInput();
FedExClientPolicy = fedExClientPolicy;
if (cart != null && cart.Lines.Any <CartLineComponent>() && cart.HasComponent <PhysicalFulfillmentComponent>())
{
var component = cart.GetComponent <PhysicalFulfillmentComponent>();
var shippingParty = component?.ShippingParty;
input.AddressLine1 = shippingParty.Address1;
input.AddressLine2 = shippingParty.Address2;
input.City = shippingParty.City;
input.CountryCode = shippingParty.CountryCode;
input.StateCode = shippingParty.StateCode;
input.ZipPostalCode = shippingParty.ZipPostalCode;
input.PriceValue = cart.Totals.SubTotal.Amount;
decimal height = 0.0M;
decimal width = 0.0M;
decimal length = 0.0m;
decimal weight = 0.0m;
foreach (var cartLineComponent in cart.Lines)
{
// get specific weight value
var productArgument = ProductArgument.FromItemId(cartLineComponent.ItemId);
if (!productArgument.IsValid())
{
continue;
}
var product = getProductCommand.Process(commerceContext, productArgument.CatalogName, productArgument.ProductId).Result;
decimal val = 0m;
if (product != null)
{
if (product.HasProperty(FedExClientPolicy.WeightFieldName) && product[FedExClientPolicy.WeightFieldName].ToString().Trim() != "")
{
val = GetFirstDecimalFromString(product[FedExClientPolicy.WeightFieldName].ToString());
}
else
{
val = GetFirstDecimalFromString(FedExClientPolicy.Weight);
}
if (val > 0)
{
weight += val;
}
val = product.HasProperty(FedExClientPolicy.HeightFieldName) && product[FedExClientPolicy.HeightFieldName].ToString().Trim() != ""
? GetFirstDecimalFromString(product[FedExClientPolicy.HeightFieldName].ToString())
: GetFirstDecimalFromString(FedExClientPolicy.Height);
if (val > 0)
{
height += val;
}
val = product.HasProperty(FedExClientPolicy.WidthFieldName) && product[FedExClientPolicy.WidthFieldName].ToString().Trim() != ""
? GetFirstDecimalFromString(product[FedExClientPolicy.WidthFieldName].ToString())
: GetFirstDecimalFromString(FedExClientPolicy.Width);
if (val > 0 && val > width)
{
width = val;
}
val = product.HasProperty(FedExClientPolicy.LengthFieldName) && product[FedExClientPolicy.LengthFieldName].ToString().Trim() != ""
? GetFirstDecimalFromString(product[FedExClientPolicy.LengthFieldName].ToString())
: GetFirstDecimalFromString(FedExClientPolicy.Length);
if (val > 0 && val > length)
{
length = val;
}
}
}
input.Height = Math.Ceiling(height).ToString(CultureInfo.CurrentCulture);
input.Width = Math.Ceiling(width).ToString(CultureInfo.CurrentCulture);
input.Length = Math.Ceiling(length).ToString(CultureInfo.CurrentCulture);
input.Weight = Math.Ceiling(weight);
}
var rates = new List <KeyValuePair <string, decimal> >();
if (input.CountryCode.ToLower() == "us")
{
rates = FedxUs.GetShippingRates(input, FedExClientPolicy);
}
else
{
rates = FedExInternational.GetShippingRates(input, FedExClientPolicy);
}
return(rates);
}
/// <summary>
///
/// </summary>
/// <param name="getProductCommand"></param>
public UpdateCartLinesFulfillmentChargeBlock(GetProductCommand getProductCommand)
{
_getProductCommand = getProductCommand;
}
