public async Task <PagingList <Post> > GetAllPageFromUserAsync(ClaimsPrincipal User, int page = 1, int itensPerPage = 10)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var query = _context.Post
.AsNoTracking()
.Include(p => p.User)
.Where(p => p.UserId == userId)
.OrderBy(p => p.CreatedAt);
var postPaginate = await PagingList.CreateAsync(query, itensPerPage, page);
postPaginate.Reverse();
return(postPaginate);
}
public async Task <IActionResult> Index(string sortOrder, int page = 1)
{
ViewData["NameSortParm"] = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
ViewData["GenderSortParm"] = sortOrder == "Gender" ? "gender_desc" : "Gender";
ViewData["PhoneSortParm"] = sortOrder == "Phone" ? "phone_desc" : "Phone";
ViewData["StatusSortParm"] = sortOrder == "Status" ? "status_desc" : "Status";
ViewData["DateSortParm"] = sortOrder == "Date" ? "date_desc" : "Date";
var customers = this.customerService.GetAll();
customers = this.customerService.Sort(sortOrder, customers);
var model = await PagingList.CreateAsync(customers.OrderBy(p => 0), 6, page);
return(View(model));
}
public async Task <IActionResult> Index(string searchString, int page = 1, string sortExpression = "MaHh")
{
var eSHOPContext = _context.HangHoa.AsNoTracking().Include(h => h.MaLoaiNavigation).Include(h => h.MaNccNavigation).AsQueryable();
if (!string.IsNullOrEmpty(searchString))
{
eSHOPContext = eSHOPContext.Where(p => p.TenHh.Contains(searchString) || p.MaNcc.Contains(searchString) || p.MaLoai.Contains(searchString));
}
var model = await PagingList.CreateAsync(eSHOPContext, 5, page, sortExpression, "MaHh");
model.RouteValue = new RouteValueDictionary {
{ "searchString", searchString }
};
// var eSHOPContext = _context.HangHoa.Include(h => h.MaLoaiNavigation).Include(h => h.MaNccNavigation);
return(View(model)); //(await eSHOPContext.ToListAsync());
}
// GET: Lookups
public async Task <IActionResult> Index(string filter, int page = 1, string sortExpression = "Group")
{
var _Lookup = _context.Lookup.Include(o => o.Parent).AsNoTracking().OrderBy(x => x.Group).AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
_Lookup = _Lookup.Where(p => p.Name.Contains(filter));
}
var _result = await PagingList <Lookup> .CreateAsync(_Lookup, 20, page, sortExpression, sortExpression);
_result.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
return(View(_result));
}
// GET: Admin/RoleViewModel
// [Breadcrumb("Tipos de Transaccion", FromController = "DashboardFinanzas", FromAction = "Clasificadores")]
public async Task <IActionResult> Index(string filter, int page = 1, string sortExpression = "Name", string a = "")
{
var consulta = DB.Roles.AsNoTracking().AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
consulta = consulta.Where(m => EF.Functions.ILike(m.Name, $"%{filter}%"));
}
var resp = await PagingList.CreateAsync(consulta, Constantes.TamanoPaginacion, page, sortExpression, "Name");
resp.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
ShowFlash(a);
return(View(resp));
}
public async Task <IActionResult> Index(string searchString, int page = 1, string sortExpression = "UserName")
{
var us = _context.User.AsNoTracking().AsQueryable();
if (!string.IsNullOrEmpty(searchString))
{
us = us.Where(p => p.UserName.Contains(searchString) || p.Name.Contains(searchString));
}
var model = await PagingList.CreateAsync(us, 3, page, sortExpression, "Username");
model.RouteValue = new RouteValueDictionary {
{ "searchString", searchString }
};
//ViewBag.SearchString = searchString;
return(View(model));
}
// GET: Users
public async Task <IActionResult> Index(string filter, int page = 1, string sortExpression = "UserId")
{
var _Users = _context.User.Include(o => o.Employee).AsNoTracking().OrderBy(x => x.UserId).AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
_Users = _Users.Where(p => p.UserId.Contains(filter));
}
var _result = await PagingList <User> .CreateAsync(_Users, 20, page, sortExpression, sortExpression);
_result.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
return(View(_result));
}
public async Task <IActionResult> Index(string searchString, int page = 1, string sortExpression = "MaTrangThaiNavigation")
{
var eSHOPContext = _context.HoaDon.AsNoTracking().Include(h => h.MaKhNavigation).Include(h => h.MaTrangThaiNavigation).AsQueryable();
if (!string.IsNullOrEmpty(searchString))
{
eSHOPContext = eSHOPContext.Where(p => p.HoTen.Contains(searchString) || p.SdtNguoinhan.Contains(searchString) || p.MaHd.ToString().Contains(searchString));
}
var model = await PagingList.CreateAsync(eSHOPContext, 5, page, sortExpression, "MaHd");
model.RouteValue = new RouteValueDictionary {
{ "searchString", searchString }
};
// var eSHOPContext = _context.HoaDon.Include(h => h.MaKhNavigation).Include(h => h.MaTrangThaiNavigation);
return(View(model));
}
public async Task <IActionResult> Search(string productSearch, int page = 1)
{
var query = (from c in _context.cellphones
join p in _context.products on c.ProductId equals p.ProductId
select new CellphoneListViewModel()
{
ProductId = p.ProductId,
Name = p.ProductName,
CellphoneId = c.CellphoneId,
CameraHas = c.CameraHas,
CameraRecording = c.CameraRecording,
CameraResolution = c.CameraResolution,
ConnectionNetworks = c.ConnectionNetworks,
ConnectionTechnologies = c.ConnectionTechnologies,
CpuChipset = c.CpuChipset,
CpuCore = c.CpuCore,
CpuFrequency = c.CpuFrequency,
GPU = c.GPU,
SimcardCount = c.SimcardCount,
CpuType = c.CpuType,
ScreenProtector = c.ScreenProtector,
SimcardDesc = c.SimcardDesc,
StorageSupport = c.StorageSupport,
Description = c.Description,
OS = c.OS,
OSVersion = c.OSVersion,
RAM = c.RAM,
ScreenSize = c.ScreenSize,
ScreenTechnology = c.ScreenTechnology,
ScreenType = c.ScreenType,
Size = c.Size,
Storage = c.Storage,
StorageType = c.StorageType,
Weight = c.Weight,
}).AsNoTracking().OrderBy(p => p.ProductId);
var modelPaging = await PagingList.CreateAsync(query, 10, page);
if (productSearch != null)
{
modelPaging = await PagingList.CreateAsync(
query.Where(m => m.Name.Contains(productSearch)).OrderBy(p => p.ProductId), 10, page);
}
return(View("Index", modelPaging));
}
public async Task <IActionResult> TrackingPDF(string filter, string type, string typeHR, DateTime startDate,
DateTime endDate, int page = 1, string sortExpression = "-FechaRegistro", string a = "")
{
var consulta = DB.CorrespondenciaHojaRuta.AsNoTracking().AsQueryable();
consulta = consulta.Include(m => m.UnidadEjecutora)
.Include(m => m.Origen)
.Where(m => (m.Id > 0));
if (startDate.Year == 1)
{
DateTime today = DateTime.Now;
startDate = new DateTime(today.Year, today.Month, 1);
endDate = today.AddDays(1);
}
consulta = consulta.Where(m => m.FechaRegistro >= startDate && m.FechaRegistro <= endDate);
if (!string.IsNullOrWhiteSpace(filter))
{
consulta = consulta.Where(m => EF.Functions.ILike(m.Referencia, $"%{filter}%") ||
EF.Functions.ILike(m.RemitenteExterno, $"%{filter}%") ||
EF.Functions.ILike(m.EntidadExterna, $"%{filter}%") ||
EF.Functions.ILike(m.Origen.Denominacion, $"%{filter}%") ||
EF.Functions.ILike(m.UnidadEjecutora.Descripcion, $"%{filter}%") ||
EF.Functions.ILike(m.CiteTramite, $"%{filter}%") ||
EF.Functions.ILike(m.CiteHojaRuta, $"%{filter}%") ||
EF.Functions.ILike(m.CiteUE, $"%{filter}%"));
}
var resp = await PagingList.CreateAsync(consulta, 10000, page, sortExpression, "FechaRegistro");
resp.RouteValue = new RouteValueDictionary {
{ "filter", filter }, { "startDate", startDate }, { "endDate", endDate }
};
return(new ViewAsPdf("_TrackingPDF", resp)
{
PageMargins = new Margins(15, 10, 12, 10),
PageSize = Size.Legal,
PageOrientation = Orientation.Landscape,
CustomSwitches =
"--footer-left \" © Sistema Integrado Versión 1.0\" --footer-center \" Página: [page]\" --footer-right \" Documento generado el: " +
DateTime.Now.ToString("dd/MM/yyyy HH:mm") + "\"" +
" --footer-line --footer-font-size \"7\" --footer-spacing 1 --footer-font-name \"Segoe UI\""
});
}
// GET: Djelatnici
public async Task <IActionResult> Index(string search, int page = 1)
{
if (!String.IsNullOrEmpty(search))
{
var query = _context.Djelatnik.AsNoTracking().Where(x => x.Ime.Contains(search)).Include(d => d.ZanimanjeClass).OrderBy(s => s.DjelatnikClassID);
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
else
{
var query = _context.Djelatnik.AsNoTracking().Include(d => d.ZanimanjeClass).OrderBy(s => s.DjelatnikClassID);
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
}
// GET: Compras
public async Task <IActionResult> Index(int page = 1)
{
if (Request.Cookies["idDoUser"] == null)
{
return(RedirectToAction("Login", "Jornaleiros"));
}
var query = _context.Compras.Include(c => c.Status).Include(c => c.fornecedor).OrderByDescending(c => c.DataCompra);
ListaDeFornecedores = query.Select(v => v.fornecedor.NomeFornecedor).OrderBy(v => v).Distinct().ToList();
ViewBag.fornecedor = ListaDeFornecedores;
ListaParaCsv.Clear();
ListaParaCsv = query.ToList();
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
// GET: Analises
public async Task <IActionResult> Index(string search, DateTime?minDate, DateTime?maxDate, int page = 1)
{
SincAll();
var suporteContext = _context.Analise.Include(a => a.Phoebus);
if (!String.IsNullOrEmpty(search))
{
var result = await _analiseService.FindByAnaliseAsync(minDate, maxDate, search);
ViewData["Filter"] = search;
ViewData["minDate"] = result.Item2.Value.ToString("yyyy-MM-dd");
ViewData["maxDate"] = result.Item3.Value.ToString("yyyy-MM-dd");
return(View(result.Item1));
}
return(View(await PagingList.CreateAsync(_context.Analise.AsNoTracking().OrderByDescending(r => r.Date_base), 20, page)));
}
// GET: Admin/AdminOrders
//public async Task<IActionResult> Index()
//{
// return View(await _context.Orders.ToListAsync());
//}
public async Task <ActionResult> Index(string filter, int pageindex = 1, string sort = "Name")
{
var result = _context.Orders.AsNoTracking().AsQueryable();
if (!string.IsNullOrEmpty(filter))
{
result = result.Where(p => p.Name.Contains(filter));
}
var model = await PagingList.CreateAsync(result, 5, pageindex, sort, "Name");
model.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
return(View(model));
}
public async Task <IActionResult> Index(string searchString, int page = 1, string sortExpression = "Email")
{
var eSHOPContext = _context.NhanVien.AsNoTracking().Include(n => n.MaPqNavigation).AsQueryable();
if (!string.IsNullOrEmpty(searchString))
{
eSHOPContext = eSHOPContext.Where(p => p.Email.Contains(searchString) || p.HoTen.Contains(searchString));
}
var model = await PagingList.CreateAsync(eSHOPContext, 5, page, sortExpression, "Email");
model.RouteValue = new RouteValueDictionary {
{ "searchString", searchString }
};
// var qry = _context.NhanVien.AsNoTracking().OrderBy(p => p.Email);
// var model = await PagingList.CreateAsync(qry, 1, page);
return(View(model));
}
public async Task <IActionResult> Show(List <string> FlightId)
{
FlightId.RemoveAt(0);
if (FlightId == null || FlightId.Count() == 0)
{
return(RedirectToAction("Error", "Error"));
}
var takeAFlightContext = _context.Flight.Include(f => f.Destination);
var Flights = from flights in takeAFlightContext
where FlightId.Contains(flights.FlightID.ToString())
select flights;
int pageSize = 10;
var model = await PagingList.CreateAsync(Flights, pageSize, 1, "FlightID", "FlightID");
SetRegisterListData();
return(View(model));
}
public async Task <IActionResult> language_set(language doc, int?idx, string sortExpression = "-idx", int page = 1)
{
if (idx != null)
{
doc = db.language.Single(x => x.idx == idx);
}
var query = db.language.AsNoTracking();
var model = await PagingList.CreateAsync(query, 100, page, sortExpression, "-idx");
ViewBag.리스트 = model;
return(View(doc));
}
// GET: Jornaleiros
public async Task <IActionResult> Index(int page = 1)
{
if (Request.Cookies["idDoUser"] == null)
{
return(RedirectToAction("Login", "Jornaleiros"));
}
//essas linhas sao necessarias para a paginaca so trocar o tipo de context, jornaleiro, produto etc
ViewBag.admin = Request.Cookies["admin"];
var query = _context.Jornaleiros.Include(j => j.Status).Include(j => j.tipo).AsNoTracking().Where(j => j.StatusId == 1).OrderBy(j => j.NomeJornaleiro);
ListaParaCsv.Clear();
ListaParaCsv = query.ToList();
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
// GET: Admin/AdminPedidos
//public async Task<IActionResult> Index()
//{
// return View(await _context.Pedidos.ToListAsync());
//}
public async Task <IActionResult> Index(string filter, int pageindex = 1, string sort = "Nome")
{
var resultado = _context.Pedidos.AsNoTracking()
.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
resultado = resultado.Where(p => p.Nome.Contains(filter));
}
var model = await PagingList.CreateAsync(resultado, 5, pageindex, sort, "Nome");
model.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
return(View(model));
}
public async Task <IActionResult> Index(int page = 1, string searchName = "")
{
if (string.IsNullOrEmpty(searchName))
{
var item = _boardBll.GetBoardTracking();
var model = await PagingList.CreateAsync(item, _pageSize, page);
return(View(model));
}
else
{
var item = _boardBll.GetBoardTracking(searchName);
var model = await PagingList.CreateAsync(item, _pageSize, page);
return(View(model));
}
}
public async Task <IActionResult> Index(int page = 1)
{
var query = (from p in _context.Order
where p.UserId == _userManager.GetUserId(User)
select new OrderListViewModel()
{
OrderId = p.OrderId,
OrderDate = p.OrderDate,
DeliveryDate = p.DeliveryDate,
Price = p.Price,
Status = p.Flag
}).AsNoTracking().OrderBy(p => p.OrderId);
var modelPaging = await PagingList.CreateAsync(query, 10, page);
return(View(modelPaging));
}
public async Task <IActionResult> Index(int page = 1)
{
var query = (from w in _context.Wishlist
join u in _context.Users on w.UserId equals u.Id
join p in _context.products on w.ProductId equals p.ProductId
where u.Id == _userManager.GetUserId(User)
select new WishlistViewModel()
{
WhishId = w.WhishId,
ProductName = p.ProductName,
ProductId = p.ProductId
}).AsNoTracking().OrderBy(p => p.ProductId);
var modelPaging = await PagingList.CreateAsync(query, 10, page);
return(View(modelPaging));
}
// GET: Generales/Barrio
//[Breadcrumb("Barrio", FromController = "DashboardPlan", FromAction = "Clasificadores")]
public async Task <IActionResult> Index(string filter, int page = 1, string sortExpression = "Descripcion", string a = "")
{
var consulta = DB.Barrio.AsNoTracking().AsQueryable();
consulta = consulta.Where(m => m.IdEstadoRegistro != 2); //!= Constantes.Eliminado); // != el estado es diferente a ANULADO
if (!string.IsNullOrWhiteSpace(filter))
{
consulta = consulta.Where(m => EF.Functions.ILike(m.Descripcion, $"%{filter}%"));
}
var resp = await PagingList.CreateAsync(consulta, Constantes.TamanoPaginacion, page, sortExpression, "Descripcion");
resp.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
ShowFlash(a);
return(View(resp));
}
// GET: Bancas
public async Task <IActionResult> Index(int page = 1)
{
if (Request.Cookies["idDoUser"] == null)
{
return(RedirectToAction("Login", "Jornaleiros"));
}
List <String> Bairros = BairroUtil.GetBairros();
ViewBag.bairros = Bairros.OrderBy(b => b).ToList();
var query = _context.Bancas.Include(j => j.Jornaleiro).AsNoTracking().OrderBy(j => j.NomeBanca);
ListaParaCsv.Clear();
ListaParaCsv = query.ToList();
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
public async Task <IActionResult> Index(string search, int page = 1)
{
if (!String.IsNullOrEmpty(search))
{
var query = _context.Natjecaj.AsNoTracking().Where(x => x.Naziv.Contains(search)).OrderBy(s => s.NatjecajClassID);
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
else
{
var query = _context.Natjecaj.AsNoTracking().OrderBy(s => s.NatjecajClassID);
var model = await PagingList.CreateAsync(query, 5, page);
return(View(model));
}
}
// GET: Admission1
public async Task <IActionResult> Index(int page = 1)
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString("Session1")))
{
return(RedirectToAction("UserLogin", "Login"));
}
var query = _context.Admission1.AsNoTracking()
.Include(a => a.FT)
.Include(a => a.St)
.Include(a => a.Std)
.AsQueryable()
.OrderBy(d => d.AdId);
var model = await PagingList.CreateAsync(query, 10, page);
return(View(model));
}
public async Task <PagingList <Movie> > GetPagingwithMoviesAsync(int?pageCount, int?itemPerPage, string category)
{
var movies = _context.Movies.AsNoTracking().OrderBy(m => m.Category);
if (category != null)
{
movies = movies.Where(m => m.Category.Title == category).OrderBy(m => m.Name);
}
var paginatedList = await PagingList.CreateAsync(movies, itemPerPage ?? 3, pageCount ?? 1);
paginatedList.RouteValue = new RouteValueDictionary
{
{ "category", category }
};
return(paginatedList);
}
// GET: Status
public async Task <IActionResult> Index(string filter, int page = 1, string sortExpression = "StatusName")
{
var qry = _context.Statuses.OrderBy(c => c.StatusName).AsNoTracking().AsQueryable();
if (!string.IsNullOrWhiteSpace(filter))
{
qry = qry.Where(c => c.StatusName.Contains(filter));
}
var model = await PagingList.CreateAsync(qry, 10, page, sortExpression, "StatusName");
model.RouteValue = new RouteValueDictionary {
{ "filter", filter }
};
return(View(model));
}
public async Task <IActionResult> Index(int page = 1)
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(User);
var completedTasks = await _exerciseService.GetCompletedExercisesIds(applicationUser.Id);
var query = _exerciseService.GetExercisesAsQueryable().AsNoTracking().OrderBy(m => m.Id);
var exercises = await PagingList.CreateAsync(query, 5, page);
var viewModel = new ShowTasksViewModel()
{
CompletedTasksIds = completedTasks,
Exercises = exercises
};
return(View(viewModel));
}
public async Task <IActionResult> Index(int page = 1)
{
Cellphone model = new Cellphone();
//LINQ to Query string
//Join on 2 tables
var query = (from c in _context.cellphones
join p in _context.products on c.ProductId equals p.ProductId
select new CellphoneListViewModel()
{
ProductId = p.ProductId,
Name = p.ProductName,
CellphoneId = c.CellphoneId,
CameraHas = c.CameraHas,
CameraRecording = c.CameraRecording,
CameraResolution = c.CameraResolution,
ConnectionNetworks = c.ConnectionNetworks,
ConnectionTechnologies = c.ConnectionTechnologies,
CpuChipset = c.CpuChipset,
CpuCore = c.CpuCore,
CpuFrequency = c.CpuFrequency,
GPU = c.GPU,
SimcardCount = c.SimcardCount,
CpuType = c.CpuType,
ScreenProtector = c.ScreenProtector,
SimcardDesc = c.SimcardDesc,
StorageSupport = c.StorageSupport,
Description = c.Description,
OS = c.OS,
OSVersion = c.OSVersion,
RAM = c.RAM,
ScreenSize = c.ScreenSize,
ScreenTechnology = c.ScreenTechnology,
ScreenType = c.ScreenType,
Size = c.Size,
Storage = c.Storage,
StorageType = c.StorageType,
Weight = c.Weight,
}).AsNoTracking().OrderBy(p => p.ProductId);
var modelPaging = await PagingList.CreateAsync(query, 10, page);
return(View(modelPaging));
}
