public PaginatedEntity <Domain.Vendas.Entities.Venda> ObterHistorico(PaginatedFilter filtro)
        {
            var lookup = new Dictionary <long, Domain.Vendas.Entities.Venda>();
            var result = new PaginatedEntity <Domain.Vendas.Entities.Venda>
            {
                Limits = filtro.Limit,
                OffSet = filtro.Offset
            };

            result.Result = _context.Connection.Query <Domain.Vendas.Entities.Venda, VendaSumario, Domain.Vendas.Entities.Venda>
                                ($@"select t0.*, t2.*  
                   from Venda t0 
                   inner join VendaSumario t2 on t0.Id = t2.VendaId
                   order by t0.DataCadastro
                   OFFSET {filtro.Offset} ROWS FETCH NEXT {filtro.Limit} ROWS ONLY  ", (s, a) =>
            {
                Domain.Vendas.Entities.Venda Venda;
                if (!lookup.TryGetValue(s.Id, out Venda))
                {
                    lookup.Add(s.Id, Venda = s);
                }
                if (Venda.VendaSumario == null)
                {
                    Venda.VendaSumario = new List <VendaSumario>();
                }
                Venda.VendaSumario.Add(a);
                return(Venda);
            });

            return(result);
        }
Exemple #2
0
        public async Task <PaginatedEntity <ShoppingorderListExport> > GetShoppingorder_By_Custom_QueryAsync(string query)
        {
            var list = new PaginatedEntity <ShoppingorderListExport>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(query, commandType: CommandType.Text))
                {
                    list.PagedSet = multiple.Read <ShoppingorderListExport>();
                }
            }
            return(list);
        }
        public async Task <PaginatedEntity <User> > GetPaginated_By_Search(SearchQuery obj)
        {
            var list = new PaginatedEntity <User>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(GetPaginated_By_SearchSP, new { obj.offset, obj.rows, obj.searchTxt }, commandType: CommandType.StoredProcedure))
                {
                    list.TotalCount = multiple.Read <long>().SingleOrDefault();
                    list.PagedSet   = multiple.Read <User>();
                    list.NumResult  = list.PagedSet.Count();
                }
            }
            return(list);
        }
        public async Task <PaginatedEntity <Review> > GetPaginated(int rows, long offset)
        {
            var list = new PaginatedEntity <Review>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(GetPaginatedSP, new { rows, offset }, commandType: CommandType.StoredProcedure))
                {
                    list.TotalCount = multiple.Read <long>().SingleOrDefault();
                    list.PagedSet   = multiple.Read <Review>();
                    list.NumResult  = list.PagedSet.Count();
                }
            }
            return(list);
        }
Exemple #5
0
        public async Task <PaginatedEntity <Cart_DTO> > GetPaginated_By_Custom_QueryAsync(string query)
        {
            var list = new PaginatedEntity <Cart_DTO>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(query, commandType: CommandType.Text))
                {
                    list.TotalCount = multiple.Read <long>().SingleOrDefault();
                    list.PagedSet   = multiple.Read <Cart_DTO>();
                    list.NumResult  = list.PagedSet.Count();
                }
            }
            return(list);
        }
        public async Task <PaginatedEntity <Game> > GetPaginated_By_PlatformId_GenreId_ConditionId_From_View(long offset, int rows, long PlatformId, long GenreId, int ConditionId)
        {
            var list = new PaginatedEntity <Game>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(GetPaginated_By_PlatformId_GenreId_ConditionId_From_ViewSP, new { offset, rows, PlatformId, GenreId, ConditionId }, commandType: CommandType.StoredProcedure))
                {
                    list.TotalCount = multiple.Read <long>().SingleOrDefault();
                    list.PagedSet   = multiple.Read <Game>();
                    list.NumResult  = list.PagedSet.Count();
                }
            }
            return(list);
        }
Exemple #7
0
        public async Task <PaginatedEntity <Cancelation_Order> > Get_Order_Cancelation_List(long offset, int rows)
        {
            var list = new PaginatedEntity <Cancelation_Order>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(Get_Order_Cancelation_ListSP, new { offset, rows }, commandType: CommandType.StoredProcedure))
                {
                    list.TotalCount = multiple.Read <long>().SingleOrDefault();
                    list.PagedSet   = multiple.Read <Cancelation_Order>();
                    list.NumResult  = list.PagedSet.Count();
                }
            }
            return(list);
        }
Exemple #8
0
        public async Task <HotDeals> Search_With_Custom_query(string query_for_game, string query_for_accessories, string query_for_console, string MaxPriceQuery)
        {
            var result           = new HotDeals();
            var game_list        = new PaginatedEntity <Game_Search>();
            var console_list     = new PaginatedEntity <Product>();
            var accessories_list = new PaginatedEntity <Product>();

            using (var con = DbHelper.GetSqlConnection())
            {
                using (var multiple = await con.QueryMultipleAsync(query_for_game, commandType: CommandType.Text))
                {
                    game_list.TotalCount = multiple.Read <int>().SingleOrDefault();
                    game_list.PagedSet   = multiple.Read <Game_Search>();
                    game_list.NumResult  = game_list.PagedSet.Count();
                }
                using (var multiple1 = await con.QueryMultipleAsync(query_for_console, commandType: CommandType.Text))
                {
                    console_list.TotalCount = multiple1.Read <int>().SingleOrDefault();
                    console_list.PagedSet   = multiple1.Read <Product>();
                    console_list.NumResult  = game_list.PagedSet.Count();
                }
                using (var multiple2 = await con.QueryMultipleAsync(query_for_accessories, commandType: CommandType.Text))
                {
                    accessories_list.TotalCount = multiple2.Read <int>().SingleOrDefault();
                    accessories_list.PagedSet   = multiple2.Read <Product>();
                    accessories_list.NumResult  = game_list.PagedSet.Count();
                }
                result.GameList    = game_list.PagedSet;
                result.Consoles    = console_list.PagedSet;
                result.Accessories = accessories_list.PagedSet;
                if (game_list != null)
                {
                    result.TotalCounts += game_list.TotalCount;
                }
                if (console_list != null)
                {
                    result.TotalCounts += console_list.TotalCount;
                }
                if (accessories_list != null)
                {
                    result.TotalCounts += accessories_list.TotalCount;
                }

                if (game_list != null)
                {
                    result.NumResult += game_list.NumResult;
                }
                if (console_list != null)
                {
                    result.NumResult += console_list.NumResult;
                }
                if (accessories_list != null)
                {
                    result.NumResult += accessories_list.NumResult;
                }
                using (var multiple = await con.QueryMultipleAsync(MaxPriceQuery, commandType: CommandType.Text))
                {
                    result.MaxPrice = multiple.Read <decimal>().SingleOrDefault();
                }
            }
            return(result);
        }