public async Task <PagedList <Employee> > GetEmployees(EmployeeParams employeeParams)
{
var employees = _context.Employees.Include(d => d.Designation)
.OrderByDescending(e => e.LastActive).AsQueryable();
//employees = employees.Where(u => u.Id != employeeParams.EmployeeId);
//employees = employees.Where(u => u.Gender == employeeParams.Gender);
//if (employeeParams.MinAge != 18 || employeeParams.MaxAge != 99)
//{
// var minDob = DateTime.Today.AddYears(-employeeParams.MaxAge - 1);
// var maxDob = DateTime.Today.AddYears(-employeeParams.MinAge);
// employees = employees.Where(u => u.DateOfBirth >= minDob && u.DateOfBirth <= maxDob);
//}
if (!string.IsNullOrEmpty(employeeParams.OrderBy))
{
switch (employeeParams.OrderBy)
{
case "created":
employees = employees.OrderByDescending(u => u.Created);
break;
default:
employees = employees.OrderByDescending(u => u.LastActive);
break;
}
}
return(await PagedList <Employee> .CreateAsync(employees, employeeParams.PageNumber, employeeParams.PageSize));
}
public async Task <IActionResult> GetDeletedEmployees([FromQuery] EmployeeParams <Employee> param)
{
param.Deleted = true;
var result = await GetAllEmployees(param);
return(Ok(result));
}
public async Task <IActionResult> GetEmployee(long id, [FromQuery] EmployeeParams employeeParams)
{
var employee = await _service.GetByIdAsync(id);
if (employeeParams.OperationStatus[employeeParams.GetOperationIndex] == employeeParams.Mode)
{
var employeeDto = _mapper.Map <EmployeeDetailDto>(employee);
return(Ok(employeeDto));
}
else
{
EmployeeEditDto employeeEditDto;
if (employeeParams.OperationStatus[employeeParams.CreateOperationIndex] == employeeParams.Mode)
{
employeeEditDto = new EmployeeEditDto();
}
else
{
employeeEditDto = _mapper.Map <EmployeeEditDto>(employee);
}
await _dataBuildHelper.GetAdditionalData(employeeEditDto);
return(Ok(employeeEditDto));
}
}
public async Task <PagedList <Employee> > GetEmployee(EmployeeParams employeeParams)
{
var employee = _context.Employees.OrderByDescending(x => x.FirstName).AsQueryable();
employee = employee.Where(x => x.EmployeeId != employeeParams.EmployeeId);
return(await PagedList <Employee> .CreateAsync(employee, employeeParams.PageNumber, employeeParams.PageSize));
}
public async Task<IActionResult> GetEmployees([FromQuery] EmployeeParams employeeParams)
{
var employee = await _repo.GetEmployee(employeeParams);
var employeeToReturn = _mapper.Map<IEnumerable<EmployeeForListDto>>(employee);
Response.AddPagination(employee.CurrentPage, employee.PageSize, employee.TotalCount, employee.TotalPages);
return Ok(employeeToReturn);
}
public async Task <PagedList <Employee> > GetAllEmployees(EmployeeParams Params)
{
var employee = _Context.Employees
.Include(b => b.Salary)
.Include(b => b.EmployeeDesignation)
.Include(b => b.Address)
.AsQueryable();
if (!string.IsNullOrEmpty(Params.Name))
{
employee = employee.Where(u => u.Name == Params.Name);
}
if (!string.IsNullOrEmpty(Params.Designation))
{
employee = employee.Where(u => u.EmployeeDesignation.Name == Params.Designation);
}
if (Params.Gender != null)
{
employee = employee.Where(u => u.Gender == Params.Gender);
}
if (Params.MinSalary != 10000 || Params.MaxSalary != 1000000)
{
employee = employee.Where(u => u.Salary.Salaries >= Params.MinSalary && u.Salary.Salaries <= Params.MaxSalary);
}
if (!string.IsNullOrEmpty(Params.OrderBy))
{
switch (Params.OrderBy)
{
case "Salary":
employee = employee.OrderByDescending(u => u.Salary.Salaries);
break;
case "Gender":
employee = employee.OrderByDescending(u => u.Gender);
break;
case "Department":
employee = employee.OrderByDescending(u => u.Department.Name);
break;
case "Designation":
employee = employee.OrderByDescending(u => u.EmployeeDesignation.Name);
break;
default:
employee = employee.OrderByDescending(u => u.Name);
break;
}
}
return(await PagedList <Employee> .CreateAsync(employee, Params.PageNumber, Params.PageSize));
}
public async Task <IEnumerable <EmployeeResource> > GetEmployees([FromQuery] EmployeeParams Params)
{
var Employee = await _repo.GetAllEmployees(Params);
var Employees = _mapper.Map <List <EmployeeResource> >(Employee);
Response.AddPagination(Employee.CurrentPage, Employee.PageSize,
Employee.TotalCount, Employee.TotalPages);
return(Employees);
}
public async Task <IActionResult> GetPagedEmployee([FromQuery] EmployeeParams employeeParams)
{
var employees = await employeeRepository.GetPagedEmployees(employeeParams);
var result = mapper.Map <IEnumerable <ViewEmployeeResource> >(employees);
Response.AddPagination(employees.CurrentPage, employees.PageSize, employees.TotalCount, employees.TotalPages);
return(Ok(result));
}
public async Task <PagedList <Employees> > GetEmployees(EmployeeParams employeeParams)
{
var employees = _context.Employees.Include(o => o.Orders).AsQueryable();
if (!string.IsNullOrEmpty(employeeParams.LastName))
{
employees = employees.Where(e => e.LastName.Contains(employeeParams.LastName));
}
return(await PagedList <Employees> .CreateAsync(employees, employeeParams.PageNumber, employeeParams.PageSize));
}
public async Task <IActionResult> Get([FromQuery] EmployeeParams employeeParams)
{
var employees = await _repo.GetEmployeesAsync(employeeParams);
if (employees == null)
{
return(NotFound());
}
return(Ok(employees));
}
public async Task <ActionResult> GetList([FromQuery] EmployeeParams <Employee> param)
{
var dailies = await _uow.DailyRepository.Get("", x => x.OrderBy(t => t.Details));
var empPagedList = await PagedList <Daily> .CreateAsync(dailies.AsQueryable(), param.PageNumber, param.PageSize);
var empsToReturn = _mapper.Map <IEnumerable <DailyListToReturn> > (empPagedList);
Response.AddPageination(empPagedList.CurrentPage, empPagedList.PageSize, empPagedList.TotalCount, empPagedList.TotalPages);
return(Ok(empsToReturn));
}
public async Task <PagedList <Employee> > GetEmployees(EmployeeParams employeeParams)
{
var employees = _context.Employees.Include(p => p.Photos).AsQueryable();
employees = employees.Where(e => e.IsDelete == false);
if (employeeParams.Name != null)
{
employees = employees.Where(e => e.Name.ToLower().Contains(employeeParams.Name));
}
if (employeeParams.Phone != null)
{
if (employeeParams.Phone.All(char.IsDigit))
{
employees = employees.Where(e => e.Phone.Contains(employeeParams.Phone));
}
}
if (employeeParams.Address != null)
{
employees = employees.Where(e => e.Address.ToLower().Contains(employeeParams.Address));
}
if (employeeParams.Gender != null)
{
employees = employees.Where(e => e.Gender.Contains(employeeParams.Gender));
}
if (employeeParams.Email != null)
{
employees = employees.Where(e => e.Email.ToLower().Contains(employeeParams.Email));
}
if (employeeParams.TeamId != 0)
{
employees = employees.Where(e => e.TeamId.Equals(employeeParams.TeamId));
}
if (employeeParams.Age != 0)
{
employees = employees.Where(e => e.DateOfBirth.CalculateAge() == employeeParams.Age);
}
return(await PagedList <Employee> .CreateAsync(employees, employeeParams.PageNumber, employeeParams.PageSize));
}
public async Task <IActionResult> GetEmployees([FromQuery] EmployeeParams employeeParams)
{
//var currentEmployeeId = int.Parse(Employee.FindFirst(ClaimTypes.NameIdentifier).Value);
//var employeeFromRepo = await _repo.GetEmployee(currentEmployeeId);
//employeeParams.EmployeeId = currentEmployeeId;
//if (string.IsNullOrEmpty(employeeParams.Gender))
//{
// employeeParams.Gender = employeeFromRepo.Gender == "male" ? "female" : "male";
//}
var employees = await _repo.GetEmployees(employeeParams);
var employeesToReturn = _mapper.Map <IEnumerable <EmployeeForListDto> >(employees);
Response.AddPagination(employees.CurrentPage, employees.PageSize,
employees.TotalCount, employees.TotalPages);
return(Ok(employeesToReturn));
}
public async Task <IActionResult> GetAllEmployees([FromQuery] EmployeeParams <Employee> param)
{
string gender = "";
string[] splitedName = param.Name.ToNormalizedString().Split(" ");
if (param.Male == true && param.Female == false)
{
gender = "Male";
}
else if (param.Female == true && param.Male == false)
{
gender = "Female";
}
else if (param.Female == false && param.Male == false)
{
gender = "None";
}
var emps = await _uow.EmployeeRepository.Get("Department",
x => x.OrderBy(t => t.Name), emp =>
splitedName.All (p => emp.KnownAs.Contains(p)) &&
emp.KnownAs.StartsWith (splitedName[0]) &&
emp.NationalId.StartsWith (param.NationalId == null ? string.Empty : param.NationalId) &&
emp.Grade.Contains (param.Grade == null ? string.Empty : param.Grade) &&
emp.Department.Name.Contains (param.Department) &&
emp.Section.Contains (param.Section == null ? string.Empty : param.Section) &&
emp.Collage.Contains (param.Collage == null ? string.Empty : param.Collage) &&
emp.Code.Contains ("") &&
emp.Gender.StartsWith (gender) &&
emp.Deleted == param.Deleted
);
var empPagedList = await PagedList <Employee> .CreateAsync(emps.AsQueryable(), param.PageNumber, param.PageSize);
var empsToReturn = _mapper.Map <IEnumerable <EmployeeDataListToReturnDto> > (empPagedList);
Response.AddPageination(empPagedList.CurrentPage, empPagedList.PageSize, empPagedList.TotalCount, empPagedList.TotalPages);
return(Ok(empsToReturn));
}
public async Task <IEnumerable <Employee> > GetEmployeesAsync(EmployeeParams employeeParams)
{
var employees = await _db.Employees.Include(x => x.Manager).OrderBy(x => x.PersonalIdentity).ToListAsync();
return(employees);
}
public async Task <PagedList <Employee> > GetPagedEmployees(EmployeeParams employeeParams)
{
var employees = context.Employee
.Include(e => e.Department)
.AsQueryable();
// perlu user id untuk membatasi
if (!string.IsNullOrEmpty(employeeParams.HrCoreNo))
{
employees = employees.Where(e =>
e.HrCoreNo.Contains(employeeParams.HrCoreNo, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(employeeParams.Firstname))
{
employees = employees.Where(e =>
e.Firstname.Contains(employeeParams.Firstname, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(employeeParams.Lastname))
{
employees = employees.Where(e =>
e.Lastname.Contains(employeeParams.Lastname, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(employeeParams.DepartmentCode))
{
employees = employees.Where(e =>
e.Department.Code.Contains(employeeParams.DepartmentCode, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(employeeParams.DepartmentName))
{
employees = employees.Where(e =>
e.Department.Name.Contains(employeeParams.DepartmentName, StringComparison.OrdinalIgnoreCase));
}
//name,sort
if (employeeParams.isDescending)
{
if (!string.IsNullOrEmpty(employeeParams.OrderBy))
{
switch (employeeParams.OrderBy.ToLower())
{
case "hrcoreno":
employees = employees.OrderByDescending(e => e.HrCoreNo);
break;
case "firstname":
employees = employees.OrderByDescending(e => e.Firstname);
break;
case "lastname":
employees = employees.OrderByDescending(e => e.Lastname);
break;
case "departmentcode":
employees = employees.OrderByDescending(e => e.Department.Code);
break;
case "departmentname":
employees = employees.OrderByDescending(e => e.Department.Name);
break;
default:
employees = employees.OrderByDescending(e => e.HrCoreNo);
break;
}
}
else
{
employees = employees.OrderByDescending(e => e.HrCoreNo);
}
}
else
{
if (!string.IsNullOrEmpty(employeeParams.OrderBy))
{
switch (employeeParams.OrderBy.ToLower())
{
case "hrcoreno":
employees = employees.OrderBy(e => e.HrCoreNo);
break;
case "firstname":
employees = employees.OrderBy(e => e.Firstname);
break;
case "lastname":
employees = employees.OrderBy(e => e.Lastname);
break;
case "departmentcode":
employees = employees.OrderByDescending(e => e.Department.Code);
break;
case "departmentname":
employees = employees.OrderByDescending(e => e.Department.Name);
break;
default:
employees = employees.OrderBy(e => e.HrCoreNo);
break;
}
}
else
{
employees = employees.OrderBy(e => e.HrCoreNo);
}
}
return(await PagedList <Employee>
.CreateAsync(employees, employeeParams.PageNumber, employeeParams.PageSize));
}
