public ActionResult Lookup(string myDesiredCustomerId)
{
OrdersViewModel ordersListViewModel;
int customerId = 0;
bool success = int.TryParse(myDesiredCustomerId, out customerId);
if (success)
{
CustomerDTO customerDTO = _customersRepo.GetCustomerById(customerId);
OrdersDTO ordersDTO = _ordersRepo.GetOrdersForCustomer(customerId);
ordersListViewModel = ConvertOrdersDTOToOrdersListViewModel(ordersDTO);
AddCustomerDTOToOrdersListViewModel(ordersListViewModel, customerDTO);
if (!ordersListViewModel.Customer.IsValidCustomer)
{
ordersListViewModel.Message = "No customer with that ID";
}
else if (ordersListViewModel.Orders.Count() == 0)
{
ordersListViewModel.Message = "No orders found";
}
}
else
{
ordersListViewModel = new OrdersViewModel()
{
Message = "Not a valid customer ID"
};
}
return(View("Index", ordersListViewModel));
}
public OrdersDTO GetOrders(Guid user_Id)
{
OrdersDTO ordersDTO = new OrdersDTO();
ordersDTO.orders = (from oc in dbContext.Order
where oc.UserID == user_Id
select new OrderDTO()
{
TotalAmount = oc.TotalAmount,
OrderDate = oc.OrderDate,
DeliveryDate = oc.DeliveryDate,
ID = oc.ID
}).ToList();
foreach (var i in ordersDTO.orders)
{
if (i.DeliveryDate <= i.OrderDate)
{
i.status = "Delivered";
}
else
{
i.status = "Not Delivered";
}
}
return(ordersDTO);
}
public void MakeOrder(OrdersDTO ordersDTO)
{
var dish = Database.Dishes.GetListFromId(ordersDTO.Id);
foreach (var p in dish)
{
ordersDTO.ResultPrice = p.Price;
}
//validating
if (dish == null)
{
throw new ValidationException("Извините, но такого блюда у нас нет", "");
}
//make discount
decimal sum = new Discount(0.2m).GetDiscountPrice(ordersDTO.ResultPrice);
Order orders = new Order
{
DishesCount = dish.Count,
ResultOrderPrice = sum,
OrderTableNumber = ordersDTO.OrderTableNumber,
Date = DateTime.Now
};
Database.Orders.Create(orders);
Database.Save();
}
public ActionResult GetOrders(OrdersDTO model)
{
model.Date = DateTime.Parse(model.StartDate);
var result = orderService.GetOrdersForAdmin(model.Date);
return(View("OrderByAllUsers", result));
}
public OrderEditFm(Utils.Operation operation, OrdersDTO order)
{
InitializeComponent();
LoadOrdersData();
this.operation = operation;
ordersBS.DataSource = Item = order;
LoadReceiptsData();
orderNumberTBox.DataBindings.Add("EditValue", ordersBS, "OrderNumber");
orderDateTBox.DataBindings.Add("EditValue", ordersBS, "OrderDate", true, DataSourceUpdateMode.OnPropertyChanged);
contractorsGridEdit.DataBindings.Add("EditValue", ordersBS, "ContractorId", true, DataSourceUpdateMode.OnPropertyChanged);
contractorsGridEdit.Properties.DataSource = contractorsService.GetContractors();
contractorsGridEdit.Properties.ValueMember = "ContractorId";
contractorsGridEdit.Properties.DisplayMember = "Name";
contractorsGridEdit.Properties.NullText = "[нет данных]";
if (this.operation == Utils.Operation.Add)
{
((OrdersDTO)Item).OrderDate = DateTime.Today;
contractorsGridEdit.EditValue = 0;
}
}
public ActionResult CreateOrder(OrdersViewModel order)
{
try
{
//Если введены поля CustomerId и OrderDate, то создаётся новый заказ
if ((ModelState.IsValidField("CustomerId")) && (ModelState.IsValidField("OrderDate")))
{
OrdersDTO OrderBLL = new OrdersDTO();
OrderBLL.CustomerID = order.CustomerID;
OrderBLL.OrderDate = order.OrderDate;
Data.CreateOrder(OrderBLL);
//После успешного создания заказа, пользователя перенаправляют на главную страницу
return(RedirectToAction("Index"));
}
else //если введено поле OrderID то пользователя перенаправляют на страницу с редактированием заказа
if (ModelState.IsValidField("OrderID"))
{
return(RedirectToAction("UpdateOrder", new { OrderID = order.OrderID }));
}
//Если валидация не проходит, то пользователя возвращают на страницу создания заказа
else
{
return(View(order));
}
}
catch (ValidationException ex)
{
return(Content(ex.Message));
}
}
public async Task <ActionResult> PutOrders([FromRoute] int orderId, [FromBody] OrdersDTO order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Entry(Mapper.Map <Orders>(order)).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(orderId))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Update(OrdersDTO dto)
{
ShippingNo = Guid.NewGuid();
OrderId = dto.OrderId;
Amount = dto.Amount;
Display();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ProductId,Quantity,Cost,Dispatched,InvoiceId")] Order order)
{
var invoice = await _context.Invoices.FirstOrDefaultAsync(i => i.Id == order.InvoiceId);
if (id != order.Id)
{
return(NotFound());
}
else if (!invoice.Invoiced)
{
return(View("NotInvoiced"));
}
order.DispatchDate = DateTime.Now;
if (ModelState.IsValid)
{
try
{
_context.Update(order);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderExists(order.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
OrdersDTO orders = new OrdersDTO
{
Id = order.Id,
Cost = order.Cost,
DispatchDate = order.DispatchDate,
Dispatched = order.Dispatched,
InvoiceId = order.InvoiceId,
ProductId = order.ProductId,
Quantity = order.Quantity
};
try
{
var response = await _ordersSevice.PushOrder(orders);
}
catch (Exception e)
{
//_logger.LogWarning(e);
}
ViewData["InvoiceId"] = new SelectList(_context.Invoices, "Id", "Id", order.InvoiceId);
ViewData["ProductId"] = new SelectList(_context.Products, "id", "Description", order.ProductId);
return(RedirectToAction(nameof(Index)));
}
public OrdersDTO GetOrders(Guid UserID)
{
var Orders = dbContext.Order.Where(o => o.UserID == UserID);
OrdersDTO ordersDTO = new OrdersDTO();
ordersDTO.Orders = _OrderMapper.Map <IEnumerable <Order>, IEnumerable <OrderDTO> >(Orders);
return(ordersDTO);
}
public void Save()
{
_ordersDto = new OrdersDTO();
_ordersDto.OrderId = OrderId;
_ordersDto.OrderDate = DateTime.Now;
_ordersDto.Amount = Amount;
notifyObserver();
}
[HttpGet("myorders")] //this is basically for users, but others also can use it
//used to see the list of all orders for all time
public async Task <IActionResult> GetUserOrders()
{
var userIdClaim = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
if (userIdClaim == null)
{
return(BadRequest(NotFound("Could not find user id")));
}
var myOrders = await _orderRepository.GetAllMyOrders(Guid.Parse(userIdClaim.ToString()));
ICollection <OrdersDTO> OrdersList = new LinkedList <OrdersDTO>();
var orderIds = myOrders.Select(ord => ord.Id).Distinct();//Берем id заказов и итерируемся по нему по записям заказов
foreach (Guid orderId in orderIds)
{
ICollection <MealToMap> mealCart = new LinkedList <MealToMap>(); //так как в заказе может быть от 1 до нескольких
//единиц еды, они помещяються в корзинку еды соответственно id заказа
foreach (var oin in myOrders.Where(ord => ord.Id == orderId))
{
mealCart.Add(
new MealToMap()
{
MealId = oin.MealId,
MealName = oin.Meals.Name,
MealAmount = (decimal)oin.Meals.Amount,
MealPrice = (decimal)oin.Meals.Price * oin.AmountBought * oin.Quantity,
OrderDetailsAmountBought = oin.AmountBought,
OrderDetailsQuantity = oin.Quantity
}
);
}
var total = mealCart.Select(m => m.MealPrice).Sum(); // используя корзинку еды, получаем сумму заказа
OrderDetails sOrd = myOrders.FirstOrDefault(ord => ord.Id == orderId); //получаем конкретный заказ
//а именно, такие поля как Id, User, OrderDate, Status.
OrdersDTO singleOrder = new OrdersDTO()
{
Id = orderId,
User = new UserToMap()
{
Id = sOrd.UserId,
FirstName = sOrd.User.FirstName,
LastName = sOrd.User.LastName
},
MealBucket = mealCart,
OrderDate = sOrd.OrderDate,
TotalPrice = (decimal)total,
Status = sOrd.Status
};
OrdersList.Add(singleOrder);
}
return(myOrders != null ? (IActionResult)Ok(OrdersList) : NoContent());
}
public async Task <IActionResult> PlaceOrder([FromBody] OrderRequest request)
{
var order = await _orderService.PlaceOrder(request);
var orderFromDb = await _orderService.GetOrder(order.Id);
var response = new OrdersDTO(orderFromDb);
return(Ok(response));
}
public ActionResult ViewOrder()
{
OrdersModel ordersModel = new OrdersModel();
OrdersDTO ordersDTO = new OrdersDTO();
Guid userId = new Guid(Session["UserID"].ToString());
ordersDTO = oc.GetOrders(userId);
ordersModel = orderMapper.Map <OrdersDTO, OrdersModel>(ordersDTO);
return(View(ordersModel));
}
public IActionResult CreateOrder
(int customerId,
[FromBody] OrdersForCreationDTO order)
{
if (order == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var customer = Repository.Instance
.Customers.FirstOrDefault(c => c.Id == customerId);
if (customer == null)
{
return(NotFound());
}
var maxOrderId =
Repository.Instance.Customers
.SelectMany(c => c.Orders)
.Max(o => o.OrderId);
var finalOrder = new OrdersDTO()
{
OrderId = maxOrderId++,
CustomerId = order.CustomerId,
EmployeeId = order.EmployeeId,
OrderDate = order.OrderDate,
RequiredDate = order.RequiredDate,
ShippedDate = order.ShippedDate,
ShipVia = order.ShipVia,
Freight = order.Freight,
ShipName = order.ShipName,
ShipAddress = order.ShipAddress,
ShipCity = order.ShipCity,
ShipRegion = order.ShipRegion,
ShipPostalCode = order.ShipPostalCode,
ShipCountry = order.ShipCountry
};
customer.Orders.Add(finalOrder);
return(CreatedAtRoute("GetOrder",
new
{
customerId = customerId,
id = finalOrder.OrderId
}, finalOrder));
}
public ActionResult Update([FromBody] OrdersDTO dto)
{
var _dto = new UpdateOrderDTO()
{
IsReady = dto.IsReady,
Repair = dto.Repair
};
_csService.Update(1, _dto);
return(RedirectToAction("index", "Home"));
}
public async Task <IActionResult> FindOrder([FromQuery] string name)
{
var orderFromDb = await _orderService.GetOrder(name);
if (orderFromDb == null)
{
return(NotFound());
}
var response = new OrdersDTO(orderFromDb);
return(Ok(response));
}
public async Task <IActionResult> FindOrder([FromRoute] int id)
{
var orderFromDb = await _orderService.GetOrder(id);
if (orderFromDb == null)
{
return(NotFound());
}
var response = new OrdersDTO(orderFromDb);
return(Ok(response));
}
public OrdersDTO GetOrdersForAdmin(DateTime date)
{
using (var work = new PechkaContext())
{
var result = new OrdersDTO();
result.Orders = work.Orders.Include(u => u.User).Where(u => u.Menu.Date == date).ToList();
result.Date = date;
result.CountOrdersWithFirst = result.Orders.Count(u => u.WithFirst == true);
result.CountOrdersWithoutFirst = result.Orders.Count(u => u.WithoutFirst == true);
return(result);
}
}
public void PlaceOrder()
{
//uzeti cart listu
List <CartVM> listCart = Session["cart"] as List <CartVM>;
//pronaci username
string username = User.Identity.Name;
//inicijalizovati orderId
int orderID = 0;
using (ShoppingCartDB db = new ShoppingCartDB())
{
//inicijalizovati OrdersDTO
OrdersDTO ordersDTO = new OrdersDTO();
//Pronaci UserId
var query = db.Users.FirstOrDefault(x => x.Username == username);
int userId = query.Id;
//dodati u OrdersDTO i sacuvati
ordersDTO.UserID = userId;
ordersDTO.CreatedAt = DateTime.Now;
db.Orders.Add(ordersDTO);
db.SaveChanges();
//Pronaci ubaceni id
orderID = ordersDTO.OrderID;
//inicijalizovati OrderDetailsDTO
OrderDetailsDTO orderDetailsDTO = new OrderDetailsDTO();
//dodati u OrderDetailsDTO
foreach (var item in listCart)
{
orderDetailsDTO.OrderID = orderID;
orderDetailsDTO.UserID = userId;
orderDetailsDTO.ProductID = item.ProductId;
orderDetailsDTO.Quantity = item.Quantity;
db.OrderDetails.Add(orderDetailsDTO);
db.SaveChanges();
}
}
//poslati email admin-u
var client = new SmtpClient("smtp.mailtrap.io", 2525)
{
Credentials = new NetworkCredential("600ce557b90f2a", "bdc3aca380f02f"),
EnableSsl = true
};
client.Send("*****@*****.**", "*****@*****.**", "New Order", "You have a new order, order number is : " + orderID);
Console.WriteLine("Sent");
//resetovati ssesion
Session["cart"] = null;
}
public OrdersDTO GetOrders(Guid UserID)
{
OrdersDTO newOrdersDTO = orderDataBaseContext.GetOrders(UserID);
if (newOrdersDTO.Orders.ToList().Count == 0)
{
throw new NoOrderException();
}
else
{
return(newOrdersDTO);
}
}
public ActionResult Edit(int id, OrdersDTO order)
{
try
{
// TODO: Add update logic here
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> UpdateOrder([FromBody] OrdersDTO orderDTO)
{
var order = _mapper.Map <Orders>(orderDTO);
var res = await _orderService.UpdateOrder(order);
if (res == null)
{
return(BadRequest(res));
}
var resDto = _mapper.Map <OrdersDTO>(res);
return(Ok(resDto));
}
public async Task <IActionResult> GetAllOrdersKassa()
{
var orders = await _orderRepository.GetAllOrderReceiptToday();//все записи с бд
ICollection <OrdersDTO> OrdersList = new LinkedList <OrdersDTO>();
var orderIds = orders.Select(ord => ord.Id).Distinct();//Берем id заказов и итерируемся по нему по записям заказов
foreach (Guid orderId in orderIds)
{
ICollection <MealToMap> mealCart = new LinkedList <MealToMap>(); //так как в заказе может быть от 1 до нескольких
//единиц еды, они помещяються в корзинку еды соответственно id заказа
foreach (var oin in orders.Where(ord => ord.Id == orderId))
{
mealCart
.Add(
new MealToMap()
{
MealId = oin.MealId,
MealName = oin.Meals.Name,
MealAmount = (decimal)oin.Meals.Amount,
MealPrice = (decimal)oin.Meals.Price * oin.AmountBought * oin.Quantity,
OrderDetailsAmountBought = oin.AmountBought,
OrderDetailsQuantity = oin.Quantity
});
}
var total = mealCart.Select(m => m.MealPrice).Sum(); // используя корзинку еды, получаем сумму заказа
OrderDetails sOrd = orders.FirstOrDefault(ord => ord.Id == orderId); //получаем конкретный заказ
//а именно, такие поля как Id, User, OrderDate, Status.
OrdersDTO singleOrder = new OrdersDTO()
{
Id = orderId,
User = new UserToMap()
{
Id = sOrd.UserId,
FirstName = sOrd.User.FirstName,
LastName = sOrd.User.LastName
},
MealBucket = mealCart,
OrderDate = sOrd.OrderDate,
TotalPrice = (decimal)total,
Status = sOrd.Status
};
OrdersList.Add(singleOrder);
}
return(orders != null ? (IActionResult)Ok(OrdersList) : NoContent());
}
public async Task <IActionResult> AddOrder([FromBody] OrdersDTO orderDTO)
{
var order = _mapper.Map <Orders>(orderDTO);
var res = await _orderService.AddOrder(order);
if (res == null)
{
return(BadRequest(res));
}
var resDto = _mapper.Map <OrdersDTO>(res);
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var loactionUri = baseUrl + "/Ordering/" + res.Id.ToString();
return(Created(loactionUri, resDto));
}
public IActionResult UpdatePutOrder(int codCliente, int codOrden, [FromBody] OrdersDTOUpDate orderForm)
{
if (orderForm != null)
{
// Buscamos el codigo del cliente
CustomerDTO customerDTO = CustomerManager.Instancia.Customers
.FirstOrDefault(cliente => cliente.Id == codCliente);
//Comprobamos que exista el cliente y el form sea correcto
if (customerDTO != null && ModelState.IsValid)
{
//Buscamos la orden con ese numero
OrdersDTO OrderToUpDate = customerDTO.ordenes.FirstOrDefault(orden => orden.OrderId == codOrden);
if (OrderToUpDate != null)
{
//Rellenamos valos del form al objeto
OrderToUpDate.CustomerId = orderForm.CustomerId;
OrderToUpDate.EmpleadoID = orderForm.EmpleadoID;
OrderToUpDate.fechaOrden = orderForm.fechaOrden;
OrderToUpDate.fechaCompra = orderForm.fechaCompra;
OrderToUpDate.fechaEntrega = orderForm.fechaEntrega;
OrderToUpDate.formaCompra = orderForm.formaCompra;
OrderToUpDate.flete = orderForm.flete;
OrderToUpDate.nombreEnvio = orderForm.nombreEnvio;
OrderToUpDate.direcionEnvio = orderForm.direcionEnvio;
OrderToUpDate.ciudadEnvio = orderForm.ciudadEnvio;
OrderToUpDate.codigoPostalEnvio = orderForm.codigoPostalEnvio;
OrderToUpDate.paisEnvio = orderForm.paisEnvio;
return(NoContent());
}
else
{
return(NotFound());
}
}
else
{
return(BadRequest(ModelState));
}
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> GetOrderDetailsById(Guid id)
{
if (id == null)
{
return(NotFound("Order not found!"));
}
var orderById = await _orderRepository.GetOrderById(id);
ICollection <MealToMap> mealCart = new LinkedList <MealToMap>();//так как в заказе может быть от 1 до нескольких
//единиц еды, они помещяються в корзинку еды соответственно id заказа
foreach (OrderDetails o in orderById)
{
mealCart.Add(
new MealToMap()
{
MealId = o.MealId,
MealName = o.Meals.Name,
MealAmount = (decimal)o.Meals.Amount,
MealPrice = (decimal)o.Meals.Price * o.AmountBought * o.Quantity,
OrderDetailsAmountBought = o.AmountBought,
OrderDetailsQuantity = o.Quantity
}
);
}
OrderDetails sOrd = orderById.FirstOrDefault(ord => ord.Id == id); //получаем конкретный заказ
//а именно, такие поля как Id, User, OrderDate, Status.
var total = mealCart.Select(m => m.MealPrice).Sum(); // используя корзинку еды, получаем сумму заказа
OrdersDTO singleOrder = new OrdersDTO()
{
Id = sOrd.Id,
User = new UserToMap()
{
Id = sOrd.UserId,
FirstName = sOrd.User.FirstName,
LastName = sOrd.User.LastName
},
MealBucket = mealCart,
OrderDate = sOrd.OrderDate,
TotalPrice = (decimal)total,
Status = sOrd.Status
};
return(orderById != null ? (IActionResult)Ok(singleOrder) : NotFound($"No records found for this Order {id}"));
}
public void MakeBookBorrowingOrder(DataGridView dataDgv,
TextBox borrowerIdTxt, TextBox LibrarianIdTxt)
{
if (CheckSessionIsvalid())
{
if (!String.IsNullOrEmpty(borrowerIdTxt.Text) && !String.IsNullOrEmpty(LibrarianIdTxt.Text))
{
var a = dataDgv.RowCount;
if (CheckIsNumber(borrowerIdTxt.Text) && CheckIsNumber(LibrarianIdTxt.Text) && dataDgv.RowCount > 1)
{
OrdersDTO ordersDto = new OrdersDTO();
ordersDto.BorrowerID = Convert.ToInt32(borrowerIdTxt.Text);
ordersDto.LibrarianID = Convert.ToInt32(LibrarianIdTxt.Text);
ordersDto.DateBorrowed = DateTime.Now;
ordersDto.ReturnDate = null;
ordersDto.Status = 1;//Dang muon; =2 da tra
List <DetailOrdersDTO> detailOrdersDtoLst = new List <DetailOrdersDTO>();
for (int i = 0; i < dataDgv.RowCount - 1; i++)
{
DetailOrdersDTO d = new DetailOrdersDTO();
d.BookId = Convert.ToInt32(dataDgv.Rows[i].Cells[0].Value.ToString());
d.QuantityBorrowed = Convert.ToInt32(dataDgv.Rows[i].Cells[2].Value.ToString());
detailOrdersDtoLst.Add(d);
}
var temp = OrdersDAO.Instance.InsertNewOrder(detailOrdersDtoLst, ordersDto);
if (temp.isSuccess)
{
MessageBox.Show("Done!");
dataDgv.DataSource = null;
borrowerIdTxt.ResetText();
}
else
{
MessageBox.Show(temp.returnMessage);
}
}
}
}
else
{
MessageBox.Show("Invalid session! Please Logout and Relogin.");
}
}
// FEEDBACK: I'd add an [HttpPost] attribute here to
// make it clearer that this method is for processing POST
// requests from a form.
// FEEDBACK: I'd use the desired data type for your parameter.
// Model binding will handle parsing the form POST string value
// to an integer for you and if it can't do that, it'll set the
// ModelState.IsValid property to "false".
public ActionResult Lookup(string myDesiredCustomerId)
{
OrdersViewModel ordersListViewModel;
// FEEDBACK: This code could be eliminated by relying upon MVC's
// model binding. Instead of switching on the result of the int.TryParse
// method, you could check if ModelState.IsValid is true/false.
int customerId = 0;
bool success = int.TryParse(myDesiredCustomerId, out customerId);
if (success)
{
// FEEDBACK: I'd would have like to have seen the repository
// classes be instance. I'd then instantiate an instance
// in the controller's constructor and use a private field to store
// the object reference. The advantage of doing that
// is that it sets you up to be able to more easily provide a mock
// of your repositories if/when you start writing unit tests.
CustomerDTO customerDTO = CdkAssign01.BAL.CustomersRepository.GetCustomerById(customerId);
// FEEDBACK: If the customer data didn't come back
// then you don't need to make the call to get the customer orders.
OrdersDTO ordersDTO = CdkAssign01.BAL.OrdersRepository.GetOrdersForCustomer(customerId);
ordersListViewModel = ConvertOrdersDTOToOrdersListViewModel(ordersDTO);
AddCustomerDTOToOrdersListViewModel(ordersListViewModel, customerDTO);
if (!ordersListViewModel.Customer.IsValidCustomer)
{
ordersListViewModel.Message = "No customer with that ID";
}
// FEEDBACK: You can use the Count property to get the number of
// items from a List<T> collection. Calling the Count method
// requires the collection to be enumerated.
else if (ordersListViewModel.Orders.Count() == 0)
{
ordersListViewModel.Message = "No orders found";
}
}
else
{
ordersListViewModel = new OrdersViewModel()
{
Message = "Not a valid customer ID"
};
}
return(View("Index", ordersListViewModel));
}
public async Task <OrdersDTO> ProcessOrderAsync(string orderId)
{
IEnumerable <KeyValuePair <string, string> > data = new[] {
new KeyValuePair <string, string>("configKey", "5ae11d19-b3ff-4254-a5e3-1c1da191ca84"),
new KeyValuePair <string, string>("userId", "bb217b61-ce89-40fc-93cb-396fa57d82db"),
new KeyValuePair <string, string>("orderId", orderId),
};
var content = new FormUrlEncodedContent(data);
content.Headers.Clear();
content.Headers.Add("Content-Type", "application/json");
string url = string.Format(ShoppingAppAPI.LiveBaseUri + ShoppingAppAPI.ProcessOrder, orderId);
OrdersDTO currentOrder = await appHttpServicesHandler.PostAsync <OrdersDTO>(new Uri(url), content);
return(currentOrder);
}
