public async Task <IActionResult> OrderHistoryAdmin(int productPage = 1)
{
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
List <OrderHeader> OrderHeaderList = await _db.OrderHeader.Include(o => o.Customer).ToListAsync();
foreach (OrderHeader item in OrderHeaderList)
{
OrderDetailsViewModel individual = new OrderDetailsViewModel
{
OrderHeader = item,
OrderDetails = await _db.OrderDetails.Where(o => o.OrderId == item.Id).ToListAsync()
};
orderListVM.Orders.Add(individual);
}
var count = orderListVM.Orders.Count;
orderListVM.Orders = orderListVM.Orders.OrderByDescending(p => p.OrderHeader.Id)
.Skip((productPage - 1) * PageAdminSize)
.Take(PageAdminSize).ToList();
orderListVM.PagingInfo = new PagingInfo
{
CurrentPage = productPage,
ItemsPerPage = PageAdminSize,
TotalItem = count,
urlParam = "/Admin/Order/OrderHistoryAdmin?productPage=:"
};
return(View(orderListVM));
}
public IActionResult Index()
{
report.GenerateReport(context.Employees);
var model = new OrderListViewModel();
model.Orders = new List <OrderListViewModel.Order>();
//STUPID??? - well it works fine..
foreach (var v in context.Orders.Include(d => d.Customer))
{
model.Orders.Add(new OrderListViewModel.Order
{
Id = v.OrderId,
CustomerName = v.Customer.CompanyName,
OrderDate = v.OrderDate
});
}
//Lets check SQL Profiler
//model.Orders = context.Orders.Include(d => d.Customer)
// .Select(v => new OrderListViewModel.Order
// {
// Id = v.OrderId,
// CustomerName = v.Customer.CompanyName,
// OrderDate = v.OrderDate
// }).ToList();
return(View(model));
}
public IActionResult GetOrders()
{
var orders = _orderService.GetOrders(_userManager.GetUserId(User));
var orderListModel = new List <OrderListViewModel>();
OrderListViewModel orderModel;
foreach (var order in orders)
{
orderModel = new OrderListViewModel();
orderModel.Id = order.Id;
orderModel.OrderNumber = order.OrderNumber;
orderModel.OrderDate = order.OrderDate;
orderModel.OrderNote = order.OrderNote;
orderModel.Phone = order.Phone;
orderModel.FirstName = order.FirstName;
orderModel.LastName = order.LastName;
orderModel.Email = order.Email;
orderModel.Address = order.Address;
orderModel.City = order.City;
orderModel.OrderItems = order.OrderItems.Select(x => new OrderItemModel()
{
OrderItemId = x.Id,
Name = x.Product.Name,
ImageUrl = x.Product.ImageUrl,
Price = x.Price,
Quantity = x.Quantity
}).ToList();
orderListModel.Add(orderModel);
}
return(View(orderListModel));
}
public Orders(Customer customer)
{
InitializeComponent();
AddToolbarItem.Icon = Device.RuntimePlatform == Device.UWP ? "Assets/add_new.png" : "add_new.png";
MessageStackLayout.IsVisible = false;
RefreshStackLayout.IsVisible = true;
MainSearchBar.IsVisible = true;
_vm = new OrderListViewModel(null, customer);
BindingContext = _vm;
if (Device.RuntimePlatform == Device.Android)
{
OrderList.IsPullToRefreshEnabled = true;
OrderList.RefreshCommand = _vm.RefreshCommand;
OrderList.SetBinding(ListView.IsRefreshingProperty, nameof(_vm.IsRefreshing));
}
else if (Device.RuntimePlatform == Device.UWP)
{
OrderList.RowHeight = OrderList.RowHeight * 2;
}
OrderList.ItemSelected += (sender, e) => {
Navigation.PushAsync(new OrderPage(((ListView)sender).SelectedItem as Order));
};
}
public IActionResult Index()
{
List <Order> order;
List <OrderListViewModel> oList = new List <OrderListViewModel>();
try
{
order = _context.Orders
.OrderBy(o => o.OrderId)
.ToList();
foreach (Order o in order)
{
OrderListViewModel ord = o.CopyTo <OrderListViewModel>();
//get user information
User user = GetUserById(o.UserId);
ord.Name = user.Name;
ord.Email = user.Email;
oList.Add(ord);
}
return(View(oList));
}
catch (Exception ex)
{
return(View("Error", new ErrorViewModel {
Exception = ex
}));
}
}
public IActionResult Statistics()
{
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
List <OrderHeader> OrderHeaderList = _db.orderHeader.ToList();
foreach (OrderHeader item in OrderHeaderList)
{
OrderDetailsViewModel individual = new OrderDetailsViewModel
{
OrderHeader = item,
OrderDetail = _db.orderDetails.ToList()
};
orderListVM.Orders.Add(individual);
}
var count = orderListVM.Orders.Count;
return(View(orderListVM));
}
public ActionResult List()
{
//var allowOrderDownloadUserIDs = new int[] { 1,4,6,10,11,12,14,16,17,22};
//if (!allowOrderDownloadUserIDs.Contains(_workContext.CurrentUser.ID))
//{
// ErrorNotification("You do not have permission to process this page.");
// return Redirect("~/"); ;
//}
if (!_permissionService.Authorize(ThirdStorePermission.OrderList.ToName()))
{
ErrorNotification("You do not have permission to process this page.");
return(Redirect("~/"));
}
var model = new OrderListViewModel();
model.OrderStatuses = ThirdStoreOrderStatus.AllGood.ToSelectList(false).ToList();
model.OrderStatuses.Insert(0, new SelectListItem {
Text = "All", Value = "0", Selected = true
});
//var canEditOrder = new int[] { 1, 4,6, 10,11,12, 14, 16, 17,22 };
//model.CanEditOrder = canEditOrder.Contains(_workContext.CurrentUser.ID);
model.CanEditOrder = _permissionService.Authorize(ThirdStorePermission.OrderEdit.ToName());
return(View(model));
}
public async Task <IActionResult> Index(string sortTime, int orderPage = 1)
{
DateTime dateSort = sortTime switch
{
"all" => dateSort = DateTime.MaxValue,
"today" => dateSort = DateTime.Today,
"toweek" => dateSort = DateTime.Today.AddDays(7),
_ => dateSort = DateTime.MaxValue
};
AppUser userOnline = await CurrentUser;
myId = userOnline.Id;
OrderListViewModel orderListViewModel = new OrderListViewModel
{
Orders = repository.Orders
.Where(o => o.RespUserId == myId)
.Where(p => p.EndDate <= dateSort)
.OrderBy(s => s.CreationDate)
.Skip((orderPage - 1) * PageSize)
.Take(PageSize),
PagingInfo = new PagingInfo
{
CurrentPage = orderPage,
ItemsPerPage = PageSize,
CurrentTime = sortTime,
TotalItems = repository.Orders.Where(o => o.RespUserId == myId).Where(p => p.EndDate <= dateSort).Count()
}
};
return(View(orderListViewModel));
}
public ShellViewModel()
{
entityService = new EntityService();
entityService.Customerentities = new MyDataEntities();
this.productListViewModel = new ProductListViewModel(entityService.Products, entityService);
this.customerListViewModel = new CustomerListViewModel(entityService.Customers, entityService);
this.orderListViewModel = new OrderListViewModel(entityService,
entityService.Orders,
entityService.Stores,
entityService.ReportMemos);
//CustomerListのイベントをOrderListが購読
this.CustomerListViewModel.OnResceiveCustomerAdded += this.OrderListViewModel.AddResceiveCustomer;
this.CustomerListViewModel.OnSendCustomerAdded += this.OrderListViewModel.AddSendCustomer;
//OrderListのイベントをCustomerListが購読
this.OrderListViewModel.OnEditCustomerButtonClick += this.CustomerListViewModel.SetSelectedCustomer;
this.OrderListViewModel.OnEditCustomerButtonClick += this.ChangeToCustomerList;
this.orderListViewModel.OnAddNewCustomerButtonClick += this.CustomerListViewModel.AddNewCustomer;
this.OrderListViewModel.OnAddNewCustomerButtonClick += this.ChangeToCustomerList;
this.OrderListViewModel.OnSendCustomerChanged += this.CustomerListViewModel.ChangeCanAddSendCustomer;
//初期描画時に既にOrderがある場合は、送付者を追加できない。
this.CustomerListViewModel.ChangeCanAddSendCustomer(this.OrderListViewModel,
new CustomerListEventArgs() { CustomerViewModel = this.OrderListViewModel.SendCustomerViewModel });
}
public async Task <IActionResult> OrderHistory(int productPage = 1)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
List <OrderHeader> OrderHeaderList = await _db.OrderHeader.Include(o => o.Utilisateur).Where(u => u.UserId == claim.Value).ToListAsync();
foreach (OrderHeader item in OrderHeaderList)
{
OrderDetailsViewModel individual = new OrderDetailsViewModel
{
OrderHeader = item,
OrderDetails = await _db.OrderDetails.Where(o => o.OrderId == item.Id).ToListAsync()
};
orderListVM.Orders.Add(individual);
}
var count = orderListVM.Orders.Count;
// orderListVM.Orders = orderListVM.Orders.OrderByDescending(p => p.OrderHeader.Id)
//.Skip((productPage - 1) * PageSize)
// .Take(PageSize).ToList();
return(View(orderListVM));
}
public ActionResult ReleaseList(string StartDate = "", string EndDate = "", string ProductName = "")
{
if (StartDate != "")
{
startDate = Convert.ToDateTime(StartDate);
}
if (EndDate != "")
{
endDate = Convert.ToDateTime(EndDate);
}
OrderListDAC dac = new OrderListDAC();
if (StartDate != "" || EndDate != "")
{
SortedList = (from sorted in dac.AllReleaseList()
where sorted.Product_Name.Contains(ProductName) && Convert.ToDateTime(sorted.Release_Date).AddDays(-1) >= startDate &&
Convert.ToDateTime(sorted.Release_Date) <= endDate
select sorted).ToList();
}
else
{
SortedList = (from sorted in dac.AllReleaseList()
where sorted.Product_Name.Contains(ProductName)
select sorted).ToList();
}
OrderListViewModel Model = new OrderListViewModel();
Model.OrderLists = SortedList;
return(View(Model));
}
public OrderListView(OrderListViewModel viewModel)
{
InitializeComponent();
// Set the ViewModel as this View's data context.
this.DataContext = viewModel;
}
public async Task <IActionResult> OrderHistory(int productPage = 1)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
List <OrderHeader> orderHeaderList = await _db.OrderHeader.Include(o => o.ApplicationUser).Where(u => u.UserID == claim.Value).ToListAsync();
foreach (OrderHeader item in orderHeaderList)
{
OrderDetailsViewModel indivisual = new OrderDetailsViewModel
{
OrderHeader = item,
OrderDetails = await _db.OrderDetail.Where(o => o.OrderId == item.Id).ToListAsync()
};
orderListVM.Orders.Add(indivisual);
}
var count = orderListVM.Orders.Count;
orderListVM.Orders = orderListVM.Orders.OrderByDescending(p => p.OrderHeader.Id).Skip((productPage - 1) * PageSize).Take(PageSize).ToList();
orderListVM.PagingInfo = new PagingInfo
{
CurrentPage = productPage,
ItemPerPage = PageSize,
TotalItem = count,
urlParam = "/Customer/Order/OrderHistory?productPage=:"
};
return(View(orderListVM));
}
private void DG_Hyperlink_Click(object sender, RoutedEventArgs e)
{
Hyperlink link = (Hyperlink)e.OriginalSource;
OrderListViewModel model = link.DataContext as OrderListViewModel;
NavigationService.Navigate(new OrderDetailPage(model));
}
public async Task <IActionResult> List(int page = 1)
{
var filter = new OrderFilter
{
Omit = (page - 1) * PageSize,
Select = PageSize,
Status = null
};
var orders = await this.ordersRepository.Find(filter).ConfigureAwait(false);
var order = orders.Select(x => new OrderListItemViewModel
{
Id = x.Id,
Status = x.Status,
Email = x.Email,
Timestamp = x.Timestamp
}).ToList();
var model = new OrderListViewModel {
Orders = order
};
ViewBag.Page = page;
return(View(model));
}
// GET: Order
public ActionResult Index(string Message)
{
DBZipShipEntities db = new DBZipShipEntities();
var orders = db.Orders.ToList();
List <OrderListViewModel> list = new List <OrderListViewModel>();
foreach (var i in orders)
{
if (i.Status != "Selected")
{
OrderListViewModel o = new OrderListViewModel();
o.Id = i.Id;
o.Name = i.Name;
o.Quantity = i.Quantity;
o.Price = Convert.ToDouble(i.Price);
o.DealPrice = Convert.ToDouble(i.DealPrice);
var forname = db.AspNetUsers.Where(x => x.Id == i.AddedBy).First();
o.AddedByName = forname.Name;
o.AddedBy = i.AddedBy;
o.ImagePath = i.ImagePath;
o.Country = i.Country;
o.Brand = i.Brand;
if (o.AddedBy != User.Identity.GetUserId())
{
list.Add(o);
}
}
}
ViewBag.Message = Message;
return(View(list));
}
private void FormOrderList_Load(object sender, EventArgs e)
{
if (id.HasValue)
{
try
{
OrderListViewModel view = service.GetElement(id.Value);
if (view != null)
{
textBoxName.Text = view.OrderListName;
textBoxPrice.Text = view.Sum.ToString();
orderlistProducts = view.OrderListProducts;
LoadData();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ошибка", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
else
{
orderlistProducts = new List <OrderListProductViewModel>();
}
}
public async Task <IActionResult> OrderHistory(int productPage = 1)
{
var getUser = await _unitOfWork.User.GetCurrentUser();
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
List <Order> orderHeader = await _unitOfWork.OrderServices.GetOrderListByUserId(getUser.Id);
foreach (Order item in orderHeader)
{
OrderDetailsViewModel individual = new OrderDetailsViewModel
{
Order = item,
OrderDetails = await _unitOfWork.OrderDetailServices.GetDetailByOrderId(item.Id)
};
orderListVM.Orders.Add(individual);
}
var count = orderListVM.Orders.Count;
orderListVM.Orders = orderListVM.Orders.OrderByDescending(p => p.Order.Id).Skip((productPage - 1) * PageSize).Take(PageSize).ToList();
orderListVM.PagingInfo = new PagingInfo
{
CurrentPage = productPage,
ItemsPerPage = PageSize,
TotalItem = count,
UrlParam = "/Order/OrderHistory?productPage=:"
};
return(View(orderListVM));
}
public ActionResult List(DataSourceRequest command, OrderListViewModel model)
{
var orders = _orderService.SearchOrders(
orderTimeFrom: model.OrderTimeFrom,
orderTimeTo: model.OrderTimeTo,
channelOrderID: model.SearchChannelOrderID,
jobItemID: model.SearchJobItemID,
customerID: model.SearchCustomerID,
consigneeName: model.SearchConsigneeName,
sku: model.SearchSKU,
statusID: model.SearchStatusID,
pageIndex: command.Page - 1,
pageSize: command.PageSize);
var orderGridViewList = orders.Select(i => {
var viewModel = i.ToModel();
if (i.OrderLines.Count > 0)
{
viewModel.OrderTransactions = i.OrderLines.Select(l => l.Ref2.ToString()).Aggregate((current, next) => current + ";" + next);
viewModel.SKUs = i.OrderLines.Select(l => l.SKU + ":" + l.Qty + (!string.IsNullOrWhiteSpace(l.Ref5)?"(" + l.Ref5 + ")":string.Empty)).Aggregate((current, next) => current + ";" + next);
}
return(viewModel);
});
var gridModel = new DataSourceResult()
{
Data = orderGridViewList, Total = orders.TotalCount
};
//return View();
return(new JsonResult
{
Data = gridModel
});
}
public IActionResult List(BaseListViewModel model)
{
if (model == null || string.IsNullOrEmpty(model.SearchData))
{
return(List());
}
else
{
List <Order> orders = new List <Order>();
int orderId = 0;
Order order = null;
if (int.TryParse(model.SearchData, out orderId))
{
order = _orderRepository.GetOrder(orderId);
}
else
{
order = _orderRepository.GetOrder(model.SearchData);
}
if (order != null)
{
orders.Add(order);
}
OrderListViewModel orderModel = new OrderListViewModel(orders, 1, _pageSize, orders.Count());
return(View(orderModel));
}
}
public async Task <IActionResult> OrderPickup(int productPage = 1, string search = null)
{
//var ClaimIdenttity = (ClaimsIdentity)User.Identity;
//var Claim = ClaimIdenttity.FindFirst(ClaimTypes.NameIdentifier);
StringBuilder param = new StringBuilder();
param.Append("/Customer/Order/OrderPickup?productPage=:");
param.Append("&search=");
if (search != null)
{
param.Append(search);
}
OrderListViewModel orderListVM = new OrderListViewModel()
{
Orders = new List <OrderDetailsViewModel>()
};
var orderList = new List <OrderHeader>();
if (!string.IsNullOrEmpty(search))
{
search = search.ToLower();
orderList = await _db.OrderHeader.Include(o => o.ApplicationUser).Where(o => o.Status == StaticDetails.StatusReady &&
(o.PickUpName.ToLower().Contains(search) ||
o.ApplicationUser.PhoneNumber.ToLower().Contains(search) ||
o.ApplicationUser.Email.ToLower().Contains(search) ||
o.PhoneNumber.ToLower().Contains(search))).OrderByDescending(o => o.OrderDate).ToListAsync();
}
else
{
orderList = await _db.OrderHeader.Include(o => o.ApplicationUser).Where(o => o.Status == StaticDetails.StatusReady).OrderByDescending(o => o.OrderDate).ToListAsync();
}
foreach (var order in orderList)
{
var orderDetailVM = new OrderDetailsViewModel()
{
OrderHeader = order,
OrderDetails = await _db.OrderDetails.Where(o => o.OrderId == order.Id).ToListAsync()
};
orderListVM.Orders.Add(orderDetailVM);
}
var count = orderListVM.Orders.Count();
orderListVM.Orders = orderListVM.Orders.OrderByDescending(p => p.OrderHeader.Id)
.Skip((productPage - 1) * PageSize)
.Take(PageSize).ToList();
orderListVM.PagingInfo = new PagingInfo
{
CurrentPage = productPage,
ItemPerPage = PageSize,
TotalItem = count,
UrlParam = param.ToString()
};
return(View(orderListVM));
}
public IActionResult Get()
{
var orders = _orderRepository.FindAll();
var model = new OrderListViewModel();
_mapper.Map(orders, model.Orders);
return(Ok(model));
}
public IActionResult Index()
{
var model = new OrderListViewModel();
model.Orders = _orderData.GetAllActive();
return(View(model));
}
public async Task <IActionResult> IndexOrders(int pageNum = 1)
{
var orders = (await _orderService.GetOrdersAsync(pageNum)).ToList();
var orderListViewModel = new OrderListViewModel(pageNum, PageSizes.Orders, orders.Count(), orders);
return(View(orderListViewModel));
}
public OrderView(OrderServiceLayer orderServiceLayer, string patientId, OrderServiceService orderServiceService, PhysicianService physicianService)
{
InitializeComponent();
_orderServiceLayer = orderServiceLayer;
var orderListViewModel = new OrderListViewModel(_orderServiceLayer, patientId);
DataContext = orderListViewModel;
}
// GET: Order
public async Task <ActionResult> Index()
{
var model = new OrderListViewModel();
var user = await _userManager.FindByIdAsync(User.Identity.GetUserId());
model.GridData.Templates = JsonTemplateConverter.ConvertFromDB(user.Templates, model.GridData.Caption);
return(View(model));
}
public IActionResult List(int customerId = 0, int currentPage = 1)
{
var orders = PaginateList(_orderRepository.GetCustomerOrders(customerId), currentPage);
OrderListViewModel model = new OrderListViewModel(orders, currentPage, _pageSize, _orderRepository.Orders.Count());
return(View(model));
}
public async Task <ActionResult> Customer(int id)
{
var vm = new OrderListViewModel();
var orders = await _orderService.GetCustomerOrders(id);
vm.Orders = orders.Select(o => new OrderItemViewModel(orders, o));
return(View("Index", vm));
}
/// <summary>
/// Indexes this instance.
/// </summary>
/// <param name="parametersSearch">The parameters search.</param>
/// <param name="pageSizeString">The page size string.</param>
/// <param name="page">The page.</param>
/// <returns></returns>
public async Task <IActionResult> Index(string parametersSearch, string pageSizeString, int page)
{
int pageSize = 20;
page = page > 0 ? page : 1;
if (!string.IsNullOrEmpty(pageSizeString))
{
pageSize = int.Parse(pageSizeString);
}
OrderRequest request = new OrderRequest()
{
Page = new PagingRequest()
{
PageIndex = page - 1, PageSize = pageSize
}
};
try
{
OrderListViewModel model = null;
if (!string.IsNullOrEmpty(parametersSearch))
{
request = JsonConvert.DeserializeObject <OrderRequest>(parametersSearch);
}
request.Page = new PagingRequest()
{
PageIndex = page - 1, PageSize = pageSize
};
var result = await this.PostAsync <BaseModel <Order> >(HttpUriFactory.GetOrdersRequest(this.options.Value.APIUrl), request);
if (result != null)
{
int pageCount = (result.TotalCount + pageSize - 1) / pageSize;
var nextPage = page == pageCount ? page : (page + 1);
var previousPage = page > 1 ? (page - 1) : page;
model = this.CreateDefaultVM <OrderListViewModel, OrderRequest>(request, parametersSearch, page, pageSize, nextPage, previousPage, pageCount, "Order", "Index");
model.Templates = result.Models;
}
else
{
model = this.CreateDefaultVM <OrderListViewModel, OrderRequest>(request, parametersSearch, page, pageSize, 1, 1, 1, "Order", "Index");
}
if (TempData["Message"] != null)
{
ViewBag.Message = TempData["Message"];
}
return(View(model));
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
Utilities.LogAppError(this.logger, ex);
return(View(this.CreateDefaultVM <OrderListViewModel, OrderRequest>(request, parametersSearch, page, pageSize, 1, 1, 1, "Order", "Index")));
}
}
public async Task <ActionResult> jqGridTempl(OrderListViewModel vm, JqGridModel model)
{
var result = false;
string jsonPostData;
using (var stream = Request.InputStream)
{
stream.Position = 0;
using (var reader = new System.IO.StreamReader(stream))
{
jsonPostData = reader.ReadToEnd();
}
}
var user = await _userManager.FindByIdAsync(User.Identity.GetUserId());
if (model.Action.Equals("apply"))
{
user.Templates += JsonTemplateConverter.ConvertToDB(jsonPostData, vm.GridData.Caption);
var resultIdent = await _userManager.UpdateAsync(user);
result = resultIdent.Succeeded;
}
else if (model.Action.Equals("remove"))
{
user.Templates = JsonTemplateConverter.RemoveTempl(user.Templates, model.TemplName, vm.GridData.Caption);
var resultIdent = await _userManager.UpdateAsync(user);
result = resultIdent.Succeeded;
}
//TODO
else if (model.Action.Equals("jqGridTempl"))
{
//var jqGrid = JsonConvert.DeserializeObject<JqGridModel>(jsonPostData, new JqGridConverter());
//int totalRecords;
//var data = GetData(jqGrid.GridSettings, out totalRecords, true);
//var arr = ConvertDataToExcel.ConvertDataToArray(data, jqGrid.ColStates);
//var colStates = ConvertDataToExcel.ConvertColStateToColumnModels(jqGrid.ColStates);
//return View("MyView");
//using (var stream = new FileStream("Orders.xlsx", FileMode.Create))
//{
// ExportToExcel.FillSpreadsheetDocument(stream, colStates.ToArray(), arr.ToArray(), "Orders");
// //return new FileStreamResult(stream, writer.MimeType);
//}
result = true;
}
return(Json(new { success = result }));
}
public async Task <ActionResult> Index()
{
var vm = new OrderListViewModel();
var orders = await _orderService.GetOrdersWithCustomers();
vm.Orders = orders.Where(o => o.Status != "cancelled")
.Select(o => new OrderItemViewModel(orders, o));
return(View(vm));
}
/// <summary>
/// Initializes a new instance of the <see cref="OrdersTabItemViewModel"/> class.
/// </summary>
/// <param name="modalDialogProvider">The modal dialog service.</param>
/// <param name="serviceFactory">The service factory.</param>
public OrdersTabItemViewModel(IMainViewModel mainViewModel, IModalDialogProvider modalDialogProvider, IServiceFactory serviceFactory)
: base(mainViewModel, modalDialogProvider, serviceFactory)
{
OrderDetailsViewModel = new OrderDetailsViewModel(MainViewModel, ModalDialogProvider, ServiceFactory);
OrderListViewModel = new OrderListViewModel(MainViewModel, OrderDetailsViewModel, ModalDialogProvider, ServiceFactory);
OrderDetailsViewModel.DeliveryNoteDetailsViewModel.ItemSaved += new System.EventHandler(DeliveryNoteDetailsViewModel_ItemSaved);
OrderDetailsViewModel.DeliveryNoteDetailsViewModel.IsReadOnlyChanged += new System.EventHandler(DeliveryNoteDetailsViewModel_IsReadOnlyChanged);
OrderDetailsViewModel.DeliveryNoteListViewModel.ItemDeactivatedFlagChanged += new System.EventHandler(DeliveryNoteListViewModel_ItemDeactivatedFlagChanged);
}
