/// <summary>
/// Method returns string value of OrderDetailItem object
/// </summary>
/// <param name="oOrderDetailItem"></param>
/// <returns>string value containing all OrderDetailItem values</returns>
public static string OrderDetailItemToString(this OrderDetailItem oOrderDetailItem)
{
if (oOrderDetailItem == null)
{
return("");
}
oOrderDetailItem.description = null;
var items = new Dictionary <string, string>()
{
{ "Description", oOrderDetailItem.description },
{ "ItemType", oOrderDetailItem.itemType.ToString() },
{ "Quantity", oOrderDetailItem.quantity.ToString() },
{ "QuantitySpecified", oOrderDetailItem.quantitySpecified.ToString() }
};
if (oOrderDetailItem.totalPrice != null)
{
items.Add("TotalPrice", oOrderDetailItem.totalPrice.ToString());
}
if (oOrderDetailItem.unitPrice != null)
{
items.Add("UnitPrice", oOrderDetailItem.unitPrice.ToString());
}
return(items.NotNullDataToString() + Environment.NewLine);
}
private void FillProductQuantities(OrderDetailItem detailItem)
{
var product = GetProduct(detailItem.ProductId);
detailItem.BagPieceQuantity = product.BagPieceQuantity;
detailItem.BoxBagQuantity = product.BoxBagQuantity;
}
public void Edit(OrderDetailItem orderDetailItem)
{
var orderDetail = _orderDetailRepository.Get(orderDetailItem.Id);
FillOrderDetail(orderDetail, orderDetailItem);
_orderDetailRepository.Save();
}
public List <OrderDetailItem> GetOrderDetailItems(int takelist = 200)
{
using (SipEntegrasyonContext db = new SipEntegrasyonContext())
{
var orders = db.Orders.Where(x => x.IsDelete == false).OrderByDescending(x => x.Id).Take(takelist);
List <OrderDetailItem> orderDetailItems = new List <OrderDetailItem>();
foreach (var dbOrder in orders)
{
OrderDetailItem item = new OrderDetailItem();
var customer = db.Customers.FirstOrDefault(x => x.Id == dbOrder.CustomerId);
var staut = db.Status.FirstOrDefault(x => x.Id == dbOrder.StatusId);
item.Id = dbOrder.Id;
item.UserId = dbOrder.UserId;
item.DeliveryId = dbOrder.DeliveryId;
item.CustomerId = dbOrder.CustomerId;
item.ExchangeId = dbOrder.ExchangeId;
item.StatusId = dbOrder.StatusId;
item.CreateDate = dbOrder.CreateDate;
item.CustomerAuthorized = dbOrder.CustomerAuthorized;
if (customer != null)
{
item.CustomerName = customer.Name;
item.CustomerPhone = customer.Phone;
item.CityName = db.Cities.FirstOrDefault(x => x.Id == customer.CityId)?.Name;
}
item.DeliveryDate = dbOrder.DeliveryDate;
item.DeliveryName = db.Deliveries.FirstOrDefault(x => x.Id == dbOrder.DeliveryId)?.Name;
item.ExchangeName = db.Excs.FirstOrDefault(x => x.Id == dbOrder.ExchangeId)?.Name;
item.ExchangeRate = dbOrder.ExchangeRate;
item.IsDelete = dbOrder.IsDelete;
item.OrderDate = dbOrder.OrderDate;
item.OrderNo = dbOrder.OrderNo;
item.OrderSeries = dbOrder.OrderSeries;
item.OrderNoSeries = Convert.ToString(dbOrder.OrderSeries) + ' ' + dbOrder.OrderNo;
item.PayMethod = dbOrder.PayMethod;
if (staut != null)
{
item.StatusName = staut.Name;
}
item.UpdateDate = dbOrder.UpdateDate;
item.UserName = db.Users.FirstOrDefault(x => x.Id == dbOrder.UserId)?.FirstName + " " +
db.Users.FirstOrDefault(x => x.Id == dbOrder.UserId)?.LastName;
item.OrderTotal =
ItemOrderTotal(db, dbOrder);
orderDetailItems.Add(item);
}
return(orderDetailItems.Where(x => x.IsDelete == false).OrderByDescending(x => x.Id).Take(takelist).ToList());
}
}
public int Add(OrderDetailItem orderDetailItem)
{
var orderDetail = new OrderDetail {
OrderId = orderDetailItem.OrderId
};
FillOrderDetail(orderDetail, orderDetailItem);
_orderDetailRepository.Add(orderDetail);
_orderDetailRepository.Save();
return(orderDetail.Id);
}
public IEnumerable <OrderDetailItem> GetItems(int orderId)
{
var orderDetails = _orderDetailRepository
.GetAllByOrder(orderId)
.ToArray();
List <OrderDetailItem> orderDetailitems = new List <OrderDetailItem>();
foreach (var orderDetail in orderDetails)
{
var orderDetailItem = new OrderDetailItem()
{
Id = orderDetail.Id,
OrderId = orderDetail.OrderId,
PieceQuantity = orderDetail.PieceQuantity,
ProductId = orderDetail.ProductId,
CustomerLocationId = orderDetail.CustomerLocationId,
CustomerLocation = new OrderDetailCustomerLocationItem
{
CustomerLocationId = orderDetail.CustomerLocationId,
CustomerLocationName = orderDetail.CustomerLocation.Name
},
Product = new OrderDetailProductItem
{
ProductId = orderDetail.ProductId,
ProductName = ProductService.GetFormattedProductName(orderDetail.Product)
},
};
var product = orderDetail.Product;
var items =
product.CustomerProductData.Where(x => x.CustomerId == orderDetail.Order.CustomerId);
var customerProduct = items.FirstOrDefault();
if (customerProduct != null)
{
orderDetailItem.BagPieceQuantity = customerProduct.PieceQuantity.HasValue
? customerProduct.PieceQuantity.GetValueOrDefault()
: 0;
orderDetailItem.BoxBagQuantity = customerProduct.BoxQuantity.HasValue
? customerProduct.BoxQuantity.GetValueOrDefault()
: 0;
}
else
{
orderDetailItem.BagPieceQuantity = orderDetail.Product.BagPieceQuantity;
orderDetailItem.BoxBagQuantity = orderDetail.Product.BoxBagQuantity;
}
orderDetailitems.Add(orderDetailItem);
}
return(orderDetailitems);
}
public ActionResult AjaxForm()
{
var model = new OrderDetailItem();
if (DoAction == ActionType.Edit)
{
model = _api.GetOrderDetailItem(ArrId.FirstOrDefault());
}
ViewBag.Action = DoAction;
model.SetupProductionItems = _setupAPI.GetList(UserItem.AgencyID);
ViewBag.AgencyID = UserItem.AgencyID;
ViewBag.ActionText = ActionText;
return(View(model));
}
private OrderInfo OrderToOrderInfo(Order order)
{
OrderInfo _orderInfo = new OrderInfo();
_orderInfo.CreateDate = order.CreateDate;
_orderInfo.CreatorId = order.CreatorId;
_orderInfo.Id = order.Id;
_orderInfo.OrderCode = order.OrderCode;
_orderInfo.Status = order.Status.ToString();
_orderInfo.OrderItems = new List <OrderDetailItem>();
foreach (var item in order.OrderItems)
{
OrderDetailItem detail = new OrderDetailItem();
detail.Info = item.Product.Name + "|Id:" + item.ProductId + "|Count:" + item.Count;
_orderInfo.OrderItems.Add(detail);
}
return(_orderInfo);
}
private void FillOrderDetail(OrderDetail orderDetail, OrderDetailItem orderDetailItem)
{
orderDetail.ProductId = orderDetailItem.ProductId;
orderDetail.CustomerLocationId = orderDetailItem.CustomerLocationId;
var customer = _orderRepository.Get(orderDetail.OrderId);
var customerProduct = _customerProductDataRepository.GetByProduct(orderDetailItem.ProductId).FirstOrDefault(x => x.CustomerId == customer.CustomerId);
if (customerProduct != null)
{
if (customerProduct.BoxQuantity.HasValue)
{
orderDetailItem.BagPieceQuantity = customerProduct.PieceQuantity.GetValueOrDefault();
}
if (customerProduct.PieceQuantity.HasValue)
{
orderDetailItem.BoxBagQuantity = customerProduct.BoxQuantity.GetValueOrDefault();
}
}
orderDetail.PieceQuantity = Math.Abs(orderDetailItem.PieceQuantity);
orderDetail.BoxQuantity = CalculateBoxQuantity(Math.Abs(orderDetailItem.PieceQuantity),
Math.Abs(orderDetailItem.BagPieceQuantity), Math.Abs(orderDetailItem.BoxBagQuantity));
}
public void Delete(OrderDetailItem orderDetailItem)
{
Delete(orderDetailItem.Id);
}
public static Dictionary<object, OrderDetailItem> GetOrderItemMenus(int orderId)
{
Dictionary<object, OrderDetailItem> result = new Dictionary<object, OrderDetailItem>( );
var cmd = new QueryCommand(ItemDetailMenusCmd);
cmd.AddParameter("@OrderId", orderId, DbType.Int32);
using (var dr = DataService.GetReader(cmd))
{
//decimal orderSum = 0, allSum = 0;
bool isFirst = true;
OrderDetailItem item;
while (dr.Read( ))
{
var id = Utilities.ToInt(dr[SysTakeawayMenu.Columns.Id]);
if (!result.TryGetValue(id, out item))
{
item = new OrderDetailItem
{
OrderSum = isFirst ? Utilities.ToDecimal(dr["OrderSum"]) : 0,
DirName = dr[SysTakeawayDirectory.Columns.DirName],
MenuName = dr[SysTakeawayMenu.Columns.Name],
MenuId = id,
OrderId = orderId,
OrderQty = Utilities.ToInt(dr[OrdersDetail.Columns.OrderQty]),
OrderPrice = Utilities.ToDecimal(dr[SysTakeawayMenu.Columns.Price]),
IsCompanyItem = true,
IsOutOfStock = Utilities.ToBool(dr[SysTakeawayMenu.Columns.IsOutOfStock])
};
result.Add(id, item);
isFirst = false;
}
else
item.OrderQty = item.OrderQty + Utilities.ToInt(dr[OrdersDetail.Columns.OrderQty]);
}
}
return result;
}
public static Dictionary<object, OrderDetailItem> GetOrderDetailByOrder(Order order)
{
if (order == null)
return new Dictionary<object, OrderDetailItem>( );
var data = GetOrderItemMenus(order.Id);
var query = DB.Select(Utilities.GetTableColumns(OrdersDetail.Schema),
SysTakeawayDirectory.DirNameColumn.QualifiedName)
.From<OrdersDetail>( )
.InnerJoin(SysTakeawayMenu.IdColumn, OrdersDetail.MenuIdColumn)
.InnerJoin(SysTakeawayDirectory.IdColumn, SysTakeawayMenu.DirIDColumn)
.Where(OrdersDetail.OrderIdColumn).IsEqualTo(order.Id);
query.GetDataReaderEnumerator( ).ForEach<IDataReader>(dr =>
{
var menuId = Utilities.ToInt(dr[OrdersDetail.Columns.MenuId]);
OrderDetailItem item;
if (!data.TryGetValue(menuId, out item))
{
item = new OrderDetailItem
{
DirName = dr[SysTakeawayDirectory.Columns.DirName],
MenuName = dr[OrdersDetail.Columns.MenuName],
MenuId = menuId,
OrderId = order.Id,
OrderQty = Utilities.ToInt(dr[OrdersDetail.Columns.OrderQty]),
OrderPrice = Utilities.ToDecimal(dr[OrdersDetail.Columns.OrderPrice]),
IsCompanyItem = false,
IsOutOfStock = Utilities.ToBool(dr[OrdersDetail.Columns.IsOutOfStock])
};
item.OrderSum = item.OrderQty * item.OrderPrice;
data.Add(menuId, item);
}
else
{
item.OrderQty = item.OrderQty + Utilities.ToInt(dr[OrdersDetail.Columns.OrderQty]);
item.IsOutOfStock = Utilities.ToBool(dr[OrdersDetail.Columns.IsOutOfStock]);
item.OrderSum += Utilities.ToInt(dr[OrdersDetail.Columns.OrderQty]) * item.OrderPrice;
}
return true;
});
return data;
}
public List <OrderDetailCategory> GetOrderDetailByOrderId(int id, string userId, bool shortList)
{
List <OrderDetailCategory> catDtlList = new List <OrderDetailCategory>();
var catService = new CategoryService(userId);
var newCategoryList = catService.GetCategories().OrderBy(o => o.CategoryName);
foreach (CareModels.Catagories.CategoryList cat in newCategoryList)
{
List <OrderDetailSubCat> subCatDtlList = new List <OrderDetailSubCat>();
var subCatService = new SubCatService(userId);
bool subCatAdded = false;
var newSubCatList = subCatService.GetSubCatsByCatId(cat.CategoryId);
foreach (CareModels.SubCategories.SubCatListShort subCat in newSubCatList)
{
List <OrderDetailItem> itemDtl = new List <OrderDetailItem>();
var itemService = new ItemService(userId);
var newItemList = itemService.GetItemsBySubCatId(subCat.SubCatId);
bool itemAdded = false;
foreach (CareModels.Items.ItemListShort itm in newItemList)
{
//OrderDetailItem snglItemDtl = new OrderDetailItem();
var orderDetailService = new OrderDetailService(userId);
var newItemDtl = orderDetailService.GetOrderDetailByOrderIdAndItemId(id, itm.ItemId);
if ((shortList && newItemDtl.ItemId > 0) || !shortList)
{
OrderDetailItem itmDtl = new OrderDetailItem
{
OrderDetailId = newItemDtl.OrderDetailId,
ItemId = itm.ItemId,
ItemName = itm.ItemName,
AisleNumber = itm.AisleNumber,
MaxAllowed = itm.MaxAllowed,
PointCost = itm.PointCost,
Quantity = newItemDtl.Quantity,
QuantityBefore = newItemDtl.Quantity,
Pulled = newItemDtl.Pulled,
PulledBefore = newItemDtl.Pulled
};
itemDtl.Add(itmDtl);
itemAdded = true;
}
}
if (itemAdded)
{
OrderDetailSubCat dtlSubCat = new OrderDetailSubCat
{
SubCatId = subCat.SubCatId,
CategoryId = cat.CategoryId,
SubCatName = subCat.SubCatName,
SubCatMaxAllowed = subCat.SubCatMaxAllowed,
OrderDetailItemList = itemDtl
};
subCatDtlList.Add(dtlSubCat);
subCatAdded = true;
}
}
if (subCatAdded)
{
OrderDetailCategory dtlCat = new OrderDetailCategory
{
CategoryId = cat.CategoryId,
CategoryName = cat.CategoryName,
OrderDetailSubCatList = subCatDtlList
};
catDtlList.Add(dtlCat);
}
}
return(catDtlList);
}
public ActionResult OrderDetailGrid_Destroy([DataSourceRequest] DataSourceRequest request, OrderDetailItem detailItem)
{
if (detailItem != null)
{
_orderDetailService.Delete(detailItem);
this.ShowNotification(NotificationType.Success, "Detail item was successfully removed from Order.");
}
return(Json(ModelState.ToDataSourceResult(), JsonRequestBehavior.AllowGet));
}
public ActionResult OrderDetailGrid_Update([DataSourceRequest] DataSourceRequest request, OrderDetailItem detailItem)
{
if (detailItem != null && ModelState.IsValid)
{
_orderDetailService.Edit(detailItem);
}
FillProductQuantities(detailItem);
return(Json(new[] { detailItem }.ToDataSourceResult(request, ModelState), JsonRequestBehavior.AllowGet));
}
