public async Task <ActionResult> CreateProduct(ProductApiModel item)
{
if (item == null)
{
return(BadRequest(item));
}
if (string.IsNullOrEmpty(item.Name))
{
ModelState.AddModelError("Name", "Name should not be empty");
}
if (!ModelState.IsValid)
{
return(BadRequest(item));
}
var result = await _productService.CreateProductAsync(_automaper.Map <ProductDbModel>(item));
if (!result)
{
return(BadRequest());
}
return(CreatedAtRoute("Product", new { id = item.ProductId }, item));
}
public ProductApiModel ProductParser(string source)
{
ProductApiModel res = null;
var columns = source.Split(',');
try
{
res = new ProductApiModel()
{
Key = columns[0],
CategoryId = columns[1],
Category = new CategoryApiModel()
{
ColorCode = columns[2],
Description = columns[3],
Id = columns[1]
},
Color = columns[9],
Price = Convert.ToDecimal(columns[4]),
DiscountPrice = Convert.ToInt16(columns[5]),
DeliveredIn = columns[6],
Q1 = columns[7],
Size = Convert.ToInt16(columns[8])
};
}
catch
{
_errors.Append(source);
}
return(res);
}
public IHttpActionResult Add([FromBody] ProductApiModel productApiModel)
{
var productModel = _mapper.Map <ProductModel>(productApiModel);
_productService.Add(productModel);
return(Ok());
}
/// <summary>
///Proceso de creación de un producto, asíncrono.
/// </summary>
/// <param name="model">Objeto de tipo producto.</param>
/// <returns>Retorna el nevo objeto creado con su id</returns>
public async Task <ProductApiModel> CreateProductAsync([FromBody] ProductCreated model)
{
ProductApiModel pro = null;
response = await client.PostAsJsonAsync($"{_HostProduct}v1/api/product", model);
var jsonSerialize = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
string mensaje = JsonConvert.SerializeObject(jsonSerialize);
throw new HttpException(new List <string> {
mensaje
}, response.StatusCode);
}
// return URI of the created resource.
pro = JsonConvert
.DeserializeObject <ProductApiModel>(jsonSerialize.ToString()
, new JsonSerializerSettings()
{
MissingMemberHandling =
MissingMemberHandling.Ignore
});
pro.CheckIsNotNull();
return(pro);
}
public ActionResult _MoneyChange(int id)
{
aJaxDto ajd = new aJaxDto();
try
{
if (User.Identity.GetUserId() == null)
{
//ajd.ErrorMsg = "下注前須先登入\n請先至會員登入中心進行登入註冊，謝謝";
ajd.isTrue = false;
throw new Exception("error");
}
ProductApiModel pm = new ProductApiModel();
Product product = new MallRepository().Get(id);
// List<Product> productAll = new MallRepository().getAll();
cfgUnit unit = new UnitsRepository().getValid(product.unitSn);
pm.unit = unit;
pm.product = product;
//pm.producList = productAll.Where(x => x.id < 5).ToList();
var gold = new AssetsRepository().getAssetsListByUserID(User.Identity.GetUserId()).Where(x => x.unitSn == product.unitSn).FirstOrDefault();
ViewBag.gold = (gold != null) ? gold.Asset : 0;
ViewBag.change = (product.Price > ViewBag.gold) ? 0 : 1;
return(View(pm));
}
catch
{
//ajd.isTrue = false;
return(Json(ajd));
}
}
public async Task <IHttpActionResult> Update(Guid id, ProductApiModel product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id == Guid.Empty)
{
return(BadRequest("The id cannot be empty!"));
}
product.Id = id;
try
{
var result = await _productServices.UpdateAsync(AutoMapper.Mapper.Map <ProductDto>(product));
return(Ok(AutoMapper.Mapper.Map <ProductApiModel>(result)));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
catch (DbUpdateConcurrencyException)
{
return(Conflict());
}
catch (Exception)
{
throw;
}
}
public ActionResult _FishPay(int id)
{
aJaxDto ajd = new aJaxDto();
try
{
if (User.Identity.GetUserId() == null)
{
//ajd.ErrorMsg = "下注前須先登入\n請先至會員登入中心進行登入註冊，謝謝";
ajd.isTrue = false;
throw new Exception("error");
}
Product product = new MallRepository().Get(id);
List <Product> productAll = new MallRepository().getAll();
cfgUnit unit = new UnitsRepository().getValid(product.unitSn);
ProductApiModel pm = new ProductApiModel();
pm.unit = unit;
pm.product = product;
pm.producList = productAll.Where(x => x.unitSn == 3 && x.type == 3).ToList();
return(View(pm));
}
catch
{
return(Json(ajd));
}
}
/// <summary>
/// 查找产品 - 根据编号
/// </summary>
/// <param name="no"></param>
/// <returns></returns>
public ProductApiModel GetProduct(int no)
{
ProductApiModel model = new ProductApiModel();
try
{
LoanMarketProduct marketProduct = product.GetProduct(no);
log.Info("产品详情,二维码" + JsonConvert.SerializeObject(marketProduct));
model = new ProductApiModel()
{
ResponseStatus = "ok",
No = marketProduct.No,
Name = marketProduct.Name,
Icon = marketProduct.Icon,
Describe1 = marketProduct.Describe1,
Describe2 = marketProduct.Describe2,
Describe3 = marketProduct.Describe3,
Describe4 = marketProduct.Describe4,
Describe5 = marketProduct.Describe5,
Url = marketProduct.Url,
QrCodeUrl = QrCode.CreateQrCode(marketProduct.Url)
};
}
catch (Exception e)
{
log.Info("获取产品详情报异常，异常信息为：" + e.Message);
}
return(model);
}
//[AsmAuthorization(ModuleCode.Product, AccessType.Update)]
public async Task <ActionResult <ProductApiModel> > Put(int id, [FromBody] ProductApiModel productApiModel)
{
_logger.LogInformationExtension(
$"Put Product - Id: {productApiModel.ProductId}, Name: {productApiModel.Name}");
if (!ModelState.IsValid)
{
_logger.LogErrorExtension("Invalid product object sent from client.", null);
return(BadRequest(new Response <ProductApiModel>(null, false, "Invalid model object")));
}
var productEntity = await _productService.GetById(id);
if (productEntity == null)
{
_logger.LogErrorExtension($"Product with id: {id}, hasn't been found in db.", null);
return(NotFound(new Response <ProductApiModel>(null, false,
$"Product with id: {id}, hasn't been found in db.")));
}
var userId = Convert.ToInt32(User.Claims.FirstOrDefault(a => a.Type == "sub")?.Value);
productApiModel.LastUpdatedBy = userId;
productApiModel.LastUpdated = DateTime.Now;
_mapper.Map(productApiModel, productEntity);
await _productService.Update(productEntity);
return(Ok(new Response <ProductApiModel>(null)));
}
private ProductApiModel InvalidModel()
{
var validModel = new ProductApiModel()
{
ProductId = 1,
Name = "Adjustable Race",
ProductNumber = "AR-5381",
MakeFlag = false,
FinishedGoodsFlag = false,
Color = "",
SafetyStockLevel = 1000,
ReorderPoint = 750,
StandardCost = 0,
ListPrice = 0,
Size = "",
SizeUnitMeasureCode = "",
WeightUnitMeasureCode = "",
Weight = 0,
DaysToManufacture = 0,
ProductLine = "",
Class = "",
Style = "",
ProductSubcategoryId = 0,
ProductModelId = 0,
SellStartDate = new System.DateTime(year: 2008, month: 04, day: 30),
SellEndDate = null,
DiscontinuedDate = null,
Rowguid = "694215b7-08f7-4c0d-acb1-d734ba44c0c8",
ModifiedDate = System.DateTime.Parse("2014-02-08T10:01:36.827")
};
validModel.Name = string.Empty;
return(validModel);
}
public ActionResult _Invoice(int id)
{
Product product = new MallRepository().Get(id);
cfgUnit unit = new UnitsRepository().getValid(product.unitSn);
ProductApiModel pm = new ProductApiModel();
pm.unit = unit;
pm.product = product;
string _Vi = "ugZbqRhI6x5LGI94";
string _key = "CON3KthrvPulsAWQQiQ3jsswLIzxxgQK";
string MerchantOrderNo = DateTime.Now.Ticks.ToString() + "0" + pm.product.id.ToString();
var user = UserManager.FindById(User.Identity.GetUserId());
var tradeInfo = new TradeInfo()
{
MerchantID = "MS15822085",
RespondType = "JSON",
TimeStamp = DateTime.Now.ToUnixTimeStamp(),
Version = "1.5",
Amt = (int)pm.product.Price,
ItemDesc = pm.product.ProductName,
//InstFlag="3,6",
//CreditRed = 0,
Email = user.Email,
EmailModify = 1,
LoginType = 0,
MerchantOrderNo = MerchantOrderNo,
TradeLimit = 180
};
var postData = tradeInfo.ToDictionary();
var cryptoHelper = new CryptoHelper(_key, _Vi);
var aesString = cryptoHelper.GetAesString(postData);
ViewData["TradeInfo"] = aesString;
ViewData["TradeSha"] = cryptoHelper.GetSha256String(aesString);
ViewData["Email"] = tradeInfo.Email;
ViewBag.TimeStamp = tradeInfo.TimeStamp;
ViewBag.MerchantOrderNo = tradeInfo.MerchantOrderNo;
User_CashReturn re = new User_CashReturn
{
userId = User.Identity.GetUserId(),
MerchantID = MerchantOrderNo,
productId = pm.product.id,
inpdate = DateTime.Now,
};
new MallRepository().CreateReturnRecord(re);
//ViewBag.sha256 = getHashSha256("HashKey=CON3KthrvPulsAWQQiQ3jsswLIzxxgQK&Amt="+pm.product.Price+"&MerchantID=MS15822085&MerchantOrderNo="+ time + "&TimeStamp="+ time + "&Version=1.5&HashIV=ugZbqRhI6x5LGI94");
return(View(pm));
}
public async void Put([FromBody] ProductApiModel productApiModel)
{
_logger.LogInformation($"Api Call: Put Product : {productApiModel.ProductId}");
var userId = Convert.ToInt32(User.Claims.FirstOrDefault(a => a.Type == "sub")?.Value);
productApiModel.CreatedBy = userId;
productApiModel.LastUpdatedBy = userId;
await _productService.Update(_mapper.Map <ProductModel>(productApiModel));
}
public IHttpActionResult Post(ProductApiModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// should do some mapping and save a product in a data store somewhere, but we don't care about that for our little demo
return(Ok(7));
}
public async Task GetProductById_WhenProductExists_ShouldReturnProduct()
{
var productMock = new ProductApiModel();
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(productMock);
var testResult = await this._productsController.GetProductById(Guid.NewGuid());
Assert.IsInstanceOfType(testResult, typeof(OkNegotiatedContentResult <ProductApiModel>));
}
public async Task GetProductById_WhenProductNotExists_ShouldReturnNotFound()
{
ProductApiModel productMock = null;
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(productMock);
var testResult = await this._productsController.GetProductById(Guid.NewGuid());
Assert.IsInstanceOfType(testResult, typeof(NotFoundResult));
}
public async Task UpdateProduct_WhenProductNotExists_ShouldReturnNotFound()
{
var productMock = new ProductApiModel();
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(null as ProductApiModel);
var testResult = await this._productsController.UpdateProduct(Guid.NewGuid(), productMock);
Assert.IsInstanceOfType(testResult, typeof(NotFoundResult));
}
public async Task CreateProduct_WhenProductExists_ShouldReturnConflict()
{
var productMock = new ProductApiModel();
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(productMock);
var testResult = await this._productsController.CreateProduct(productMock);
Assert.IsInstanceOfType(testResult, typeof(ConflictResult));
}
public async Task <IHttpActionResult> Create(ProductApiModel product)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _productServices.CreateAsync(AutoMapper.Mapper.Map <ProductDto>(product));
return(CreatedAtRoute("DefaultApi", new { id = result.Id }, AutoMapper.Mapper.Map <ProductApiModel>(result)));
}
public IHttpActionResult Post(ProductApiModel model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// should do some mapping and save a product in a data store somewhere, but we don't care about that for our little demo
return Ok(7);
}
public async Task <ProductApiModel> AddProduct(ProductApiModel newProduct)
{
Product product = newProduct.Convert();
product = await _productRepository.AddAsync(product);
newProduct.Id = product.Id;
return(newProduct);
}
public async Task <ProductApiModel> AddProductAsync(ProductApiModel newProductApiModel,
CancellationToken ct = default)
{
var product = _mapper.Map <Product>(newProductApiModel);
product.Category = null;
product = await _productRepository.AddAsync(product, ct);
return(newProductApiModel);
}
public async Task CreateProduct_WhenProductNotExists_ShouldReturnCreated()
{
var productMock = new ProductApiModel();
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(null as ProductApiModel);
this._mockProductAppService.Setup(p => p.CreateAsync(It.IsAny <ProductApiModel>())).ReturnsAsync(productMock);
var testResult = await this._productsController.CreateProduct(productMock);
Assert.IsInstanceOfType(testResult, typeof(CreatedAtRouteNegotiatedContentResult <ProductApiModel>));
}
public async Task RemoveProduct_WhenProductExists_ShouldReturnOk()
{
var productMock = new ProductApiModel();
this._mockProductAppService.Setup(p => p.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(productMock);
this._mockProductAppService.Setup(p => p.RemoveAsync(It.IsAny <ProductApiModel>())).Returns(Task.CompletedTask);
var testResult = await this._productsController.RemoveProductById(Guid.NewGuid());
Assert.IsInstanceOfType(testResult, typeof(OkResult));
}
public async Task <ProductApiModel> CreateAsync(ProductApiModel productApiModel)
{
// Transaction is being used here just as an example (let's consider that more than one operation could happen below)
this.BeginTransaction();
var newProduct = await this._productService.CreateAsync(productApiModel.Adapt <Product>());
this.Commit();
return(newProduct.Adapt <ProductApiModel>());
}
public async Task<CreateProductResponse> CreateProduct(ProductViewModel product)
{
var apiModel = new ProductApiModel
{
CreatedOn = DateTime.Now,
Name = product.Name,
Description = product.Description
};
var createProductResponse = await PostEncodedContentWithSimpleResponse<CreateProductResponse, ProductApiModel>(ProductsUri, apiModel);
return createProductResponse;
}
private static ProductApiModel CreateProduct(int productId)
{
var product = new ProductApiModel
{
ProductId = productId,
Name = "Product " + productId,
Description = "Description " + productId,
CreatedOn = DateTime.Now
};
return product;
}
public async Task <CreateProductResponse> CreateProduct(ProductViewModel product)
{
var apiModel = new ProductApiModel
{
CreatedOn = DateTime.Now,
Name = product.Name,
Description = product.Description
};
var createProductResponse = await PostEncodedContentWithSimpleResponse <CreateProductResponse, ProductApiModel>(ProductsUri, apiModel);
return(createProductResponse);
}
/*public ActionResult Pay()
* {
* return View();
* }*/
public ActionResult Pay(int id)
{
Product product = new MallRepository().Get(id);
cfgUnit unit = new UnitsRepository().getValid(product.unitSn);
ProductApiModel pm = new ProductApiModel();
pm.unit = unit;
pm.product = product;
return(View(pm));
}
private static ProductApiModel CreateProduct(int productId)
{
var product = new ProductApiModel
{
ProductId = productId,
Name = "Product " + productId,
Description = "Description " + productId,
CreatedOn = DateTime.Now
};
return(product);
}
public async Task <IActionResult> Put(ProductApiModel product, Guid id)
{
bool insertResult;
var removeResult = await _apiRepository.DeleteProduct(id);
_apiRepository.InsertProduct(product, out insertResult);
if (removeResult && insertResult)
{
return(Ok(removeResult && insertResult));
}
return(BadRequest(false));
}
public IActionResult Category(string name)
{
try
{
Category category = _context.Categories.Where(c => c.Name == name).FirstOrDefault();
if (category == null)
{
return(NotFound());
}
var products = _context.Products.Where(p => p.CategoryId == category.Id).ToList();
var apiProducts = new List <ProductApiModel>();
foreach (var product in products)
{
var apiProduct = new ProductApiModel();
apiProduct.Code = product.Code;
apiProduct.Name = product.Name;
apiProduct.Description = product.Description;
apiProduct.Price = product.Price;
apiProduct.ImgUrl = product.ImgUrl;
apiProduct.Factory = _context.Factories.Where(f => f.Id == product.FactoryId).FirstOrDefault().Name;
apiProduct.Category = _context.Categories.Where(c => c.Id == product.CategoryId).FirstOrDefault().Name;
var uniqueSpecs = _context.ProductUniqueSpecs.Where(pus => pus.ProductId == product.Id).ToList();
var specs = _context.ProductSpecs.Where(ps => ps.ProductId == product.Id).ToList();
var apiSpecs = new List <SpecificationsApiModel>();
foreach (var spec in uniqueSpecs)
{
var apiSpec = new SpecificationsApiModel();
apiSpec.Name = spec.Name;
apiSpec.Value = spec.Value;
apiSpecs.Add(apiSpec);
}
foreach (var spec in specs)
{
var apiSpec = new SpecificationsApiModel();
apiSpec.Name = _context.CategorySpecs.Where(cs => cs.Id == spec.CategorySpecId).FirstOrDefault().Name;
apiSpec.Value = spec.Value;
apiSpecs.Add(apiSpec);
}
apiProduct.Specifications = apiSpecs;
apiProducts.Add(apiProduct);
}
return(Ok(apiProducts));
}
catch
{
return(BadRequest());
}
}
public async Task <IActionResult> Post(ProductApiModel productApiModel)
{
bool result;
var product = _apiRepository.InsertProduct(productApiModel, out result);
if (result)
{
return(Ok(new { Message = true, Product = product }));
}
else
{
return(BadRequest(new { Message = false, Product = product }));
}
}
public async Task <IActionResult> PostAsync([FromBody] ProductApiModel productApi)
{
_logger.LogInformation($"Iniciando -> PostAsync v1.0");
ProductModel product = _mapper.Map <ProductModel>(productApi);
product = await _productService.AddAsync(product);
productApi = _mapper.Map <ProductApiModel>(product);
_logger.LogInformation($"Finalizando -> PostAsync v1.0");
return(new CreatedResult(product.Id, productApi));
}
