public void OrderFilter_ByLanguage()
{
var languageFirst = mockLanguages.Where(l => l.Name == "English").Single();
var languageSecond = mockLanguages.Where(l => l.Name == "German").Single();
var filterFirst = new OrderFilterModel
{
LanguageId = languageFirst.LanguageId,
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
LanguageId = languageSecond.LanguageId,
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
var actualFirst = mockOrderListRows.Where(o => o.LanguageId == languageFirst.LanguageId);
var actualSecond = mockOrderListRows.Where(o => o.LanguageId == languageSecond.LanguageId);
listFirst.Should().HaveCount(actualFirst.Count());
listFirst.Should().Contain(actualFirst);
listSecond.Should().HaveCount(actualSecond.Count());
listSecond.Should().Contain(actualSecond);
}
public OrderResponseModel GetUserOrders(UserModel user, int page = Constants.DEFAULTPAGE)
{
var filter = new OrderFilterModel
{
UserId = user.Id
};
var dbOrders = _orderRepository.Get(filter, page: page).ToList();
var orders = new List <OrderModel>();
var orderIds = dbOrders.Select(order => order.Id).ToList();
var itemsFilter = new OrderItemFilterModel {
OrderIds = orderIds
};
var allItems = _itemRepository.Get(itemsFilter);
foreach (var order in dbOrders)
{
var mappedOrder = _mapper.Map <OrderModel>(order);
var currentItems = allItems.Where(item => item.OrderId == order.Id).ToList();
mappedOrder.CurrentItems = _mapper.Map <List <OrderItemModel> >(currentItems);
mappedOrder.Total = currentItems.Sum(item => item.SubTotal);
orders.Add(mappedOrder);
}
return(new OrderResponseModel
{
Orders = orders,
PageCount = GetPageCount(user.Id)
});
}
public void OrderFilter_ByBroker()
{
var brokerFirst = 1;
var brokerSecond = 2;
var filterFirst = new OrderFilterModel
{
BrokerId = brokerFirst,
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
BrokerId = brokerSecond,
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
var actualFirst = mockOrderListRows.Where(o => o.BrokerId == brokerFirst);
var actualSecond = mockOrderListRows.Where(o => o.BrokerId == brokerSecond);
listFirst.Should().HaveCount(actualFirst.Count());
listFirst.Should().Contain(actualFirst);
listSecond.Should().HaveCount(actualSecond.Count());
listSecond.Should().Contain(actualSecond);
}
public void OrderFilter_ComboByRegionLanguage()
{
var languageFirst = mockLanguages.Where(l => l.Name == "Chinese").Single();
var languageSecond = mockLanguages.Where(l => l.Name == "German").Single();
var regionFirst = Region.Regions.Where(r => r.Name == "Västra Götaland").Single();
var regionSecond = Region.Regions.Where(r => r.Name == "Stockholm").Single();
var filterFirst = new OrderFilterModel
{
LanguageId = languageFirst.LanguageId,
RegionId = regionFirst.RegionId,
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
LanguageId = languageSecond.LanguageId,
RegionId = regionSecond.RegionId,
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
var actualFirst = mockOrderListRows.Where(o => o.LanguageId == languageFirst.LanguageId &&
o.RegionId == regionFirst.RegionId);
var actualSecond = mockOrderListRows.Where(o => o.LanguageId == languageSecond.LanguageId &&
o.RegionId == regionSecond.RegionId);
listFirst.Should().HaveCount(actualFirst.Count());
listFirst.Should().Contain(actualFirst);
listSecond.Should().HaveCount(actualSecond.Count());
listSecond.Should().Contain(actualSecond);
}
public List <OrderModel> GetAllOrders(bool isPaid = true, bool isUnpaid = true, string field = null, string ascending = Constants.DEFAULTSORTORDER, int page = Constants.DEFAULTPAGE, bool getRemoved = false)
{
var filter = new OrderFilterModel
{
IsPaid = isPaid,
IsUnpaid = isUnpaid
};
var dbOrders = _orderRepository.Get(filter, field, ascending == Constants.DEFAULTSORTORDER, getRemoved, page);
var orders = new List <OrderModel>();
var orderIds = dbOrders.Select(order => order.Id).ToList();
var itemsFilter = new OrderItemFilterModel {
OrderIds = orderIds
};
var allItems = _itemRepository.Get(itemsFilter);
foreach (var order in dbOrders)
{
var mappedOrder = _mapper.Map <OrderModel>(order);
var currentItems = allItems.Where(item => item.OrderId == order.Id).ToList();
var mappedItems = _mapper.Map <List <OrderItemModel> >(currentItems);
mappedOrder.CurrentItems = mappedItems;
mappedOrder.Total = currentItems.Sum(item => item.SubTotal);
orders.Add(mappedOrder);
}
return(orders);
}
public List <OrderBasicViewModel> Filter(OrderFilterModel model)
{
var items = m_Context.Orders.AsQueryable();
if (model != null)
{
if (!string.IsNullOrEmpty(model.S_Customer_ID))
{
int CategoryID = Int32.Parse(model.S_Customer_ID);
items = items.Where(x => x.CustomerID == CategoryID);
}
if (!string.IsNullOrEmpty(model.S_Returned))
{
bool castedInt = model.S_Returned.Equals("0") ? false : true;
if (!castedInt)
{
items = items.Where(x => x.Date_Return == null);
}
else
{
items = items.Where(x => x.Date_Return != null);
}
}
if (model.S_ID != null)
{
items = items.Where(x => x.ID == model.S_ID);
}
}
return(_mapper.Map <List <OrderBasicViewModel> >(items.ToList()));
}
public void OrderFilter_ComboByTimeBroker()
{
var filterFirst = new OrderFilterModel
{
DateRange = new DateRange {
Start = new DateTime(2018, 09, 01), End = new DateTime(2018, 10, 30)
},
BrokerId = 1,
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
DateRange = new DateRange {
Start = new DateTime(2018, 06, 01), End = new DateTime(2018, 08, 31)
},
BrokerId = 2,
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
listFirst.Should().HaveCount(3);
listFirst.Should().Contain(new[] { mockOrderListRows[3], mockOrderListRows[4], mockOrderListRows[6], });
listSecond.Should().OnlyContain(o => o == mockOrderListRows[0]);
}
public void OrderFilter_ByOrderNumber()
{
var firstUser = MockCustomerUsers.First();
var filterFirst = new OrderFilterModel
{
OrderNumber = "337",
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
OrderNumber = "2018-001337",
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
var actualFirst = mockOrderListRows.Where(o => o.EntityNumber.Contains(filterFirst.OrderNumber));
var actualSecond = mockOrderListRows.Where(o => o.EntityNumber.Contains(filterSecond.OrderNumber));
listFirst.Should().HaveCount(actualFirst.Count());
listFirst.Should().Contain(actualFirst);
listSecond.Should().HaveCount(actualSecond.Count());
listSecond.Should().Contain(actualSecond);
}
public void OrderFilter_ByDate()
{
var filterFirst = new OrderFilterModel
{
DateRange = new DateRange {
Start = new DateTime(2018, 06, 01), End = new DateTime(2018, 08, 31)
},
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
DateRange = new DateRange {
Start = new DateTime(2018, 09, 01), End = new DateTime(2018, 11, 01)
},
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
listFirst.Should().HaveCount(4);
listFirst.Should().Contain(new[] { mockOrderListRows[0], mockOrderListRows[1], mockOrderListRows[2], mockOrderListRows[7] });
listSecond.Should().HaveCount(4);
listSecond.Should().Contain(new[] { mockOrderListRows[3], mockOrderListRows[4], mockOrderListRows[5], mockOrderListRows[6] });
}
public void OrderFilter_ByRegion()
{
var regionFirst = Region.Regions.Where(r => r.Name == "Västra Götaland").Single();
var regionSecond = Region.Regions.Where(r => r.Name == "Gotland").Single();
var filterFirst = new OrderFilterModel
{
RegionId = regionFirst.RegionId,
IsAdmin = true
};
var filterSecond = new OrderFilterModel
{
RegionId = regionSecond.RegionId,
IsAdmin = true
};
var listFirst = filterFirst.Apply(mockOrderListRows.AsQueryable());
var listSecond = filterSecond.Apply(mockOrderListRows.AsQueryable());
var actualFirst = mockOrderListRows.Where(o => o.RegionId == regionFirst.RegionId);
var actualSecond = mockOrderListRows.Where(o => o.RegionId == regionSecond.RegionId);
listFirst.Should().HaveCount(actualFirst.Count());
listFirst.Should().Contain(actualFirst);
listSecond.Should().HaveCount(actualSecond.Count());
listSecond.Should().Contain(actualSecond);
}
public ActionResult Filter()
{
var model = new OrderFilterModel();
model.Products = this._IG_LoanProductService.GetAll();
return(View(model));
}
public async Task <ActionResult <GetOrderDTO[]> > GetAsync([FromQuery] OrderFilterModel filter)
{
var entities = await _manager.GetAsync(filter);
var dtos = _mapper.Map <OrderEntity[], GetOrderDTO[]>(entities);
return(Ok(dtos));
}
public ActionResult Orders(int pageIndex = 1, OrderFilterModel filter = null)
{
const int pageSize = 20;
ViewBag.status = filter.Status.ToString().ToLower();
ViewBag.filter = filter.IsFilter;
var list = this._IG_OrderService.GetAll(pageIndex, pageSize, null, this.GetStatus(filter.Status), filter.ProductCode, filter.Month, filter.Keyword, null, null, filter.BankClerkCode, null, this.User.G_UserDetail.Code);
return(View(list));
}
public ActionResult Index(OrderFilterModel filterModel)
{
OrderIndexViewModel model = new OrderIndexViewModel()
{
OrderList = filterModel.IsFiltered ? _orderService.Filter(filterModel).ToPagedList() : _orderService.GetAll().ToPagedList(1, PAGE_SIZE),
FilterModel = filterModel,
};
return(View(GetIndexViewModel(model)));
}
public IActionResult GetHotelOrders(int id, [FromQuery] OrderFilterModel filter)
{
if (filter is null)
{
return(BadRequest(nameof(filter)));
}
IEnumerable <ActiveOrderDTO> orders = hotelAdminService.GetHotelOrders(id, mapper.Map <OrderFilterDTO>(filter));
return(Ok(mapper.Map <IEnumerable <ActiveOrderDTO>, IEnumerable <ActiveOrderModel> >(orders)));
}
/// <summary>
/// 根据业务状态获取订单状态列表
/// </summary>
/// <param name="status">业务状态</param>
/// <returns></returns>
private List <G_OrderStatusEnum> GetStatus(OrderFilterModel filter)
{
var list = new List <G_OrderStatusEnum>();
if (!filter.IsFilter)
{
return(list);
}
switch (filter.Status)
{
case G_OrderBusinessStatusEnum.Canceled:
{
list.Add(G_OrderStatusEnum.Canceled);
list.Add(G_OrderStatusEnum.SignCanceled);
}
break;
case G_OrderBusinessStatusEnum.PreProcess:
{
list.Add(G_OrderStatusEnum.GojiajuPassed);
}
break;
case G_OrderBusinessStatusEnum.PreSign:
{
list.Add(G_OrderStatusEnum.BankPassed);
}
break;
case G_OrderBusinessStatusEnum.PreSuccess:
{
list.Add(G_OrderStatusEnum.BankSigned);
}
break;
case G_OrderBusinessStatusEnum.Successed:
{
list.Add(G_OrderStatusEnum.Successed);
}
break;
case G_OrderBusinessStatusEnum.Other:
{
//list.Add(G_OrderStatusEnum.Canceled);
//list.Add(G_OrderStatusEnum.SignCanceled);
//list.Add(G_OrderStatusEnum.InProcess);
//list.Add(G_OrderStatusEnum.BankPassed);
//list.Add(G_OrderStatusEnum.BankSigned);
//list.Add(G_OrderStatusEnum.Successed);
}
break;
}
return(list);
}
public void OrderFilter_NoSettings()
{
var filter = new OrderFilterModel {
IsAdmin = true
};
var list = filter.Apply(mockOrderListRows.AsQueryable());
list.Should().HaveCount(mockOrderListRows.Count());
list.Should().Contain(mockOrderListRows, because: "no filter parameters are specified");
}
public void OrderFilter_ByCustomerOrderNumber(string input, int count)
{
var filter = new OrderFilterModel
{
CustomerReferenceNumber = input,
IsAdmin = true
};
var list = filter.Apply(mockOrderListRows.AsQueryable());
list.Should().HaveCount(count);
}
public void OrderFilter_NoResults()
{
var filter = new OrderFilterModel
{
BrokerId = 3,
IsAdmin = true
};
var list = filter.Apply(mockOrderListRows.AsQueryable());
list.Should().BeEmpty("no order is assigned to {0}", filter.BrokerId);
}
public async Task <IActionResult> GetAll([FromHeader] string authorization, [FromBody] OrderFilterModel orderFilter)
{
string userRole = _jwtHelper.GetUserRoleFromToken(authorization);
if (userRole.Equals(Enums.Role.RoleName.Client.ToString()))
{
orderFilter.UserId = _jwtHelper.GetUserIdFromToken(authorization);
}
var orderModel = await _orderService.GetAllAsync(orderFilter);
return(Ok(orderModel));
}
public int GetCount(OrderFilterModel orderFilter, bool getRemoved = false)
{
Expression <Func <OrderEntity, bool> > filter = null;
if (orderFilter is not null)
{
filter = order => ((orderFilter.IsPaid && order.Status == Enums.OrderStatusType.Paid) ||
(orderFilter.IsUnpaid && order.Status == Enums.OrderStatusType.Unpaid)) &&
(string.IsNullOrWhiteSpace(orderFilter.UserId) || order.UserId == orderFilter.UserId) &&
(orderFilter.PaymentId != null || order.PaymentId == orderFilter.PaymentId);
}
return(base.Get(filter, getRemoved: getRemoved).Count());
}
public int GetPageCount(string usedId = null, bool isPaid = true, bool isUnpaid = true)
{
var filter = new OrderFilterModel
{
UserId = usedId,
IsPaid = isPaid,
IsUnpaid = isUnpaid
};
int dbOrdersCount = _orderRepository.GetCount(filter);
int pageCount = (int)Math.Ceiling(dbOrdersCount / (double)Constants.ORDERPAGESIZE);
return(pageCount);
}
public ActionResult GetFilter(OrderFilterModel model, string userId)
{
OrderDTO product = new OrderDTO
{
ProfileId = userId,
ProductName = model.ProductName,
ProductModel = model.ProductModel,
StartDate = model.StartDate == DateTime.MinValue ? model.StartDate = DateTime.Parse("01.01.2000") : model.StartDate,
EndDate = model.EndDate == DateTime.MinValue ? model.EndDate = DateTime.MaxValue : model.EndDate,
};
var list = _orderService.GetFilter(product);
return(View("GetCustomerOrders", list.ToPagedList(1, 5)));
}
public int GetCount(OrderFilterModel orderFilter = null, bool getRemoved = false)
{
string filterString = BuildFilter(orderFilter, getRemoved);
string sql = $"select o.*, u.* from Orders o inner join AspNetUsers u on o.UserId=u.Id {filterString}";
using SqlConnection connection = new(_connectionString);
var orders = connection.Query <OrderEntity, UserEntity, OrderEntity>(sql, (OrderEntity, UserEntity) =>
{
OrderEntity.User = UserEntity;
return(OrderEntity);
});
return(orders.Count());
}
public void OrderFilter_DateInclusivity()
{
var filter = new OrderFilterModel
{
DateRange = new DateRange {
Start = new DateTime(2018, 06, 07), End = new DateTime(2018, 08, 07)
},
IsAdmin = true
};
var list = filter.Apply(mockOrderListRows.AsQueryable());
list.Should().HaveCount(3);
list.Should().Contain(new[] { mockOrderListRows[0], mockOrderListRows[1], mockOrderListRows[2] }, because: "these orders fall within these dates");
}
public List <OrderEntity> Get(OrderFilterModel orderFilter = null, string field = Constants.DEFAULTORDERSORT, bool ascending = true, bool getRemoved = false, int page = Constants.DEFAULTPAGE)
{
page = page < Constants.DEFAULTPAGE ? Constants.DEFAULTPAGE : page;
string sortOrder = ascending ? "asc" : "desc";
string filterString = BuildFilter(orderFilter, getRemoved);
string sql = $"select o.*, u.* from Orders o inner join AspNetUsers u on o.UserId=u.Id {filterString} order by {field} {sortOrder} offset {(page - Constants.DEFAULTPREVIOUSPAGEOFFSET) * Constants.ORDERPAGESIZE} rows fetch next {Constants.ORDERPAGESIZE} rows only";
using SqlConnection connection = new(_connectionString);
var orders = connection.Query <OrderEntity, UserEntity, OrderEntity>(sql, (OrderEntity, UserEntity) =>
{
OrderEntity.User = UserEntity;
return(OrderEntity);
});
return(orders.ToList());
}
public List <OrderEntity> Get(OrderFilterModel orderFilter = null, string field = null, bool ascending = true, bool getRemoved = false, int page = Constants.DEFAULTPAGE)
{
page = page < Constants.DEFAULTPAGE ? Constants.DEFAULTPAGE : page;
Expression <Func <OrderEntity, bool> > filter = null;
if (orderFilter is not null)
{
filter = order => ((orderFilter.IsPaid && order.Status == Enums.OrderStatusType.Paid) ||
(orderFilter.IsUnpaid && order.Status == Enums.OrderStatusType.Unpaid)) &&
(string.IsNullOrWhiteSpace(orderFilter.UserId) || order.UserId == orderFilter.UserId) &&
(orderFilter.PaymentId != null || order.PaymentId == orderFilter.PaymentId);
}
return(base.Get(filter, field, ascending, getRemoved)
.Skip((page - Constants.DEFAULTPREVIOUSPAGEOFFSET) * Constants.ORDERPAGESIZE)
.Take(Constants.ORDERPAGESIZE).ToList());
}
private string BuildFilter(OrderFilterModel orderFilter = null, bool getRemoved = false)
{
string paidFilter = orderFilter.IsPaid ? $"o.Status={(int)Enums.OrderStatusType.Paid}" : string.Empty;
string unpaidFilter = orderFilter.IsUnpaid ? $"o.Status={(int)Enums.OrderStatusType.Unpaid}" : string.Empty;
string paymentIdFilter = (orderFilter.PaymentId is not null) ? $"o.PaymentId={orderFilter.PaymentId}" : string.Empty;
string userIdFilter = !string.IsNullOrWhiteSpace(orderFilter.UserId) ? $"o.UserId='{orderFilter.UserId}'" : string.Empty;
string removedFilter = getRemoved ? "1" : "0";
string filterString = $"where o.IsRemoved={removedFilter}";
if (!string.IsNullOrWhiteSpace(paidFilter) || !string.IsNullOrWhiteSpace(unpaidFilter))
{
filterString += " and (";
}
if (!string.IsNullOrWhiteSpace(paidFilter))
{
filterString += $" {paidFilter} ";
}
if (!string.IsNullOrWhiteSpace(paidFilter) && !string.IsNullOrWhiteSpace(unpaidFilter))
{
filterString += " or ";
}
if (!string.IsNullOrWhiteSpace(unpaidFilter))
{
filterString += $" {unpaidFilter} ";
}
if (!string.IsNullOrWhiteSpace(paidFilter) || !string.IsNullOrWhiteSpace(unpaidFilter))
{
filterString += ")";
}
if (!string.IsNullOrWhiteSpace(userIdFilter) || !string.IsNullOrWhiteSpace(paymentIdFilter))
{
filterString += " and ";
}
if (!string.IsNullOrWhiteSpace(userIdFilter))
{
filterString += $"{userIdFilter}";
}
if (!string.IsNullOrWhiteSpace(paymentIdFilter))
{
filterString += " and ";
}
if (!string.IsNullOrWhiteSpace(paymentIdFilter))
{
filterString += $"{paymentIdFilter}";
}
return(filterString);
}
public async Task <(IEnumerable <Order>, int)> GetFilteredOrdersAsync(OrderFilterModel model, PaginationFilterModel pagination)
{
var result = await _dbSet.Include(user => user.User)
.Include(orderItem => orderItem.OrderItems)
.ThenInclude(printingEdition => printingEdition.PrintingEdition)
.Where(order => model.Status == null || order.Status == model.Status)
.OrderBy($"{model.SortBy} {model.TypeSort}")
.ToListAsync();
int countElement = result.Count();
result = result.Skip((pagination.PageNumber - Constants.Page.PAGE_NUMBER) * pagination.PageSize).Take(pagination.PageSize).ToList();
(IEnumerable <Order>, int)tupleResult = (result, countElement);
return(tupleResult);
}
public PartialViewResult OrdersList(OrderFilterModel filter, int page = 1)
{
// get schedules from channel, start date
DateTime startDate = DateTime.Now;
if (!string.IsNullOrEmpty(filter.StartDate))
{
DateTime.TryParse(filter.StartDate, out startDate);
}
var schedules = _scheduleService.GetList(filter.IdChannel, startDate);
// get orders
List <Order> orders = new List <Order>();
foreach (var item in schedules)
{
var ord = _orderService.GetList(item.IdSchedule, filter.SearchString, filter.Phone);
if (ord.Any())
{
orders.AddRange(ord);
}
}
// setup data
var model = _mapper.Map <IEnumerable <OrderItemModel> >(orders).ToPagedList(page, _pageSize);
foreach (var item in model)
{
var seats = _orderDetailService.GetByOrderID(item.IdOrder);
if (seats.Any())
{
item.Seats = string.Join(", ", seats.Select(o => o.SeatNumber));
item.IdSchedule = seats.Select(o => o.IdSchedule).First();
}
}
// store filter
ViewBag.SearchString = filter.SearchString;
ViewBag.Phone = filter.Phone;
ViewBag.StartDate = filter.StartDate;
ViewBag.IdChannel = filter.IdChannel;
return(PartialView(model));
}
