public ActionResult Index(NewOrderModel model)
{
if (ModelState.IsValid)
{
Order order = new Order()
{
UserEmail = User.Identity.Name,
Detail = new OrderDetail()
{
Pieces = model.Pieces, ProductId = 1
}
};
Result resultApi = new Result();
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(baseUrl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage res = client.PostAsJsonAsync("api/Sales/NewOrder/", order).Result;
if (res.IsSuccessStatusCode)
{
var response = res.Content.ReadAsStringAsync().Result;
resultApi = JsonConvert.DeserializeObject <Result>(response);
if (resultApi.Status == ResultStatus.Ok)
{
resultApi = JsonConvert.DeserializeObject <Result>(resultApi.ObjectResult.ToString());
}
}
}
}
return(View(model));
}
public void ShowNewOrder()
{
var view = new NewOrder(this);
var model = new NewOrderModel(session);
var presenter = new NewOrderPresenter(model, view);
ShowControl(view);
}
public void MakeNewOrder(NewOrderModel order)
{
_commundBus.SendCommand(new AddOrderCommand()
{
TableLogin = order.TableLogin,
MenuItemsQuantities = order.OrderingMenuItems,
});
}
public IActionResult New()
{
NewOrderModel model = new NewOrderModel();
model.Customers = new List <SelectListItem>(this._customers.Items.ToSelectList(c => c.Name, c => c.Id, null));
model.Products = new List <SelectListItem>(this._products.Items.ToSelectList(p => p.Name, p => p.Id, null));
return(this.View(model));
}
public async Task Create(NewOrderModel order)
{
try
{
await _orders.InsertOneAsync(order);
}
catch { }
}
public NewOrderPresenter(NewOrderModel model, INewOrder view)
{
this.model = model;
this.view = view;
view.SelectDrivers += PresenterSelectDrivers;
view.LoadDriver += PresenteLoadDriver;
view.SelectProducts += PresenterSelectProducts;
view.CreateProduct += PresenterCertainProduct;
view.CreateOrder += PresenterCreateOrder;
}
public async Task <IActionResult> New(NewOrderModel model)
{
Customer customer = await this._customers.GetByIdAsync(model.CustomerId);
Product product = await this._products.GetByIdAsync(model.ProductId);
Order order = await this._orders.AddAsync(customer, model.Description, DateTime.Now);
this._orders.AddLine(order, product, model.Amount);
return(this.RedirectToAction("List"));
}
public NewOrder Map(NewOrderModel obj)
{
return(new NewOrder
{
OrderId = obj.OrderId,
ProductionIds = obj.ProductionIds,
Products = obj.Products,
StoreName = obj.StoreName,
Total = obj.Total
});
}
public int AddOrderAndDetails(NewOrderModel data)
{
int orderId = 0;
try
{
orderId = objData.AddOrderAndDetails(data);
}
catch (Exception ex)
{
throw ex;
}
return(orderId);
}
public IActionResult Put(NewOrderModel model)
{
if (!dataContext.Clients.Any(x => x.Number == model.ClientNumber))
{
return(BadRequest("Invalid client id"));
}
var order = new Order {
ClientNumber = model.ClientNumber, Description = model.Description
};
dataContext.Add(order);
dataContext.SaveChanges();
return(Ok(order.Number));
}
public async Task <IActionResult> CreateOrder(
[FromBody] NewOrderModel newOrder)
{
var createOrderCommand = new NewOrderCommand(
newOrder.SelectedProductIds,
Guid.NewGuid());
await this.orderOpsService.CreateOrder(
new NewAnonymousOrderCommand(
newOrder.PhoneNumber,
newOrder.SelectedProductIds));
return(this.StatusCode((int)HttpStatusCode.Created));
}
public ActionResult AddNewOrder(NewOrderModel model)
{
Customer customer;
int id = (int)Session["EmployeeId"];
using (NorthwindConnection db = new NorthwindConnection())
{
customer = db.Customers.SingleOrDefault(x => x.CustomerID == model.Order.CustomerID);
db.AddOrderTemporary(customer.CustomerID, id, model.Order.OrderDate, model.Order.RequiredDate,
model.Order.ShippedDate, model.Order.ShipVia, customer.CompanyName);
db.SaveChanges();
}
return(RedirectToAction("Index", "Home"));
}
// view for creating new orders
public ActionResult NewOrder()
{
// need to eventually query our business layers to retrieve information to pre-populates parts of the form
// create bll viewer objects used for populating data
int StoreID = 1; // Santa Cruz Store
StaffViewer staffViewer = new StaffViewer();
ProductViewer productViewer = new ProductViewer();
CustomerViewer customerViewer = new CustomerViewer();
StoreViewer storeViewer = new StoreViewer();
NewOrderModel model = new NewOrderModel()
{
Staff = staffViewer.GetAllEmployesByStore(StoreID),
Products = productViewer.GetRandom10(),
Customers = customerViewer.GetRandom10(),
Store = storeViewer.GetStore(StoreID)
};
return(View(model));
}
public bool SubmitNewOrder(NewOrderModel data)
{
Boolean result = false;
try
{
int orderId = 0;
orderId = objBusiness.AddOrderAndDetails(data);
if (orderId > 0)
{
result = true;
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public void DeleteCheckedTests_TestReturnedStringWithoutInputCode()
{
var tubestList = new BindingList <TubeForGrid>();
var tube1 = new TubeForGrid()
{
Tests = "qwe, asd, zxc"
};
tubestList.Add(tube1);
var tube2 = new TubeForGrid()
{
Tests = "asd, qwe, zxc"
};
tubestList.Add(tube2);
var tube3 = new TubeForGrid()
{
Tests = "asd, zxc, qwe"
};
tubestList.Add(tube3);
var tube4 = new TubeForGrid()
{
Tests = "qwe"
};
tubestList.Add(tube4);
var updatedTubesList = new NewOrderModel().DeleteCheckedTests(tubestList, "qwe");
string updatedTestsString = "asd, zxc";
Assert.AreEqual(updatedTubesList[0].Tests, updatedTestsString);
Assert.AreEqual(updatedTubesList[1].Tests, updatedTestsString);
Assert.AreEqual(updatedTubesList[2].Tests, updatedTestsString);
Assert.IsEmpty(updatedTubesList[3].Tests);
}
//new
public int AddOrderAndDetails(NewOrderModel data)
{
bool result = false;
int orderId;
OrdersModel objOrder = new OrdersModel();
try
{
objOrder.OrderID = data.OrderID;
objOrder.CustomerID = data.CustomerID;
objOrder.TotalQty = data.TotalQty;
objOrder.TotalAmount = data.TotalAmount;
orderId = AddNewOrder(objOrder);
if (orderId > 0)
{
DataTable dtOrders = new DataTable();
dtOrders = GetOrderDetailsTable(data.lstOrderDetails, orderId);
if (dtOrders != null && dtOrders.Rows.Count == data.lstOrderDetails.Count)
{
result = AddAllOrderDetails(dtOrders, orderId);
}
//for (int i = 0; i < data.lstOrderDetails.Count; i++)
//{
// data.lstOrderDetails[i].OrderID = orderId;
// result = AddOrderDetails(data.lstOrderDetails[i]);
//}
}
}
catch (Exception ex)
{
throw ex;
}
return(orderId);
}
public ActionResult AddNewOrder()
{
int employeeId = (int)Session["EmployeeId"];
List <Customer> customers;
List <Customer> customersForEmployee = new List <Customer>();
List <Shipper> shippers;
using (NorthwindConnection db = new NorthwindConnection())
{
shippers = db.Shippers.ToList();
customers = db.Customers.ToList();
var orders = db.Orders.Where(x => x.EmployeeID == employeeId).ToList().GroupBy(x => x.CustomerID);
foreach (IGrouping <string, Order> grouping in orders)
{
Customer customer = db.Customers.SingleOrDefault(x => x.CustomerID == grouping.Key);
customersForEmployee.Add(customer);
}
}
NewOrderModel model = new NewOrderModel();
model.CustomerNames = customers.Select(x => new SelectListItem()
{
Value = x.CustomerID,
Text = x.CompanyName
});
model.CustomerNamesForEmployee = customersForEmployee.Select(x => new SelectListItem()
{
Value = x.CustomerID,
Text = x.CompanyName
});
model.Shippers = shippers.Select(x => new SelectListItem()
{
Value = x.ShipperID.ToString(),
Text = x.CompanyName
});
return(View(model));
}
public async Task <Order> OrderNewItemAsync(NewOrderModel model)
{
try
{
var patient = await _userService.GetCurrentUserAsync <Patient>(UserTypes.Patient) as Patient;
if (patient == null)
{
throw new Exception("user is not a patient.");
}
var script = await _context.Scripts.Include(x => x.ScriptDetails).FirstOrDefaultAsync(x => x.Id.Equals(model.Script));
if (script == null)
{
throw new Exception("script not found.");
}
var order = await _context.Orders.FirstOrDefaultAsync(x => x.ScriptId.Equals(script.Id));
if (order == null)
{ // order is new
#region submit new order
order = new Order()
{
PatientId = patient.Id,
ScriptId = script.Id,
Status = OrderStatuses.Preorder,
};
await _context.Orders.AddAsync(order);
await _context.SaveChangesAsync();
#endregion
}
var products = await _context.Products.Include(x => x.Medicine).Where(x => model.Products.Contains(x.Id)).ToListAsync();
if (!products.Any())
{
throw new Exception("There is not product for these medicines");
}
var scriptDetails = await _context.ScriptDetails.Where(x => x.ScriptId.Equals(script.Id)).ToListAsync();
List <OrderDetail> orderDetails = new List <OrderDetail>();
#region submit order details
foreach (var item in products)
{
if (item.Quantity <= 0)
{
continue;
}
var prdMedId = item.MedicineId;
var scriptDetailId = scriptDetails.FirstOrDefault(x => x.MedicineId.Equals(prdMedId));
if (scriptDetailId == null)
{
continue;
}
orderDetails.Add(new OrderDetail()
{
OrderId = order.Id,
ScriptDetailId = scriptDetailId.Id,
ProductId = item.Id,
});
//decrease the product quantity
item.Quantity = item.Quantity - 1;
}
await _context.OrderDetails.AddRangeAsync(orderDetails);
await _context.SaveChangesAsync();
#endregion
return(order);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult CreateOrder(NewOrderModel model)
{
//thực hiện tạo order dựa tên orderdetail
if (Request.IsAuthenticated)
{
using (var dbContextTransaction = db.Database.BeginTransaction())
{
try
{
var rate = db.Rates.FirstOrDefault();
var user = db.UserProfiles.First(a => a.Email == User.Identity.Name);
var order = new Order
{
CreateDate = DateTime.Now,
TotalPrice = model.ListOrderDetail.Sum(a => (a.Quantity ?? 0) * (a.Price ?? 0)),
Status = OrderStatus.New.ToString(),
Rate = rate != null ? rate.Price : 0,
Phone = user.Phone,
UserName = user.Email
};
var saleManage = db.SaleManageClients.FirstOrDefault(a => a.User_Client == user.Email);
order.TotalPriceConvert = order.TotalPrice * order.Rate;
if (saleManage != null)
{
order.SaleManager = saleManage.User_Sale;
}
db.Entry(order).State = EntityState.Added;
db.Orders.Add(order);
db.SaveChanges();
int orderId = order.OrderId;
foreach (var orderDetail in model.ListOrderDetail)
{
orderDetail.OrderId = orderId;
orderDetail.Phone = user.Phone;
db.Entry(orderDetail).State = EntityState.Added;
db.OrderDetails.Add(orderDetail);
db.SaveChanges();
}
dbContextTransaction.Commit();
ViewData["message"] = "Tạo đơn hàng thành công.";
return(RedirectToAction("Manage", "Account"));
}
catch (Exception)
{
dbContextTransaction.Rollback();
}
}
}
else
{
using (var dbContextTransaction = db.Database.BeginTransaction())
{
try
{
var rate = db.Rates.FirstOrDefault();
var order = new Order
{
CreateDate = DateTime.Now,
TotalPrice = model.ListOrderDetail.Sum(a => a.Price ?? 0),
Status = OrderStatus.New.ToString(),
Rate = rate != null ? rate.Price : 0,
Phone = model.ListOrderDetail.First().Phone
};
db.Entry(order).State = EntityState.Added;
db.Orders.Add(order);
db.SaveChanges();
int orderId = order.OrderId;
foreach (var orderDetail in model.ListOrderDetail)
{
orderDetail.OrderId = orderId;
db.Entry(orderDetail).State = EntityState.Added;
db.OrderDetails.Add(orderDetail);
db.SaveChanges();
}
dbContextTransaction.Commit();
ViewData["message"] = "Tạo đơn hàng thành công, chờ nhân viên kinh doanh liên hệ với bạn.";
return(View());
}
catch (Exception)
{
dbContextTransaction.Rollback();
}
}
}
return(View());
}
public IActionResult AddOrder([FromBody] NewOrderModel model)
{
try {
if (model == null)
{
return(BadRequest("Body content is not valid!"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!(model.StartDate.ToLocalTime() > DateTime.Now.AddDays(-1)) ||
!(model.EndDate > model.StartDate)
)
{
return(BadRequest("Inavalid dates range!"));
}
var requestHeaders = HttpContext.Request.Headers;
int userId = 0;
if (requestHeaders.TryGetValue("Authorization", out StringValues token))
{
userId = JwtService.GetUserIdFromToken(JwtService.DecodeToken(token.ToString()));
if (userId < 1)
{
return(Unauthorized());
}
}
else
{
return(Unauthorized());
}
var entity = model.Map <OrderEntity>();
entity.StartDate = entity.StartDate.ToLocalTime();
entity.EndDate = entity.EndDate.ToLocalTime();
entity.UserId = userId;
var vehicle = _vehicleLogic.GetVehicleById(entity.VehicleId);
if (vehicle == null || vehicle.CarClass == null)
{
return(BadRequest());
}
var userRole = JwtService.GetRoleFromToken(JwtService.DecodeToken(token.ToString()));
if (userRole == Roles.user.GetEnumDescription() &&
(vehicle.IsActive == null ||
!(bool)vehicle.IsActive ||
!vehicle.IsAvailable ||
!vehicle.IsProper)
)
{
return(BadRequest());
}
entity.Price = (decimal)((entity.EndDate - entity.StartDate).TotalDays * vehicle.CarClass.DailyPrice);
entity.Price = decimal.Round(entity.Price, 2);
entity = _orderLogic.AddOrder(entity);
if (entity == null)
{
throw new Exception("Somthing went wrong while adding model to DB!");
}
if (entity.User != null)
{
entity.User.Password = "";
}
return(Ok(entity));
} catch (Exception e) {
return(StatusCode(500, e));
}
}
public void NewOrder(NewOrderModel order) => this.Execute(model: order);
public async Task PlaceNewOrder(NewOrderModel model)
{
var result = await _apiClient.Post("/v3/orders", null, model);
Console.WriteLine(result);
}
public OrdersViewModel()
{
_businessLogic = new BusinessLogic();
var ordersbl = _businessLogic.GetOrdersBL();
NewOrder = new NewOrderModel();
List <ItemsFilters> items = new List <ItemsFilters>();
items.Add(new ItemsFilters()
{
Name = "Всі", Category = "A"
});
items.Add(new ItemsFilters()
{
Name = "Оплачені", Category = "B"
});
items.Add(new ItemsFilters()
{
Name = "Не оплачені", Category = "B"
});
items.Add(new ItemsFilters()
{
Name = "Відправлені", Category = "C"
});
items.Add(new ItemsFilters()
{
Name = "Не відправлені", Category = "C"
});
items.Add(new ItemsFilters()
{
Name = "Оплачені, не відправлені", Category = "C"
});
items.Add(new ItemsFilters()
{
Name = "Трек номер не вказаний", Category = "C"
});
items.Add(new ItemsFilters()
{
Name = "Продано на eBay", Category = "D"
});
items.Add(new ItemsFilters()
{
Name = "Продано на Allegro", Category = "D"
});
items.Add(new ItemsFilters()
{
Name = "Продано іншим чином", Category = "D"
});
ICollectionView groupedFilters = new ListCollectionView(items);
groupedFilters.GroupDescriptions.Add(new PropertyGroupDescription("Category"));
OrdersFiltersSource = groupedFilters;
ICollectionView collection = new ListCollectionView(ordersbl);
//collection.GroupDescriptions.Add(new PropertyGroupDescription("NickName1"));
Orders = collection;
SelectedItemFilter = items[0];
collection.Filter = OrderFilter;
}
public ActionResult Importexcel()
{
NewOrderModel objNewOrder = new NewOrderModel();
int custId = 0;
int orderId = 0;
try
{
custId = Convert.ToInt32(TempData["CustomerId"]);
orderId = Convert.ToInt32(TempData["orderId"]);
objNewOrder.OrderID = orderId;
if (custId > 0)
{
objNewOrder.CustomerID = custId;
DataTable dt = new DataTable();
if (Request.Files["FileUpload1"].ContentLength > 0)
{
string extension = System.IO.Path.GetExtension(Request.Files["FileUpload1"].FileName).ToLower();
string query = null;
string connString = "";
string[] validFileTypes = { ".xls", ".xlsx", ".csv" };
string path1 = string.Format("{0}/{1}", Server.MapPath("~/Content/Uploads"), Request.Files["FileUpload1"].FileName);
if (!Directory.Exists(path1))
{
Directory.CreateDirectory(Server.MapPath("~/Content/Uploads"));
}
if (validFileTypes.Contains(extension))
{
if (System.IO.File.Exists(path1))
{
System.IO.File.Delete(path1);
}
Request.Files["FileUpload1"].SaveAs(path1);
//Connection String to Excel Workbook
if (extension.Trim() == ".xls")
{
connString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + path1 + ";Extended Properties=\"Excel 8.0;HDR=Yes;IMEX=2\"";
dt = ConvertXSLXtoDataTable(path1, connString);
ViewBag.Data = dt;
}
else if (extension.Trim() == ".xlsx")
{
connString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + path1 + ";Extended Properties=\"Excel 12.0;HDR=Yes;IMEX=2\"";
dt = ConvertXSLXtoDataTable(path1, connString);
ViewBag.Data = dt;
}
else if (extension == ".csv")
{
dt = ConvertCSVtoDataTable(path1);
ViewBag.Data = dt;
}
if (dt != null && dt.Rows.Count > 1)
{
List <OrderDetailsModel> lstOrderDetails = new List <OrderDetailsModel>();
for (int i = 0; i < dt.Rows.Count; i++)
{
OrderDetailsModel objOrderDetails = new OrderDetailsModel();
objOrderDetails.ProductCode = Convert.ToString(dt.Rows[i][0]);
objOrderDetails.Qty = Convert.ToInt32(dt.Rows[i][1]);
ProductModel objProduct = new ProductModel();
objProduct = objBusiness.GetProductByCode(objOrderDetails.ProductCode);
if (objProduct != null)
{
objOrderDetails.Amount = objProduct.Rate * objOrderDetails.Qty;
objNewOrder.TotalAmount = objNewOrder.TotalAmount + objOrderDetails.Amount;
objNewOrder.TotalQty = objNewOrder.TotalQty + objOrderDetails.Qty;
lstOrderDetails.Add(objOrderDetails);
}
}
objNewOrder.lstOrderDetails = lstOrderDetails;
if (objNewOrder.lstOrderDetails != null)
{
orderId = objBusiness.AddOrderAndDetails(objNewOrder);
if (orderId > 0)
{
ViewBag.Result = "Success: Excel Uploaded Successfully!";
// Source file to be renamed
string sourceFile = path1;
// Create a FileInfo
System.IO.FileInfo fi = new System.IO.FileInfo(sourceFile);
// Check if file is there
if (fi.Exists)
{
string fileName = "OrderID_" + orderId + System.IO.Path.GetExtension(Request.Files["FileUpload1"].FileName).ToLower();
string newFilePath = Server.MapPath("~/Content/Uploads/") + fileName;
if (System.IO.File.Exists(newFilePath))
{
System.IO.File.Delete(newFilePath);
}
fi.MoveTo(Server.MapPath("~/Content/Uploads/") + fileName);
}
}
else
{
ViewBag.Error = "Failure: Something went wrong while uploading.";
}
}
}
}
else
{
ViewBag.Error = "Please Upload Files in .xls, .xlsx or .csv format";
}
}
}
else
{
ViewBag.Error = "Something went wrong";
}
}
catch (Exception ex)
{
throw ex;
}
return(View());
}
