protected async Task <List <TDTO> > Get <TEntidad, TDTO>(PaginacionDTO paginacionDTO)
where TEntidad : class
{
var queryable = context.Set <TEntidad>().AsQueryable();
return(await Get <TEntidad, TDTO>(paginacionDTO, queryable));
}
public async Task <ActionResult <List <Persona> > > Get([FromQuery] PaginacionDTO paginacion)
{
var queryable = context.Personas.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnRespuesta(queryable, paginacion.CantidadRegistros);
return(await queryable.Paginar(paginacion).ToListAsync());
}
public MethodResponseDTO <PaginacionDTO <List <CarteraVencidaPaginadorDTO> > > ObtenerCarteraVencidaPaginacion(int page, int size, int sort, string sortDireccion, string filter, int filterCliente, int filterEstado, DateTime filterPeriodo, int Id_Empresa)
{
using (var context = new DB_9F97CF_CatarsysSGCEntities())
{
try
{
var response = new MethodResponseDTO <PaginacionDTO <List <CarteraVencidaPaginadorDTO> > >()
{
Code = 0
};
var responsePag = new PaginacionDTO <List <CarteraVencidaPaginadorDTO> >();
ObjectParameter totalrow = new ObjectParameter("totalrow", typeof(int));
var asignacion = context.sp_GetCarteraVencidaPaginacion(page, size, sort, Id_Empresa, sortDireccion, filter, filterEstado, filterPeriodo, totalrow).ToList();
//var asignacion = context.sp_GetCarteraVencidaPaginacion(0, 10, 1, 1, "asc", "",1, filterPeriodo, totalrow).ToList();
responsePag.data = Mapper.Map <List <CarteraVencidaPaginadorDTO> >(asignacion);
responsePag.recordsTotal = Convert.ToInt32(totalrow.Value);
responsePag.draw = page;
response.Result = responsePag;
return(response);
}
catch (Exception ex)
{
return(new MethodResponseDTO <PaginacionDTO <List <CarteraVencidaPaginadorDTO> > > {
Code = -100, Message = "Obtner Facturas Paginador: " + ex.Message
});
}
}
}
public async Task <ActionResult <List <UsuarioDTO> > > Get([FromQuery] PaginacionDTO paginationDTO)
{
var queryable = context.Users.AsQueryable();
queryable = queryable.OrderBy(x => x.Email);
return(await Get <IdentityUser, UsuarioDTO>(paginationDTO));
}
public MethodResponseDTO <PaginacionDTO <List <AsignacionPaginadorDTO> > > ObtenerAsignacionesPaginacion(int page, int size, int sort, string sortDireccion, string filter, int Id_Empresa)
{
using (var context = new DB_9F97CF_CatarsysSGCEntities())
{
try
{
var response = new MethodResponseDTO <PaginacionDTO <List <AsignacionPaginadorDTO> > >()
{
Code = 0
};
var responsePag = new PaginacionDTO <List <AsignacionPaginadorDTO> >();
ObjectParameter totalrow = new ObjectParameter("totalrow", typeof(int));
var asignacion = context.sp_GetAsigPaginacion(page, size, sort, Id_Empresa, sortDireccion, filter, totalrow).ToList();
responsePag.data = Mapper.Map <List <AsignacionPaginadorDTO> >(asignacion);
responsePag.recordsTotal = Convert.ToInt32(totalrow.Value);
responsePag.draw = page;
response.Result = responsePag;
return(response);
}
catch (Exception ex)
{
return(new MethodResponseDTO <PaginacionDTO <List <AsignacionPaginadorDTO> > > {
Code = -100, Message = "ObtenerAsignaciones: " + ex.Message
});
}
}
}
public async Task <IActionResult> GetAllPaginado([FromQuery] PaginacionDTO paginacionDTO)
{
var response = await _actoresApplication.GetAllPaginado(paginacionDTO);
_httpContextAccessor.HttpContext.Response.Headers.Add("cantidadPaginas", response.cantidadPaginas.ToString());
return(Ok(response));
}
protected async Task <ActionResult <List <TDTO> > > Get <TEntidad, TDTO>(PaginacionDTO paginacionDTO, IQueryable <TEntidad> queryable) where TEntidad : class
{
await HttpContext.InsertarParametrosPaginacion(queryable, paginacionDTO.Cantidad);
var lista = await queryable.Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <TDTO> >(lista));
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
return(await Get <Actor, ActorDTO>(paginacionDTO));
//var queryable = context.Actores.AsQueryable();
//await HttpContext.InsertarParametrosPaginacion(queryable, paginacionDTO.CantidadRegistrosPorPagina);
//return mapper.Map<List<ActorDTO>>(await queryable.Paginar(paginacionDTO).ToListAsync());
}
public async Task <ActionResult <List <ReviewDTO> > > Get(int peliculaId,
[FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = _context.Reviews.Include(r => r.Usuario).AsQueryable();
queryable = queryable.Where(p => p.PeliculaId == peliculaId);
return(await Get <Review, ReviewDTO>(paginacionDTO, queryable));
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = this.context.Actores.AsQueryable();
await HttpContext.InsertarParametrosPaginacion(queryable, paginacionDTO.CantidadRegistrosPorPagina);
var entidades = await queryable.Paginar(paginacionDTO).ToListAsync();
return(this.mapper.Map <List <ActorDTO> >(entidades));
}
public async Task <ActionResult <List <CineDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
IQueryable <Cine> cines;
cines = context.Cines.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(cines);
return(mapper.Map <List <CineDTO> >(await cines.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync()));
}
protected async Task <List <TDTO> > Get <TEntidad, TDTO>(PaginacionDTO paginacionDTO) where TEntidad : class
{
var queryable = context.Set <TEntidad>().AsQueryable();
//await HttpContext.InsertarParametrosPaginacion(queryable, paginacionDTO.CantidadRegistrosPorPagina);
//var entidades = await queryable.Paginar(paginacionDTO).ToListAsync();
//return mapper.Map<List<TDTO>>(entidades);
return(await Get <TEntidad, TDTO>(paginacionDTO, queryable));
}
protected async Task <List <TDTO> > Get <TEntidad, TDTO>(PaginacionDTO paginacionDTO, IQueryable <TEntidad> queryable)
where TEntidad : class
{
await HttpContext.InsertarParametrosPaginacion(queryable, paginacionDTO.CantidadRegistroPorPagina);
var entidades = await queryable.Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <TDTO> >(entidades));
}
public async Task <ActionResult <List <GeneroDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = context.Generos.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var generos = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <GeneroDTO> >(generos));
}
[HttpGet] //Para mostrar todos
public async Task <ActionResult <List <CineDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO) //tambien puedo usar ations result en una lista
{
var queryable = context.Cines.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var cines = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync(); // asincrono
return(mapper.Map <List <CineDTO> >(cines));
}
public async Task <ActionResult <List <UsuarioDTO> > > ListadoUsuarios([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = context.Users.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var usuarios = await queryable.OrderBy(x => x.Email).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <UsuarioDTO> >(usuarios));
}
public static List <T> PaginarLista <T>(List <T> lista, PaginacionDTO paginacionDTO, out int nroRegistros, string ordenDefault = "", string orientacion = "")
{
List <T> salida = new List <T>();
nroRegistros = lista.Count;
if (paginacionDTO.HabilitarPaginacion == true)
{
bool hayorden = false;
if (paginacionDTO.sidx != null)
{
if (paginacionDTO.sidx.Length > 0)
{
hayorden = true;
}
}
if (!hayorden)
{
paginacionDTO.sidx = ordenDefault;
if (orientacion != string.Empty)
{
paginacionDTO.sord = orientacion;
}
}
string orden = paginacionDTO.GetOrdenamiento().Trim();
if (orden.Length > 0)
{
string sortfield = orden.Split(' ')[0].Trim();
string sortExpression = orden.Split(' ')[1].ToUpper().Trim();
if (sortExpression == "ASC")
{
salida = lista.OrderBy(
x => Helper.GetPropertyValue(x, sortfield)
).Skip((paginacionDTO.GetNroPagina() - 1) * paginacionDTO.GetNroFilas()).Take(paginacionDTO.GetNroFilas()).ToList();
}
else
{
salida = lista.OrderByDescending(
x => Helper.GetPropertyValue(x, sortfield)
).Skip((paginacionDTO.GetNroPagina() - 1) * paginacionDTO.GetNroFilas()).Take(paginacionDTO.GetNroFilas()).ToList();
}
}
else
{
salida = lista.Skip((paginacionDTO.GetNroPagina() - 1) * paginacionDTO.GetNroFilas()).Take(paginacionDTO.GetNroFilas()).ToList();
}
}
else
{
salida = lista;
}
return(salida);
}
protected async Task <List <TDTO> > Get <Tentidad, TDTO>(PaginacionDTO paginacion) where Tentidad : class, IID
{
var queryable = context.Set <Tentidad>().AsQueryable();
await HttpContext.InsertarParametrosPaginacion(queryable, paginacion.CantidadRegistroPorPagina);
var entidades = await queryable.Paginar(paginacion).ToListAsync();
return(mapper.Map <List <TDTO> >(entidades));
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var actores = _context.Actores.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(actores);
var generos = await actores.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
//aqui estamos diciendo toma el listado de generos y mapealo al listado de GeneroDTO
return(_mapper.Map <List <ActorDTO> >(actores));
}
public async Task <ActionResult <List <UsuariosDTO> > > Get([FromQuery] PaginacionDTO paginacion)
{
IQueryable <IdentityUser> queryable = _context.Users.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnRespuesta(queryable, paginacion.CantidadRegistros);
return(await queryable.Paginar(paginacion)
.Select(x => new UsuariosDTO {
Email = x.Email, UserId = x.Id
}).ToListAsync());
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = context.Actores.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var actores = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
//todo lo que hay en genero, lo pasa (mapea) a listado de generoDTO que es lo qe se le muestra al usuario
return(mapper.Map <List <ActorDTO> >(actores));
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
// paginando y ordenando por nombre
var queryable = context.Actores.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var actors = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <ActorDTO> >(actors));
}
public async Task <ActionResult <List <ComercialDatoDTO> > > Get(PaginacionDTO paginacionDTO)
{
var queryable = context.ComercialDatos.Include(x => x.Planta).AsQueryable();
//queryable = queryable.Where(x => x.PeliculaId == peliculaId);
paginacionDTO.CantidadRegistrosPorPagina = 200000;
return(await Get <ComercialDato, ComercialDatoDTO>(paginacionDTO, queryable));
// return await Get<ScadaValor, ScadaValorDTO>();
}
[HttpGet] //la url queda api/genero
public async Task <ActionResult <List <cineDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
//logger.LogInformation("vamos a mostrar los generos");
var queryable = context.Cines.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var cines = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <cineDTO> >(cines));
}
public async Task <ActionResult <List <ActorDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = context.Actores.AsQueryable();
/* Usamos la clase HttpContextExtensions con el metodo InsertarParametrosPaginacionEnCabecera() para insertar la cantidad total de registros
* de la entidad actor con el fin de que el cliente sepa estos datos
*/
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var actores = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <ActorDTO> >(actores));
}
public async Task <ActionResult <List <ReviewDTO> > > Get(int peliculaId, [FromQuery] PaginacionDTO paginacionDTO)
{
//var existePelicula = await context.Peliculas.AnyAsync(x => x.Id == peliculaId);
//if (!existePelicula)
//{
// return NotFound();
//}
var queryable = context.Reviews.Include(x => x.Usuario).AsQueryable();
queryable = queryable.Where(x => x.PeliculaId == peliculaId);
return(await Get <Review, ReviewDTO>(paginacionDTO, queryable));
}
public async Task <ActionResult <List <GeneroDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO)
{
var queryable = context.Generos.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var generos = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync();
return(mapper.Map <List <GeneroDTO> >(generos));
//var resultado = new List<GeneroDTO>();
//foreach (var genero in generos)
//{
// resultado.Add(new GeneroDTO() { Id = genero.Id, Nombre = genero.Nombre });
//}
//return resultado;
}
[HttpGet] //metodo http get Trae todos
public async Task <ActionResult <List <GeneroDTO> > > Get([FromQuery] PaginacionDTO paginacionDTO) //tambien puedo usar ations result en una lista
{
// return new List<Genero>() { new Genero() { Id = 1, Nombre = "Comedia" } };
//return await context.Generos.ToListAsync(); // asincrono
//Obtiene la lista sin paginacion
//var generos = await context.Generos.ToListAsync();
//return mapper.Map<List<GeneroDTO>>(generos); // automapper
var queryable = context.Generos.AsQueryable();
await HttpContext.InsertarParametrosPaginacionEnCabecera(queryable);
var generos = await queryable.OrderBy(x => x.Nombre).Paginar(paginacionDTO).ToListAsync(); // asincrono
return(mapper.Map <List <GeneroDTO> >(generos));
}
public async Task <Response <List <PeliculaDTO> > > GetAllPaginado(PaginacionDTO paginacionDTO)
{
//return _actoresDomain.GetAllAsQueryable();
var response = new Response <List <PeliculaDTO> >();
var queryable = _peliculasDomain.GetAllAsQueryable();
ParametersPagination(queryable.Count(), paginacionDTO.CantidadRegistrosPorPagina);
var entities = queryable.Skip((paginacionDTO.Pagina - 1) * paginacionDTO.CantidadRegistrosPorPagina)
.Take(paginacionDTO.CantidadRegistrosPorPagina);
response.Data = _mapper.Map <List <PeliculaDTO> >(entities.ToList());
response.cantidadPaginas = cantidadPaginas;
return(response);
}
public static DataTable PaginarDataTable(DataTable dt, PaginacionDTO paginacionDTO, out int nroRegistros, string ordenDefault = "")
{
DataTable salida = new DataTable();
nroRegistros = dt.Rows.Count;
if (paginacionDTO.HabilitarPaginacion == true)
{
bool hayorden = false;
if (paginacionDTO.sidx != null)
{
if (paginacionDTO.sidx.Length > 0)
{
hayorden = true;
}
}
if (!hayorden)
{
paginacionDTO.sidx = ordenDefault;
}
string orden = paginacionDTO.GetOrdenamiento().Trim();
if (orden.Length > 0)
{
string sortfield = orden.Split(' ')[0].Trim();
string sortExpression = orden.Split(' ')[1].ToUpper().Trim();
DataView dv = dt.DefaultView;
dv.Sort = sortfield + " " + sortExpression;
salida = dv.ToTable();
salida = salida.AsEnumerable().Skip((paginacionDTO.GetNroPagina() - 1) * paginacionDTO.GetNroFilas()).Take(paginacionDTO.GetNroFilas()).CopyToDataTable();
salida.Columns.RemoveAt(salida.Columns.Count - 1);
}
else
{
salida = dt;
//salida = lista.Skip((paginacionDTO.GetNroPagina() - 1) * paginacionDTO.GetNroFilas()).Take(paginacionDTO.GetNroFilas()).ToList();
}
}
else
{
salida = dt;
}
return(salida);
}
