public async Task <GetProductResponse> GetProductAsync(int id)
{
Product product = await _productDBContext.Products.Where(p => p.ID == id)
.FirstOrDefaultAsync();
GetProductResponse productResponse = null;
if (product != null)
{
productResponse = new GetProductResponse();
productResponse.ID = product.ID;
productResponse.Name = product.Name;
productResponse.Category = product.Category;
productResponse.Price = product.Price;
List <Comment> comments = await _productCommentService.GetComments(id);
productResponse.Comments = comments.Select(c => new GetProductCommentResponse()
{
Content = c.Content
}).ToList();
if (comments.Count > 0)
{
List <Comment> commentsWithSentimentAnalysis = await _productCommentService.CalculateCommentsSentimentScoreAsync(comments);
productResponse.CustomerRating = await CalculateProductCustomerRatingScore(commentsWithSentimentAnalysis);
}
}
return(productResponse);
}
public Task <GetProductResponse> getProductById(int id)
{
GetProductResponse response = new GetProductResponse();
try
{
ProductModel p = _service.Get(id);
p.Unit = _unitService.Get(p.UnitId); //lay don vi tinh thong thuong
p.OtherUnitOfProduct = _unitService.GetALlOtherUnitOfProduct(p.Id); //lay don vi tinh trong bao gia
p.Preservation = _preservationService.Get(p.PreservationId);
DataProductResponse d = new DataProductResponse();
d.ID = p.Id;
d.UpdatedAt = p.UpdatedAt;
d.CreatedAt = p.CreatedAt;
d.ProductInfo = p;
response.Data = d;
response.Message = "Success";
response.Success = true;
}
catch (Exception e)
{
response.Message = e.ToString();
response.Success = true;
}
return(Task.FromResult(response));
}
public void QueryUserEditProducts(OrderManager manager, List <Order> orders, int index)
{
bool divider = false;
orders[index].DynamicDisplayFormat();
Instructions.EditingInstructions();
Prompt.PressKeyToContinue();
while (!divider)
{
string product = Query.GetProductFromUser();
GetProductResponse productResponse = new GetProductResponse();
productResponse = manager.AssignProductInfo(product, FunctionType.EditOrder);
if (productResponse.Success)
{
if (productResponse.Edited)
{
orders[index].CalculateOrderValues(orders[index].CustomerName, orders[index].Area, productResponse.Product, orders[index].Taxes);
divider = true;
}
else
{
divider = true;
}
}
else
{
Alert.AlertUserInvalidInput(productResponse);
}
}
}
public async Task <Result <GetProductResponse> > GetProductAsync(GetProductByCodeRequest request)
{
//
// TODO: Perform application validation here.
//
var cancellationToken = new CancellationTokenSource().Token;
var operation = await _dataService.GetProductAsync(request, cancellationToken);
if (!operation.Status)
{
return(Result <GetProductResponse> .Failure(operation.Validation));
}
var product = operation.Data;
if (product == null)
{
return(Result <GetProductResponse> .Success(null));
}
var productResponse = new GetProductResponse
{
ProductCode = product.ProductCode,
ProductName = product.ProductName
};
return(Result <GetProductResponse> .Success(productResponse));
}
public async Task TestGetProduct_ElastiCache_SingleSkuFromOffer()
{
// ARRANGE
string sku = "HBRQZSXXSY2DXJ77";
PriceListClient client = new PriceListClient();
GetProductRequest request = new GetProductRequest("AmazonElastiCache")
{
Format = Format.JSON
};
GetProductResponse response = await client.GetProductAsync(request);
ProductOffer ecOffer = response.ProductOffer;
// ACT
IEnumerable <IGrouping <string, PricingTerm> > groupedTerms = ecOffer.Terms
.SelectMany(x => x.Value) // Get all of the product item dictionaries from on demand and reserved
//.Where(x => ApplicableProductSkus.Contains(x.Key)) // Only get the pricing terms for products we care about
.SelectMany(x => x.Value) // Get all of the pricing term key value pairs
.Select(x => x.Value) // Get just the pricing terms
.GroupBy(x => x.Sku); // Put all of the same skus together
IGrouping <string, PricingTerm> skuTerms = groupedTerms.First(x => x.Key.Equals(sku));
// ASSERT
Assert.True(skuTerms.Where(x => x.TermAttributes.PurchaseOption == PurchaseOption.ON_DEMAND).Count() == 1);
}
public GetProductResponse GetProductInfo(string type)
{
var listResponse = _productRepository.LoadProducts(ConfigurationManager.AppSettings["ProductFilePath"].ToString());
GetProductResponse response = new GetProductResponse();
if (listResponse.Success)
{
foreach (Product product in listResponse.ProductList)
{
if (product.FloorType == type)
{
response.ProductInfo = product;
response.Success = true;
}
}
}
else
{
response.Success = false;
response.Message = listResponse.Message;
}
return(response);
}
/// <summary>
/// 下载产品
/// </summary>
public static void LoadProduct()
{
GetProductParam getProductParam = new GetProductParam();
getProductParam.productId = 547363119296;// 576620941437 565461451556 561577651929 554833936110
getProductParam.GetRequestUrl();
string url = getProductParam.URL;
string postData = string.Join("&", getProductParam.m_DictParameters.Select(zw => zw.Key + "=" + zw.Value));
HttpClientRequest httpClient = new HttpClientRequest();
ResponseResult responseResult = httpClient.RequesResult(url, postData);
if (responseResult.Success)
{
//进行序列化
if (!string.IsNullOrEmpty(responseResult.Result))
{
try
{
GetProductResponse productResponse = JsonConvert.DeserializeObject <GetProductResponse>(responseResult.Result);
string productId = productResponse.productInfo.productID.ToString();
string staus = productResponse.productInfo.status;
string subject = productResponse.productInfo.subject;
string categoryName = productResponse.productInfo.categoryName;
List <SkuInfos> skuInfosList = new List <SkuInfos>();
List <SkuInfos> list = productResponse.productInfo.skuInfos;
}
catch (Exception ex)
{
string meg = ex.Message;
}
}
}
}
public ActionResult VariantExists(VariantPickerVariantExistsViewModel viewModel)
{
var getProductResponse = new GetProductResponse();
if (_getProductPipeline.Execute(new GetProductPipelineArgs(new GetProductRequest(new ProductIdentifier(viewModel.ProductSku, null)), getProductResponse)) == PipelineExecutionResult.Error)
{
return(Json(new { ProductVariantSku = "" }));
}
var product = getProductResponse.Product;
if (!product.ProductDefinition.IsProductFamily())
{
return(Json(new { ProductVariantSku = "" }));
}
if (!viewModel.VariantNameValueDictionary.Any())
{
return(Json(new { ProductVariantSku = "" }));
}
var variant = product.Variants.FirstOrDefault(v => v.ProductProperties
.Where(pp => pp.ProductDefinitionField.DisplayOnSite)
.Where(pp => pp.ProductDefinitionField.IsVariantProperty)
.Where(pp => !pp.ProductDefinitionField.Deleted)
.All(p => viewModel.VariantNameValueDictionary
.Any(kv => kv.Key.Equals(p.ProductDefinitionField.Name, StringComparison.InvariantCultureIgnoreCase) && kv.Value.Equals(p.Value, StringComparison.InvariantCultureIgnoreCase)))
);
var variantSku = variant != null ? variant.VariantSku : "";
return(Json(new { ProductVariantSku = variantSku }));
}
public static GetProductResponse GetProductToCellarArea(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
response.Error = new Handler.ErrorObject();
response.ProductList = new List <Products>();
try
{
var bussines = ProductData.Select.GetProductToCellarArea(request.CellarAreaID);
if (!bussines.Item1.Error)
{
foreach (var item in bussines.Item2)
{
response.ProductList.Add(new Products()
{
id = item.id,
name = item.name
});
}
}
else
{
response.Error.InfoError(bussines.Item1);
}
}
catch (Exception ex)
{
response.Error.InfoError(ex);
}
return(response);
}
public void CanOnlyAssignValidProduct(string product, bool expected)
{
OrderManager manager = OrderManagerFactory.Create();
GetProductResponse actual = manager.AssignProductInfo(product, FunctionType.AddOrder);
Assert.AreEqual(expected, actual.Success);
}
private static async Task GetProductAsync(string barcode)
{
String userAgent = UserAgentHelper.GetUserAgent("OpenFoodFacts4Net.ApiClient.TestConsoleApp", ".Net Platform", "0.1", null);
Client client = new Client(Constants.BaseUrl, userAgent);
GetProductResponse productResponse = await client.GetProductAsync(barcode);
Console.WriteLine(productResponse.Product.GenericName);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
response.Product = _mapper.Map <ProductTitle, ProductView>(FindAllProductTitles().FirstOrDefault(p => p.Id == request.ProductId));
return(response);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
response.Product = FindAllProductTitles().Where(p => p.Id == request.ProductId).FirstOrDefault();
return(response);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
var response = new GetProductResponse();
response.Product = _productTitleRepository.FindBy(request.ProductId).ToProductView();
return(response);
}
public void Should_Deserialize_GetProductResponse_3029330003533()
{
string json = DataSetHelper.ReadFileContent("GetProductResponse.3029330003533.json");
GetProductResponse response = JsonConvert.DeserializeObject <GetProductResponse>(json);
Assert.Equal(1, response.Status);
Assert.Equal("3029330003533", response.Code);
Assert.Equal("product found", response.StatusVerbose);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
Product product = _productRepository.FindBy(request.ProductId);
response.Product = product.ConvertToProductDetailView();
return(response);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
ProductTitle productTitle = _productTitleRepository.FindBy(request.ProductId);
response.Product = _mapper.Map <ProductTitle, ProductView>(productTitle);
return(response);
}
public async Task Should_GetProductAsync_3029330003533()
{
string barcode = "3029330003533";
String userAgent = UserAgentHelper.GetUserAgent("OpenFoodFacts4Net.ApiClient.Tests", ".Net Platform", "0.1", null);
Uri baseAddress = new Uri(Constants.BaseUrl);
HttpClient httpClient = HttpClientHelper.Create(baseAddress, userAgent);
GetProductResponse productResponse = await httpClient.GetProductAsync(barcode);
Assert.Equal("Pain de mie complet", productResponse.Product.GenericName);
}
public void GotProducts(GetProductResponse getProductResponse)
{
productList.Products = getProductResponse.Products.Select(x => new ProductsModel
{
Id = x.Id,
Desription = x.Description,
Name = x.Name,
Price = x.Price
}).ToList();
}
public GetProductResponse AssignProductInfo(string product, FunctionType type)
{
GetProductResponse response = new GetProductResponse();
IGetProduct getProduct = GetProductRuleFactory.Create(type);
response = getProduct.GetProduct(product);
return(response);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
ProductTitle productTitle = _productTitleRepository.GetById(request.ProductId);
response.Product = productTitle.ConvertToProductDetailView();
return(response);
}
private ProductView GetProductView(string id)
{
GetRequest request = new GetRequest();
request.ID = Guid.Parse(id);
GetProductResponse response = this._productService.GetProduct(request);
return(response.ProductView);
}
public GetProductResponse GetProductById(GetProductRequest request)
{
GetProductResponse response = new GetProductResponse();
ProductBusinessComponent bc = DependencyInjectionHelper.GetProductBusinessComponent();
Product product = bc.GetProductById(request.Id);
response.Product = ProductAdapter.ProductToDto(product);
return(response);
}
private GetProductResponse ConvertToProductResponse(Product product)
{
GetProductResponse convertToResponseProduct = new GetProductResponse()
{
Id = product.Id,
Name = product.Name,
Price = product.Price
};
return(convertToResponseProduct);
}
public override async Task <GetProductResponse> GetProduct(GetProductRequest request, ServerCallContext context)
{
var product = await _productsRepository.GetByIdAsync(request.ProductId);
var response = new GetProductResponse
{
Product = product?.MapToMessage()
};
return(response);
}
public GetProductResponse GetProduct(GetProductRequest request)
{
var response = new GetProductResponse
{
Product =
_presentationRepository.FindFirstByExample <ProductDetailDto>(
new { Id = request.ProductId })
};
return(response);
}
public async Task <int> MultiplyNumber(int number)
{
MultiplyController.MultiplyControllerClient client = _factory.CreateClient <MultiplyController.MultiplyControllerClient>();
MultiplyNumberRequest request = new MultiplyNumberRequest {
Number = number
};
GetProductResponse response = await client.MultiplyNumberAsync(request);
return(response.Value);
}
public async Task <GetProductResponse> GetProductByIdAsync(int productId, string email)
{
Product product = await _dataContext.Products
.AsNoTracking()
.SingleOrDefaultAsync(p => p.ProductId == productId);
GetProductResponse response = _mapper.Map <GetProductResponse>(product);
response.IsFavourite = await _favouriteService.IsProductFavourite(email, productId);
return(response);
}
public GetProductResponse GetProduct(GetProductRequest getProductRequest)
{
var response = new GetProductResponse();
_loggingService.LogInfo(this, "Starting GetProduct method");
try
{
var cacheKey = "GetProductById";
var returnDefault = this._configurationRepository.GetConfigurationValue <bool>("ReturnDefaultProduct");
response.Product = this._cacheStorage.Get <Product>(cacheKey);
if (response.Product == null)
{
response.Product = this._productRepository.FindBy(getProductRequest.Id);
if (response.Product != null)
{
this._cacheStorage.Set(cacheKey, response.Product, DateTime.Now.AddMinutes(5), TimeSpan.Zero);
}
}
if (returnDefault && response.Product == null)
{
response.Product = BuildDefaultProduct();
}
else if (!returnDefault && response.Product == null)
{
response.Exception = "No such product.";
}
if (response.Product != null)
{
response.Success = true;
}
if (response.Success)
{
_loggingService.LogInfo(this, "GetProduct success!");
}
else
{
_loggingService.LogError(this, "GetProduct failure...", new Exception(response.Exception));
}
}
catch (Exception ex)
{
response.Exception = ex.Message;
_loggingService.LogError(this, "Exception in GetProduct!", ex);
}
return(response);
}
public void GetProductUseCaseEqualTest()
{
GetProductRequest getProductRequest = new GetProductRequest(new Department {
Id = 1
});
IRepositoryFactory repositoryFactory = new RepositoryFactory(new DBContext());
IActivityFactory activityFactory = new ActivityFactory(repositoryFactory, new ValidationRuleFactory());
IUseCaseFactory useCaseFactory = new UseCaseFactory(activityFactory);
GetProductResponse getProductResponse = useCaseFactory.Create <IUseCase <GetProductRequest, GetProductResponse> >().Execute(getProductRequest);
Assert.IsTrue(getProductResponse.Products.Count > 0);
}
