private void AddTransferOrder(Order order)
{
order.FilterOrders(CurrentSettings.GroupType, CurrentSettings.OrderInfoDisplay);
List <Order> sourceOrders = TotalOrders.Where(s => s.TableTabName == order.SourceTableName).ToList();
order.DisplayAttributes.SourceTabTableText = order.SourceTableName;
var destinationOrders = TotalOrders.FirstOrDefault(s => s.TableTabName == order.TableTabName);
if (destinationOrders != null)
{
ProcessTransferWhenDestinationExist(sourceOrders, order, destinationOrders);
destinationOrders.DisplayAttributes.SourceTabTableText = order.DisplayAttributes.SourceTabTableText;
}
else
{
order.OrderState = OrderState.Complete;
DbOrder.AddOrder(order, CurrenTerminal.TerminalId, false);
ProcessTransferWhenDestinationNotExist(sourceOrders, order);
TotalOrders.Add(order);
AnalyticalData.TotalOrdersCount++;
AnalyticalData.CurrentOrdersCount++;
}
if (CurrentSettings.ConfirmOnTransfer)
{
ShowMessageBox("Order Transferred", order.SourceTableName + " is transferred to " + order.TableTabName);
}
TotalOrders.RemoveAll(s => s.Items.Count == 0);
PublishRedrawEvent();
}
public string ToSqlOrder(IFieldInfoIndexer indexer)
{
TkDebug.AssertArgumentNull(indexer, "indexer", this);
var fieldInfo = indexer[NickName];
if (fieldInfo == null)
{
return(null);
}
string fieldName = fieldInfo.FieldName;
bool isSimple = true;
if (fieldInfo is ITk5FieldInfo fieldInfoEx)
{
if (!string.IsNullOrEmpty(fieldInfoEx.ListDetail?.SortField))
{
fieldName = fieldInfoEx.ListDetail.SortField;
isSimple = fieldName.IndexOfAny(new char[] { '(', ')' }) == -1;
}
}
if (isSimple)
{
return(Order == DbOrder.Asc ? fieldName : fieldName + " DESC");
}
else
{
Order = DbOrder.Asc;
return(fieldName);
}
}
public void SaveOrder(DbOrder order)
{
using (var db = new LiteDatabase(DbName))
{
db.GetCollection <DbOrder>().Upsert(order);
}
}
public Order BuildOrderFromOrderItemKey(int inOrderItemDbKey)
{
var order = DbOrder.GetOrderFromOrderItemKey(inOrderItemDbKey, ChefmateController.Instance.CurrenTerminal.TerminalId);
SetOrderState(order);
return(order);
}
public static IEnumerable <Transaction> GetTransactions(
DbFilter filter = DbFilter.All,
IEnumerable <long> ids = null,
DbOrder order = DbOrder.None)
{
using (var connection = OpenConnection())
using (var command = new SQLiteCommand(connection))
{
command.CommandText = "SELECT * FROM Transactions";
AddFilter(filter, command, ids);
AddOrder(order, command);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
yield return(new Transaction
{
TransactionId = reader.GetInt64(0),
Date = reader.GetDateTime(1),
Type = reader.GetString(2),
Reference = reader.GetString(3),
Value = reader.GetInt32(4),
CategoryId = reader.GetValue(5) as long?,
});
}
}
}
}
public void Setup()
{
myEvent = new Event
{
Title = "This is a Test Event",
Description = "Thsi is the description of the test event",
Gate = "FB22",
GateOpens = new DateTime(2018, 11, 20, 12, 00, 00),
StartTime = new DateTime(2018, 11, 20, 12, 15, 00),
Date = DateTime.Now.Date,
AvailableTickets = 20,
TicketPrice = 10
};
eventDb = new DbEvent();
orderDb = new DbOrder();
string customerId = orderDb.GetRandomUser();
myOrder = new Order
{
Quantity = 3,
Date = DateTime.Now.Date,
CustomerId = customerId
};
myOrder.TotalPrice = myOrder.Quantity * myEvent.TicketPrice;
}
public static IEnumerable <Category> GetCategories(
DbFilter filter = DbFilter.All,
IEnumerable <long> ids = null,
DbOrder order = DbOrder.None)
{
using (var connection = OpenConnection())
using (var command = new SQLiteCommand(connection))
{
command.CommandText = "SELECT * FROM Categories";
AddFilter(filter, command, ids);
AddOrder(order, command);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
yield return(new Category
{
CategoryId = reader.GetInt64(0),
Name = reader.GetString(1),
});
}
}
}
}
private static Model.Order ToModel(DbOrder value)
{
if (value.Projection != null && value.Projection.Film != null)
{
return(new Model.Order(
value.Id,
value.ProjectionId,
new Model.Projection(
value.Projection.Id,
value.Projection.FilmId,
new Model.Film(
value.Projection.Film.Id,
value.Projection.Film.Title,
value.Projection.Film.Director,
value.Projection.Film.Description,
value.Projection.Film.Rating),
value.Projection.RoomId,
value.Projection.Start),
value.Price,
value.ReservedSeats,
value.ViewerId));
}
else
{
return(new Model.Order(value.Id, value.ProjectionId, value.Price, value.ReservedSeats, value.ViewerId));
}
}
private static void AddOrder(
DbOrder order,
SQLiteCommand command)
{
switch (order)
{
case DbOrder.None:
break;
case DbOrder.ByDate:
command.CommandText += " ORDER BY Date";
break;
case DbOrder.ByDateDescending:
command.CommandText += " ORDER BY Date DESC";
break;
case DbOrder.ByValue:
command.CommandText += " ORDER BY Value";
break;
case DbOrder.ByValueDescending:
command.CommandText += " ORDER BY Value DESC";
break;
}
}
public FieldOrder(string nickName, DbOrder order)
{
TkDebug.AssertArgumentNullOrEmpty(nickName, "nickName", null);
NickName = nickName;
Order = order;
}
public async Task <DbOrder> AddNewOrder(DbOrder dbOrder)
{
await _dbContext.AddAsync(dbOrder);
await _dbContext.SaveChangesAsync();
return(dbOrder);
}
private void DAFDone_Click(object sender, RoutedEventArgs e)
{
Order o = dgOrder.SelectedItem as Order;
o.Address = DAFAddress.SelectedItem as Address;
DbOrder.UpdateOrderedAddress(o);
dgOrder.Items.Refresh();
}
public void SaveOrder(Order order, bool isFraud)
{
using var db = new LocalDbContext();
var dbOrder = new DbOrder(order, isFraud);
db.Orders.Add(dbOrder);
db.SaveChanges();
}
public ActionResult DeleteConfirmed(int id)
{
DbOrder dbOrders = db.Orders.Find(id);
//dbOrders.Pizza.Clear();
db.Orders.Remove(dbOrders);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void loadOrders()
{
Data.Orders = DbOrder.GetOrders();
OrderView = CollectionViewSource.GetDefaultView(Data.Orders);
OrderView.Filter = orderFilter;
dgOrder.ItemsSource = OrderView;
}
private void BShipTheOrder_Click(object sender, RoutedEventArgs e)
{
Order o = dgOrder.SelectedItem as Order;
o.Shipped = 1;
bShipTheOrder.IsEnabled = false;
DbOrder.UpdateShipOrder(o);
dgOrder.Items.Refresh();
}
public ActionResult Edit([Bind(Include = "Id,dateTime,FullNameCustomer,Address,Price")] DbOrder dbOrders)
{
if (ModelState.IsValid)
{
db.Entry(dbOrders).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dbOrders));
}
public ActionResult Edit([Bind(Include = "Id,FullName,OrderDate,Deadline,Price")] DbOrder dbOrder)
{
if (ModelState.IsValid)
{
db.Entry(dbOrder).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dbOrder));
}
private void MainForm_Load(object sender, EventArgs e)
{
caServerComboBox.DataSource = DbAccount.WellKnownAcmeServers.ToList();
_account = Repo.GetAccount();
RebindAccountControls();
_lastOrder = Repo.GetOrders().LastOrDefault();
RebindOrderControls();
}
public ObservableCollection <Order> GetAllOrders(int terminalKey)
{
var orders = DbOrder.GetAllOrders(terminalKey);
foreach (var order in orders)
{
order.OrderState = ChefmateController.Instance.CurrentSettings.TerminalType == TerminalType.Runner ? OrderState.Runner : OrderState.Complete;
SetOrderStatus(order);
}
return(orders);
}
public ActionResult Create([Bind(Include = "Id,dateTime,FullNameCustomer,Address,Price")] DbOrder dbOrders)
{
if (ModelState.IsValid)
{
db.Orders.Add(dbOrders);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dbOrders));
}
public async Task <DbOrder> HandleOrder(DbOrder dbOrder)
{
var order = _ordersConverter.ConvertFromDbModel(dbOrder);
foreach (var product in order.Products)
{
product.PaidPrice = Math.Abs(product.PaidPrice);
}
dbOrder.ConvertedOrder = JsonSerializer.Serialize(order);
return(dbOrder);
}
public ActionResult DeleteConfirmed(int id)
{
DbOrder dbOrder = db.Orders.Find(id);
// db.Decorations.Remove(dbDec);
//db.Cakes.Remove(dbCake);
db.Orders.Remove(dbOrder);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Print(HttpPostedFileBase file)
{
if (file != null && file.ContentLength > 0)
{
var dto = OrderCakes.FileHelper.LoadFromStream(file.InputStream);
using (var db = new ApplicationDbContext())
{
var row = new DbOrder
{
FullName = dto.FullName,
OrderDate = dto.OrderDate,
Deadline = dto.Deadline,
Price = dto.Price,
};
row.TypeCakes = new Collection <DbCake>();
List <Collection <DbDecoration> > decorations = new List <Collection <DbDecoration> >();
foreach (var cake in dto.TypeCakes)
{
decorations.Add(new Collection <DbDecoration>());
foreach (var dec in cake.DecorationType)
{
decorations[decorations.Count - 1].Add(new DbDecoration {
Decoration = (Models.Decoration)dec
});
}
row.TypeCakes.Add(new DbCake
{
CakeShape = (Models.Shapes)cake.CakeShape,
FillingType = (Models.Filling)cake.FillingType,
NumberTiers = cake.NumberTiers,
ShellType = (Models.Shells)cake.ShellType,
DecorationType = decorations[decorations.Count - 1]
});
}
db.Orders.Add(row);
db.SaveChanges();
}
return(View(dto));
}
return(RedirectToAction("Index"));
}
private void SelectedOrderChangedHandler()
{
if (_selectedOrder != null)
{
this.IsEnabled = false;
StatusText = "Loading Items......";
var order = DbOrder.GetOrder(_selectedOrder.OrderKey, 0, true);
SelectedOrderItems = order.Items;
this.IsEnabled = true;
StatusText = "";
}
}
// GET: Order/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
DbOrder dbOrder = db.Orders.Find(id);
if (dbOrder == null)
{
return(HttpNotFound());
}
return(View(dbOrder));
}
private void LoadOrdersCommandHandler(object sender)
{
this.IsEnabled = false;
StatusText = "Loading Orders......";
this.Dispatcher.BeginInvoke(new Action(() =>
{
bool canLoadMoreOrders = false;
var orders = DbOrder.GetBumpedOrders(_skipCount, ChefmateController.Instance.CurrentSettings.RecallCount, ref canLoadMoreOrders);
CanLoadMoreOrders = canLoadMoreOrders;
_skipCount += ChefmateController.Instance.CurrentSettings.RecallCount;
Orders.AddRange(orders);
this.IsEnabled = true;
StatusText = "";
}));
}
public Order ConvertFromDbModel(DbOrder dbOrder)
{
var orderRequest = DeserializeJsonSource <AddOrderRequest>(dbOrder.SourceOrder);
var products = orderRequest.Products
.Select(x => _productsConverter.ConvertFromRequest(x))
.ToArray();
return(new Order
{
OrderNumber = dbOrder.OrderNumber,
SystemType = dbOrder.SystemType,
CreatedAt = dbOrder.CreatedAt,
Products = products,
Id = dbOrder.Id
});
}
public async Task <Response <int> > Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
//model validation
var order = new DbOrder
{
No = request.OrderNo,
Total = request.Total,
Date = DateTime.Now,
CustomerId = request.CustomerId
};
await _db.Orders.AddAsync(order);
await _db.SaveChangesAsync();
return(Response.Success(order.Id, ""));
}
public void AddRecallOrder(Order inOrder)
{
lock (_syncRoot)
{
var order = DbOrder.GetOrder(inOrder.OrderKey, 0, true);
AnalyticalData.CurrentOrdersCount++;
AnalyticalData.CurrentItems += order.Items.Count;
TimeSpan recalledOrderMakeTime = order.BumpTime - order.ArrivalTime;
AnalyticalData.TotalMakeTime = new TimeSpan(AnalyticalData.TotalMakeTime.Ticks - recalledOrderMakeTime.Ticks);
foreach (var item in order.Items)
{
DbOrderItem.UpdateOrderItemTerminalKey(item.OrderItemKey, CurrenTerminal.TerminalId);
}
TotalOrders.Add(order);
PublishAddOrder(order);
}
}
public ActionResult AddOrder()
{
var db = new DbOrder();
var cdb = new DbCustomer();
Cart cart = (Cart)HttpContext.Session["Cart"];
int sumTotal = SumTotal(cart.productids);
int customerID = cdb.CurrentCustomer();
Debug.Write("SumTotal" + sumTotal);
int orderid = db.saveOrer(sumTotal, customerID);
Debug.Print("Orderid: " + orderid);
if (orderid!=0)
{
db.addOrderList(orderid);
return RedirectToAction( "OrderComplete", "Orders");
}
return RedirectToAction("Customer", "List");
}
public void addToCart(string Productid, string Quantity)
{
Debug.Print("Productid " + Productid);
Debug.Print("Quantity " + Quantity);
int productid = Int32.Parse(Productid);
int quantity = Int32.Parse(Quantity);
var db = new DbOrder();
Cart cart;
if (Session["Cart"] == null)
{
cart = new Cart();
cart.productids = db.addToCart(productid, quantity);
Session["Cart"] = cart;
}
else
{
cart = (Cart)Session["Cart"];
cart.productids.AddRange(db.addToCart(productid, quantity));
Session["Cart"] = cart;
}
}
public Product FindProduct(int productid)
{
var db = new DbOrder();
return db.FindProduct(productid);
}
