/// <summary>
/// Cập nhật thông tin của các thuốc tính trong 1 sản phẩm
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public bool Update(ProductAttributes data)
{
int rowsAffected = 0;
using (SqlConnection connection = new SqlConnection(this.connectionString))
{
connection.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = @"Update ProductAttributes
SET
ProductID = @ProductID,
AttributeName = @AttributeName,
AttributeValues = @AttributeValues,
DisplayOrder = @DisplayOrder
WHERE
AttributeID = @AttributeID;";
cmd.CommandType = CommandType.Text;
cmd.Connection = connection;
cmd.Parameters.AddWithValue("@ProductID", data.ProductID);
cmd.Parameters.AddWithValue("@AttributeName", data.AttributeName);
cmd.Parameters.AddWithValue("@AttributeValues", data.AttributeValues);
cmd.Parameters.AddWithValue("@DisplayOrder", data.DisplayOrder);
cmd.Parameters.AddWithValue("@AttributeID", data.AttributeID);
rowsAffected = Convert.ToInt32(cmd.ExecuteNonQuery());
connection.Close();
}
return(rowsAffected > 0);
}
public IActionResult OnPost(int?productId) // Make sure productId gets in here OK
{
if (!ModelState.IsValid)
{
return(Page());
}
if (Attribute.Id > 0)
{
Attribute = attributeData.Update(Attribute);
}
else
{
attributeData.Add(Attribute);
}
attributeData.Commit();
TempData["Message"] = "Attribute has been saved!";
if (productId.HasValue)
{
ProductAttributes = new ProductAttributes();
ProductAttributes.ProductId = productId.Value;
ProductAttributes.AttributeId = Attribute.Id;
productAttributesData.Add(ProductAttributes);
productAttributesData.Commit();
}
return(RedirectToPage("./AttributeDetails", new { attributeId = Attribute.Id }));
}
public async Task <string> AttributeUpdateSpecific(int id, [FromBody] string value)
{
string UpdateResult = "Success";
try
{
ProductAttributes ProductAttributeToUpdate = JsonConvert.DeserializeObject <ProductAttributes>(value);
ProductAttributeToUpdate.product_attribute_id = id;
Dictionary <String, String> ValuesToUpdate = new Dictionary <string, string>();
if (ProductAttributeToUpdate.sku != null)
{
ValuesToUpdate.Add("sku", ProductAttributeToUpdate.sku.ToString());
}
await _ProductRepo.AttributeUpdateSpecific(ValuesToUpdate, "product_attribute_id=" + id);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger("internal_error_log");
logger.LogInformation("Problem happened in updating new Product with message" + ex.Message);
UpdateResult = "Failed";
}
return(UpdateResult);
}
public async Task <int> Update(ProductAttributes productAttributes)
{
_dataContext.ProductAttributes.Update(productAttributes);
var Updated = await _dataContext.SaveChangesAsync();
return(Updated);
}
public async Task <IActionResult> Create([FromBody] CreateProductAttributeRequest attributeRequest)
{
var Attr = new ProductAttributes
{
ArabicName = attributeRequest.ArabicName,
EnglishName = attributeRequest.EnglishName,
ProductId = attributeRequest.ProductId
};
var status = await _productAttributeService.Create(Attr);
if (status == 1)
{
var response = new
{
status = Ok().StatusCode,
message = "Success"
};
return(Ok(response));
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
public ProductAttributes Update(ProductAttributes updatedProductAttributes)
{
var entity = db.ProductAttributes.Attach(updatedProductAttributes);
entity.State = EntityState.Modified;
return(updatedProductAttributes);
}
public override IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
base.Validate(validationContext);
if (PaymentExpireIn.HasValue && PaymentExpireIn.Value < TimeSpan.Zero)
{
yield return(new ValidationResult(
"PaymentExpireIn should be greater than or equal to 0.",
new[] { "PaymentExpireIn" }
));
}
if (ProductAttributes.Select(a => a.DisplayName.Trim()).Distinct().Count() != ProductAttributes.Count)
{
yield return(new ValidationResult(
"DisplayNames of ProductAttributes should be unique!",
new[] { "ProductAttributes" }
));
}
var optionNameList = ProductAttributes.SelectMany(a => a.ProductAttributeOptions)
.Select(o => o.DisplayName.Trim()).ToList();
if (optionNameList.Distinct().Count() != optionNameList.Count)
{
yield return(new ValidationResult(
"DisplayNames of ProductAttributeOptions should be unique!",
new[] { "ProductAttributeOptions" }
));
}
}
public CategoryEntity(Category Category, params object[] args) : base(Category)
{
foreach (object arg in args)
{
if (arg is Category Parent)
{
ParentEntity = new CategoryEntity(Parent);
}
if (arg is ICollection <CategoryName> CategoryNames)
{
CategoryNameEntities = CategoryNames.Select(model => new CategoryNameEntity(model, model.Language)).ToList();
}
if (arg is ICollection <Category> InverseParent)
{
InverseParentEntities = InverseParent.Select(model => new CategoryEntity(model)).ToList();
}
if (arg is ICollection <ProductAttribute> ProductAttributes)
{
ProductAttributeEntities = ProductAttributes.Select(model => new ProductAttributeEntity(model)).ToList();
}
if (arg is ICollection <Product> Products)
{
ProductEntities = Products.Select(model => new ProductEntity(model, model.Manufacturer)).ToList();
}
if (arg is ICollection <Tax> Taxes)
{
TaxEntities = Taxes.Select(model => new TaxEntity(model, model.Country)).ToList();
}
}
}
/// <summary>
/// Lấy thông tin thuộc tính theo mã sản phẩm
/// </summary>
/// <param name="ProductID"></param>
/// <returns></returns>
public ProductAttributes Get(int ProductID)
{
ProductAttributes data = null;
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = @"SELECT * FROM ProductAttributes WHERE ProductID = @ProductID";
cmd.CommandType = CommandType.Text;
cmd.Connection = connection;
cmd.Parameters.AddWithValue("@ProductID", ProductID);
using (SqlDataReader dbReader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
if (dbReader.Read())
{
data = new ProductAttributes()
{
AttributeID = Convert.ToInt32(dbReader["AttributeID"]),
ProductID = Convert.ToInt32(dbReader["ProductID"]),
AttributeName = Convert.ToString(dbReader["AttributeName"]),
AttributeValues = Convert.ToString(dbReader["AttributeValues"]),
DisplayOrder = Convert.ToInt32(dbReader["DisplayOrder"]),
};
}
}
connection.Close();
}
return(data);
}
public async Task <int> Create(ProductAttributes productAttributes)
{
await _dataContext.ProductAttributes.AddAsync(productAttributes);
var Created = await _dataContext.SaveChangesAsync();
return(Created);
}
public Product FetchProduct(int productId)
{
Product product = new Product();
try
{
using (IDbConnection connection = dbObj.CreateOpenConnection())
{
string query = "select p.ProductId, p.ProductCategoryId, pc.ProductCategoryName, p.Name, p.Description from Product p JOIN ProductCategory pc on p.ProductCategoryId = pc.ProductCategoryId where p.ProductId = " + productId;
using (IDbCommand command = dbObj.CreateCommand(query, connection))
{
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
product.ProductId = reader["ProductId"] == DBNull.Value ? 0 : (int)reader["ProductId"];
product.ProductCategoryId = reader["ProductCategoryId"] == DBNull.Value ? 0 : (int)reader["ProductCategoryId"];
product.ProductCategoryName = reader["ProductCategoryName"] == DBNull.Value ? "" : (string)reader["ProductCategoryName"];
product.Name = reader["Name"] == DBNull.Value ? "" : (string)reader["Name"];
product.Description = reader["Description"] == DBNull.Value ? "" : (string)reader["Description"];
}
reader.Dispose();
}
command.Dispose();
}
List <ProductAttributes> lstattr = new List <ProductAttributes>();
query = "select pa.AttributeId,pa.AttributeValue,pal.AttributeName, pc.ProductCategoryId, pc.ProductCategoryName from ProductAttributes pa JOIN ProductAttributeLookup pal on pa.AttributeId = pal.AttributeId JOIN ProductCategory pc on pc.ProductCategoryId = pal.ProductCategoryId where ProductId = " + productId;
using (IDbCommand command = dbObj.CreateCommand(query, connection))
{
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
var data = new ProductAttributes
{
ProductId = productId,
AttributeId = reader["AttributeId"] == DBNull.Value ? 0 : (int)reader["AttributeId"],
AttributeValue = reader["AttributeValue"] == DBNull.Value ? "" : (string)reader["AttributeValue"],
AttributeName = reader["AttributeName"] == DBNull.Value ? "" : (string)reader["AttributeName"],
ProductCategoryId = reader["ProductCategoryId"] == DBNull.Value ? 0 : (int)reader["ProductCategoryId"],
ProductCategoryName = reader["ProductCategoryName"] == DBNull.Value ? "" : (string)reader["ProductCategoryName"],
};
lstattr.Add(data);
}
reader.Dispose();
}
command.Dispose();
}
connection.Dispose();
product.lstProductAttributes = lstattr;
}
}
catch (Exception)
{
}
return(product);
}
public void WriteToParcel(Parcel dest, [GeneratedEnum] ParcelableWriteFlags flags)
{
dest.WriteInt(Id);
dest.WriteString(Avatar);
dest.WriteString(Name);
dest.WriteString(Barcode);
dest.WriteParcelableArray(ProductAttributes.ToArray(), ParcelableWriteFlags.None);
dest.WriteParcelableArray(ProductDetails.ToArray(), ParcelableWriteFlags.None);
}
public void IsBookFactoryCreateBookProduct()
{
ProductFactory pFactory = new BookFactory();
ProductAttributes pAttr = new ProductAttributes("book", 20, 2, true);
Product book = pFactory.CreateProduct(pAttr);
Assert.IsNotNull(book);
Assert.IsInstanceOfType(book, typeof(BookProduct));
}
public ActionResult Edit([Bind(Include = "Id,AttributeName,AttributeDescription")] ProductAttributes PA)
{
if (ModelState.IsValid)
{
_repository.Update(PA);
_repository.Save();
this.AddNotification("Updated successfully.", NotificationType.SUCCESS);
return(RedirectToAction("Index"));
}
return(View(PA));
}
public ActionResult InputProductAttribute(ProductAttributes model)
{
if (model.AttributeID == 0)
{
var addAttr = CatalogBLL.ProductAttribute_Add(model);
return(RedirectToAction("Input", "Product", new { id = model.ProductID }));
}
else
{
var editAttr = CatalogBLL.ProductAttributes_Update(model);
return(RedirectToAction("Input", "Product", new { id = model.ProductID }));
}
}
public async Task <string> createProductAttributesAsync(int product_id, int attribute_id, string sku, string value_id)
{
ProductAttributes _productAttribute = new ProductAttributes();
_productAttribute.product_id = product_id;
_productAttribute.attribute_id = attribute_id;
_productAttribute.sku = sku;
_productAttribute.value_id = value_id;
String returnID = await _BadgerApiHelper.GenericPostAsyncString <String>(JsonConvert.SerializeObject(_productAttribute), "/product/createProductAttribute");
return(returnID);
}
// GET: /Category/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProductAttributes PA = _repository.GetById(id);
if (PA == null)
{
return(HttpNotFound());
}
return(View(PA));
}
public Product SearchAndRetrieveItemFromShelf(String name, double price, bool imported, int quantity)
{
if (productItems.ContainsKey(name))
{
ProductAttributes pAttributes = new ProductAttributes(name, price, quantity, imported);
Product productItem = productItems[name].GetFactory().CreateProduct(pAttributes);
return(productItem);
}
else
{
Console.WriteLine("Product not available, pls enter another product \n");
return(null);
}
}
public async Task <string> PostAsyncAttribute([FromBody] string value)
{
string NewInsertionID = "0";
try
{
ProductAttributes newProductAttributes = JsonConvert.DeserializeObject <ProductAttributes>(value);
NewInsertionID = await _ProductRepo.CreateProductAttribute(newProductAttributes);
}
catch (Exception ex)
{
var logger = _loggerFactory.CreateLogger("internal_error_log");
logger.LogInformation("Problem happened in making new product with message" + ex.Message);
}
return(NewInsertionID);
}
public ProductAttributes SaveProductAttribute(string attributeName)
{
var chkAttribute = _currentDbContext.ProductAttributes.FirstOrDefault(a => a.AttributeName.Equals(attributeName, StringComparison.CurrentCultureIgnoreCase));
if (chkAttribute != null)
{
return(null);
}
var att = new ProductAttributes()
{
AttributeName = attributeName
};
_currentDbContext.Entry(att).State = EntityState.Added;
_currentDbContext.SaveChanges();
return(att);
}
public Task SetAttributes(ProductAttributes attributes)
{
if (!State.IsActivated)
{
State.Id = attributes.Id;
State.StockId = attributes.StockId;
State.Title = attributes.Title;
State.Description = attributes.Description;
State.IsActivated = true;
State.CurrentPrice = attributes.CurrentPrice;
var stock = this.GrainFactory.GetGrain <IStockGrain>(State.StockId);
stock.SetAttributes(State.Id, 10);
return(WriteStateAsync());
}
return(Task.FromResult(0));
}
public IActionResult OnPost(int attributeId)
{
var i = 0;
ProductAttributesData = productAttributesData;
foreach (var boolean in IsChecked)
{
if (boolean)
{
var pa = new ProductAttributes();
pa.AttributeId = attributeId;
pa.ProductId = productData.GetProductsByName("").ToList()[i].Id;
ProductAttributesData.Add(pa);
productAttributesData.Commit();
}
i++;
}
return(RedirectToPage("./List"));
}
/*
* Developer: Sajid Khan
* Date: 7-5-19
* Action: Create new product attributes into databaset
* Input: product attributes data
* output: string of product attributes
*/
public async Task <string> CreateProductAttribute(ProductAttributes NewProductAttributes)
{
string ProductAttributesExistsQuery = "SELECT * FROM product_attributes WHERE sku='" + NewProductAttributes.sku + "' and attribute_id='" + NewProductAttributes.attribute_id + "' and product_id='" + NewProductAttributes.product_id + "';";
using (IDbConnection conn = Connection)
{
var ProductAttributesExist = await conn.QueryAsync <ProductAttributes>(ProductAttributesExistsQuery);
if (ProductAttributesExist == null || ProductAttributesExist.Count() == 0)
{
var result = await conn.InsertAsync <ProductAttributes>(NewProductAttributes);
return(result.ToString());
}
else
{
return(ProductAttributesExist.First().product_attribute_id.ToString());
}
}
}
public ActionResult InputDetail(string id)
{
if (string.IsNullOrEmpty(id))
{
ViewBag.Title = "Add new attribute";
ProductAttributes newAttribute = new ProductAttributes();
newAttribute.AttributeID = 0;
return(View(newAttribute));
}
else
{
ViewBag.Title = "Edit attribute";
ProductAttributes editAttribute = CatalogBLL.ProductAttribute_GetAttr(Convert.ToInt32(id));
if (editAttribute == null)
{
return(RedirectToAction("Input"));
}
return(View(editAttribute));
}
}
public ActionResult InputDetail(ProductAttributes model)
{
try
{
//kiem tra tinh hop le
if (string.IsNullOrEmpty(model.AttributeName))
{
ModelState.AddModelError("AttributeName", "AttributeName is required");
}
if (string.IsNullOrEmpty(model.AttributeValues))
{
ModelState.AddModelError("AttributeValues", "AttributeValues is required");
}
if (model.DisplayOrder == 0)
{
ModelState.AddModelError("DisplayOrder", "DisplayOrder is required");
}
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.AttributeID == 0)
{
int attributeId = CatalogBLL.ProductAttribute_Add(model);
return(RedirectToAction("Index"));
}
else
{
bool updateResult = CatalogBLL.ProductAttribute_Update(model);
return(RedirectToAction("Input", "Product", new { id = model.ProductID }));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message + ":" + ex.StackTrace);
return(View(model));
}
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
if (ProductAttributes.Select(a => a.DisplayName.Trim()).Distinct().Count() != ProductAttributes.Count)
{
yield return(new ValidationResult(
"DisplayNames of ProductAttributes should be unique!",
new[] { "ProductAttributes" }
));
}
var optionNameList = ProductAttributes.SelectMany(a => a.ProductAttributeOptions)
.Select(o => o.DisplayName.Trim()).ToList();
if (optionNameList.Distinct().Count() != optionNameList.Count)
{
yield return(new ValidationResult(
"DisplayNames of ProductAttributeOptions should be unique!",
new[] { "ProductAttributeOptions" }
));
}
}
public ActionResult Create(ProductModelBrandViewModel productModel)
{
try
{
if (ModelState.IsValid)
{
Product newProduct = new Product()
{
BrandId = productModel.BrandId,
ModelId = productModel.ModelId,
Name = productModel.Name
};
product.Add(newProduct);
product.SaveAll();
for (int i = 0; i < productModel.ProductAttributes.Count; i++)
{
ProductAttributes newProductAttributes = new ProductAttributes()
{
ProductId = newProduct.Id,
AttributeName = productModel.ProductAttributes[i].Name,
Value = productModel.ProductValues[i]
};
productAttributes.Add(newProductAttributes);
}
productAttributes.SaveAll();
return(Ok("Product has been Add"));
}
return(BadRequest("Product Data is not valid"));
}
catch
{
return(BadRequest("Product Data is not valid"));
}
}
public async Task <IActionResult> Update([FromRoute] Int32 id, [FromBody] UpdateProductAttributeRequest attributeRequest)
{
var Attr = new ProductAttributes
{
Id = id,
ArabicName = attributeRequest.ArabicName,
EnglishName = attributeRequest.EnglishName,
ProductId = attributeRequest.ProductId
};
var status = await _productAttributeService.Update(Attr);
if (status == 1)
{
return(Ok());
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
/// <summary>
/// Bổ sung một thuộc tính cho sản phẩm
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public int Add(ProductAttributes data)
{
int attributeId = 0;
using (SqlConnection connection = new SqlConnection(this.connectionString))
{
connection.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = @"INSERT INTO ProductAttributes
(
ProductID,
AttributeName,
AttributeValues,
DisplayOrder
)
VALUES
(
@ProductID,
@AttributeName,
@AttributeValues,
@DisplayOrder
);
SELECT @@IDENTITY;";
cmd.CommandType = CommandType.Text;
cmd.Connection = connection;
cmd.Parameters.AddWithValue("@ProductID", data.ProductID);
cmd.Parameters.AddWithValue("@AttributeName", data.AttributeName);
cmd.Parameters.AddWithValue("@AttributeValues", data.AttributeValues);
cmd.Parameters.AddWithValue("@DisplayOrder", data.DisplayOrder);
attributeId = Convert.ToInt32(cmd.ExecuteScalar());
connection.Close();
}
return(attributeId);
}
public ActionResult Attribute(string id = "")
{
try
{
Product checkProduct = CatalogBLL.Product_Get(id);
List <ProductAttributes> data = new List <ProductAttributes>();
data = CatalogBLL.Product_GetAttribute(id);
if (data == null)
{
ProductAttributes newAttribute = new ProductAttributes();
return(View(newAttribute));
}
var model = new Models.AttributeResult()
{
Data = data,
};
return(View(model));
}
catch (Exception e)
{
return(RedirectToAction("Index"));
}
}
