static private void Subquery()
{
OrdersQuery orders = new OrdersQuery("o");
OrderDetailsQuery details = new OrderDetailsQuery("oi");
orders.Select
(
orders.OrderID,
orders.OrderDate,
details.Select
(
details.UnitPrice.Max()
)
.Where(orders.OrderID == details.OrderID).As("MaxUnitPrice")
);
OrdersCollection coll = new OrdersCollection();
if (coll.Load(orders))
{
foreach (Orders order in coll)
{
}
}
}
public async Task OrdersQuery_IndexHelperWithNoUsername()
{
var ordersQuery = new OrdersQuery(new FakeDataContext());
var model = await ordersQuery.IndexHelperAsync(null, new DateTime(2016, 1, 1), new DateTime(2016, 1, 3), null, false);
Assert.AreEqual(2, model.Orders.Count());
}
public async Task <IActionResult> Put(int id, [FromBody] Orders body)
{
await Db.Connection.OpenAsync();
body.Id = id;
body.Db = Db;
var orderQuery = new OrdersQuery(Db);
var result = await orderQuery.FindOneAsync(id);
if (result is null)
{
return(new NotFoundResult());
}
await result[0].UpdateAsync(body, result[0].OrdersD);
await body.UpdateOrderAsync();
var order = await orderQuery.FindOneAsync(id);
if (order[0] is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(order[0]));
}
public int Orders_GetCount(string serializedQuery)
{
OrdersQuery query = OrdersQuery.SerializeHelper.FromXml(
serializedQuery, typeof(OrdersQuery), AllKnownTypes) as OrdersQuery;
return(query.ExecuteScalar <int>());
}
public async Task GetOrders_AllOrders_SuccessfulRead()
{
IServiceCollection services = new ServiceCollection();
services.AddServingDomain()
.AddServingApplication()
.AddServingInfrastructure("Server=.;Database=RestaurantManagementSystem;Trusted_Connection=True;MultipleActiveResultSets=true", "S0M3 M4G1C UN1C0RNS G3N3R4T3D TH1S S3CR3T");
var serviceProviderFactory = new DefaultServiceProviderFactory();
IServiceProvider serviceProvider = serviceProviderFactory.CreateServiceProvider(services);
IMediator Mediator = serviceProvider.GetService <IMediator>();
var getOrdersQuery = new OrdersQuery();
var dbOrders = await Mediator.Send(getOrdersQuery);
foreach (var order in dbOrders.Orders)
{
Assert.IsNotNull(order.Items);
foreach (var item in order.Items)
{
Assert.IsNotNull(item.Dish);
}
}
}
public async Task <IActionResult> Post([FromBody] Orders body)
{
await Db.Connection.OpenAsync();
body.Db = Db;
var itemQuery = new ItemsQuery(Db);
for (int i = 0; i < body.OrdersD.Count; i++)
{
var itemId = body.OrdersD[i].IdItem;
var findItemID = itemQuery.FindOneAsync(itemId);
if (findItemID.Result == null)
{
FoundExceptions.NotFoundException(itemId);
}
}
var orderId = await body.InsertOrdersAsync();
await body.InsertOrderDetailAsync(body);
var orderQuery = new OrdersQuery(Db);
var result = await orderQuery.FindOneAsync(orderId);
return(new OkObjectResult(result[0]));
}
public async Task <IEnumerable <OrderServiceResult> > GetOrdersAsync(OrdersQuery qp)
{
try
{
// Here I list the query result from cache if they exist, but now the data can vary according to the category ID, page and amount of
// items per page. I have to compose a cache to avoid returning wrong data.
string cacheKey = GetCacheKeyForOrdersQuery(qp);
var entities = await _cache.GetOrCreateAsync(cacheKey, (entry) => {
entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1);
return(_customersRepository.ListPaginationAsync(qp));
});
var models = entities != null && entities.Any()
? _mapper.Map(entities, new List <OrderServiceResult>())
: new List <OrderServiceResult>();
return(models);
}
catch (Exception ex)
{
_logger?.LogError(ex.ToString());
throw;
}
}
public OrdersSchema(OrdersQuery query, OrdersMutation mutation, OrderSubscription subscription,
IDependencyResolver resolver)
{
Query = query;
DependencyResolver = resolver;
Mutation = mutation;
Subscription = subscription;
}
public async Task <Order> GetAsync(Guid id)
{
var query = new OrdersQuery {
FilterIds = id.Collect()
};
return((await _queryInvoker.Execute <OrdersQuery, Order>(query)).SingleOrDefault());
}
public async Task OrdersQuery_IndexHelperWithUsername()
{
var ordersQuery = new OrdersQuery(new FakeDataContext());
var model = await ordersQuery.IndexHelperAsync("bob", new DateTime(2016, 1, 1), new DateTime(2016, 1, 3), null, false);
Assert.AreEqual(1, model.Orders.Count());
Assert.IsTrue(model.Orders.Any(o => o.Username == "bob"));
Assert.IsFalse(model.Orders.Any(o => o.Username == "sue"));
}
public void SyncDate(DateTime from, DateTime to)
{
var fieldControlConfiguration = new FieldControlApi.Configuration.AppSettingsConfiguration();
var client = new Client(fieldControlConfiguration);
var authenticationCache = new SimpleFileCache("authentication");
var accessToken = authenticationCache.GetOrPut(() => {
client.Authenticate();
return(client.AuthenticationToken);
});
client.AuthenticationToken = accessToken;
FileLog.WriteJson(fieldControlConfiguration);
FileLog.WriteJson(client);
var cPlusConfiguration = new CPlus.Configurations.AppSettingsConfiguration();
var cPlusOrdersQuery = new OrdersQuery(cPlusConfiguration);
var orderDao = new OrderDao(cPlusConfiguration);
FileLog.WriteJson(cPlusConfiguration);
var orders = cPlusOrdersQuery.Execute(from, to);
var activities = client.Execute(new GetActivitiesRequest(from, to));
FileLog.WriteJson(orders);
FileLog.WriteJson(activities);
var geoCoderConfiguration = new AppSettingsGeoCoderConfiguration();
IGeocoder geocoder = new GoogleGeocoder()
{
ApiKey = geoCoderConfiguration.GoogleKey
};
var services = client.Execute(new GetServicesRequest());
var employees = client.Execute(new GetActiveEmployeesRequest(from));
var activityConveter = new ActivityConverter(
services: services,
employees: employees,
customerFieldControlService: new CustomerFieldControlService(client, geocoder)
);
FileLog.WriteJson(services);
FileLog.WriteJson(employees);
var commands = new List <ICommand>()
{
new CreateFieldControlActivityCommand(orders, activities, activityConveter, client),
new UpdateCPlusOrderStatusCommand(orders, activities, orderDao)
};
commands.ForEach(command => {
command.Run();
});
}
public async Task <List <OrderModel> > Handle(OrdersQuery request, CancellationToken cancellationToken)
{
var data = await _context
.Orders
.Include(x => x.ProductLineItems).ThenInclude(x => x.Product)
.OrderByDescending(x => x.DateCreated)
.ToListAsync(cancellationToken);
return(_mapper.Map <List <OrderModel> >(data));
}
public UserOrdersViewModel()
{
Orders = new OrdersQuery().GetUserOrders();
Orders.CollectionChanged += Orders_CollectionChanged;
UpdateStatus = new DelegateCommand <string>(Update_Status);
DeleteOrder = new DelegateCommand <object>(Delete);
UserProfile = new DelegateCommand <object>(ViewUserProfile);
}
public OrdersCollection Orders_LoadByDynamic(string serializedQuery)
{
OrdersQuery query = OrdersQuery.SerializeHelper.FromXml(
serializedQuery, typeof(OrdersQuery), AllKnownTypes) as OrdersQuery;
OrdersCollection coll = new OrdersCollection();
coll.es.IsLazyLoadDisabled = true;
coll.Load(query);
return(coll);
}
private string GetCacheKeyForOrdersQuery(OrdersQuery query)
{
string key = CacheKeys.OrdersList.ToString();
if (!string.IsNullOrEmpty(query.Search))
{
key = string.Concat(key, "_", query.Search);
}
key = string.Concat(key, "_", query.CustomerId, "_", query.Limit, "_", query.Offset);
return(key);
}
public async Task <ActionResult> Get(int id)
{
await Db.Connection.OpenAsync();
var query = new OrdersQuery(Db);
var result = await query.FindOneAsync(id);
if (result[0] is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result[0]));
}
//TODO: Trigers
//TODO: Fix
private void Update_Status(string status)
{
if (SelectedOrder.Status == "Waiting")
{
SelectedOrder.Status = status;
new OrdersQuery().OrderUpdate(SelectedOrder);
Orders = new OrdersQuery().GetUserOrders();
}
else
{
MessageBox.Show($"You cant change status. Current status: {SelectedOrder.Status}");
}
}
public async Task <ActionResult> Get()
{
await Db.Connection.OpenAsync();
var query = new OrdersQuery(Db);
var result = await query.GetAllAsync();
if (result is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result));
}
public async Task CreateOrder_NewOrder_SuccessfullRead()
{
IServiceCollection services = new ServiceCollection();
services.AddServingDomain()
.AddServingApplication()
.AddServingInfrastructure("Server=.;Database=RestaurantManagementSystem;Trusted_Connection=True;MultipleActiveResultSets=true", "S0M3 M4G1C UN1C0RNS G3N3R4T3D TH1S S3CR3T")
.AddTransient <ICurrentUser, CurrentUserServiceMock>();
var serviceProviderFactory = new DefaultServiceProviderFactory();
IServiceProvider serviceProvider = serviceProviderFactory.CreateServiceProvider(services);
IMediator Mediator = serviceProvider.GetService <IMediator>();
var createDishCommand = new CreateDishCommand();
createDishCommand.Description = "Vkusno";
createDishCommand.Name = "Mnogo Vkusna Mandja";
createDishCommand.RecipeId = 3;
createDishCommand.Price = new Money(10);
await Mediator.Send(createDishCommand);
createDishCommand = new CreateDishCommand();
createDishCommand.Description = "Vkusno";
createDishCommand.Name = "Oshte Po Vkusna Mandja";
createDishCommand.RecipeId = 4;
createDishCommand.Price = new Money(10);
await Mediator.Send(createDishCommand);
var createOrderCommand = new CreateOrderCommand();
createOrderCommand.TableId = 5;
createOrderCommand.AssigneeId = "Goshko";
createOrderCommand.Items.Add(new OrderItemInputModel(1, "Bez Kurkuma"));
createOrderCommand.Items.Add(new OrderItemInputModel(2));
var createOrderCommandOutput = await Mediator.Send(createOrderCommand);
var getOrdersQuery = new OrdersQuery();
var dbOrder = (await Mediator.Send(getOrdersQuery)).Orders.FirstOrDefault(order => order.Id == createOrderCommandOutput.OrderId);
Assert.AreEqual(dbOrder.Id, createOrderCommandOutput.OrderId);
Assert.AreEqual(dbOrder.TableId, createOrderCommand.TableId);
Assert.AreEqual(dbOrder.AssigneeId, createOrderCommand.AssigneeId);
foreach (var item in dbOrder.Items)
{
var commandItem = createOrderCommand.Items.FirstOrDefault(commandItem => commandItem.DishId == item.Dish.Id);
Assert.AreEqual(item.Dish.Id, commandItem.DishId);
Assert.AreEqual(item.Note, commandItem.Note);
}
}
public OrdersCollectionProxyStub Orders_QueryForCollection(string serializedQuery)
{
OrdersQuery query = OrdersQuery.SerializeHelper.FromXml(
serializedQuery, typeof(OrdersQuery), AllKnownTypes) as OrdersQuery;
OrdersCollection coll = new OrdersCollection();
if (coll.Load(query))
{
return(coll);
}
return(null);
}
public OrdersProxyStub Orders_QueryForEntity(string serializedQuery)
{
OrdersQuery query = OrdersQuery.SerializeHelper.FromXml(
serializedQuery, typeof(OrdersQuery), AllKnownTypes) as OrdersQuery;
Orders obj = new Orders();
if (obj.Load(query))
{
return(obj);
}
return(null);
}
public Task <PaginatedList <OrdersQueryDto> > Handle(OrdersQuery request, CancellationToken cancellationToken)
{
return(_unitOfWork.OrderRepository.GetAll()
.OrderByDescending(x => x.CreatedDate)
.Select(x => new OrdersQueryDto
{
Id = x.Id,
Status = x.Status,
Comments = x.Comments,
Currency = x.PaymentAmount.Currency,
ExecutionCountry = x.ExecutionCountry,
NetPaymentAmount = x.PaymentAmount.NetValue
})
.AsPaginatedList(request.GetPagingElements()));
}
public static int GetItensCart()
{
int userid = AlgeCookieController.UserID;
if (userid == 0)
{
return(0);
}
else
{
Order order = new Order().GetCardUser(userid);
int itens = new OrdersQuery().ReturnItensCard(order.id_pedido);
return(itens);
}
}
private void btnDynamicQuery_Click(object sender, EventArgs e)
{
btnAdd.Enabled = false;
btnDelete.Enabled = false;
btnSave.Enabled = false;
EmployeesQuery eq = new EmployeesQuery("eq");
OrdersQuery oq = new OrdersQuery("oq");
eq.Select(eq.EmployeeID, eq.LastName, eq.FirstName, oq.OrderID, oq.ShipCity);
eq.InnerJoin(oq).On(eq.EmployeeID == oq.EmployeeID);
coll = new EmployeesCollection();
coll.Load(eq);
_bindingSource.DataSource = coll;
}
public async Task <IEnumerable <Order> > GetAsync([FromQuery] string nameLike,
[FromQuery] OrderType?typeExact, [FromQuery] OrderStatus?statusExact,
[FromQuery] Guid?customer, int?take, int?skip, string orderBy, string orderMode)
//ToDo:4 optionally include archived?
{
var query = new OrdersQuery
{
Take = take,
Skip = skip,
OrderBy = orderBy,
OrderMode = orderMode,
FilterNameLike = nameLike,
FilterTypeExact = typeExact,
FilterStatusExact = statusExact,
FilterCustomerExact = customer
};
//ToDo:2 query.AsLazy(); ??
return(await _queryInvoker.Execute <OrdersQuery, Order>(query));
}
public jsResponse <EmployeesCollection, Employees> Employees_LoadHierarchical()
{
jsResponse <EmployeesCollection, Employees> response = new jsResponse <EmployeesCollection, Employees>();
try
{
// The Main Query
EmployeesQuery q = new EmployeesQuery("e");
q.Select(q.EmployeeID, q.FirstName, q.LastName, q.City, q.Country, q.HomePhone, q.Region, q.PostalCode, q.Title);
q.Where(q.EmployeeID < 7);
// The OrdersCollection
OrdersQuery o1 = q.Prefetch <OrdersQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID);
EmployeesQuery emp1 = o1.GetQuery <EmployeesQuery>();
o1.Where(emp1.EmployeeID < 7);
// The OrdersDetailsCollection
OrderDetailsQuery od = q.Prefetch <OrderDetailsQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID, Orders.Prefetch_OrderDetailsCollectionByOrderID);
EmployeesQuery emp2 = od.GetQuery <EmployeesQuery>();
OrdersQuery o2 = od.GetQuery <OrdersQuery>();
od.Where(emp2.EmployeeID < 7);
// Load It
EmployeesCollection coll = new EmployeesCollection();
if (coll.Load(q))
{
response.collection = coll;
response.columnCollection["Employees"] = jsColumn.PopulateColumns(coll[0]);
response.columnCollection["Orders"] = jsColumn.PopulateColumns(coll[0].OrdersCollectionByEmployeeID[0]);
response.columnCollection["OrderDetails"] = jsColumn.PopulateColumns(coll[0].OrdersCollectionByEmployeeID[0].OrderDetailsCollectionByOrderID[0]);
}
}
catch (Exception ex)
{
response.exception = ex.Message;
}
return(response);
}
public EmployeesCollection Employees_PrefetchSophisticated()
{
// EmployeeID = "1"
EmployeesCollection coll = new EmployeesCollection();
coll.Query.Where(coll.Query.EmployeeID == 1);
// Orders Query (nothing fancy, just ensure we're only getting Orders for EmployeeID = 1
OrdersQuery o = coll.Query.Prefetch <OrdersQuery>(Employees.Prefetch_OrdersCollectionByEmployeeID);
EmployeesQuery e1 = o.GetQuery <EmployeesQuery>();
o.Where(e1.EmployeeID == 1);
// OrderDetailsQuery (here we even limit the Select in addition to EmployeeID = 1) notice the "false"
OrderDetailsQuery od = coll.Query.Prefetch <OrderDetailsQuery>(false, Employees.Prefetch_OrdersCollectionByEmployeeID, Orders.Prefetch_OrderDetailsCollectionByOrderID);
EmployeesQuery e2 = od.GetQuery <EmployeesQuery>();
od.Where(e2.EmployeeID == 1);
od.Select(od.OrderID, od.ProductID, od.UnitPrice);
coll.Query.Load();
return(coll);
}
public async Task <IEnumerable <Order> > ListPaginationAsync(OrdersQuery query)
{
// AsNoTracking tells EF Core it doesn't need to track changes on listed entities. Disabling entity
// tracking makes the code a little faster
IQueryable <Order> queryable = _orders.Include(p => p.Items).AsNoTracking();
if (query.CustomerId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(query.CustomerId), $"The {nameof(query.CustomerId)} can not be null");
}
queryable = queryable.Where(p => p.CustomerId.Equals(query.CustomerId));
// Here I apply a simple calculation to skip a given number of items, according to the current page and amount of items per page,
// and them I return only the amount of desired items. The methods "Skip" and "Take" do the trick here.
if (query.Limit.HasValue && query.Offset.HasValue)
{
queryable = queryable.Skip(query.Offset.Value)
.Take(query.Limit.Value);
}
return(await queryable.ToListAsync());
}
public Order GetCardUser(int userID)
{
Order Orders = new OrdersQuery().ReturnOrderCart(userID);
return(Orders);
}
public List <Order> GetAllUserOrders(int userID)
{
List <Order> Orders = new OrdersQuery().ReturnOrders(userID);
return(Orders);
}
public void Execute_Returns_Correct_Result(OrdersQuery sut)
{
var result = sut.Execute(TestData.UserId);
result.Count().Should().BeGreaterThan(0);//avoid vacuous truth
result.All(o => o.EventId == TestData.EventId).Should().BeTrue();
}
