public async Task <IActionResult> GetOrders([FromQuery] OrderFilter filter)
{
IQueryable <Order> orders = _context.Orders;
if (filter.FName != null)
{
orders = orders?.Where(o => o.Customer.FirstName == filter.FName) ?? Enumerable.Empty <Order>().AsQueryable();
}
if (filter.LName != null)
{
orders = orders?.Where(o => o.Customer.LastName == filter.LName) ?? Enumerable.Empty <Order>().AsQueryable();
}
if (filter.Address != null)
{
orders = orders?.Where(o => o.DeliveryAddress.Contains(filter.Address)) ?? Enumerable.Empty <Order>().AsQueryable();
}
if (filter.Page.Size != int.MaxValue)
{
orders = orders?.Skip((filter.Page.Num - 1) * filter.Page.Size)
.Take(filter.Page.Size) ?? Enumerable.Empty <Order>().AsQueryable();
}
List <Order> orderList = await orders.Include(o => o.OrderDetails)
.ToListAsync();
var orderDTOs = Mapper.Map <List <OrderToGetDTO> >(orderList);
return(Ok(orderDTOs));
}
public async Task <IActionResult> GetOrders([FromQuery] int?orderId)
{
const string loggerHeader = "GetOrders -";
_logService.Info($"{loggerHeader} Start");
var result = new ApiJsonResult();
try
{
var userLogin = await _userService.GetCurrentUserLogin(HttpContext);
_logService.Info($"{loggerHeader} with tenantId {userLogin?.TenantId}");
var orderFilter = new OrderFilter
{
TenantId = userLogin.TenantId,
OrderId = orderId
};
result.Data = await _orderService.GetByFilter(orderFilter);
}
catch (Exception ex)
{
_logService.Error($"{loggerHeader} Throw error {ex.Message}");
result.Code = CodeModel.Fail;
result.Message = ex.Message;
}
return(Ok(result));
}
static public List <Order> GetOrders()
{
List <Order> data = new List <Order>();
try
{
OrderFilter filter = new OrderFilter()
{
Status = "closed"
};
int count = OrderService.CountAsync(filter).Result;
int pages = (count / 250) + 1;
for (int page = 1; page <= pages; page++)
{
filter.Limit = 250;
filter.Page = page;
data.AddRange(OrderService.ListAsync(filter).Result);
}
}
catch (Exception)
{
}
return(data);
}
public async Task <IActionResult> GetOrderUser(string userId, [FromQuery] OrderFilter filter)
{
var orderSource = await _context.Orders.Include(o => o.OrderItems).ToListAsync();
// var order = orderSource;
// string access_token = await HttpContext.GetTokenAsync("access_token");
// var user = _token.GetPayloadAsync(access_token);
var order = orderSource.Where(o => o.UserId == userId).ToList();
if (filter.Status != 0)
{
order = order.Where(o => o.Status == filter.Status).ToList();
}
var totalAllPrice = 0;
foreach (var item in order)
{
if (item.Status != 4)
{
totalAllPrice += item.Total;
}
}
return(Ok(new { success = true, filter = filter, data = order, totalAllPrice = totalAllPrice }));
}
public ActionResult OrderSearchPartial(OrderFilter filter, string page, int?Status, string FormSettings, string ListOverride)
{
var options = new OrderSearchTableOptions();
if (FormSettings.IsFilled())
{
options =
(OrderSearchTableOptions)
new JsonSerializable(new OrderSearchTableOptions()).FromString(FormSettings);
}
var osb = new OrderSearchBlock(options.Page.IsNullOrEmpty() ? page : options.Page);
osb.Options = options;
if (Status.HasValue)
{
filter.Status = Status.Value;
}
filter.ListOverride = ListOverride.Split <int>("_").ToList();
filter.Search(DB);
osb.Model = filter;
return(PartialView(osb));
}
public ActionResult OrderSearch(OrderFilter filterModel)
{
_logger.Info("Метод OrderSearch, SaleController, POST");
var orderModel = MapperHelper.Mapper.Map <IEnumerable <OrderDTO>, IEnumerable <HomeOrderViewModel> >(orderService.Get());
var orders = from s in orderModel
select s;
if (filterModel.DateTime != null)
{
orders = orders.Where(x => (x.DateTime.Equals(filterModel.DateTime)));
}
if (filterModel.ClientName != null)
{
orders = orders.Where(x => x.Client.Name.ToLower().Contains(filterModel.ClientName.ToLower()));
}
if (filterModel.ProductName != null)
{
orders = orders.Where(x => x.Product.Name.ToLower().Contains(filterModel.ProductName.ToLower()));
}
if (orders.ToList().Count <= 0)
{
return(HttpNotFound());
}
return(PartialView("List", orders.ToPagedList(1, orders.Count() == 0 ? 1 : orders.Count())));
}
public async Task <IndexViewModel> CreateAsync(HttpContext httpContext, OrderFilter filter, IEnumerable <Order> orders, string orderBy, int skip, int take, int total)
{
IStringLocalizer <IndexViewModelFactory> localizer = httpContext.GetStringLocalizer <IndexViewModelFactory>();
return(new IndexViewModel()
{
Grid = new GridViewModelFactory().Create(
httpContext,
new[] {
new FilterViewModelFactory().Create(httpContext, "OrderState.Id.Equals", localizer["Order state"], await this.GetOrderStateOptionsAsync(httpContext)),
new FilterViewModelFactory().Create(httpContext, "DeliveryMethod.Id.Equals", localizer["Delivery method"], await this.GetDeliveryMethodOptionsAsync(httpContext)),
new FilterViewModelFactory().Create(httpContext, "PaymentMethod.Id.Equals", localizer["Payment method"], await this.GetPaymentMethodOptionsAsync(httpContext)),
new FilterViewModelFactory().Create(httpContext, "Customer.Phone.Contains", localizer["Customer phone"])
},
orderBy, skip, take, total,
new[] {
new GridColumnViewModelFactory().Create(localizer["#"]),
new GridColumnViewModelFactory().Create(localizer["Order state"]),
new GridColumnViewModelFactory().Create(localizer["Delivery method"]),
new GridColumnViewModelFactory().Create(localizer["Payment method"]),
new GridColumnViewModelFactory().Create(localizer["Customer"]),
new GridColumnViewModelFactory().Create(localizer["Total"]),
new GridColumnViewModelFactory().Create(localizer["Created"], "Created"),
new GridColumnViewModelFactory().CreateEmpty()
},
orders.Select(o => new OrderViewModelFactory().Create(o)),
"_Order"
)
});
}
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));
}
public IActionResult Orders([FromQuery] OrderFilter filter)
{
return(Ok(dbContext.Orders
.Include(i => i.OrderDetails)
.ThenInclude(ti => ti.Product)
.ApplyFilter(filter)));
}
public async Task <ActionResult <List <Food_FoodFoodTypeMappingDTO> > > ListRecently([FromBody] Food_FoodFilterDTO Food_FoodFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
var AccountId = CurrentContext.AccountId;
OrderFilter OrderFilter = new OrderFilter
{
Skip = 0,
Take = 10,
AccountId = new IdFilter {
Equal = AccountId
},
StatusId = new IdFilter {
Equal = Enums.OrderStatus.DONE.Id
},
OrderBy = OrderOrder.OrderDate,
OrderType = OrderType.DESC,
Selects = OrderSelect.ALL
};
List <Order> Orders = await OrderService.List(OrderFilter);
List <OrderContent> OrderContents = Orders.SelectMany(o => o.OrderContents).Skip(0).Take(10).ToList();
List <Food_FoodFoodTypeMappingDTO> Food_FoodFoodTypeMappingDTOs = OrderContents
.Select(o => new Food_FoodFoodTypeMappingDTO(o.FoodFoodTypeMapping)).ToList();
return(Food_FoodFoodTypeMappingDTOs);
}
public async Task <int> Count(OrderFilter filter)
{
IQueryable <OrderDAO> Orders = DataContext.Order;
Orders = DynamicFilter(Orders, filter);
return(await Orders.CountAsync());
}
/// <summary>
/// Perform data sorting.
/// </summary>
/// <typeparam name="T">Return type.</typeparam>
/// <param name="filter">.</param>
/// <param name="data">Data for sort.</param>
/// <param name="step">Step number.</param>
/// <returns>Sorted query.</returns>
public static IOrderedQueryable <T> GetOrderedQueryable <T>(this OrderFilter filter, IQueryable <T> data, OrderStep step)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x" + step);
Expression expr = arg;
string[] spl = filter.Field.Split('.');
for (int i = 0; i < spl.Length; i++)
{
PropertyInfo pi = GetDeclaringProperty(type, spl[i]);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(typeof(T), type);
Expression lambda = Expression.Lambda(delegateType, expr, arg);
MethodInfo m = step == OrderStep.First
? filter.Order == OrderFilterType.Asc ? QueryableOrderBy : QueryableOrderByDescending
: filter.Order == OrderFilterType.Asc ? QueryableThenBy : QueryableThenByDescending;
return((IOrderedQueryable <T>)m.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] { data, lambda }));
}
public ActionResult GraphIndex(string type)
{
ViewBag.StatGraph = type;
var filter = new OrderFilter();
return(View(filter));
}
static public async Task <List <Order> > GetOrdersAsync()
{
List <Order> data = new List <Order>();
try
{
OrderFilter filter = new OrderFilter()
{
Status = "closed"
};
int count = await OrderService.CountAsync(filter).ConfigureAwait(false);
int pages = (count / 250) + 1;
for (int page = 1; page <= pages; page++)
{
filter.Limit = 250;
filter.Page = page;
data.AddRange(await OrderService.ListAsync(filter).ConfigureAwait(false));
}
}
catch (Exception e)
{
}
return(data);
}
public OrderFilter ConvertFilterDTOToFilterEntity(OrderMaster_OrderFilterDTO OrderMaster_OrderFilterDTO)
{
OrderFilter OrderFilter = new OrderFilter();
OrderFilter.Selects = OrderSelect.ALL;
OrderFilter.Id = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.Id
};
OrderFilter.CustomerId = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.CustomerId
};
OrderFilter.CreatedDate = new DateTimeFilter {
Equal = OrderMaster_OrderFilterDTO.CreatedDate
};
OrderFilter.VoucherCode = new StringFilter {
StartsWith = OrderMaster_OrderFilterDTO.VoucherCode
};
OrderFilter.Total = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.Total
};
OrderFilter.VoucherDiscount = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.VoucherDiscount
};
OrderFilter.CampaignDiscount = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.CampaignDiscount
};
OrderFilter.StatusId = new LongFilter {
Equal = OrderMaster_OrderFilterDTO.StatusId
};
return(OrderFilter);
}
public async Task <List <Table_OrderDTO> > SingleListOrder([FromBody] Table_OrderFilterDTO Table_OrderFilterDTO)
{
OrderFilter OrderFilter = new OrderFilter();
OrderFilter.Skip = 0;
OrderFilter.Take = 20;
OrderFilter.OrderBy = OrderOrder.Id;
OrderFilter.OrderType = OrderType.ASC;
OrderFilter.Selects = OrderSelect.ALL;
OrderFilter.Id = Table_OrderFilterDTO.Id;
OrderFilter.Code = Table_OrderFilterDTO.Code;
OrderFilter.OrderDate = Table_OrderFilterDTO.OrderDate;
OrderFilter.PayDate = Table_OrderFilterDTO.PayDate;
OrderFilter.AccountId = Table_OrderFilterDTO.AccountId;
OrderFilter.NumOfTable = Table_OrderFilterDTO.NumOfTable;
OrderFilter.NumOfPerson = Table_OrderFilterDTO.NumOfPerson;
OrderFilter.Descreption = Table_OrderFilterDTO.Descreption;
OrderFilter.StatusId = Table_OrderFilterDTO.StatusId;
List <Order> Orders = await OrderService.List(OrderFilter);
List <Table_OrderDTO> Table_OrderDTOs = Orders
.Select(x => new Table_OrderDTO(x)).ToList();
return(Table_OrderDTOs);
}
public ActionResult GetPageList(PageParameter param, OrderFilter filter)
{
filter.LangType = SystemLanguage;
var result = service.GetPayMessage(param, filter);
return(PartialView("_PageList", result));
}
public async Task <IActionResult> Details(long id)
{
var seller = await HttpContext.GetMemberAsync();
var filter = new OrderFilter {
OrderId = id
};
if (!(await _userService.IsInRoleAsync(seller, RoleNames.Admin)))
{
filter.SellerId = seller.Id;
}
var order = await _orderService.GetAsync(filter);
if (order == null)
{
return(NotFound());
}
var model = new OrderModel();
if (HttpMethods.IsGet(Request.Method))
{
ModelState.Clear();
await _appService.PrepareModelAsync(model, order);
}
return(PartialView("Partials/_SharedOrderDetails", model));
}
public void Orders()
{
PropertyBag["Orders"] = new OrderFilter {
NotSent = true
}.Find();
PropertyBag["IsMonitoring"] = true;
}
private static void GetOrderListTest(MarketplaceAPIService serviceClient, HeaderMessage headerMessage)
{
OrderFilter orderFilter = new OrderFilter();
orderFilter.BeginCreationDate = DateTime.Parse("2011-12-01T00:00:00.00");
orderFilter.BeginModificationDate = DateTime.Parse("2012-01-02T01:00:00.00");
orderFilter.EndCreationDate = DateTime.Parse("2012-12-01T23:59:59.99");
orderFilter.EndModificationDate = DateTime.Parse("2012-01-02T02:00:00.00");
orderFilter.FetchOrderLines = true;
orderFilter.States = new OrderStateEnum[]
{
OrderStateEnum.CancelledByCustomer,
OrderStateEnum.WaitingForSellerAcceptation,
OrderStateEnum.AcceptedBySeller,
OrderStateEnum.PaymentInProgress,
OrderStateEnum.WaitingForShipmentAcceptation,
OrderStateEnum.Shipped,
OrderStateEnum.RefusedBySeller,
OrderStateEnum.AutomaticCancellation,
OrderStateEnum.PaymentRefused,
OrderStateEnum.ShipmentRefusedBySeller,
OrderStateEnum.RefusedNoShipment
};
var getOrderListResponse = serviceClient.GetOrderList(headerMessage, orderFilter);
}
protected void OrderDs_Selecting(object sender, System.Web.UI.WebControls.ObjectDataSourceSelectingEventArgs e)
{
// ADD IN THE SEARCH CRITERIA
OrderFilter filter = GetOrderFilter();
e.InputParameters["filter"] = filter;
}
protected OrderFilter GetOrderFilter()
{
// CREATE CRITERIA INSTANCE
OrderFilter criteria = new OrderFilter();
if (OrderStartDate.SelectedStartDate > DateTime.MinValue)
{
criteria.OrderDateStart = OrderStartDate.SelectedStartDate;
}
if (OrderEndDate.SelectedEndDate > DateTime.MinValue && OrderEndDate.SelectedEndDate < DateTime.MaxValue)
{
criteria.OrderDateEnd = OrderEndDate.SelectedEndDate;
}
criteria.OrderNumberRange = OrderNumberFilter.Text;
criteria.PaymentStatus = (OrderPaymentStatus)AlwaysConvert.ToByte(PaymentStatusFilter.SelectedValue);
criteria.ShipmentStatus = (OrderShipmentStatus)AlwaysConvert.ToByte(ShipmentStatusFilter.SelectedValue);
// ADD IN ORDER STATUS FILTER
int statusId = 0;
if (StatusFilter.SelectedValue == "-2")
{
IList <OrderStatus> statuses = OrderStatusDataSource.LoadAll();
foreach (OrderStatus status in statuses)
{
if (status.IsValid)
{
criteria.OrderStatus.Add(status.Id);
}
}
}
else if (StatusFilter.SelectedValue == "-3")
{
IList <OrderStatus> statuses = OrderStatusDataSource.LoadAll();
foreach (OrderStatus status in statuses)
{
if (!status.IsValid)
{
criteria.OrderStatus.Add(status.Id);
}
}
}
else
{
statusId = AlwaysConvert.ToInt(StatusFilter.SelectedValue);
if (statusId > 0)
{
criteria.OrderStatus.Add(statusId);
}
}
// ADD IN KEYWORD FILTER
criteria.Keyword = KeywordSearchText.Text;
criteria.KeywordField = (KeywordFieldType)Enum.Parse(typeof(KeywordFieldType), KeywordSearchField.SelectedValue, true);
// RETURN THE CRITERIA OBJECT
Session["OrderFilter"] = criteria;
Session["OrderFilterSelectedStatus"] = StatusFilter.SelectedValue;
return(criteria);
}
public FilteredList <Order> GetOrdersOfACustomer(OrderFilter filter, int id)
{
if (id == 0)
{
throw new InvalidDataException("Cannot get order by ID without user ID!");
}
return(_repo.ReadAll(filter));
}
public IQueryable <Order> GetFilteredOrdersFromFilter(OrderFilter Filter, Guid guid)
{
Filter.SelectedUsersStr = Filter.getSelectedUsersJoinStr();
Filter.SelectedObjectsStr = Filter.getSelectedObjectsJoinStr();
Logger.info("Получение списка заказов (GetFilteredOrdersFromXML)", Logger.LoggerSource.service);
LastUpdate.saveUpdate(guid);
return(context.getOrders(Filter));
}
public async Task <IActionResult> GetAsync([FromQuery] OrderFilter filter)
{
var orders = await _orderService.ListAsync(filter);
var ordersResponse = _mapper.Map <IEnumerable <OrderResponse> >(orders);
return(Result(ordersResponse));
}
//訂單過濾
public ActionResult OrderListFilter(OrderFilter filter)
{
MemberService service = new MemberService();
filter.list = service.GetOrderHeader(Int32.Parse(Request.Cookies["upid"].Value));
List <OrderHeaderView> newlist = service.OrderHeaderFilter(filter);
return(Json(newlist, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Get([FromQuery] OrderFilter filter, [FromQuery] EntityOrder order, [FromQuery] PagingParams pagination)
{
var list = await orderRepository.Browse()
.AplyFilter(filter)
.AplyOrder(order)
.ToEntityPaginated(pagination);
return(Ok(list));
}
public Task <List <Order> > Find(OrderFilter filter)
{
return(this.context.Orders.Where(order => !filter.Status.HasValue || order.Status == filter.Status)
.OrderByDescending(x => x.Timestamp)
.Skip(filter.Omit)
.Take(filter.Select)
.AsNoTracking()
.ToListAsync());
}
public ActionResult ApplyFilter(OrderFilter model)
{
if (!ModelState.IsValid)
{
return(PartialView("Sales", null));
}
Session["orderFilter"] = model;
return(RedirectToAction("Sales"));
}
private bool Filter(OrderFilter filter, IPurchaseOrder order)
{
var result = true;
if (result && !string.IsNullOrEmpty(filter.OrderGroupId))
{
result = order.OrderLink.OrderGroupId.ToString().Contains(filter.OrderGroupId);
}
if (result && !string.IsNullOrEmpty(filter.PurchaseOrderNumber))
{
result = order.OrderNumber.Contains(filter.PurchaseOrderNumber);
}
if (result && filter.DateFrom.HasValue)
{
result = order.Created.Date >= filter.DateFrom.Value.Date;
}
if (result && filter.DateTo.HasValue)
{
result = order.Created.Date <= filter.DateTo.Value.Date;
}
if (result && !(filter.OrderStatusId == 0))
{
result = order.OrderStatus.Id == filter.OrderStatusId;
}
if (result && filter.PriceFrom > 0)
{
result = order.GetTotal() >= filter.PriceFrom;
}
if (result && filter.PriceTo > 0)
{
result = order.GetTotal() <= filter.PriceTo;
}
if (result && !string.IsNullOrEmpty(filter.AddressId))
{
result = order.GetFirstForm().Shipments.Where(x => x.ShippingAddress.Id == filter.AddressId).Count() > 0;
}
if (result && !string.IsNullOrEmpty(filter.PaymentMethodId))
{
result = order.GetFirstForm().Payments.Where(x => x.PaymentMethodId.ToString() == filter.PaymentMethodId).Count() > 0;
}
if (result && !string.IsNullOrEmpty(filter.Keyword))
{
result = order.GetAllLineItems().Where(x => x.DisplayName.Contains(filter.Keyword) || x.Code.Contains(filter.Keyword)).Count() > 0;
}
return(result);
}
public void Show(OrderFilter filter)
{
SetupViews(filter);
FindViewById<Button>(Resource.Id.apply).Click += delegate
{
Dismiss();
OnApply(filter);
};
base.Show();
}
private void SetupViews(OrderFilter filter)
{
//SetTitle("Filter Orders");
SetContentView(Resource.Layout.order_filter_dialog);
var orderStatuses = FindViewById<ViewGroup>(Resource.Id.order_statuses);
filter.ProcessingStatuses.ForEach(s =>
{
var checkBox = (CheckBox)LayoutInflater.From(Context).Inflate(Resource.Layout.order_filter_dialog_checkbox, null);
checkBox.CheckedChange += delegate { s.Selected = checkBox.Checked; };
checkBox.Text = s.DisplayName;
checkBox.Checked = s.Selected;
orderStatuses.AddView(checkBox);
});
var startDate = FindViewById<TextView>(Resource.Id.start_date);
startDate.PaintFlags = startDate.PaintFlags | PaintFlags.UnderlineText;
startDate.Text = filter.StartDate.ToString("yyyy-MM-dd");
startDate.Click += delegate
{
new DatePickerDialog(Context,
delegate(object sender, DatePickerDialog.DateSetEventArgs e)
{
filter.StartDate = e.Date;
startDate.Text = filter.StartDate.ToString("yyyy-MM-dd");
},
filter.StartDate.Year,
filter.StartDate.Month - 1,
filter.StartDate.Day)
.Show();
};
var endDate = FindViewById<TextView>(Resource.Id.end_date);
endDate.PaintFlags = endDate.PaintFlags | PaintFlags.UnderlineText;
endDate.Text = filter.EndDate.ToString("yyyy-MM-dd");
endDate.Click += delegate
{
new DatePickerDialog(Context,
delegate(object sender, DatePickerDialog.DateSetEventArgs e)
{
filter.EndDate = e.Date;
endDate.Text = filter.EndDate.ToString("yyyy-MM-dd");
},
filter.EndDate.Year,
filter.EndDate.Month - 1,
filter.EndDate.Day)
.Show();
};
}
public static string OrdersWithStatusWithinDateRange(OrderFilter filter)
{
var joined = string.Join(",", filter.SelectedProcessingStatuses.Select(s => (int) s));
return OrdersWithStatusWithinDateRange(joined, filter.StartDate, filter.EndDate);
}
public AqlQuery GetOrderSelectionQuery(OrderFilter filter)
{
if (WAFShopHelper.SiteHasShop(WAFContext.Request.SiteId)) {
if (WAFShopHelper.GetCurrentShopId() > 0) {
AqlQuery query = WAFContext.Session.CreateQuery();
AqlAliasShop aliasShop = new AqlAliasShop();
AqlAliasOrder aliasOrder = new AqlAliasOrder();
AqlAliasOrderItem aliasOrderItem = new AqlAliasOrderItem();
AqlAliasProductBase aliasProductBase = new AqlAliasProductBase();
AqlAliasCountry aliaCountry = new AqlAliasCountry();
AqlAliasRelShopOrders relShopOrder = new AqlAliasRelShopOrders(aliasShop, aliasOrder);
AqlAliasRelOrderItems relOrderItems = new AqlAliasRelOrderItems(relShopOrder, aliasOrderItem, aliasOrder);
AqlAliasRelProductOrdeItems relProductOrderItems = new AqlAliasRelProductOrdeItems(aliasProductBase, relOrderItems, aliasOrderItem);
AqlAliasRelOrderShippingCountry relOrderShippingCountry = new AqlAliasRelOrderShippingCountry(relShopOrder, aliaCountry, aliasOrder);
switch (filter) {
case OrderFilter.NoFilter:
query.From(relShopOrder);
break;
case OrderFilter.OrderStatus:
query.From(relShopOrder);
query.Where(aliasOrder.OrderStatus == Utils.GetIntegerOnly(ddlOrderStatusFilter.SelectedValue));
break;
case OrderFilter.NumItemsOrdered:
//int rangeType = Utils.GetIntegerOnly(ddlNumItemsCriteria.SelectedValue);
//query.From(relProductOrderItems);
//AqlResultInteger orderItemsCount = query.Select(Aql.Count(aliasOrder.NodeId));
//query.GroupBy(aliasOrder.NodeId);
//query.GroupBy(aliasOrder.LCID);
//query.GroupBy(aliasOrder.Revision);
//query.GroupBy(aliasOrder.ContentClassId);
//switch ((RangeCriteria)rangeType) {
// case RangeCriteria.Above:
// int aboveNumber = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel1.Text);
// query.Having(Aql.Count(aliasOrder.NodeId) >= aboveNumber);
// break;
// case RangeCriteria.Below:
// int belowNum = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel1.Text);
// query.Having(Aql.Count(aliasOrder.NodeId) <= belowNum);
// break;
// case RangeCriteria.Between:
// int level1Num = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel1.Text);
// int level2Num = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel2.Text);
// query.Having(Aql.Count(aliasOrder.NodeId) > level1Num & Aql.Count(aliasOrder.NodeId) < level2Num);
// break;
// case RangeCriteria.EqualTo:
// int orderedNumber = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel1.Text);
// query.Having(Aql.Count(aliasOrder.NodeId) == orderedNumber);
// break;
// default:
// break;
//}
break;
case OrderFilter.OrderTotal:
int rangeOrderTotalType = Utils.GetIntegerOnly(ddlOrderTotalCriteria.SelectedValue);
switch ((RangeCriteria)rangeOrderTotalType) {
case RangeCriteria.Above:
int aboveNumber = Utils.GetIntegerOnly(txtOrderTotalFilterLevel1.Text);
query.Where(aliasOrder.OrderTotal >= aboveNumber);
break;
case RangeCriteria.Below:
int belowNum = Utils.GetIntegerOnly(txtOrderTotalFilterLevel1.Text);
query.Where(aliasOrder.OrderTotal <= belowNum);
break;
case RangeCriteria.Between:
int level1Num = Utils.GetIntegerOnly(txtOrderTotalFilterLevel1.Text);
int level2Num = Utils.GetIntegerOnly(txtOrderTotalFilterLevel2.Text);
query.Where(aliasOrder.OrderTotal > level1Num & aliasOrder.OrderTotal < level2Num);
break;
case RangeCriteria.EqualTo:
int orderedNumber = Utils.GetIntegerOnly(txtOrderTotalFilterLevel1.Text);
query.Where(aliasOrder.OrderTotal == orderedNumber);
break;
default:
break;
}
query.From(relShopOrder);
break;
case OrderFilter.Country:
int countryId = Utils.GetIntegerOnly(ddlCountryFilter.SelectedValue);
query.Where(aliaCountry.NodeId == countryId);
query.From(relOrderShippingCountry);
break;
case OrderFilter.Search:
int searchTypeId = Utils.GetIntegerOnly(ddlSearchType.SelectedValue);
if (searchTypeId == 0) { //order id
query.Where(aliasOrder.NodeId == Utils.GetIntegerOnly(txtSearch.Text));
} else if (searchTypeId == 1) { //surname
query.Where(Aql.Like(aliasOrder.ShippingSurname, "%" + txtSearch.Text + "%"));
} else if (searchTypeId == 2) { //forename
query.Where(Aql.Like(aliasOrder.ShippingForename, "%" + txtSearch.Text + "%"));
} else if (searchTypeId == 4) {
query.Where(Aql.Like(aliasOrder.BillingCompany, "%" + txtSearch.Text + "%"));
} else { //regular index search
var nodeIds = from o in WAFContext.Session.Search<Order>("%" + txtSearch.Text + "%", null, true) select o.NodeId;
query.Where(Aql.In(aliasOrder.NodeId, nodeIds.ToList<int>()));
}
query.From(relShopOrder);
break;
case OrderFilter.DateOrdered:
int numDateCriteriaFilter = Utils.GetIntegerOnly(ddlDateCriteria.SelectedValue);
DateTime dt1 = new DateTime();
DateTime dt2 = new DateTime();
switch ((DateCriteria)numDateCriteriaFilter) {
case DateCriteria.Before:
//int aboveNumber = Utils.GetIntegerOnly(txtNumItemsOrderedFilterLevel1.Text);
if (DateTime.TryParse(datePicker1.Text, out dt1)) {
query.Where(aliasOrder.DateOrdered <= (DateTime)dt1);
}
break;
case DateCriteria.After:
if (DateTime.TryParse(datePicker1.Text, out dt1)) {
query.Where(aliasOrder.DateOrdered >= (DateTime)dt1);
}
break;
case DateCriteria.Between:
if (DateTime.TryParse(datePicker1.Text, out dt1)) {
if (DateTime.TryParse(datePicker2.Text, out dt2)) {
if (dt1 != null && dt2 != null) {
query.Where(aliasOrder.DateOrdered >= (DateTime)dt1);
query.Where(aliasOrder.DateOrdered <= (DateTime)dt2);
} else if (dt1 == null && dt2 != null) {
query.Where(aliasOrder.DateOrdered <= (DateTime)dt2);
} else if (dt1 != null && dt2 == null) {
query.Where(aliasOrder.DateOrdered >= (DateTime)dt1);
}
}
}
break;
default:
break;
}
query.From(relShopOrder);
break;
default:
break;
}
if (filter != OrderFilter.OrderStatus) {
if (!chkIncludeCartStatus.Checked) {
query.Where(aliasOrder.OrderStatus != (int)OrderStatus.Basket);
}
}
query.Distinct();
//query.Select<Order>();
query.Select(aliasOrder);
query.Select(aliasOrder.NodeId);
query.Select(aliasOrder.BillingForename);
query.Select(aliasOrder.BillingSurname);
query.Select(aliasOrder.OrderTotal);
query.Select(aliasOrder.ItemsSubtotalExVat);
//query.Select(aliasOrder.C);
query.Select(aliasOrder.VATAmount);
query.Select(aliasOrder.ShippingAmount);
query.Select(aliasOrder.CreateDate);
query.Select(aliasOrder.ChangeDate);
query.Select(aliasOrder.DateOrdered);
query.Where(AqlShop.NodeId == WAFShopHelper.GetCurrentShopId());
query.OrderBy(aliasOrder.DateOrdered, true);
query.OrderBy(aliasOrder.ChangeDate, true);
return query;
//contentListOrders.Query = query;
//contentListOrders.DataBind();
} else {
AqlQuery q = WAFContext.Session.CreateQuery();
AqlAliasOrder aliasOrder = new AqlAliasOrder();
q.Select(aliasOrder);
q.From(aliasOrder);
q.Where(aliasOrder.SiteId == WAFContext.Request.SiteId);
q.Where(aliasOrder.Name == "e4r5345345 25er grf d");
return q;
}
} else {
AqlQuery q = WAFContext.Session.CreateQuery();
AqlAliasOrder aliasOrder = new AqlAliasOrder();
q.Select(aliasOrder);
q.From(aliasOrder);
q.Where(aliasOrder.SiteId == WAFContext.Request.SiteId);
q.Where(aliasOrder.Name == "e4r5345345 25er grf d");
return q;
//contentListOrders.Query = q;
//contentListOrders.DataBind();
}
}
private void ShowFilterPanel(OrderFilter filter)
{
switch (filter) {
case OrderFilter.NoFilter:
ShowPanels(false, false, false, false, false, false);
break;
case OrderFilter.OrderStatus:
ShowPanels(true, false, false, false, false, false);
break;
case OrderFilter.NumItemsOrdered:
ShowPanels(false, true, false, false, false, false);
break;
case OrderFilter.OrderTotal:
ShowPanels(false, false, true, false, false, false);
break;
case OrderFilter.Country:
ShowPanels(false, false, false, false, true, false);
break;
case OrderFilter.Search:
ShowPanels(false, false, false, true, false, false);
break;
case OrderFilter.DateOrdered:
ShowPanels(false, false, false, false, false, true);
break;
default:
ShowPanels(false, false, false, false, false, false);
break;
}
}
