public async Task <ActionResult <IEnumerable <AdminUsersDto> > > GetUsersWithRoles([FromQuery] UserParams userParams)
{
userParams.CurrentUsername = User.GetUsername();
var users = await GetAdminUsers(userParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize,
users.TotalCount, users.TotalPages);
return(Ok(users));
}
public async Task <IActionResult> ObtenerListaRubroPresupuestalPorPapa([FromQuery] int rubroPresupuestalId, [FromQuery] UserParams userParams)
{
var pagedList = await _repo.ObtenerListaRubroPresupuestalPorPapa(rubroPresupuestalId, userParams);
var listaDto = _mapper.Map <IEnumerable <RubroPresupuestal> >(pagedList);
Response.AddPagination(pagedList.CurrentPage, pagedList.PageSize,
pagedList.TotalCount, pagedList.TotalPages);
return(base.Ok(listaDto));
}
//public async Task<IEnumerable<User>> GetUsers()
//{
// var users = await _context.Users.Include(p => p.Photos).ToListAsync();
// return users;
//}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = await _context.Users.Include(p => p.Photos).ToListAsync();
return(await PagedList <User> .CreateAsync((IQueryable <User>) users, userParams.PageNumber, userParams.PageSize)); //users;
}
public async Task <PagedList <UsuarioParaDetalleDto> > ObtenerUsuarios(int tipo, int?usuarioId, UserParams userParams)
{
IOrderedQueryable <UsuarioParaDetalleDto> lista = null;
lista = (from t in _context.Usuario
join ar in _context.Area on t.AreaId equals ar.AreaId
join ca in _context.Cargo on t.CargoId equals ca.CargoId
where t.UsuarioId == usuarioId || usuarioId == null
where t.PciId == userParams.PciId
select new UsuarioParaDetalleDto()
{
UsuarioId = t.UsuarioId,
Nombres = t.Nombres,
Apellidos = t.Apellidos,
CargoNombre = ca.Nombre,
AreaNombre = ar.Nombre,
Username = t.Username,
})
.Distinct()
.OrderBy(t => t.Nombres);
return(await PagedList <UsuarioParaDetalleDto> .CreateAsync(lista, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <Actividad> > GetActividades(UserParams userParams)
{
var actividades = _context.Actividades.Where(a => a.UserId != userParams.UserId);
return(await PagedList <Actividad> .CreateAsync(actividades, userParams.PageNumber, userParams.PageSize));
}
public async Task <ActionResult> ObtenerCompromisosParaClavePresupuestalContable([FromQuery(Name = "tipo")] int tipo,
[FromQuery(Name = "terceroId")] int?terceroId,
[FromQuery] UserParams userParams)
{
try
{
valorPciId = User.FindFirst(ClaimTypes.Role).Value;
if (!string.IsNullOrEmpty(valorPciId))
{
pciId = int.Parse(valorPciId);
}
userParams.PciId = pciId;
var pagedList = await _repo.ObtenerCompromisosParaClavePresupuestalContable(tipo, terceroId, userParams);
var listaDto = _mapper.Map <IEnumerable <CDPDto> >(pagedList);
Response.AddPagination(pagedList.CurrentPage, pagedList.PageSize,
pagedList.TotalCount, pagedList.TotalPages);
return(Ok(listaDto));
}
catch (Exception)
{
throw;
}
throw new Exception($"No se pudo obtener la lista de compromisos");
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.Include(p => p.Photos).OrderByDescending(u => u.LastActive).AsQueryable();
users = users.Where(u => u.Id != userParams.UserId);
users = users.Where(u => u.Gender == userParams.Gender);
if (userParams.Likers)
{
var userLikers = await GetUserLikes(userParams.UserId, userParams.Likers);
users = users.Where(u => userLikers.Contains(u.Id));
}
if (userParams.Likees)
{
var userLikees = await GetUserLikes(userParams.UserId, userParams.Likers);
users = users.Where(u => userLikees.Contains(u.Id));
}
if (userParams.Blockers)
{
var userBlockers = await GetUserBlocks(userParams.UserId, userParams.Blockers);
users = users.Where(u => !(userBlockers.Contains(u.Id)));
Console.WriteLine("Blocker" + users);
}
if (userParams.Blockees)
{
var userBlockers = await GetUserBlocks(userParams.UserId, userParams.Blockers);
users = users.Where(u => (userBlockers.Contains(u.Id)));
Console.WriteLine("Blocker" + users);
}
if (userParams.Dislikers)
{
var userDislikers = await GetUserDislikes(userParams.UserId, userParams.Dislikers);
users = users.Where(u => userDislikers.Contains(u.Id));
}
if (userParams.Dislikees)
{
var userDislikees = await GetUserDislikes(userParams.UserId, userParams.Dislikers);
users = users.Where(u => userDislikees.Contains(u.Id));
}
if (userParams.MinAge != 18 || userParams.MaxAge != 99)
{
var minDob = DateTime.Today.AddYears(-userParams.MaxAge - 1);
var maxDob = DateTime.Today.AddYears(-userParams.MinAge - 1);
users = users.Where(users => users.DateOfBirth >= minDob && users.DateOfBirth <= maxDob);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "created":
users = users.OrderByDescending(u => u.Created);
break;
default:
users = users.OrderByDescending(u => u.LastActive);
break;
}
}
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var repo = new TableStorageRepository();
await userTable.CreateIfNotExistsAsync();
var results = (await userTable.ExecuteQuerySegmentedAsync(new TableQuery <User>(), null)).AsQueryable();
results = results.Where(x => x.IsDeleted == false).Where(x => x.Role != "admin").Where(x => x.RowKey != userParams.UserId).OrderBy(x => x.Name);
if ((!string.IsNullOrEmpty(userParams.Role)) && userParams.Team)
{
if (userParams.Role == "manager")
{
var newResults = await repo.GetMyTeamAsManager(userParams.UserId);
results = newResults.AsQueryable().OrderByDescending(x => x.Name);
}
else if (userParams.Role == "employee")
{
var newResults = await repo.GetMyTeamAsEmployee(userParams.Manager);
results = newResults.AsQueryable().Where(x => x.RowKey != userParams.UserId).Union(results.AsQueryable()
.Where(x => x.Name == userParams.Manager)).OrderByDescending(x => x.Name);
}
else
{
userParams.Role = null;
}
}
if (!string.IsNullOrEmpty(userParams.Search))
{
results = results.Where(x => x.Name.ToLower().Contains(userParams.Search.ToLower()) ||
x.Manager_ID.ToLower().Contains(userParams.Search.ToLower()) ||
x.Email.ToLower().Contains(userParams.Search.ToLower())
);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "desc":
results = results.OrderByDescending(u => u.Name);
break;
case "asc":
results = results.OrderBy(u => u.Name);
break;
case "man-asc":
results = results.OrderBy(u => u.Manager_ID);
break;
case "man-desc":
results = results.OrderByDescending(u => u.Manager_ID);
break;
default:
results = results.OrderBy(u => u.Name);
break;
}
}
if (results == null)
{
return(null);
}
var paginatedResult = PagedList <User> .Create(results, userParams.PageNumber, userParams.PageSize);
if (paginatedResult == null)
{
return(null);
}
return(paginatedResult);
}
public async Task <PagedList <Product> > GetAllProductsWithPagination(UserParams userParams)
{
var products = _dataContext.Products.Include(p => p.Assets).Include(p => p.Photos);
return(await PagedList <Product> .CreateAsync(products, userParams.PageNumber, userParams.PageSize));
}
public async Task <IActionResult> GetAllFixtures([FromQuery] UserParams userParams)
{
var fixtures = await _repository.GetFixtures(userParams);
return(Ok(fixtures));
}
// action updated for pagination in section 14 lecture 139
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
// previously we had toListAsync in the foll. line, but due to the pagination code addition, this has been deferred to the PagedList class
// ASQueryable: https://weblogs.asp.net/zeeshanhirani/using-asqueryable-with-linq-to-objects-and-linq-to-sql
// https://stackoverflow.com/questions/17366907/what-is-the-purpose-of-asqueryable
var users = _context.Users.Include(p => p.Photos).OrderByDescending(u => u.LastActive).AsQueryable();
users = users.Where(u => u.ID != userParams.UserID); // this would filter out the current logged in user from their matches list
users = users.Where(u => u.Gender == userParams.Gender); // this would filter out users acc.to gender
// if the query string from the SPA has likers/likees, we filter only the users that either have a liker or a likee id from the likes table
if (userParams.Likers)
{
var userLikers = await GetUserLikes(userParams.UserID, userParams.Likers);
// filtering the users that like the currently logged user
users = users.Where(u => userLikers.Contains(u.ID));
}
if (userParams.Likees)
{
var userLikees = await GetUserLikes(userParams.UserID, userParams.Likers); // it is fine to use userParams.likers here,
// since it is anyway a boolean that gets sent to GetUserLikes
// filtering the users that are liked by the currently logged in user
users = users.Where(u => userLikees.Contains(u.ID));
}
// if user customizes the filter for age
if (userParams.MinAge != 18 || userParams.MaxAge != 99)
{
// since we have to calculate the age using date of birth for minDOB, we are subtracting maxAge from today
// the -1 is because we are asking for maximum year of a person
// That is, for eg, if user searches with maxAge as 30 on Jan 18 2019, then AddYears(-maxAge) will give Jan 18, 1989. But
// suppose someone turns 31 tomorrow i.e. on Jan 19, 2019, he should still show up in the user's search of maxAge 30.
// Which means the DOB of that person would be Jan 19 1988. That's why we have -1 in the formula. Basically since a person is
// the same age for 364 days, we include the -1.
// https://stackoverflow.com/questions/9/how-do-i-calculate-someones-age-in-c
var minDOB = DateTime.Today.AddYears(-userParams.MaxAge - 1);
var maxDOB = DateTime.Today.AddYears(-userParams.MinAge);
users = users.Where(u => u.DateOfBirth >= minDOB && u.DateOfBirth <= maxDOB);
}
// if user wants to see the results in a specific order
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "created":
users = users.OrderByDescending(u => u.Created);
break;
default:
users = users.OrderByDescending(u => u.LastActive);
break;
}
}
// since CreateAsync is a static class, we can call it directly as below
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public static IQueryable <T> Pager <T>(this IQueryable <T> source, UserParams userParams)
{
userParams.Count = source.Count();
return(source.Skip((userParams.PageNumber - 1) * userParams.PageSize).Take(userParams.PageSize));
}
public Task <PagedList <User> > GetUsers(UserParams userParams)
{
return(_datingDal.GetUsers(userParams));
}
public async Task <IEnumerable <UserForListDto> > GetUSersWithPhotos(HttpResponse response, UserParams userParams)
{
var currentUserId = int.Parse(httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await userDal.GetUserWithPhotos(currentUserId);
userParams.UserId = currentUserId;
if (string.IsNullOrEmpty(userParams.Gender))
{
userParams.Gender = userFromRepo.Gender == "male" ? "female" : "male";
}
var users = await userDal.GetUsersWithPhotos(userParams);
if (users == null)
{
throw new Exception("Failed to retrieve user list.!!");
}
var userForReturn = mapper.Map <IEnumerable <UserForListDto> >(users);
response.AddPagination(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPages);
return(userForReturn);
}
public async Task <ActionResult <Pagination <ProductToReturnDto> > > GetDtoProducts([FromQuery] UserParams userParams)
{
var spec = new ProductsWithTypesAndRegionsSpecification(userParams);
var specForCount = new ProductWithFiltersForCountSpecification(userParams);
var totalItems = await _productsRepo.CountAsync(specForCount);
var products = await _productsRepo.ListAsync(spec);
var data = _mapper.Map <IReadOnlyList <Product>, IReadOnlyList <ProductToReturnDto> >(products);
await SetTimeOut();
return(Ok(new Pagination <ProductToReturnDto>(userParams.PageIndex, userParams.PageSize, totalItems, data)));
}
public async Task <PagedList <Product> > GetProducts(UserParams userParams)
{
var products = _context.Products;
return(await PagedList <Product> .CreateAsync(products, userParams.PageIndex, userParams.PageSize));
}
public async Task <PagedList <CDPDto> > ObtenerCompromisosParaClavePresupuestalContable(int tipo, int?terceroId, UserParams userParams)
{
IOrderedQueryable <CDPDto> lista = null;
//var notFoundItems = _context.CDP.Where(item => !listaCompromisos.Contains(item.Crp)).Select(x => x.Crp).ToHashSet();
var listaCompromisos = (from pp in _context.ClavePresupuestalContable
where pp.PciId == userParams.PciId
select pp.Crp).ToHashSet();
if (tipo == (int)TipoOperacionTransaccion.Creacion)
{
lista = (from c in _context.CDP
join t in _context.Tercero on c.TerceroId equals t.TerceroId
where !listaCompromisos.Contains(c.Crp)
where c.PciId == userParams.PciId
where c.Instancia == (int)TipoDocumento.Compromiso
where c.SaldoActual > 0 //Saldo Disponible
where c.TerceroId == terceroId || terceroId == null
select new CDPDto()
{
Crp = c.Crp,
Detalle4 = c.Detalle4,
NumeroIdentificacionTercero = t.NumeroIdentificacion,
NombreTercero = t.Nombre,
})
.Distinct()
.OrderBy(x => x.Crp);
}
else
{
lista = (from cla in _context.ClavePresupuestalContable
join c in _context.CDP on cla.Crp equals c.Crp
join t in _context.Tercero on c.TerceroId equals t.TerceroId
where cla.PciId == c.PciId
where c.Instancia == (int)TipoDocumento.Compromiso
where cla.PciId == userParams.PciId
where c.SaldoActual > 0 //Saldo Disponible
where c.TerceroId == terceroId || terceroId == null
select new CDPDto()
{
Crp = c.Crp,
Detalle4 = c.Detalle4,
NumeroIdentificacionTercero = t.NumeroIdentificacion,
NombreTercero = t.Nombre,
})
.Distinct()
.OrderBy(x => x.Crp);
}
return(await PagedList <CDPDto> .CreateAsync(lista, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <User> > GetUser(UserParams userParams)
{
var users = _context.Users.Include(e => e.Photos);
return await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize)
}
public async Task<IActionResult> MassUpload(int id, string roleToReg, [FromForm]XlsForUploadDto xlsForUploadDto){
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
return Unauthorized();
Stream stream = xlsForUploadDto.File.OpenReadStream();
UserParams userParams = new UserParams();
userParams.RoleName = roleToReg;
List<string> cohorts = new List<string>();
List<string> lastNames = new List<string>();
List<string> firstNames = new List<string>();
List<string> emails = new List<string>();
List<string> streetAdress = new List<string>();
List<string> city = new List<string>();
List<User> userList = new List<User>();
List<string> userNames = new List<string>();
var usersFromDb = _context.Users.ToList();
int it = 1;
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
var values = line.Split(',');
cohorts.Add(values[0]);
lastNames.Add(values[1]);
firstNames.Add(values[2]);
emails.Add(values[9]);
streetAdress.Add(values[11]);
city.Add(values[12]);
}
Console.WriteLine("Stop");
}
while(it <= lastNames.Count)
{
// if (firstNames[it] == "Eamon")
// {
// Console.WriteLine("Test");
// }
if (lastNames[it] != "")
{
string userName = UserNameGenerator.ReturnUserName(firstNames[it], lastNames[it], usersFromDb, userNames).Trim();
userNames.Add(userName);
string sL = StudLevCalc.ReturnStudLev(cohorts, it);
string pw = UserNameGenerator.ReturnPassword(streetAdress[it], city[it]).Trim();
UserForRegisterDto userFromFile = new UserForRegisterDto
{
FirstName = firstNames[it].Trim(),
LastName = lastNames[it].Trim(),
Email = emails[it].Trim(),
StudentLevel = sL,
Username = userName,
Password = pw,
};
var userToCreate = _mapper.Map<User>(userFromFile);
var assignments = await _context.Assignments.Where(a => a.StudentLevel == userToCreate.StudentLevel).ToListAsync();
var result = await _userManager.CreateAsync(userToCreate, userFromFile.Password);
var userToReturn = _mapper.Map<UserForDetailedDto>(userToCreate);
if (result.Succeeded)
{
foreach(var assignment in assignments)
{
var userAssignment = new UserAssignment
{
UserId = userToReturn.Id,
AssignmentId = assignment.Id,
Completed = false
};
_context.Add(userAssignment);
}
switch (roleToReg)
{
case "student":
_userManager.AddToRolesAsync(userToCreate, new [] {"Student"}).Wait();
break;
case "tutor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Tutor"}).Wait();
break;
case "mentor":
_userManager.AddToRolesAsync(userToCreate, new [] {"Mentor"}).Wait();
break;
case "admin":
_userManager.AddToRolesAsync(userToCreate, new [] {"Admin"}).Wait();
break;
}
}
}
it++;
}
return Ok();
throw new Exception("");
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = context.Users.Include(p => p.Photos)
.OrderByDescending(u => u.LastActive).AsQueryable();
users = users.Where(u => u.Id != userParams.UserId);
users = users.Where(u => u.Gender == userParams.Gender);
if (userParams.Likers)
{
var userLikers = await GetUserLikes(userParams.UserId, userParams.Likers);
users = users.Where(u => userLikers.Contains(u.Id));
}
if (userParams.Likees)
{
var userLikees = await GetUserLikes(userParams.UserId, userParams.Likers);
users = users.Where(u => userLikees.Contains(u.Id));
}
DateTime?minDateOfBirth = null;
DateTime?maxDateOfBirth = null;
if (userParams.MinAge.HasValue)
{
maxDateOfBirth = DateTime.Today.AddYears(-userParams.MinAge.Value);
}
if (userParams.MaxAge.HasValue)
{
minDateOfBirth = DateTime.Today.AddYears(-userParams.MaxAge.Value - 1);
}
if (minDateOfBirth.HasValue && maxDateOfBirth.HasValue)
{
users = users.Where(u => u.DateOfBirth >= minDateOfBirth && u.DateOfBirth <= maxDateOfBirth);
}
else if (minDateOfBirth.HasValue)
{
users = users.Where(u => u.DateOfBirth >= minDateOfBirth);
}
else if (maxDateOfBirth.HasValue)
{
users = users.Where(u => u.DateOfBirth <= maxDateOfBirth);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "created":
users = users.OrderByDescending(u => u.Created);
break;
default:
users = users.OrderByDescending(u => u.LastActive);
break;
}
}
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public IActionResult Edit(UserParams userParams)
{
var result = _userService.Edit(userParams.ToDto <UserParams, UserAddAndEditModel>());
return(Json(result));
}
public async Task <PagedList <CDPDto> > ObtenerDetallePlanAnualAdquisicion(long cdp, int instancia, UserParams userParams)
{
var lista = (from c in _context.CDP
join t in _context.Tercero on c.TerceroId equals t.TerceroId into TerceroCdp
from terceroCdp in TerceroCdp.DefaultIfEmpty()
where c.Cdp == cdp
where c.PciId == userParams.PciId
where c.Instancia == instancia
select new CDPDto()
{
Fecha = c.Fecha,
FechaFormato = c.Fecha.ToString(),
Cdp = c.Cdp,
Crp = c.Crp,
Obligacion = c.Obligacion,
OrdenPago = c.OrdenPago,
ValorInicial = c.ValorInicial,
Operacion = c.Operacion,
ValorTotal = c.ValorTotal,
SaldoActual = c.SaldoActual,
Detalle1 = c.Detalle1,
//Detalle4 = c.Detalle4.Length > 100 ? c.Detalle4.Substring(0, 100) + "..." : c.Detalle4,
Detalle4 = c.Detalle4,
NumeroIdentificacionTercero = c.TerceroId > 0 ? terceroCdp.NumeroIdentificacion : string.Empty,
NombreTercero = c.TerceroId > 0 ? terceroCdp.Nombre : string.Empty,
NumeroDocumento = (instancia == (int)TipoDocumento.Cdp ? c.Cdp :
(instancia == (int)TipoDocumento.Compromiso ? c.Crp :
(instancia == (int)TipoDocumento.Obligacion ? c.Obligacion :
(instancia == (int)TipoDocumento.OrdenPago ? c.OrdenPago : 0))))
})
.Distinct();
return(await PagedList <CDPDto> .CreateAsync(lista, userParams.PageNumber, userParams.PageSize));
}
public async Task <ActionResult <IEnumerable <MemberDto> > > GetPaginatedUsers([FromQuery] UserParams userParams)
{
var users = await _unitOfWork.UserRepository.GetMembersPaginationAsync(userParams);
Response.AddPaginationHeader(users.CurrentPage, users.PageSize, users.TotalCount, users.TotalPage);
return(Ok(users));
}
public async Task <ActionResult <IEnumerable <Semester> > > GetSemestersPaged([FromQuery] UserParams userParams)
{
userParams.CurrentUserName = User.GetUsername(); // From Token
var semesters = await this.unitOfWork.CoursesRepository.GetSemestersPagedAsync(userParams);
Response.AddPaginationHeader(semesters.CurrentPage, semesters.PageSize, semesters.TotalCount, semesters.TotalPages);
return(Ok(semesters));
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.Include(u => u.Photos).OrderByDescending(u => u.LastActive).AsQueryable();
users = users.Where(u => u.Id != userParams.UserId);
if (!userParams.Likers && !userParams.Likees)
{
var genders = new List <string> {
"male", "female"
};
if (genders.Contains(userParams?.Gender.ToLower()))
{
users = users.Where(u => u.Gender == userParams.Gender);
}
}
if (userParams.Likers && userParams.Likees)
{
var commonLikes = await GetUserLikes(userParams.UserId, userParams.Likers, true);
users = users.Where(u => commonLikes.Contains(u.Id));
}
else
{
if (userParams.Likers)
{
var userLikers = await GetUserLikes(userParams.UserId, userParams.Likers, false);
users = users.Where(u => userLikers.Contains(u.Id));
}
if (userParams.Likees)
{
var userLikees = await GetUserLikes(userParams.UserId, userParams.Likers, false);
users = users.Where(u => userLikees.Contains(u.Id));
}
}
if (userParams.MinAge != 18 || userParams.MaxAge != 99)
{
var minDob = DateTime.Today.AddYears(-userParams.MaxAge - 1);
var maxDob = DateTime.Today.AddYears(-userParams.MinAge);
users = users.Where(u => u.DateOfBirth >= minDob && u.DateOfBirth <= maxDob);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "created":
users = users.OrderByDescending(u => u.Created);
break;
case "age":
users = users.OrderByDescending(u => u.DateOfBirth);
break;
default:
users = users.OrderByDescending(u => u.LastActive);
break;
}
}
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <Ticket> > GetTickets(UserParams userParams)
{
var tickets = _context.Tickets.Include(u => u.User).OrderBy(t => t.Id).AsQueryable();
// tickets = tickets.Where(u => u.UserId == userParams.UserId);
if (userParams.Estatus > 0)
{
tickets = tickets.Where(t => t.Estatus == userParams.Estatus);
}
if (userParams.FechaIni != null && userParams.FechaFin != null)
{
tickets = tickets.Where(t => t.FechaAlta >= userParams.FechaIni && t.FechaAlta <= userParams.FechaFin);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "Id":
tickets = tickets.OrderBy(t => t.Id);
break;
case "Estatus":
tickets = tickets.OrderBy(t => t.Estatus);
break;
case "estatus":
tickets = tickets.OrderByDescending(t => t.Estatus);
break;
case "Fecha":
tickets = tickets.OrderBy(t => t.FechaAlta);
break;
case "fecha":
tickets = tickets.OrderByDescending(t => t.FechaAlta);
break;
case "Prioridad":
tickets = tickets.OrderBy(t => t.Prioridad);
break;
case "prioridad":
tickets = tickets.OrderByDescending(t => t.Prioridad);
break;
case "Usuario":
tickets = tickets.OrderBy(t => t.User.UserName);
break;
case "usuario":
tickets = tickets.OrderByDescending(t => t.User.UserName);
break;
default:
tickets = tickets.OrderByDescending(t => t.Id);
break;
}
}
return(await PagedList <Ticket> .CreateAsync(tickets, userParams.NumPagina, userParams.ItemsxPagina));
}
public SignOutCommand() : base(nameof(SignOutCommand))
{
UserParams.Add("userId", PlayerPrefs.GetString("userId"));
}
public async Task <(IEnumerable <UserForListDto>, PaginationHeader)> GetUsers(UserParams userParams)
{
var user = await _localStorage.GetItemAsync <UserForDetailedDto>("user");
userParams.UserId = user.ID;
string userParamsAsJson = userParams.ToQueryString();
var result = await _httpClient.GetAsync($"api/users/?{userParamsAsJson}");
var usersResult = JsonSerializer.Deserialize <IEnumerable <UserForListDto> >(await result.Content.ReadAsStringAsync(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
var pagination = JsonSerializer.Deserialize <PaginationHeader>(result.Headers.GetValues("Pagination").First(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
if (result.IsSuccessStatusCode)
{
return(usersResult, pagination);
}
return(null, null);
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.Include(a => a.Apps);
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PagedList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.Include(p => p.Photos).AsQueryable();
return(await PagedList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
