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(); }