public async Task <PageList <MessageModel> > GetMessagesForUser(MessageParams messageParams)
{
var messages = _context.Messages
.Include(u => u.Sender).ThenInclude(p => p.Photos)
.Include(u => u.Recipient).ThenInclude(p => p.Photos)
.AsQueryable();
switch (messageParams.MessageContainer)
{
case "Inbox":
messages = messages.Where(u => u.RecipientId == messageParams.UserId && u.RecipientDeleted == false);
break;
case "Outbox":
messages = messages.Where(u => u.SenderId == messageParams.UserId && u.SenderDeleted == false);
break;
default:
messages = messages.Where(u => u.RecipientId == messageParams.UserId && u.RecipientDeleted == false && u.IsRead == false);
break;
}
messages = messages.OrderByDescending(d => d.MessageSent);
return(await PageList <MessageModel> .CreateAsync(messages, messageParams.PageNumber, messageParams.PageSize));
}
public async Task <Result <PageList <ActivityDto> > > Handle(Query request, CancellationToken cancellationToken)
{
var query = _context.Activities
.Where(d => d.Date >= request.Params.StartDate)
.OrderBy(d => d.Date)
.ProjectTo <ActivityDto>(_mapper.ConfigurationProvider,
new { currentUserName = _userAccessor.GetUserName() })
.AsQueryable();
// .ToListAsync(cancellationToken);
if (request.Params.IsGoing && !request.Params.IsHost)
{
query = query.Where(x => x.Attendees.Any(a => a.Username == _userAccessor.GetUserName()));
}
if (!request.Params.IsGoing && request.Params.IsHost)
{
query = query.Where(x => x.HostUsername == _userAccessor.GetUserName());
}
return(Result <PageList <ActivityDto> > .Success(
await PageList <ActivityDto> .CreateAsync(
query, request.Params.PageNumber, request.Params.PageSize)
)); // ToListAsync: extension method
}
public async Task <PageList <LikesDTO> > GetLikes(LikesParams likesParams)
{
IQueryable <LikesDTO> result = null;
if (likesParams.Predicate == "like")
{
result = _context.Users
.Include(x => x.Photos)
.Where(x => _context.Likes.Where(x => x.likedByUserId == likesParams.UserId).Select(x => x.likedUserId).Contains(x.Id))
.Select(u => new LikesDTO {
UserName = u.UserName,
Country = u.Country,
photoUrl = u.Photos.FirstOrDefault(x => x.isMain).Url,
Age = u.Age,
KnownAs = u.KnownAs,
}).OrderBy(x => x.KnownAs);
}
if (likesParams.Predicate == "likeBy")
{
result = _context.Users
.Include(x => x.Photos)
.Where(x => _context.Likes.Where(x => x.likedUserId == likesParams.UserId).Select(x => x.likedByUserId).Contains(x.Id))
.Select(u => new LikesDTO {
UserName = u.UserName,
Country = u.Country,
photoUrl = u.Photos.FirstOrDefault(x => x.isMain).Url,
Age = u.Age,
KnownAs = u.KnownAs,
}).OrderBy(x => x.KnownAs);
}
return(await PageList <LikesDTO> .CreateAsync(result, likesParams.PageSize, likesParams.PageNumber));
}
public async Task <PageList <Aluno> > GetAllAlunosAsync(PageParams pageParams, bool incluirDisciplina)
{
IQueryable <Aluno> query = _context.Alunos;
if (incluirDisciplina)
{
query = query.Include(a => a.AlunosDisciplinas) // Coloca dentro de alunos a tabela AlunosDisciplina
.ThenInclude(ad => ad.Disciplina) // Coloca dentro da tabela Alunos disciplina os dados da disciplina
.ThenInclude(d => d.Professor); // Coloca dentro da tabela disciplina os dados do professor que da a aula
}
query = query.AsNoTracking().OrderBy(a => a.Id);
if (!string.IsNullOrEmpty(pageParams.Nome))
{
query = query.Where(
aluno => aluno.Nome.ToUpper().Contains(pageParams.Nome.ToUpper()) ||
aluno.Sobrenome.ToUpper().Contains(pageParams.Nome.ToUpper())
);
}
if (pageParams.Matricula > 0)
{
query = query.Where(aluno => aluno.Matricula == pageParams.Matricula);
}
if (pageParams.Ativo)
{
query = query.Where(aluno => aluno.Ativo == pageParams.Ativo);
}
return(await PageList <Aluno> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.OrderByDescending(o => o.LastActive).AsQueryable();
users = users.Where(u => u.Id != userParams.UserId);
users = users.Where(u => u.Gender == userParams.Gender);
if (userParams.MinAge != 18 || userParams.MaxAge != 99)
{
var minDateOfBirth = DateTime.Today.AddYears(-userParams.MaxAge - 1);
var maxDateOfBirth = DateTime.Today.AddYears(-userParams.MinAge);
users = users.Where(u => u.DateOfBirth >= minDateOfBirth && u.DateOfBirth <= maxDateOfBirth);
}
if (!string.IsNullOrEmpty(userParams.OrderBy))
{
switch (userParams.OrderBy)
{
case "created":
users = users.OrderByDescending(o => o.Created);
break;
default:
users = users.OrderByDescending(o => o.LastActive);
break;
}
}
return(await PageList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PageList <LikeDto> > GetUserLikes(LikesParams likesParams)
{
var users = _context.Users.OrderBy(u => u.UserName).AsQueryable();
var likes = _context.Likes.AsQueryable();
if (likesParams.Predicate == "liked")
{
likes = likes.Where(like => like.SourceUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
if (likesParams.Predicate == "likedBy")
{
likes = likes.Where(like => like.LikedUserId == likesParams.UserId);
users = likes.Select(like => like.LikedUser);
}
var likeUsers = users.Select(user => new LikeDto
{
Username = user.UserName,
KnownAs = user.KnownAs,
Age = user.DateOfBirth.CalculateAge(),
PhotoUrl = user.Photos.FirstOrDefault(p => p.IsMain).Url,
City = user.City,
Id = user.Id
});
return(await PageList <LikeDto> .CreateAsync(likeUsers, likesParams.PageNumber, likesParams.PageSize));
}
public async Task <PageList <Aluno> > GetAllAlunosAsync(PageParams pageParams, bool includeProfessor = false)
{
IQueryable <Aluno> query = database.alunos;
if (includeProfessor)
{
query = query.Include(a => a.AlunosDisciplinas).ThenInclude(a => a.Disciplina).ThenInclude(a => a.Professor);
}
query = query.AsNoTracking().OrderBy(a => a.Id);
if (!string.IsNullOrEmpty(pageParams.Nome))
{
query = query.Where(aluno => aluno.Nome.ToUpper().Contains(pageParams.Nome.ToUpper()) || aluno.Sobrenome.ToUpper().Contains(pageParams.Nome.ToUpper()));
}
if (pageParams.Matricula > 0)
{
query = query.Where(aluno => aluno.Matricula == pageParams.Matricula);
}
if (pageParams.Ativo != null)
{
query = query.Where(aluno => aluno.Ativo == (pageParams.Ativo != 0));
}
return(await PageList <Aluno> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
// GET: /Sales
public async Task <IActionResult> Index(string sortOrder, string filter, string search, int?pageIndex)
{
ViewData["SortOrder"] = sortOrder; // SORT ORDER WHILE NAVIGATING "NEXT/PREVIOUS" PAGES
ViewData["SortCustomerNumber"] = String.IsNullOrEmpty(sortOrder) ? "cusnum_desc" : "";
ViewData["SortOrderCount"] = (sortOrder == "ordercount_asc") ? "ordercount_desc" : "ordercount_asc";
if (search != null)
{
pageIndex = 1; // NEW SEARCH LEADS TO NEW RESULTS, RESET PAGE TO 1
}
else
{
search = filter;
}
ViewData["SearchFilter"] = search; // KEEP SEARCH FILTER WHILE "PAGING"
IQueryable <CustomerOrdersViewModel> groupQuery =
from item in _ctx.Orders
group item by item.Customer.CustomerNumber into orderGroup
select new CustomerOrdersViewModel()
{
CustomerNumber = orderGroup.Key,
OrderCount = orderGroup.Count(),
};
if (!String.IsNullOrEmpty(filter))
{
groupQuery = groupQuery.Where(p => p.CustomerNumber.ToString().Contains(filter));
}
switch (sortOrder)
{
case "cusnum_desc":
groupQuery = groupQuery.OrderByDescending(p => p.CustomerNumber);
break;
case "ordercount_asc":
groupQuery = groupQuery.OrderBy(i => i.OrderCount);
break;
case "ordercount_desc":
groupQuery = groupQuery.OrderByDescending(i => i.OrderCount);
break;
default:
groupQuery = groupQuery.OrderBy(p => p.CustomerNumber);
break;
}
int itemsOnPage = 6;
// CONVERT QUERY TO SINGLE PAGE OF ITEMS IN COLLECTION THAT SUPPORTS PAGING
return(View(await PageList <CustomerOrdersViewModel> .CreateAsync(groupQuery.AsNoTracking(),
pageIndex ?? 1, // IF NULL, RETURN 1 - ELSE RETURN PAGEINDEX VALUE
itemsOnPage)));
//return View(await groupQuery.AsNoTracking().ToListAsync());
}
private async Task <PageList <TodoItem> > GetTestTodos()
{
var todos = new List <TodoItem>();
todos.Add(new TodoItem()
{
Id = "da57e03d-aa64-4655-9e9f-00bcc5e7fc9d",
Title = "Teszt Feladat 1234",
Description = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor.",
IsFinished = false
});
todos.Add(new TodoItem()
{
Id = "2083af66-2b81-420b-ad3b-3b5e2ed3d3eb",
Title = "Teszt Feladat 212389",
Description = "Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.",
IsFinished = false
});
todos.Add(new TodoItem()
{
Id = "a1b3f565-884a-4ac9-bfb1-9a73ce411923",
Title = "Teszt Feladat 12974",
Description = "Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.",
IsFinished = false
});
todos.Add(new TodoItem()
{
Id = "a64c051d-23fa-4a6e-8f17-0e3ddb328d6d",
Title = "Teszt Feladat 3447",
Description = "Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu.",
IsFinished = false
});
todos.Add(new TodoItem()
{
Id = "79629919-a85c-4215-8951-e0005cf26945",
Title = "Teszt Feladat 9999",
Description = " In enim justo, rhoncus ut, imperdiet a, venenatis vitae, justo.",
IsFinished = true
});
todos.Add(new TodoItem()
{
Id = "e9aba336-e89b-489b-ab34-d10765ef38c0",
Title = "Teszt Feladat 1357",
Description = "Nullam dictum felis eu pede mollis pretium. Integer tincidunt.",
IsFinished = true
});
todos.Add(new TodoItem()
{
Id = "e2174a67-8d46-4fb4-b360-d14cd4404247",
Title = "Teszt Feladat",
Description = "Cras dapibus. Vivamus elementum semper nisi. ",
IsFinished = true
});
var todosMock = todos.AsQueryable().BuildMock();
var pageList = await PageList <TodoItem> .CreateAsync(todosMock.Object, 1, 25);
return(pageList);
}
// GET: Products
public async Task <IActionResult> Index(string sortOrder, string filter, string search, int?pageIndex)
{
ViewData["SortOrder"] = sortOrder; // SORT ORDER WHILE NAVIGATING "NEXT/PREVIOUS" PAGES
ViewData["SortProductNumber"] = String.IsNullOrEmpty(sortOrder) ? "prodnum_desc" : "";
ViewData["SortPrice"] = (sortOrder == "price_asc") ? "price_desc" : "price_asc";
ViewData["SortName"] = (sortOrder == "name_asc") ? "name_desc" : "name_asc";
if (search != null)
{
pageIndex = 1; // NEW SEARCH LEADS TO NEW RESULTS, RESET PAGE TO 1
}
else
{
search = filter;
}
ViewData["SearchFilter"] = search;
var query = from product in _ctx.Products select product;
if (!String.IsNullOrEmpty(filter))
{
query = query.Where(p => p.ProductNumber.ToString().Contains(filter) || p.Name.Contains(filter));
}
switch (sortOrder)
{
case "prodnum_desc":
query = query.OrderByDescending(p => p.ProductNumber);
break;
case "price_asc":
query = query.OrderBy(p => p.Price);
break;
case "price_desc":
query = query.OrderByDescending(p => p.Price);
break;
case "name_asc":
query = query.OrderBy(p => p.Name);
break;
case "name_desc":
query = query.OrderByDescending(p => p.Name);
break;
default:
query = query.OrderBy(p => p.ProductNumber);
break;
}
int itemsOnPage = 3;
// CONVERT QUERY TO SINGLE PAGE OF ITEMS IN COLLECTION THAT SUPPORTS PAGING
return(View(await PageList <Product> .CreateAsync(query.AsNoTracking(),
pageIndex ?? 1, // IF NULL, RETURN 1 - ELSE RETURN PAGEINDEX VALUE
itemsOnPage)));
}
public async Task <PageList <User> > GetUsers(UserParams userParams)
{
var users = _context.Users.Include(p => p.Photos);
//return users;
return(await PageList <User> .CreateAsync(users, userParams.PageNumber, userParams.PageSize));
}
public async Task <PageList <Order> > GetCustomerOrders(int id, PageParams pageParams)
{
//var customer = await _dbContext.Customers.SingleOrDefaultAsync(c => c.Id == id);
var orders = _dbContext.Orders.Where(o => o.Customer.Id == id).AsQueryable();
return(await PageList <Order> .CreateAsync(orders, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <InvoiceSlabTypeHeaderDto> > GetInvoiceTypeslabHeader(int invProfile, int pageIndex, int pageSize)
{
var invSlabHeaderList = _tcContext.InvoiceSlabTypeHeaders.Where(x => x.InvoiceProfileId == invProfile)
.ProjectTo <InvoiceSlabTypeHeaderDto>(_mapper.ConfigurationProvider)
.AsNoTracking();
return(await PageList <InvoiceSlabTypeHeaderDto> .CreateAsync(invSlabHeaderList, pageIndex, pageSize));
}
public async Task <PageList <InvoiceProfileDto> > GetInvoiceProfile(int pageIndex, int pageSize)
{
var invProfileList = _tcContext.InvoiceProfiles
.ProjectTo <InvoiceProfileDto>(_mapper.ConfigurationProvider)
.AsNoTracking();
return(await PageList <InvoiceProfileDto> .CreateAsync(invProfileList, pageIndex, pageSize));
}
public async Task <PageList <Party> > GetPartyList(BaseParameter para)
{
var list = _db.Party
.OrderByDescending(p => p.PartyDate)
.AsQueryable();
return(await PageList <Party> .CreateAsync(list, para.PageNumber, para.PageSize));
}
public async Task <PageList <Project> > GetAllProjectsAsync(PageParams pageParams)
{
IQueryable <Project> query = _context.Project;
query = query.AsNoTracking().OrderBy(d => d.Id);
return(await PageList <Project> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <Turma> > GetAllTurmas(PageParams pageParams)
{
IQueryable <Turma> query = _context.Turmas
.Include(t => t.Escola);
//return await query.ToArrayAsync();
return(await PageList <Turma> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <Member> > GetUserFriends(ParaMember para)
{
var list = _db.Member
.Where(x => !x.IsCloseData)
.OrderByDescending(x => x.LastDate)
.AsQueryable();
return(await PageList <Member> .CreateAsync(list, para.PageNumber, para.PageSize));
}
public async Task <PageList <Aluno> > GetAllAlunos(PageParams pageParams)
{
IQueryable <Aluno> query = _context.Alunos.Include(a => a.Turma);
query = query.AsNoTracking().OrderBy(a => a.IdAluno);
//return await query.ToArrayAsync();
return(await PageList <Aluno> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <Activity> > GetMyActivityList(int userId, ParaActivity para)
{
var results = _db.Activity
.Where(x => x.UserId == userId)
.OrderByDescending(p => p.PartyId)
.AsQueryable();
return(await PageList <Activity> .CreateAsync(results, para.PageNumber, para.PageSize));
}
public async Task <PageList <Componentas> > GetComponents(ComponentParams componentParams)
{
var componentass = _context.Componentass.Include(p => p.Photos).AsQueryable();
if (componentParams.Size != null)
{
componentass = componentass.Where(u => u.Size == componentParams.Size);
}
if (componentParams.Type != null)
{
componentass = componentass.Where(u => u.Type == componentParams.Type);
}
if (componentParams.Mnf != null)
{
componentass = from u in componentass
where u.Mnf.Contains(componentParams.Mnf)
select u;
}
if (componentParams.Nominal != null)
{
componentass = from u in componentass
where u.Nominal.Contains(componentParams.Nominal)
select u;
}
if (componentParams.BuhNr != null)
{
componentass = from u in componentass
where u.BuhNr.Contains(componentParams.BuhNr)
select u;
}
if (!string.IsNullOrEmpty(componentParams.OrderBy))
{
switch (componentParams.OrderBy)
{
case "created":
componentass = componentass.OrderByDescending(u => u.Created);
break;
case "nominal":
componentass = componentass.OrderBy(u => u.Nominal);
break;
case "mnf":
componentass = componentass.OrderBy(u => u.Mnf);
break;
default:
componentass = componentass.OrderBy(u => u.Id);
break;
}
}
return(await PageList <Componentas> .CreateAsync(componentass, componentParams.PageNumber, componentParams.PageSize));
}
public async Task <PageList <Inventory> > GetProductInventories(Product product, PageParams pageParams)
{
var inventories = _dbContext.Inventories
.Where(i => i.Product == product)
.Where(i => i.IsArchived == false)
.AsQueryable();
return(await PageList <Inventory> .CreateAsync(inventories, pageParams.PageNumber, pageParams.PageSize));
}
public async Task <PageList <Member> > GetMemberList(BaseParameter para)
{
var list = _db.Member
.Include(x => x.MemberPhoto)
.OrderByDescending(x => x.UserId)
.AsQueryable();
return(await PageList <Member> .CreateAsync(list, para.PageNumber, para.PageSize));
}
public async Task <PageList <Party> > GetMemberPartyList(ParaMember para)
{
var partylist = _db.Activity
.Include(x => x.Party)
.OrderByDescending(x => x.Party.PartyDate)
.Where(x => x.UserId == para.UserId)
.Select(x => x.Party);
return(await PageList <Party> .CreateAsync(partylist, para.PageNumber, para.PageSize));
}
public async Task <PageList <CheckeDto> > GetCheckesAsync(CheckParams checkParams)
{
var query = _context.Checkes
.ProjectTo <CheckeDto>(_mapper.ConfigurationProvider)
.AsNoTracking()
.OrderByDescending(x => x.DateCreated)
.Where(x => x.DateCreated >= checkParams.MinDate && x.DateCreated <= checkParams.MaxDate);
return(await PageList <CheckeDto> .CreateAsync(query, checkParams.PageNumber, checkParams.PageSize));
}
public async Task <PageList <User> > GetUsers(UserParams userParams)
{
var loginUser = await this.GetUser(userParams.UserId);
var users = _context.Users.Include(p => p.Photos).AsQueryable();
users = users.Where(u => u.Gender != loginUser.Gender);
return(await PageList <User> .CreateAsync(users, userParams.CurrentPage, userParams.PageSize));
}
public async Task <PageList <Party> > GetHistoryList(ParaParty para)
{
var today = System.DateTime.Today;
var lists = _db.Party
.Where(p => p.PartyDate < today)
.OrderByDescending(p => p.PartyDate)
.AsQueryable();
return(await PageList <Party> .CreateAsync(lists, para.PageNumber, para.PageSize));
}
public async Task <IActionResult> GetMovieList(int page = 1)
{
if (_context.Movies.Count() == 0)
{
return(View("MovieList", new PageList <Movie>(new List <Movie>(), 1, 1, CountOnPage)));
}
page = Math.Clamp(page, 1, (int)Math.Ceiling(_context.Movies.Count() / (double)CountOnPage));
var pageList = await PageList <Movie> .CreateAsync(_context.Movies.Include(m => m.Author), page, CountOnPage);
return(View("MovieList", pageList));
}
public async Task <PageList <InventoryTransaction> > GetTransactionsByInventoryId(int id,
TransactionParams transactionParams)
{
var transactionQuery = _dbContext.InventoryTransactions
.Include(t => t.TransactionType)
.Where(t => t.IsArchived == false)
.Where(t => t.Inventory.Id == id).AsQueryable();
return(await PageList <InventoryTransaction> .CreateAsync(transactionQuery, transactionParams.PageNumber,
transactionParams.PageSize));
}
public async Task <BookingPage> GetBookingBySalesUnitIDAsync(int?salesUnitId, int?PageIndex, int?PageSize)
{
//validate parameters
if (salesUnitId == null)
{
throw new ArgumentNullException();
}
//Set default values if not specified
if (PageIndex == null)
{
PageIndex = 1;
}
if (PageSize == null)
{
PageSize = 1;
}
//Define the date duration for quering the data
DateTime dtStart = new DateTime(2016, 1, 1);
DateTime dtEnd = new DateTime(2016, 3, 31);
//Linq query to get list of bookings related to the sales unit
var fullInfoList = from b in _context.Bookings
join sItem in _context.Ships on b.ShipId equals sItem.Id
join soUnit in _context.SalesUnits on sItem.SalesUnitId equals soUnit.Id
where sItem.SalesUnitId.Equals(salesUnitId) && b.BookingDate.Date >= dtStart.Date && b.BookingDate.Date <= dtEnd.Date
orderby b.BookingDate descending
select new UIBooking()
{
Id = b.Id,
Currency = soUnit.Currency,
BookingDate = b.BookingDate,
Price = b.Price,
ShipName = sItem.Name
};
//initialize an object of class helper to select only one page of the result
var pageList = new PageList <UIBooking>();
//Get a page of result asynchrounosly
await pageList.CreateAsync(fullInfoList, PageIndex.Value, PageSize.Value);
//if page index is greater than the total page count
if (pageList.PageCount < PageIndex)
{
throw new IndexOutOfRangeException();
}
//return the specific page of result
return(new BookingPage()
{
TotalCount = pageList.TotalCount,
PageCount = pageList.PageCount,
BookingList = pageList.ToList()
});
}
