Guid GetCartID(string userName)
{
Guid result = Guid.NewGuid();
var existsSql = OrdersTable.Select(OrdersTable.Columns.OrderID)
.Where(OrdersTable.Columns.UserName, userName)
.And(OrdersTable.Columns.OrderStatusID, 99);
object existingID = existsSql.BuildCommand().ExecuteScalar();
if (existingID == null)
{
//create one!
var sql = OrdersTable.Insert(new Dictionary <string, object>()
{
{ OrdersTable.Columns.OrderID, result },
{ OrdersTable.Columns.UserName, userName },
{ OrdersTable.Columns.OrderStatusID, 99 },
{ OrdersTable.Columns.UserLanguageCode, System.Globalization.CultureInfo.CurrentCulture.TwoLetterISOLanguageName },
{ OrdersTable.Columns.CreatedOn, DateTime.Now }
});
//save it
sql.BuildCommand().ExecuteNonQuery();
}
else
{
result = (Guid)existingID;
}
return(result);
}
private void addOrderToolStripMenuItem_Click(object sender, EventArgs e)
{
OrdersTable newOrder = new OrdersTable();
AddOrder form = new AddOrder(newOrder, true);
form.Show();
}
private void InitializeElements()
{
this.pageTitle.findsBy = By.CssSelector(this.pageTitle.locator);
this.defaultEducateText.findsBy = By.CssSelector(this.defaultEducateText.locator);
this.searchBoldText.findsBy = By.CssSelector(this.searchBoldText.locator);
this.statusSelect.findsBy = By.CssSelector(this.statusSelect.locator);
this.statusSelectOptions.findsBy = By.CssSelector(this.statusSelectOptions.locator);
this.searchBySelect.findsBy = By.CssSelector(this.searchBySelect.locator);
this.searchBySelectOptions.findsBy = By.CssSelector(this.searchBySelectOptions.locator);
this.searchByInput.findsBy = By.CssSelector(this.searchByInput.locator);
this.fromDateField.findsBy = By.Id(this.fromDateField.locator);
this.toDateField.findsBy = By.Id(this.toDateField.locator);
this.searchButton.findsBy = By.Id(this.searchButton.locator);
this.textMessageWhenNoOrders.findsBy = By.CssSelector(this.textMessageWhenNoOrders.locator);
this.datePicker.findsBy = By.CssSelector(this.datePicker.locator);
this.ordersTable = new OrdersTable(Driver);
this.busyIndicator.findsBy = By.CssSelector(this.busyIndicator.locator);
this.filterForm.Init(Driver, SeleniumConstants.defaultWaitTime);
}
public AddOrder(OrdersTable order, bool New)
{
InitializeComponent();
MdiParent = Application.OpenForms["OrderManagement"];
isNew = New;
_order = order;
orderList = new List <OrderLinesTable>();
if (isNew)
{
this.Text = "New Order";
}
else
{
this.Text = "Edit Order";
btnAddOrder.Text = "Save Changes";
List <OrderLinesTable> orderLines = OrderingRepository.getInstance.GetOrderLines(_order);
//if order is editing takes all orderlines of that order and puts it in orderList (another list of order lines)
foreach (OrderLinesTable item in orderLines)
{
item.ProductsTable = (ProductsTable)OrderingRepository.getInstance.GetProducts().First(c => c.Id == item.ProductID);
item.OrdersTable = _order;
orderList.Add(item);
}
}
if (!isNew)
{
RefreshOrderList();
tbxAddress.Text = _order.DeliveryAddress;
lblTotal.Text = _order.Total.ToString();
}
}
private void dgvAllOrders_SelectionChanged(object sender, EventArgs e)
{
if (dgvAllOrders.SelectedRows.Count == 1)
{
OrdersTable order = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
RefreshOrderListByOrderId(order);
}
}
private void init_param()
{
OrdersTable.DataSource = (new OrdersBLL().GetCustomerOrders());
OrdersTable.DataBind();
var x = OrdersTable.Columns;
OrdersTable.Columns[8].Visible = false;
}
private void btnAdd_Click(object sender, EventArgs e)
{
OrdersTable order = new OrdersTable();
AddOrder form = new AddOrder(order, true);
form.Show();
form.FormClosed += AddOrder_FormClosed;
}
// ********************************************************************************************************************************************
// POST: api/orders/admin/add/
// function that get 1 parameter from OrdersTable type and adds it to the table
public IHttpActionResult Post([FromBody] OrdersTable order)
{
using (CarsDBEntities db = new CarsDBEntities())
{
db.OrdersTables.Add(order);
db.SaveChanges();
return(Ok("the order has been added"));
}
}
private void AllOrders_Activated(object sender, EventArgs e)
{
RefreshOrders();
if (dgvAllOrders.RowCount > 0)
{
OrdersTable order = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
RefreshOrderListByOrderId(order);
}
}
private void btnOrder_Click(object sender, EventArgs e)
{
OrdersTable c = new OrdersTable();
DataRow dr = c.Find("CodeOrder", txtCodeOrder.Text);
Orders ord = new Orders(dr);
FrmOrder f = new FrmOrder(ord, statusKind);
f.Show();
}
public void RefreshOrderListByOrderId(OrdersTable order)
{
dgvOrderList.SuspendLayout();
orderLinesTableBindingSource.SuspendBinding();
orderLinesTableBindingSource.DataSource = OrderingRepository.getInstance.GetOrderLines(order);
dgvOrderList.DataSource = null;
dgvOrderList.DataSource = orderLinesTableBindingSource;
orderLinesTableBindingSource.ResumeBinding();
dgvOrderList.ResumeLayout();
}
// DELETE: api/Orders/5
public void Delete(int id)
{
OrdersTable o = YRentDB.OrdersTables.FirstOrDefault(o1 => o1.Order_ID == id);
if (o != null)
{
YRentDB.OrdersTables.Remove(o);
YRentDB.SaveChanges();
}
}
protected void nextBtn_Click(object sender, EventArgs e)
{
if (pageIndex >= pageMax)
{
return;
}
OrdersTable.DataSource = (new OrdersBLL().GetCustomerOrders(++pageIndex));
OrdersTable.DataBind();
}
protected void prevBtn_Click(object sender, EventArgs e)
{
if (pageIndex <= 0)
{
return;
}
OrdersTable.DataSource = (new OrdersBLL().GetCustomerOrders(--pageIndex));
OrdersTable.DataBind();
}
public void SaveCart(ShoppingCart cart)
{
//using the Orders/OrderItems tables to persist the car
//with the idea that a cart is an order that hasn't checked out
//yet. This is a DB-centric decision, our model separates this
//concept. StatusID 99 marks an order as "Not Checked Out"
List <DbCommand> commands = new List <DbCommand>();
Guid orderID = Guid.NewGuid();
orderID = GetCartID(cart.UserName);
var settings = new Dictionary <string, object>();
if (cart.BillingAddress != null)
{
settings.Add(OrdersTable.Columns.BillingAddressID, cart.BillingAddress.AddressID);
}
if (cart.ShippingAddress != null)
{
settings.Add(OrdersTable.Columns.ShippingAddressID, cart.ShippingAddress.AddressID);
}
settings.Add(OrdersTable.Columns.ShippingService, cart.ShippingService);
settings.Add(OrdersTable.Columns.ShippingAmount, cart.ShippingAmount);
settings.Add(OrdersTable.Columns.TaxAmount, cart.TaxAmount);
//save down any address (billing/shipping), selected shipping, and tax info
var sql = OrdersTable.Update(settings)
.Where(OrdersTable.Columns.OrderID, orderID);
commands.Add(sql.BuildCommand());
//remove the existing items
commands.Add(OrderItemsTable.Delete().Where(OrderItemsTable.Columns.OrderID, orderID).BuildCommand());
//save each item in the cart
foreach (var item in cart.Items)
{
var itemSql = OrderItemsTable.Insert(new Dictionary <string, object>()
{
{ OrderItemsTable.Columns.SKU, item.Product.SKU },
{ OrderItemsTable.Columns.OrderID, orderID },
{ OrderItemsTable.Columns.Quantity, item.Quantity },
{ OrderItemsTable.Columns.DateAdded, item.DateAdded },
{ OrderItemsTable.Columns.Discount, item.Discount },
{ OrderItemsTable.Columns.DiscountReason, item.DiscountReason }
});
commands.Add(itemSql.BuildCommand());
}
//all in one, nice transaction BOOYAH!
SqlHelper.Execute(commands, connectionStringName);
}
private void UpdateOrder(object parameter)
{
if (Order != null &&
Order.Name != null &&
Order.Employer != null)
{
OrdersTable OT = context.OrdersTable.Single(o => o.Номер == Order.Id);
EmployerOrder EO = Orders.Single(o => o.Id == Order.Id);
OT.Название_товара = Product.Name;
OT.Сотрудник_ID = Order.Employer.Id;
EO.Name = Product.Name;
EO.Employer = Order.Employer;
Order = null;
Product = null;
context.SaveChanges();
}
}
private void btnEdit_Click(object sender, EventArgs e)
{
OrdersTable order = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
if (order.OrderStatus == OrderStatus.Canceled.ToString())
{
MessageBox.Show("Canceled Order Can Not Be Edited");
}
else if (order.OrderStatus == OrderStatus.Processed.ToString())
{
MessageBox.Show("Processed Order Can Not Be Edited");
}
else
{
AddOrder form = new AddOrder(order, false);
form.Show();
}
}
private void AddOrder(object parameter)
{
if (Order != null &&
Order.Name != null &&
Order.Employer != null)
{
OrdersTable OT = new OrdersTable();
OT.Название_товара = Order.Name;
OT.Сотрудник_ID = Order.Employer.Id;
context.OrdersTable.Add(OT);
context.SaveChanges();
Order.Id = OT.Номер;
Orders.Add(Order);
Order = null;
}
}
public HttpResponseMessage OrderStart([FromBody] OrdersTable order)
{
using (CarsDBEntities db = new CarsDBEntities())
{
var currentCar = db.CarsTables.FirstOrDefault(tmpcar => tmpcar.CarLicenseNumber == order.CarLicenseNumber);
if (currentCar != null)
{
currentCar.isRentable = false;
db.OrdersTables.Add(order);
db.SaveChanges();
return(Request.CreateResponse <CarsTable>(HttpStatusCode.OK, currentCar));
}
else
{
return(Request.CreateResponse <string>(HttpStatusCode.BadRequest, "Count find that current car"));
}
}
}
private void btnProcessed_Click(object sender, EventArgs e)
{
if (dgvAllOrders.SelectedRows.Count == 1)
{
OrdersTable order = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
if (order.OrderStatus == OrderStatus.Canceled.ToString())
{
MessageBox.Show("Canceled Order Can Not Be Processed!");
}
else if (order.OrderStatus == OrderStatus.Processed.ToString())
{
MessageBox.Show("Order is Already Processed!");
}
else
{
order.OrderStatus = OrderStatus.Processed.ToString();
OrderingRepository.getInstance.EditOrder(order);
RefreshOrders();
}
}
}
private void btnDelete_Click(object sender, EventArgs e)
{
if (dgvAllOrders.SelectedRows.Count == 1)
{
OrdersTable order = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
List <OrderLinesTable> orderLines = OrderingRepository.getInstance.GetOrderLines(order);
foreach (var item in orderLines)
{
OrderingRepository.getInstance.DeleteOrderLine(item);
}
OrderingRepository.getInstance.DeleteOrder(order);
RefreshOrders();
if (dgvAllOrders.RowCount > 0)
{
OrdersTable anotherOrder = (OrdersTable)dgvAllOrders.SelectedRows[0].DataBoundItem;
RefreshOrderListByOrderId(anotherOrder);
}
}
}
public void ImportTest()
{
Customer customer1 = new Customer(1, "GYJ");
Customer customer2 = new Customer(2, "SYY");
Good Dior = new Good(1, "Dior", 330.5f);
Good Chanel = new Good(2, "Chanel", 220.6f);
Good TF = new Good(3, "TF", 500.3f);
Order order1 = new Order(1, customer1);
order1.AddPurchase(new Purchase(Dior, 40));
order1.AddPurchase(new Purchase(Chanel, 80));
order1.AddPurchase(new Purchase(TF, 50));
Order order2 = new Order(2, customer2);
order2.AddPurchase(new Purchase(Dior, 40));
order2.AddPurchase(new Purchase(TF, 50));
Order order3 = new Order(3, customer1);
order3.AddPurchase(new Purchase(Dior, 450));
ordersTable.AddOrder(order1);
ordersTable.AddOrder(order2);
ordersTable.AddOrder(order3);
String expectXMLFile = "../../ordersTarget.xml";
ordersTable.Export(expectXMLFile);
OrdersTable os = new OrdersTable();
List <Order> list = os.Import("../../ordersTarget.xml");
Assert.IsNotNull(list);
Assert.AreEqual(list.Count, 3);
}
// ********************************************************************************************************************************************
// PUT: api/orders/admin/edit/
// function that get one parameter from orderstable type seach if this id is already exists
// if true it changes the property value to the ordertable type object
// and return ok and the current user
// else return bad request
public HttpResponseMessage Put([FromBody] OrdersTable value)
{
using (CarsDBEntities db = new CarsDBEntities())
{
var currentOrder = db.OrdersTables.FirstOrDefault(o => o.OrderID == value.OrderID);
if (currentOrder != null)
{
currentOrder.CarLicenseNumber = value.CarLicenseNumber;
currentOrder.EstimatedReturnDate = value.EstimatedReturnDate;
currentOrder.OrderID = value.OrderID;
currentOrder.ReturnDate = value.ReturnDate;
currentOrder.StartDate = value.StartDate;
currentOrder.UserID = value.UserID;
db.SaveChanges();
return(Request.CreateResponse <OrdersTable>(HttpStatusCode.OK, currentOrder));
}
else
{
return(Request.CreateResponse <string>(HttpStatusCode.BadRequest, "Couldnt find the current order"));
}
}
}
public void Put(int id, [FromBody] OrdersTable u1)
{
OrdersTable u = YRentDB.OrdersTables.FirstOrDefault(f => f.Order_ID == id);
if (u != null)
{
u.Car_ID = u1.Car_ID;
u.Start_Date = u1.Start_Date;
u.Return_Estimate_Date = u1.Return_Estimate_Date;
u.Return_Real_Date = u1.Return_Real_Date;
u.User_ID = u1.User_ID;
u.Order_Status = u1.Order_Status;
u.Car_Number = u1.Car_Number;
u.Number_Of_Days = u1.Number_Of_Days;
u.Price_PerDay = u1.Price_PerDay;
u.Estimate_Cost = u1.Estimate_Cost;
u.Number_Of_Delay = u1.Number_Of_Delay;
u.PricePerDelay = u1.PricePerDelay;
u.Total_Cost = u1.Total_Cost;
YRentDB.SaveChanges();
}
}
public Customer GetCustomer(string userName)
{
var productRepo = new SimpleProductRepository();
Customer result = null;
var batch = new BatchSql();
//see if there's a customer - if not create one
object user = CustomersTable.Select(CustomersTable.Columns.UserName)
.Where(CustomersTable.Columns.UserName, userName)
.BuildCommand()
.ExecuteScalar();
if (user == null)
{
CustomersTable.Insert(
new Dictionary <string, object>()
{
{ CustomersTable.Columns.UserName, userName },
{ CustomersTable.Columns.LanguageCode, System.Globalization.CultureInfo.CurrentCulture.TwoLetterISOLanguageName }
})
.BuildCommand()
.ExecuteNonQuery();
}
//customer
batch.Append(CustomersTable.Select()
.Where(CustomersTable.Columns.UserName, userName));
//addresses
batch.Append(AddressesTable.Select()
.Where(AddressesTable.Columns.UserName, userName));
//shopping cart
Guid orderID = GetCartID(userName);
batch.Append(OrdersTable.Select()
.Where(OrdersTable.Columns.OrderID, orderID));
//items
//avert your eyes if this bothers you
var itemSql = new SqlStatement(connectionStringName);
itemSql.Add(string.Format("SELECT {0}, {1} ", OrderItemsTable.COLUMN_LIST, ProductsTable.COLUMN_LIST));
itemSql.InnerJoin(
OrderItemsTable.TABLE_NAME,
OrderItemsTable.ColumnsQualified.SKU,
ProductsTable.TABLE_NAME,
ProductsTable.ColumnsQualified.SKU)
.Where(OrderItemsTable.Columns.OrderID, orderID);
batch.Append(itemSql);
var cmd = batch.BuildCommand(connectionStringName);
using (var rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection)) {
//customer
if (rdr.Read())
{
result = new Customer(userName,
CustomersTable.ReadEmail(rdr),
CustomersTable.ReadFirst(rdr),
CustomersTable.ReadLast(rdr));
}
else
{
result = new Customer();
}
//address
result.AddressBook = new List <Address>();
if (rdr.NextResult())
{
while (rdr.Read())
{
result.AddressBook.Add(LoadAddress(rdr));
}
}
//cart
result.Cart = new ShoppingCart(userName);
if (rdr.NextResult())
{
if (rdr.Read())
{
result.Cart.ShippingAddress = result.AddressBook.SingleOrDefault(x => x.AddressID == OrdersTable.ReadShippingAddressID(rdr));
result.Cart.BillingAddress = result.AddressBook.SingleOrDefault(x => x.AddressID == OrdersTable.ReadBillingAddressID(rdr));
result.Cart.ShippingService = OrdersTable.ReadShippingService(rdr) ?? "";
result.Cart.ShippingAmount = OrdersTable.ReadShippingAmount(rdr);
result.Cart.TaxAmount = OrdersTable.ReadTaxAmount(rdr);
}
}
//items
if (rdr.NextResult())
{
while (rdr.Read())
{
var product = productRepo.LoadProduct(rdr);
result.Cart.Items.Add(new ShoppingCartItem(product, CartItemsTable.ReadQuantity(rdr), CartItemsTable.ReadDateAdded(rdr)));
}
}
}
return(result);
}
public async Task <IEnumerable <OrdersTable> > ManageOrdersResp(string connectionString, OrdersTable data)
{
return(await formBLL.ManageOrdersBLL(connectionString, data));
}
//add row for order, rows for order details and row for credit card.
private bool addOrderDetails()
{
bool returnValue = true;
int orderCode = 0;
ItemStockTable itemStockT = new ItemStockTable();
ItemsTable itemT = new ItemsTable();
OrderDetailsTable orderDetailsT = new OrderDetailsTable();
//add order
try
{
OrdersTable ordersTable = new OrdersTable();
DataRow rowToAdd = ordersTable.Dt.NewRow();
DataRow currentRow = OrderToAdd.BuildRow();
orderCode = int.Parse(currentRow["CodeOrder"].ToString());
rowToAdd["CodeOrder"] = currentRow["CodeOrder"];
rowToAdd["IDCust"] = currentRow["IDCust"];
rowToAdd["DateOrder"] = currentRow["DateOrder"];
returnValue = ordersTable.Add(rowToAdd);
}
catch (Exception)
{
returnValue = false;
}
//add order details
OrderDetails detailToAdd;
groupItemsList();
foreach (var item in ShoppingCartListItems)
{
if (item.ItemAmount > 0)
{
detailToAdd = new OrderDetails();
detailToAdd.CodeOrder = orderCode;
detailToAdd.CodeItemStoke = itemStockT.getItemStockCode(item.ItemCode, item.ColorCode, item.SizeCode) + "";
//decrease amount of items in stock
returnValue = decreaseAmountOfItemInStock(int.Parse(detailToAdd.CodeItemStoke), item.ItemAmount);
detailToAdd.Amount = item.ItemAmount;
detailToAdd.PriceItem = itemT.getItemPrice(item.ItemCode);
detailToAdd.SaleItem = itemT.isSaleItem(item.ItemCode);
try
{
DataRow rowToAdd = detailToAdd.BuildRow();
returnValue = orderDetailsT.Add(rowToAdd);
}
catch (Exception)
{
returnValue = false;
}
}
}
//add credit card details
CreditCardOfCustomers card = new CreditCardOfCustomers();
CreditCardOfCustomersTable creditCardT = new CreditCardOfCustomersTable();
card.CodeCreditCard = creditCardT.getNextCode();
card.CodeOrder = orderCode;
card.NumCreditCard = txtNumCard.Text;
card.ValidityOfCreditCard = dtpValidate.Value;
card.IdOwner = txtBID.Text;
card.ThreeNumOnCard = int.Parse(txtBThree.Text);
card.TotalOfPrice = lblPaymentSum.Text;
card.NumOfPayments = (int)nudNumOfPayments.Value;
card.KindOfDeal = "חיוב";
DataRow rowToAddToCreditCardT = card.BuildRow();
try
{
creditCardT.Add(rowToAddToCreditCardT);
}
catch (Exception)
{
returnValue = false;
}
return(returnValue);
}
public async Task <IHttpActionResult> ManageOrders(OrdersTable data)
{
return(Json(await iform.ManageOrdersResp(connectionString, data)));
}
protected void deleteBtn_Click(object sender, EventArgs e)
{
OrdersTable.DeleteRow(OrdersTable.SelectedIndex);
}
public void Post([FromBody] OrdersTable O1)
{
YRentDB.OrdersTables.Add(O1);
YRentDB.SaveChanges();
}
