public List <SizeDTO> FindAll()
{
SizeDTO size;
ProductDTO product;
List <SizeDTO> results = new List <SizeDTO>();
string queryString = "SELECT * FROM dbo.Size";
try
{
//The connection is automatically closed at the end of the using block.
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(queryString, con))
{
con.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
size = new SizeDTO();
product = new ProductDTO();
size = GenerateDetail(reader, product, size);
//return product instance as data object
Debug.Print("SizeDAL: /FindByAll/ " + size.GetID().ToString());
results.Add(size);
}
}
}
}
catch (Exception e)
{
e.GetBaseException();
}
return(results);
}
public SizeDTO FindPriceBySize(int productID, int sizeProduct)
{
SizeDTO size;
ProductDTO product;
string queryString = "SELECT * FROM dbo.Size WHERE unitSize = @unitSize AND productID = @id";
try
{
//The connection is automatically closed at the end of the using block.
using (SqlConnection con = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(queryString, con))
{
cmd.Parameters.AddWithValue("@unitSize", SqlDbType.Decimal).Value = sizeProduct;
cmd.Parameters.AddWithValue("@id", SqlDbType.Int).Value = productID;
con.Open();
SqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
size = new SizeDTO();
product = new ProductDTO();
size = GenerateDetail(reader, product, size);
//return product instance as data object
Debug.Print("SizeDAL: /FindByProduct/ " + size.GetID().ToString());
return(size);
}
}
}
}
catch (Exception e)
{
e.GetBaseException();
}
return(null);
}
public async Task <bool> EditAsync(SizeDTO model)
{
var size = _mapper.Map <Size>(model);
_repository.Edit(size);
return(await _repository.SaveAsync() > 0 ? true : false);
}
public static SizeDTO MapToDTO(SizeDAO size)
{
var s = new SizeDTO();
s.Id = size.Id;
s.Name = size.Name;
s.Active = size.Active;
return(s);
}
public static SizeDTO ConvertToDTOSize(DataRow dr)
{
SizeDTO si = new SizeDTO();
si.Id = Convert.ToInt32(dr["id"]);
si.Sizenumber = dr["sizenumber"].ToString();
si.Masp_id = dr["masp_id"].ToString();
si.Soluongtonkho = Convert.ToInt32(dr["SoLuongTonKho"]);
return(si);
}
public static SizeDTO SizeToSizeDTO(Size item)
{
SizeDTO result = new SizeDTO();
result.Id = item.Id;
result.Heft = item.Heft;
result.Name = item.Name;
/*foreach(var menu in item.Menus)
* {
* result.Menus.Add(MenuToMenuDTO(menu));
* }*/
return(result);
}
public Decimal GetPrice(SizeDTO size)
{
if (size.Name.ToLower() == "personal")
{
return(4.00m);
}
else if (size.Name.ToLower() == "small")
{
return(6.00m);
}
else if (size.Name.ToLower() == "medium")
{
return(8.00m);
}
else if (size.Name.ToLower() == "large")
{
return(10.00m);
}
return(0m);
}
private static StyleItemDTO CreateStyleItem(IUnitOfWork db,
long styleId,
SizeDTO size)
{
var styleItem = new StyleItem()
{
StyleId = styleId,
SizeId = size.Id,
Size = size.Name,
CreateDate = DateHelper.GetAppNowTime()
};
db.StyleItems.Add(styleItem);
db.Commit();
return(new StyleItemDTO()
{
StyleItemId = styleItem.Id,
StyleId = styleItem.StyleId,
Size = styleItem.Size,
SizeId = styleItem.SizeId,
});
}
public async Task Update(SizeDTO obj)
{
var model = _mapper.Map <SizeDTO, Size>(obj);
await UOW.SizeRepository.Update(model);
}
public async Task Insert(SizeDTO obj)
{
var model = _mapper.Map <SizeDTO, Size>(obj);
await UOW.SizeRepository.Insert(model);
}
public StyleItemDTO FindOrCreateForItem(long styleId,
int itemTypeId,
ItemDTO item,
bool canCreate,
SizeMode sizeMode,
DateTime when)
{
var department = item.Department;
//Step 1. Compose possible style sizes list
var existStyleItems = GetStyleItemsByStyleIdWithBarcodes(styleId);
var possibleSizeList = unitOfWork.SizeMappings
.GetStyleSizesByItemSize(item.Size, itemTypeId)
.ToList(); //NOTE: at first items with max priority
var size = unitOfWork.Sizes.GetAllWithGroupByItemTypeAsDto(itemTypeId)
.FirstOrDefault(s => s.Name == item.Size);
if (size != null) //Keep style sizes sort order (size with same size name has max priority)
{
possibleSizeList.Insert(0, size);
}
//NOTE: For BLNKT sku
if (!possibleSizeList.Any())
{
if (!String.IsNullOrEmpty(item.SKU) &&
item.SKU.EndsWith("BLNKT", StringComparison.InvariantCultureIgnoreCase))
{
var emptySize = unitOfWork.Sizes.GetAllAsDto().FirstOrDefault(s => s.Name == "OneSize");
if (emptySize != null)
{
possibleSizeList.Add(emptySize);
}
}
}
//Step 2. Get/create suitable styleItem
//NOTE: get first suitable style item BY SIZE (TODO: add condition by color)
var suitableStyleItems = new List <StyleItem>();
//0. Get full size equivalent
suitableStyleItems = existStyleItems.Where(i => i.Size == item.Size).ToList();
//1. Get using possible mappings
if (suitableStyleItems.Count == 0 &&
size == null) //NOTE: use possible size list only when system haven't equal size (6 always should map to 6, 8 to 8 and e.t.c)
{
suitableStyleItems = existStyleItems
.Where(e => possibleSizeList.Any(sl => sl.Name == e.Size))
.ToList();
}
//If not suitable styleItem
if (canCreate && suitableStyleItems.Count == 0)
{
SizeDTO betterSize = null;
//0. Trying get equal size (max priority => min value)
betterSize = possibleSizeList.FirstOrDefault(i => i.Name == item.Size);
//NOTE: detect which size is better
//1. Find by department
if (betterSize == null)
{
if (!String.IsNullOrEmpty(department))
{
foreach (var possibleSize in possibleSizeList)
{
if (!String.IsNullOrEmpty(possibleSize.Departments))
{
var sizeDepartmentList = possibleSize.Departments.Split(";, \t\r\n".ToCharArray(),
StringSplitOptions.RemoveEmptyEntries);
if (betterSize == null && //If not found yet, first match has max priority
StringHelper.IsMatchWithAny(department, sizeDepartmentList))
{
betterSize = possibleSize;
}
}
}
}
}
if (betterSize == null) //If can't found by department, get by max priority (i.e. first item from list)
{
betterSize = possibleSizeList.FirstOrDefault();
}
if (sizeMode == SizeMode.DirectNaming)
{
betterSize = new SizeDTO()
{
Name = item.Size,
};
}
if (betterSize != null)
{
var newStyleItem = new StyleItem
{
StyleId = styleId,
Size = betterSize.Name,
//Color=TODO:
SizeId = betterSize.Id > 0 ? (int?)betterSize.Id : null,
Quantity = item.RealQuantity,
QuantitySetBy = null,
QuantitySetDate = when,
CreateDate = when,
StyleItemBarcodes = new Collection <StyleItemBarcode>()
};
Add(newStyleItem);
unitOfWork.Commit();
var styleItemHistory = new StyleItemQuantityHistory()
{
StyleItemId = newStyleItem.Id,
Quantity = item.RealQuantity,
Type = (int)QuantityChangeSourceType.Initial,
CreateDate = when,
};
unitOfWork.StyleItemQuantityHistories.Add(styleItemHistory);
unitOfWork.Commit();
suitableStyleItems.Add(newStyleItem);
}
}
var styleItemForItem = suitableStyleItems.FirstOrDefault();
if (styleItemForItem == null &&
existStyleItems.Count == 1 &&
((String.IsNullOrEmpty(item.Size) &&
String.IsNullOrEmpty(item.Color)) ||
(String.IsNullOrEmpty(existStyleItems[0].Size) &&
String.IsNullOrEmpty(existStyleItems[0].Color))))
{
styleItemForItem = existStyleItems[0];
}
//Step 3. Add barcode
if (!String.IsNullOrEmpty(item.Barcode))
{
var isExistBarcode = suitableStyleItems.Any(si =>
si.StyleItemBarcodes != null &&
si.StyleItemBarcodes.Any(b => b.Barcode == item.Barcode));
if (!isExistBarcode)
{
if (styleItemForItem != null)
{
unitOfWork.StyleItemBarcodes.Add(new StyleItemBarcode
{
StyleItemId = styleItemForItem.Id,
Barcode = item.Barcode,
CreateDate = when
});
unitOfWork.Commit();
}
}
}
if (styleItemForItem != null)
{
return(new StyleItemDTO()
{
StyleItemId = styleItemForItem.Id,
StyleId = styleItemForItem.StyleId,
});
}
return(null);
}
public async Task AddSizeAsync(SizeDTO size)
{
Size Size = new Size(Guid.NewGuid(), size.Name, size.Description, size.Details);
await _sizeRepository.AddAsync(Size);
}
public bool CreatePizza(SizeDTO size, CrustDTO crust, SauceDTO sauce, CheeseDTO cheese, List <CheeseDTO> cheeses, List <MeatDTO> meats, List <VegetableDTO> vegetables, int quantity)
{
PizzaDTO pizza = new PizzaDTO {
Size = size, Crust = crust, Sauce = sauce, Cheese = cheese, Quantity = quantity, Active = true
};
if (InsertPizza(pizza))
{
pizza = GetPizzas().Last();
if (cheeses != null)
{
foreach (var item in cheeses)
{
CheeseToppingDTO ct = new CheeseToppingDTO {
Cheese = item, Pizza = pizza
};
if (InsertCheeseTopping(ct))
{
continue;
}
else
{
return(false);
}
}
}
if (meats != null)
{
foreach (var item in meats)
{
MeatToppingDTO mt = new MeatToppingDTO {
Meat = item, Pizza = pizza
};
if (InsertMeatTopping(mt))
{
continue;
}
else
{
return(false);
}
}
}
if (vegetables != null)
{
foreach (var item in vegetables)
{
VegetableToppingDTO vt = new VegetableToppingDTO {
Vegetable = item, Pizza = pizza
};
if (InsertVegetableTopping(vt))
{
continue;
}
else
{
return(false);
}
}
}
}
return(true);
}
public bool InsertSize(SizeDTO item)
{
return(pssc.InsertSize(SizeMapper.MapToDAO(item)));
}
public bool DeleteSize(SizeDTO item)
{
return(pssc.DeleteSize(SizeMapper.MapToDAO(item)));
}
public bool ChangeSize(SizeDTO item)
{
return(pssc.ChangeSize(SizeMapper.MapToDAO(item)));
}
private static SizeDTO GenerateDetail(SqlDataReader reader, ProductDTO product, SizeDTO size)
{
product.SetId(Convert.ToInt32(reader["productID"]));
size.SetProduct(product);
size.SetID(Convert.ToInt32(reader["sizeID"]));
size.SetPrice(Convert.ToDecimal(reader["unitPrice"]));
size.SetSize(Convert.ToInt32(reader["unitSize"]));
return(size);
}
public RedirectToRouteResult AddToOrder(OrderDTO order, string returnUrl, int size, int crust, int sauce, int cheese, int[] cheeses, int[] meats, int[] veggies, string quantity)
{
if (size != 0 && crust != 0 && sauce != 0 && cheese != 0 && quantity != null)
{
SizeDTO Size = data.GetSize(size);
CrustDTO Crust = data.GetCrust(crust);
SauceDTO Sauce = data.GetSauce(sauce);
CheeseDTO Cheese = data.GetCheese(cheese);
List <CheeseDTO> Cheeses = new List <CheeseDTO>();;
List <MeatDTO> Meats = new List <MeatDTO>();
List <VegetableDTO> Veggies = new List <VegetableDTO>();
int Quantity = int.Parse(quantity);
if (cheeses != null)
{
for (int i = 0; i < cheeses.Length; i++)
{
Cheeses.Add(data.GetCheese(cheeses[i]));
}
}
else
{
Cheeses = null;
}
if (meats != null)
{
for (int i = 0; i < meats.Length; i++)
{
Meats.Add(data.GetMeat(meats[i]));
}
}
else
{
Meats = null;
}
if (veggies != null)
{
for (int i = 0; i < veggies.Length; i++)
{
Veggies.Add(data.GetVegetable(veggies[i]));
}
}
else
{
Veggies = null;
}
if (data.CreatePizza(Size, Crust, Sauce, Cheese, Cheeses, Meats, Veggies, Quantity))
{
PizzaDTO pizza = data.GetPizzas().Last();
OrderDetailsDTO orderDetail = new OrderDetailsDTO {
Pizza = pizza, Order = order
};
if (data.InsertOrderDetail(orderDetail))
{
return(RedirectToAction("Order", new { returnUrl }));
}
}
}
return(RedirectToAction("Order", new { returnUrl }));
}
