public List <Patient> GetAll(PageParameters pageParameters)
{
string sql = "SELECT p.PatientId," +
"p.FirstName," +
"p.LastName," +
"p.Email," +
"p.CPF," +
"p.RG," +
"p.Phone," +
"p.BirthDate," +
"p.CreatedAt," +
"a.AppointmentId as Appointments_AppointmentId," +
"a.Schedule as Appointments_Schedule," +
"a.PatientId as Appointments_PatientId," +
"a.Description as Appointments_Description" +
" FROM patients p" +
" LEFT JOIN appointments a ON a.PatientId = p.PatientId" +
" ORDER BY p.FirstName " +
$" LIMIT {pageParameters.PageNumber},{pageParameters.PageSize}";
var data = _session.Connection.Query <dynamic>(sql);
AutoMapper.Configuration.AddIdentifier(typeof(Patient), "PatientId");
AutoMapper.Configuration.AddIdentifier(typeof(Appointment), "AppointmentId");
List <Patient> patients =
AutoMapper.MapDynamic <Patient>(data).ToList();
return(patients);
}
public async Task <PageList <Aluno> > GetAllAlunosAsync(PageParameters pageParams, bool includeProfessor = false)
{
IQueryable <Aluno> query = _context.Alunos;
if (includeProfessor)
{
query = query.Include(a => a.AlunosDisciplinas)
.ThenInclude(ad => ad.Disciplina)
.ThenInclude(d => d.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 query.ToListAsync();
return(await PageList <Aluno> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
}
public async Task ShouldReturnPageLinks(Mock <ITeamsService> teamsService, string code, Mock <IUrlHelper> urlHelper, TeamFacade value)
{
// Arrange
var pageParams = new PageParameters {
PageNumber = 2, PageSize = 1
};
urlHelper.Setup(
u => u.Link(
It.IsAny <string>(),
It.Is <PageParameters>(p => p.PageNumber == pageParams.PageNumber - 1 && p.PageSize == pageParams.PageSize)))
.Returns("PREV");
urlHelper.Setup(
u => u.Link(
It.IsAny <string>(),
It.Is <PageParameters>(p => p.PageNumber == pageParams.PageNumber + 1 && p.PageSize == pageParams.PageSize)))
.Returns("NEXT");
var pagedCollection = new PagedCollection <TeamFacade>(new[] { value }, pageParams.PageNumber, 3, pageParams.PageSize);
teamsService.Setup(s => s.GetTeams(code, pageParams, It.IsAny <CancellationToken>())).ReturnsAsync(pagedCollection);
var sut = new TeamsController(teamsService.Object, urlHelper.Object);
// Act
var ores = await sut.Get(code, pageParams);
// Assert
var okres = Assert.IsType <OkObjectResult>(ores);
var actual = Assert.IsType <PagedResult <TeamFacade> >(okres.Value);
Assert.True(actual.Links.ContainsKey(LinkType.PreviousPage));
Assert.True(actual.Links.ContainsKey(LinkType.NextPage));
Assert.Equal("NEXT", actual.Links[LinkType.NextPage].Href);
Assert.Equal("PREV", actual.Links[LinkType.PreviousPage].Href);
}
public async Task DeleteUserAsync_should_delete_existing_record()
{
var testDataUsed = new List <User>();
using (var context = GetContextWithData())
{
var repository = new UserRepository(context);
var newRecord = new User
{
Id = 32,
FirstName = "BarFirstFname",
LastName = "BarLastName",
Age = 23,
Address = "Delete Drive"
};
testDataUsed.Add(newRecord);
await repository.CreateUserAsync(newRecord);
var pageParameters = new PageParameters
{
Filter = "Delete Drive",
PageNumber = 1,
PageSize = 5,
SortColumn = "FirstName",
SortOrder = "asc"
};
var result = await repository.GetUsersAsync(pageParameters);
HandleInMemoryContextForCrudOperation(context, testDataUsed);
// validate new records creation part
Assert.NotNull(result);
var userList = new List <User>(result.Item1);
Assert.True(userList.Count == 1);
Assert.NotNull(userList[0]);
Assert.True(userList[0].FirstName.Equals(newRecord.FirstName, StringComparison.OrdinalIgnoreCase) && userList[0].Id > 0);
// validate deleting the records after creation.
var recordToDelete = new User {
Id = 0, FirstName = "BarFirstFname", LastName = "BarLastName"
};
testDataUsed.Add(newRecord);
HandleInMemoryContextForCrudOperation(context, testDataUsed);
await repository.DeleteUserAsync(userList[0]);
var updatedResult = await repository.GetUsersAsync(pageParameters);
Assert.NotNull(updatedResult);
var updatedList = new List <User>(updatedResult.Item1);
Assert.True(updatedList.Count == 0);
context.Database.EnsureDeleted();
}
}
public async Task <PagingResponse <PlaceInfo> > GetItems(PageParameters parameters)
{
var queryStringParam = new Dictionary <string, string>
{
["pageNumber"] = parameters.PageNumber.ToString(),
["searchTerm"] = parameters.SearchTerm == null ? "" : parameters.SearchTerm,
["orderBy"] = parameters.OrderBy
};
var response = await _client.GetAsync(QueryHelpers.AddQueryString("/api/placeinfo", queryStringParam));
var content = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException(content);
}
var pagingResponse = new PagingResponse <PlaceInfo>
{
Items = JsonSerializer.Deserialize <List <PlaceInfo> >(content, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
}),
MetaData = JsonSerializer.Deserialize <MetaData>(response.Headers.GetValues("X-Pagination").First(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
})
};
return(pagingResponse);
}
public ActionResult Create()
{
PageParameters _pageParameters = new PageParameters()
{
PageTitle = "Nuovo Preventivo",
ControllerName = ControllerName.PreventiveController,
HasScrollButton = false,
HasAddElementButton = false,
HasEditButton = false,
HasDeleteButton = false,
HasGeneralFilter = false
//ButtonMenu= new List<ButtonMenuViewModel>()
//{
// new ButtonMenuViewModel()
// {
// ButtonName="Salva e vai al detta",
// ButtonValue="SaveAndGenerate"
// }
//}
};
ViewBag.pageParameters = _pageParameters;
return(View());
}
public PagedDataViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//build observable predicate from search text
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//build observable sort comparer
var sort = SortParameters.WhenValueChanged(t => t.SelectedItem)
.Select(prop => prop.Comparer)
.ObserveOn(schedulerProvider.Background);
//build observable comparer
var currentPageChanged = PageParameters.WhenValueChanged(p => p.CurrentPage);
var pageSizeChanged = PageParameters.WhenValueChanged(p => p.PageSize);
var pager = currentPageChanged.CombineLatest(pageSizeChanged, (page, size) => new PageRequest(page, size))
.StartWith(new PageRequest(1, 25))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100));
// filter, sort, page and bind to observable collection
_cleanUp = tradeService.All.Connect()
.Filter(filter) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sort, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pager)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => PageParameters.Update(changes.Response))
.Bind(out _data) // update observable collection bindings
.DisposeMany() // dispose when no longer required
.Subscribe();
}
public IActionResult Query(int page = 1, int limit = 20, string search = "")
{
var result = new PageResultDto();
try
{
DynamicParameters parm = new DynamicParameters();
parm.Add("search", search);
parm.Add("page", page);
parm.Add("size", limit);
parm.Add("@count", dbType: System.Data.DbType.Int32, direction: System.Data.ParameterDirection.Output);
var par = new PageParameters <InterInvite>();
par.Proc = new PageProc {
ProcName = "pr_inter_invite_list", ProcParm = parm, ProcOutName = "count"
};
var list = _services.Query(par, out int outCount);
result.Data = list;
result.Count = outCount;
}
catch (Exception ex)
{
result.Code = (int)ResultCode.INTERNAL_SERVER_ERROR;
result.Msg = "内部操作错误，请联系管理员或查看错误日志。";
log.Error($"/{System.Reflection.MethodBase.GetCurrentMethod().Name}方法/错误信息：【{ex.Message}】");
}
return(Ok(result));
}
protected string CreateResourceUri(string apiRoute, PageParameters pageParameters, ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link(apiRoute,
new
{
pageNumber = pageParameters.PageNumber - 1,
pageSize = pageParameters.PageSize
}
));
case ResourceUriType.NextPage:
return(_urlHelper.Link(apiRoute,
new
{
pageNumber = pageParameters.PageNumber + 1,
pageSize = pageParameters.PageSize
}));
default:
return(_urlHelper.Link(apiRoute,
new
{
pageNumber = pageParameters.PageNumber,
pageSize = pageParameters.PageSize
}
));
}
}
public virtual IActionResult GetPage([FromQuery] PageParameters parameters)
{
var data = _baseRepository.GetPaged(parameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(data.MetaData));
return(Ok(data));
}
public async Task GetRestaurantsByCityAsync_GetRestaurants_RestaurantsGetedWhithPagination()
{
// Arrange
var pageParameters = new PageParameters()
{
PageNumber = Common.PageNumber,
PageSize = Common.PageSize
};
var commonVariables = new Common();
var resultRestaurants = commonVariables.Restaurants;
var resultRestaurantsDto = commonVariables.RestaurantsDto;
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <IRestaurantRepository>();
mockRepo.Setup(cityRepo =>
cityRepo.GetRestaurantsByCityAsync(It.IsAny <PageParameters>(), Common.CityId))
.Returns(Task.FromResult(resultRestaurants));
mockUow.Setup(rmService => rmService.Restaurants)
.Returns(mockRepo.Object);
var svc = new RestaurantManagementService(mockUow.Object);
// Act
var result = await svc.GetRestaurantsByCityAsync(pageParameters, Common.CityId);
// Assert
Assert.Equal(resultRestaurantsDto, result);
}
private PageParameters <User> GetIndexParameters(int?pageSize, int?pageNumber, string sort, string dir, string fullName, string email, string role)
{
Expression <Func <User, bool> > filter = u => (string.IsNullOrEmpty(fullName) || u.FullName.ToLower().Contains(fullName.ToLower())) &&
(string.IsNullOrEmpty(email) || u.Email.ToLower().Contains(email.ToLower())) &&
(string.IsNullOrEmpty(role) || u.Email.ToLower().Contains(email.ToLower()));
Expression <Func <User, dynamic> > orderBy = null;
switch (sort.ToLower())
{
case "fullname":
orderBy = u => u.FullName;
break;
case "email":
orderBy = u => u.Email;
break;
case "role":
orderBy = u => u.Role;
break;
default:
break;
}
PageParameters <User> pageParameters = new PageParameters <User>(pageSize, pageNumber, filter, orderBy, dir);
return(pageParameters);
}
public async Task <IHttpActionResult> GetVehicleModelsAsync(string search, int?makeId, string sortOrder = "", int?page = 1, int pageSize = 5, string sortBy = "")
{
var filter = new FilterParameters
{
Search = search,
MakeId = makeId
};
var sort = new SortParameters
{
SortBy = sortBy,
SortOrder = sortOrder
};
var pagep = new PageParameters
{
Page = (int)page,
PageSize = pageSize,
};
var vmlist = await _vehicleModelService.GetVehicleModelsAsync(sort, filter, pagep);
return(Ok(new
{
Data = vmlist,
PaggingInfo = vmlist.GetMetaData()
}));
}
public List <Subject> GetAll(PageParameters pageParameters)
{
string sql = $"SELECT * FROM subjects ORDER BY Name LIMIT {pageParameters.PageNumber}, 10";
List <Subject> subjects = _session.Connection.Query <Subject>(sql).ToList();
return(subjects);
}
public async Task <ActionResult <List <JobsiteDto> > > SearchJobsites([FromQuery] string q,
[FromQuery] PageParameters pageParameters)
{
try
{
//returns a paged list of query matches
var searchResults = await _repository.SearchJobsites(q, pageParameters);
var metadata = new
{
searchResults.TotalCount,
searchResults.PageSize,
searchResults.CurrentPage,
searchResults.HasNext,
searchResults.HasPrevious
};
//Add page info to header
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(_mapper.Map <List <JobsiteDto> >(searchResults)));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Server Error: Failed to find jobsite."));
}
}
public async Task <IActionResult> GetRolesAllAsync([FromQuery] PageParameters pageParameters)
{
//var id = Convert.ToInt32(User.Identity.Name);
IQueryable <Roles> source = context.Roles.Where(m => m.IsDel == 0);
//角色名称查询
if (!string.IsNullOrEmpty(pageParameters.RoleName))
{
source = source.Where(m => m.Name.Contains(pageParameters.RoleName) && m.IsDel == 0);
}
if (pageParameters.CreateTimeByFind != null)
{
source = source.Where(m => m.CreateTime >= pageParameters.CreateTimeByFind);
}
var pagelist = await PageList <Roles> .CreatePageList(source, pageParameters.Page, pageParameters.Limit);
var roleShowDtos = mapper.Map <List <RolesShowDto> >(pagelist.Source);
//var list = await context.Roles.ToListAsync();
//return Ok(new { code = 0, data = list });
return(Ok(new { code = 0, data = roleShowDtos, msg = "", count = pagelist.Count }));
}
public async Task <ActionResult <List <JobsiteDto> > > GetAllJobsites([FromQuery] PageParameters pageParameters)
{
try
{
var results = await _repository.GetAllJobsitesAsync(pageParameters);
//create metadata based on PagedList pagination
var metadata = new
{
results.TotalCount,
results.PageSize,
results.CurrentPage,
results.HasNext,
results.HasPrevious
};
//Add page info to header
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(_mapper.Map <List <JobsiteDto> >(results));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Server Error: Failed to retrieve all jobsites."));
}
}
public async Task <IActionResult> GetAllManagers([FromQuery] PageParameters pageParameters)
{
try
{
//admin status
var loggedInUser = await _userRepository.GetUser(_userAccessor.GetCurrentUsername());
if (loggedInUser.Admin == false)
{
return(Unauthorized(new RestError(HttpStatusCode.Unauthorized, new { Unauthorized = "Unauthorized to perform action" })));
}
//get all managers
var managers = await _userRepository.GetAllManagers(pageParameters);
var metadata = new
{
managers.TotalCount,
managers.PageSize,
managers.CurrentPage,
managers.HasNext,
managers.HasPrevious
};
//Add page info to header
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(_mapper.Map <ICollection <UserGeneralInfoDto> >(managers)));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Server Error: Failed to query database."));
}
}
public async Task <ActionResult <DeveloperGroupModel> > GetAllDevelopers([FromQuery] PageParameters pageParameters)
{
var developers = await _developerService.GetAllDeveloperPage(pageParameters.PageNumber, pageParameters.PageSize);
_logger.LogInformation($"Geting all {developers} by {_currentUserService.Username}");
return(Ok(developers));
}
public async Task <ActionResult <List <Album> > > Get([FromQuery] PageParameters parameters, [FromQuery] string nome, [FromServices] MaiaContext context)
{
if (nome == null)
{
int size = parameters.Size;
int page = parameters.Page;
try
{
return(await context.Albums
.Skip((page - 1) *size)
.Take(size)
.ToListAsync());
}
catch (Exception e)
{
throw e;
}
}
else
{
return(await context.Albums
.FromSqlRaw($"SELECT * FROM maia.albums WHERE Titulo LIKE '%{nome}%'")
.Include(a => a.Artista)
.ToListAsync());
}
}
public async Task GetUsersAsync_should_return_same_results_using_case_insensitive_filter()
{
using (var context = GetContextWithData())
{
var repository = new UserRepository(context);
var pageParameters = new PageParameters {
Filter = "Movies"
};
var result1 = await repository.GetUsersAsync(new PageParameters { Filter = "Movies" });
var result2 = await repository.GetUsersAsync(new PageParameters { Filter = "MOviEs" });
Assert.NotNull(result1);
Assert.NotNull(result2);
var userList1 = new List <User>(result1.Item1);
var userList2 = new List <User>(result2.Item1);
Assert.True(userList1.Count > 0 && userList1.Count == userList2.Count);
Assert.Equal(userList1[0].FirstName, userList2[0].FirstName);
var pageMetadata = result1.Item2;
Assert.NotNull(pageMetadata);
Assert.True(result1.Item2.RecordCount == result2.Item2.RecordCount); // same count in metadata
context.Database.EnsureDeleted();
}
}
/// <summary>
/// Get method,
/// /api/VehicleMake/?page=&pagesize=5&search=&sort=&direction=
/// </summary>
/// <param name="page">Current page</param>
/// <param name="pagesize">Page size, if page size is not given it's set to 0</param>
/// <param name="search">Search</param>
/// <param name="sort">Sort by Name or Abrv</param>
/// <param name="direction">Sort direction it can be ascending or descending</param>
/// <returns>Returns a list of VehicleMakeVM</returns>
public async Task <IHttpActionResult> Get(int?page, int?pagesize, string search, string sort, string direction)
{
var sortParameters = new SortParameters()
{
Sort = sort,
SortDirection = direction ?? "Descending"
};
var filterParameters = new FilterParameters()
{
Search = search
};
var pageParameters = new PageParameters()
{
Page = page ?? 1,
/*I set the page size to 0, because as you can see in VehicleMakeService when page size is set to 0 it skips pagging.
* Because in one case I need to get all of thevehicle makes.
* Example is in angular part when I need to get all VehicleMakes when I'm creating a new VehicleModel,
* it needs VehicleMakeId to be created.
* So a drop down menu with all Vehicle Makes can be created from which VehicleMakeId can be chosen from.
*/
PageSize = pagesize ?? 0
};
var vehicleMakeListPaged = AutoMapper.Mapper.Map <IPagedResult <VehicleMakeVM> >(await service.GetVehicleMakesAsync(sortParameters, filterParameters, pageParameters));
return(Ok(vehicleMakeListPaged));
}
public async Task GetUsersAsync_should_return_all_the_results_for_empty_filter()
{
using (var context = GetContextWithData())
{
var repository = new UserRepository(context);
var pageParameters = new PageParameters
{
Filter = string.Empty,
PageNumber = 1,
PageSize = 5,
SortColumn = "FirstName",
SortOrder = "asc"
};
var result = await repository.GetUsersAsync(pageParameters);
Assert.NotNull(result);
var userList = new List <User>(result.Item1);
Assert.NotNull(userList);
var pageMetadata = result.Item2;
Assert.NotNull(pageMetadata);
Assert.True(userList.Count == pageParameters.PageSize);
Assert.True(pageMetadata.RecordCount == 11);
context.Database.EnsureDeleted();
}
}
public async Task <IHttpActionResult> GetVehicleMakesAsync(string search, int?page = 1, int pageSize = 5, string sortOrder = "", string sortBy = "")
{
var filter = new FilterParameters
{
Search = search
};
var sort = new SortParameters
{
SortBy = sortBy,
SortOrder = sortOrder
};
var pagep = new PageParameters
{
Page = (int)page,
PageSize = pageSize
};
var vmlist = await _vehicleMakeService.GetVehicleMakesAsync(sort, filter, pagep);
var makeVMList = AutoMapper.Mapper.Map <IEnumerable <VehicleMakeVM> >(vmlist);
return(Ok(new
{
Data = makeVMList,
PaggingInfo = vmlist.GetMetaData()
}));
}
protected override async Task PublishFileToDestinationAsync(FileInfo sourceFile, DirectoryInfo destinationRoot, DocFile page, IssueLogger issues)
{
this.LogMessage(new ValidationMessage(sourceFile.Name, "Publishing file to HTML"));
var destinationPath = this.GetPublishedFilePath(sourceFile, destinationRoot, HtmlOutputExtension);
// Create a tag processor
string tagsInput;
if (null == PageParameters || !PageParameters.TryGetValue("tags", out tagsInput))
{
tagsInput = string.Empty;
}
var markdownSource = page.ReadAndPreprocessFileContents(tagsInput, issues);
var converter = this.GetMarkdownConverter();
var html = converter.Transform(markdownSource);
// Post-process the resulting HTML for any remaining tags
TagProcessor tagProcessor = new TagProcessor(tagsInput,
page.Parent.SourceFolderPath, LogMessage);
html = tagProcessor.PostProcess(html, sourceFile, converter);
var pageData = page.Annotation ?? new PageAnnotation();
if (string.IsNullOrEmpty(pageData.Title))
{
pageData.Title = (from b in page.OriginalMarkdownBlocks
where b.BlockType == BlockType.h1
select b.Content).FirstOrDefault();
}
page.Annotation = pageData;
await this.WriteHtmlDocumentAsync(html, page, destinationPath, destinationRoot.FullName);
}
public List <Academic> GetAll(PageParameters pageParameters)
{
string sql = "SELECT * FROM academics";
List <Academic> academics = (List <Academic>)_session.Connection.Query <Academic>(sql);
return(academics);
}
public override void WritePropertiesData(DataWriter writer)
{
writer.WriteStartObject(Name);
base.WritePropertiesData(writer);
if (Status == Core.Process.ProcessStatus.Inactive)
{
writer.WriteFinishObject();
return;
}
if (PageParameters != null)
{
if (PageParameters.GetType().IsSerializable || PageParameters.GetType().GetInterface("ISerializable") != null)
{
writer.WriteSerializableObjectValue("PageParameters", PageParameters, null);
}
}
if (!HasMapping("ProcessKey"))
{
writer.WriteValue("ProcessKey", ProcessKey, null);
}
if (!HasMapping("UserContextKey"))
{
writer.WriteValue("UserContextKey", UserContextKey, null);
}
if (!HasMapping("UseCurrentActivePage"))
{
writer.WriteValue("UseCurrentActivePage", UseCurrentActivePage, false);
}
writer.WriteFinishObject();
}
public async Task <PaginableList <User> > GetPagedList(PageParameters <User> pageParameter)
{
PaginableList <User> dataSource = new PaginableList <User>();
IQueryable <User> query = _context.Users;
if (pageParameter.Filter != null)
{
query = query.Where(pageParameter.Filter);
}
if (pageParameter.Includes != null)
{
pageParameter.Includes.ForEach(fk => query = query.Include(fk));
}
dataSource.TotalRows = await query.CountAsync();
if (pageParameter.Sort != null)
{
query = pageParameter.Direction == GridDirection.Asc ? query.OrderBy(pageParameter.Sort) : query.OrderByDescending(pageParameter.Sort);
}
dataSource.Rows = await query
.Skip((pageParameter.PageNumber - 1) *pageParameter.PageSize)
.Take(pageParameter.PageSize)
.ToListAsync();
return(dataSource);
}
public async Task <IActionResult> GetUser(int id, [FromQuery] PageParameters pageParameters)
{
int userId;
if (User.Identity.IsAuthenticated)
{
userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
}
else
{
userId = 0;
}
var user = await _repo.GetUserDetails(id, userId, pageParameters);
Pagger <UserDetailsPostDto> postToReturn = new Pagger <UserDetailsPostDto>(user.Posts);
DetailsUserPaggedDto detailsUserPaggedDto = new DetailsUserPaggedDto()
{
Login = user.Login,
Posts = postToReturn,
FirstName = user.FirstName,
LastName = user.LastName,
Description = user.Description,
MainPhotoUrl = user.MainPhotoUrl,
AmountFollowers = user.AmountFollowers,
AmoutnFollowing = user.AmoutnFollowing,
FollowingId = user.FollowingId
};
if (user == null)
{
return(NotFound());
}
return(Ok(detailsUserPaggedDto));
}
public PagedList <Employee> GetPaged_Status(int status, PageParameters parameters)
{
var data = GetEmployeebyStatus(status);
if (parameters.Search != null)
{
data = data.Where(x => x.EmployeeName.Contains(parameters.Search));
}
if (parameters.position != 0)
{
data = data.Where(x => x.PositionId == parameters.position).ToList();
}
if (parameters.title != 0)
{
data = data.Where(x => x.TitleId == parameters.title).ToList();
}
if (parameters.interviewaddress != null)
{
data = data.Where(x => x.InterviewAddress == parameters.interviewaddress).ToList();
}
if (parameters.from != null)
{
data = data.Where(x => x.InterviewTime > parameters.from).ToList();
}
if (parameters.to != null)
{
data = data.Where(x => x.InterviewTime < parameters.to).ToList();
}
return(GetPaged_Shered(data, parameters));
}
