public async Task <IActionResult> Index()
{
using (IDbConnection conn = Connection)
{
string sql = @"SELECT e.Id,
e.FirstName,
e.LastName,
e.IsSupervisor,
e.DepartmentId,
d.Id,
d.Name,
d.Budget
FROM Employee e JOIN Department d on e.DepartmentId = d.Id
ORDER BY e.Id";
IEnumerable <Employee> employees = await conn.QueryAsync <Employee, Department, Employee>(
sql,
(employee, department) =>
{
employee.Department = department;
return(employee);
});
EmployeeIndexViewModel model = new EmployeeIndexViewModel();
model.Employees = employees;
return(View(model));
}
}
// GET: Employee
public ActionResult Index(string query = null)
{
if (!String.IsNullOrWhiteSpace(query))
{
var employee = _context.Employees.Include(e => e.Contact).
Where(e => e.Name.Contains(query) ||
e.Designation.Contains(query) ||
e.Contact.Number.Contains(query)).ToList();
var viewModel = new EmployeeIndexViewModel()
{
Employee = employee,
SearchTerm = query
};
return(View(viewModel));
}
else
{
var employee = _context.Employees.Include(e => e.Contact).ToList();
var viewModel = new EmployeeIndexViewModel()
{
Employee = employee,
SearchTerm = query
};
return(View(viewModel));
}
}
// GET: Employee
public async Task <ActionResult> Index()
{
var employee = await _employeeRepository.GetEmployeeWithEventsAsync(CurrentUser);
var todayEvent = await _employeeRepository.GetEmployeeEventByDayAsync(CurrentUser, DateTime.Now.Day, DateTime.Now.Month);
var tomorrowEvent = await _employeeRepository.GetEmployeeEventByDayAsync(CurrentUser, DateTime.Now.Day + 1, DateTime.Now.Month);
var strategy = new PaymentStrategy();
strategy.SetPaymentStrategy(employee.PayMethod);
var payment = strategy.MakePayment(employee, DateTime.Now.Month, DateTime.Now.Year);
EmployeeIndexViewModel model = new EmployeeIndexViewModel
{
LoggedCompany = CurrentCompany, //BaseViewModel
LoggedUser = CurrentUser, //BaseViewModel
LogoUrl = CurrentLogoUrl, //BaseViewModel
Employee = employee,
Today = todayEvent,
Tomorrow = tomorrowEvent,
TotalPay = payment.TotalPay,
};
return(View(model));
}
public JsonResult EditEmployee(int id)
{
string status = "";
EmployeeIndexViewModel employee = null;
Employee dbEmployee = _db.Employees.Find(id);
if (dbEmployee != null)
{
employee = new EmployeeIndexViewModel
{
Id = dbEmployee.Id,
FirstName = dbEmployee.FirstName,
LastName = dbEmployee.LastName,
Designation = dbEmployee.Designation,
JoinDate = dbEmployee.JoinDate,
CurrentSalary = dbEmployee.CurrentSalary,
Department = dbEmployee.Department,
NextReviewDate = dbEmployee.NextReviewDate,
DateOfBirth = dbEmployee.DateOfBirth,
Gender = dbEmployee.Gender
};
}
else
{
status = "No Employee Found!";
}
return(Json(new { employee = employee, status = status }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 获取EmployeeIndexViewModel
/// </summary>
/// <param name="employeeIQ"></param>
/// <param name="pageIndex"></param>
/// <param name="username"></param>
/// <param name="orderByString"></param>
/// <param name="searchString"></param>
/// <param name="orderByType"></param>
/// <returns></returns>
public async Task <EmployeeIndexViewModel> GetEmployeeIndexModelAsync(int?pageIndex, string username, string orderByString, string searchString, string orderByType)
{
int pageSize = Configuration.GetSection("Constant").GetValue <int>("PageSize");
PaginatedList <Employee> paginatedList = await PaginatedList <Employee> .CreateAsync(EmployeeIQ, pageIndex ?? 1, pageSize);
EmployeeIndexViewModel employeeIndexModel = new EmployeeIndexViewModel(username, pageSize, orderByString, searchString, orderByType, paginatedList);
return(employeeIndexModel);
}
// GET: Employees
public IActionResult Index()
{
var employees = new EmployeeIndexViewModel
{
Employees = db.Employees.ToList()
};
return(View(employees)); //pass model to view
}
public ActionResult Index(int?page)
{
EmployeeIndexViewModel model = new EmployeeIndexViewModel()
{
EmployeeList = _employeeService.GetAll().ToPagedList(page ?? 1, PAGE_SIZE),
};
return(View(GetIndexViewModel(model)));
}
public ActionResult Index(EmployeeFilterModel filterModel)
{
EmployeeIndexViewModel model = new EmployeeIndexViewModel()
{
EmployeeList = filterModel.IsFiltered ? _employeeService.Filter(filterModel).ToPagedList() : _employeeService.GetAll().ToPagedList(1, PAGE_SIZE),
FilterModel = filterModel
};
return(View(GetIndexViewModel(model)));
}
//public async Task<ActionResult> Index()
//{
// var employee = await _db.Employees.ToListAsync();
// return View(employee);
//}
//[HttpPost]
//public async Task<ActionResult> Index(string searchData, string Filter_Value, int? pageNo)
//{
// ICollection<Employee> employee;
// if (searchData != null)
// {
// pageNo = 1;
// }
// else
// {
// searchData = Filter_Value;
// }
// ViewBag.FilterValue = searchData;
// if (!string.IsNullOrWhiteSpace(searchData))
// {
// employee = await _db.Employees
// .Where(emp => emp.FirstName.ToUpper().Contains(searchData.ToUpper())
// || emp.LastName.ToUpper().Contains(searchData.ToUpper())
// || emp.Designation.ToUpper().Contains(searchData.ToUpper())
// || emp.Department.ToUpper().Contains(searchData.ToUpper())
// || emp.Gender.ToUpper().Contains(searchData.ToUpper())).ToListAsync();
// }
// else
// {
// employee = await _db.Employees.ToListAsync();
// }
// int Size_Of_Page = 5;
// int No_Of_Page = pageNo ?? 1;
// return View(employee.ToPagedList(No_Of_Page, Size_Of_Page));
//}
public ActionResult Index()
{
var employees = _db.Employees.ToList();
var viewModel = new EmployeeIndexViewModel
{
Employees = employees
};
return(View(viewModel));
}
public async Task <PartialViewResult> EmployeesView(int?id)
{
EmployeeIndexViewModel employeeIndexViewModel = new EmployeeIndexViewModel();
var employees = await _webApiCalls.GetEmployeesAsync();
if (id != null)
{
employees = employees.Where(e => e.Id == id).ToList();
}
employeeIndexViewModel.Employees = employees;
return(PartialView("_Employees", employees));
}
public IActionResult Index(EmployeeIndexViewModel employeeIndexViewModel)
{
EmployeeIndexViewModel employeeView = new EmployeeIndexViewModel();
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var CurrentEmployee = _context.Employees.Where(w => w.IdentityUserId == userId).SingleOrDefault();
// we want to include people who have a one time pickup for todays date and are in the employees zipcode
// want to NOT include people who are within their selected suspension dates
employeeView.Customers = _context.Customers.Where(a => a.ZipCode == CurrentEmployee.ZipCode && a.RequestedDayEachWeek == employeeIndexViewModel.RequestedFilterDay).ToList();
return(View(employeeView));
}
public IActionResult Index(int page = 1, string position = "Все", string education = null, string type = null)
{
int pageSize = 20;
List <Employee> employees;
if (!cache.TryGetValue("Employees", out employees))
{
employees = db.Employees.ToList();
cache.Set("Employees", db.Employees.ToList(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(10)));
}
List <int> Ids = employees.Select(item => item.Id).ToList();
List <string> positions = employees.Select(item => item.Position).ToList();
positions.Add("Все");
if (position != "Все")
{
employees = employees.Where(item => item.Position == position).ToList();
}
if (education != null)
{
employees = employees.Where(item => item.Education.Contains(education)).ToList();
}
if (type != null)
{
employees = type switch
{
"Id" => employees.OrderBy(item => item.Id).ToList(),
"pos" => employees.OrderBy(item => item.Position).ToList(),
"fio" => employees.OrderBy(item => item.FIO).ToList(),
_ => employees.OrderBy(item => item.Education).ToList(),
};
}
EmployeeIndexViewModel employeeIndexViewModel = new EmployeeIndexViewModel()
{
Employees = employees.Skip((page - 1) * pageSize).Take(pageSize).ToList(),
Ids = Ids,
PageViewModel = new PageViewModel(employees.Count, page, pageSize),
FilterPositions = positions
};
return(View(employeeIndexViewModel));
}
public ActionResult Index()
{
var company = db.Employees.Find(User.Identity.GetUserId()).Company;
List<Employee> employees = company.Employees.ToList();
EmployeeIndexViewModel employeesIndex = new EmployeeIndexViewModel();
List<EmployeeViewModel> employeesList = new List<EmployeeViewModel>();
foreach (Employee elem in employees)
{
var roleId = elem.Roles.FirstOrDefault().RoleId;
var role = db.Roles.Where(x => x.Id == roleId).FirstOrDefault();
employeesList.Add(new EmployeeViewModel() { Employee = elem, EmployeeType = role.Name });
}
employeesIndex.EmployeesVM = employeesList.AsQueryable();
return View(employeesIndex);
}
public IActionResult AddEmployee(EmployeeIndexViewModel model)
{
var fios = db.Employees.Select(item => item.FIO);
ViewData["Message"] = "";
model.Employees = db.Employees.ToList();
model.Ids = db.Employees.Select(item => item.Id).ToList();
if (model.FIO == null || model.Education == null || model.Position == null)
{
ViewData["Message"] += "Отсутствие значений в строках";
return(View("~/Views/Employee/Index.cshtml", model));
}
if (fios.Contains(model.FIO) || model.FIO.Length == 0 || model.FIO.Length > 100)
{
ViewData["Message"] += "Неправильный ввод ФИО";
return(View("~/Views/Employee/Index.cshtml", model));
}
else if (model.Position.Length == 0 || model.Position.Length > 50)
{
ViewData["Message"] += "Неправильный ввод должности";
return(View("~/Views/Employee/Index.cshtml", model));
}
else if (model.Education.Length < 9 || model.Education.Length > 200)
{
ViewData["Message"] += "Неправильный ввод образования";
return(View("~/Views/Employee/Index.cshtml", model));
}
else
{
var id = 0;
if (db.Employees.Count() != 0)
{
id = db.Employees.Select(item => item.Id).Max();
}
id++;
db.Employees.Add(new Employee()
{
Id = id, FIO = model.FIO, Position = model.Position, Education = model.Education
});
db.SaveChanges();
cache.Remove("Employees");
cache.Set("Employees", db.Employees.ToList(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(10)));
return(RedirectToAction("Index", "Employee"));
}
}
/// <summary>
/// 查询排序分页
/// </summary>
/// <param name="searchString"></param>
/// <param name="orderByString"></param>
/// <param name="pageIndex"></param>
/// <returns></returns>
// GET: Employees
public async Task <IActionResult> Index(string searchString, string orderByString, int?pageIndex, string username, string orderByType)
{
username = HttpContext.Session.GetString("loginUsername");
//IQueryable<Employee> employeeIQ = _context.Employee;
// 查询
if (!string.IsNullOrEmpty(searchString))
{
EmployeeIQ = EmployeesService.SearchEmployee(searchString.Trim());
}
// 排序
if (!string.IsNullOrEmpty(orderByString))
{
EmployeeIQ = EmployeesService.OrderByEmployee(orderByString, orderByType);
}
EmployeeIndexViewModel employeeIndexModel = await EmployeesService.GetEmployeeIndexModelAsync(pageIndex, username, orderByString, searchString, orderByType);
return(View(employeeIndexModel));
}
public IActionResult UpdateEmployee(EmployeeIndexViewModel model, string action = null)
{
if (action != null)
{
return(DeleteEmployee(model.Id));
}
var fios = db.Employees.Select(item => item.FIO);
ViewData["Message"] = "";
model.Employees = db.Employees.ToList();
model.Ids = db.Employees.Select(item => item.Id).ToList();
if (model.FIO == null || model.Education == null || model.Position == null)
{
ViewData["Message"] += "Отсутствие значений в строках";
return(View("~/Views/Employee/Index.cshtml", model));
}
if (fios.Contains(model.FIO) || model.FIO.Length == 0 || model.FIO.Length > 100)
{
ViewData["Message"] += "Неправильный ввод ФИО";
return(View("~/Views/Employee/Index.cshtml", model));
}
else if (model.Position.Length == 0 || model.Position.Length > 50)
{
ViewData["Message"] += "Неправильный ввод должности";
return(View("~/Views/Employee/Index.cshtml", model));
}
else if (model.Education.Length < 0 || model.Education.Length > 200)
{
ViewData["Message"] += "Неправильный ввод образования";
return(View("~/Views/Employee/Index.cshtml", model));
}
else
{
var employee = db.Employees.Where(item => item.Id == model.Id).FirstOrDefault();
employee.FIO = model.FIO;
employee.Position = model.Position;
employee.Education = model.Education;
db.SaveChanges();
cache.Remove("Employees");
cache.Set("Employees", db.Employees.ToList(), new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(10)));
return(RedirectToAction("Index", "Employee"));
}
}
public async Task <IActionResult> Index(string firstName, string lastName, string jobTitle,
string telephone, string mobileTelephone, string email)
{
List <Employee> employeeList = await EmployeeRepo.GetAll();
if (!string.IsNullOrEmpty(firstName))
{
employeeList = employeeList.Where(f => f.FirstName.Contains(firstName)).ToList();
}
if (!string.IsNullOrEmpty(lastName))
{
employeeList = employeeList.Where(l => l.LastName.Contains(lastName)).ToList();
}
if (!string.IsNullOrEmpty(jobTitle))
{
employeeList = employeeList.Where(j => j.JobTitle.Contains(jobTitle)).ToList();
}
if (!string.IsNullOrEmpty(telephone))
{
employeeList = employeeList.Where(t => t.Telephone.Contains(telephone)).ToList();
}
if (!string.IsNullOrEmpty(mobileTelephone))
{
employeeList = employeeList.Where(m => m.MobileTelephone.Contains(mobileTelephone)).ToList();
}
if (!string.IsNullOrEmpty(email))
{
employeeList = employeeList.Where(e => e.Email.Contains(email)).ToList();
}
EmployeeIndexViewModel employeeIndexViewModel = new EmployeeIndexViewModel()
{
Employees = employeeList
};
return(View(employeeIndexViewModel));
}
public IActionResult Index()
{
var result = _Employee.Employees().Select
(
a => new EmployeeViewModel
{
Id = a.Id,
EmployeeNo = a.EmployeeNo,
Name = a.LastName + ", " + a.FirstName + " " + a.MiddleName,
Company = a.Company.Description,
Branch = a.Branch.Description,
Department = a.Department.Description,
Position = a.Position.Description,
}
).ToList();
var model = new EmployeeIndexViewModel
{
Employees = result
};
return(View(model));
}
// GET: Employees
public async Task <IActionResult> Index()
{
EmployeeIndexViewModel employeeView = new EmployeeIndexViewModel();
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var CurrentEmployee = _context.Employees.Where(w => w.IdentityUserId == userId).SingleOrDefault();
if (CurrentEmployee == null)
{
return(RedirectToAction("Create"));
}
ViewData["RequestedDayOfWeek"] = new SelectList(_context.Users, "Id", "RequestedDayOfWeek");
// we want to include people who have a one time pickup for todays date and are in the employees zipcode
// want to NOT include people who are within their selected suspension dates
string dayOfWeek = DateTime.Today.DayOfWeek.ToString();
employeeView.Customers = await _context.Customers.Where(a => a.ZipCode == CurrentEmployee.ZipCode && a.RequestedDayEachWeek == dayOfWeek).ToListAsync();
return(View(employeeView));
}
// GET
public async Task <IActionResult> Index(int page = 1)
{
string userId = _userManager.GetUserId(User);
if (User.IsInRole(Convert.ToString(Roles.SuperAdmin)))
{
User admin = await _userManager.FindByIdAsync(userId);
userId = admin.IdOfTheSelectedRestaurateur;
}
User user = await _db.Users.FirstOrDefaultAsync(u => u.Id == userId);
int pageSize = 5;
List <User> users = _db.Users.Where(u => u.RestaurantId == user.RestaurantId && u.Position == EmployeePosition.AdministratorRestaurant || u.Position == EmployeePosition.ContentManager).Skip((page - 1) * pageSize).Take(pageSize).ToList();
SuperAdminIndexPageInfo pageInfo = new SuperAdminIndexPageInfo {
PageNumber = page, PageSize = pageSize, TotalItems = _db.Users.Count(u => u.RestaurantId == user.RestaurantId && u.Position == EmployeePosition.AdministratorRestaurant || u.Position == EmployeePosition.ContentManager)
};
EmployeeIndexViewModel ivm = new EmployeeIndexViewModel {
PageInfo = pageInfo, Users = users
};
return(View(ivm));
}
public async Task <IActionResult> Index(
string searchFirstName, string searchDepartment,
int?page,
string currentOrderParam, string sortOrderParam = "FirstName", string sortOrder = "asc"
)
{
// if (!IsLogin()) { return RedirectToAction("Login", "Login"); } //login already?
IQueryable <Employee> employees = _context.Employee;
employees = SearchEmployees(searchFirstName, searchDepartment, employees);
//sort
sortOrder = JudgeSortOrder(sortOrderParam, currentOrderParam, sortOrder);
employees = SortEmployees(sortOrder, sortOrderParam, employees);
int pageSize = Configuration.GetSection("Constant").GetValue <int>("PageSize");
PaginatedList <Employee> pageShow = await PaginatedList <Employee> .CreateAsync(employees.AsNoTracking(), page ?? 1, pageSize);
EmployeeIndexViewModel employeeIndexViewModel = new EmployeeIndexViewModel(searchFirstName, searchDepartment, sortOrderParam, sortOrder, pageShow);
return(View(employeeIndexViewModel));
}
public ActionResult Search(EmployeeIndexViewModel viewModel)
{
return(RedirectToAction("Index", "Employee", new { query = viewModel.SearchTerm }));
}
public IActionResult Index(EmployeeIndexViewModel model)
{
//1. Initialize pager
#region Pagination
model.Pager = model.Pager ?? new PagerViewModel();
model.Pager.CurrentPage = model.Pager.CurrentPage <= 0 ? 1 : model.Pager.CurrentPage;
model.Pager.ItemsPerPage = model.Pager.ItemsPerPage <= 0 ? 10 : model.Pager.ItemsPerPage;
#endregion
//2. Initialize filter, 3. Check if the filter is active, 4. Query filtered items
#region Filter
//2. Initialize Filter
model.Filter = model.Filter ?? new EmployeeFilterViewModel();
//3. Check if the filter is active
bool emptyUsername = string.IsNullOrWhiteSpace(model.Filter.Username);
bool emptyFirstName = string.IsNullOrWhiteSpace(model.Filter.FirstName);
bool emptyMiddleName = string.IsNullOrWhiteSpace(model.Filter.MiddleName);
bool emptyLastName = string.IsNullOrWhiteSpace(model.Filter.LastName);
bool emptyEmail = string.IsNullOrWhiteSpace(model.Filter.Email);
//4. Query
IQueryable <EmployeeUser> employeeUsers = _userManager.Users
.Where(item =>
(emptyUsername || item.UserName.Contains(model.Filter.Username)) &&
(emptyFirstName || item.FirstName.Contains(model.Filter.FirstName)) &&
(emptyMiddleName || item.MiddleName.Contains(model.Filter.MiddleName)) &&
(emptyLastName || item.LastName.Contains(model.Filter.LastName)) &&
(emptyEmail || item.Email.Contains(model.Filter.Email)));
#endregion
//5. Build view model object
//Calculate total pages
model.Pager.Pages = (int)Math.Ceiling((double)employeeUsers.Count() / model.Pager.ItemsPerPage);
//Calculate which users to show on the current page and order them by whether they are active or not
employeeUsers = employeeUsers.OrderByDescending(item => item.IsActive)
.Skip((model.Pager.CurrentPage - 1) * model.Pager.ItemsPerPage)
.Take(model.Pager.ItemsPerPage);
//Make viewmodels from the EmployeeUser items to show in the View
model.Items = employeeUsers.Select(item => new EmployeeViewModel()
{
Id = item.Id,
FirstName = item.FirstName,
MiddleName = item.MiddleName,
LastName = item.LastName,
UserName = item.UserName,
Email = item.Email,
PhoneNumber = item.PhoneNumber,
EGN = item.EGN,
Reservations = item.Reservations.Select(res => new ReservationViewModel()
{
Id = res.Id,
RoomId = res.RoomId,
CreatorId = res.CreatorId,
Arrival = res.Arrival,
Departure = res.Departure,
BreakfastIncluded = res.BreakfastIncluded,
IsAllInclusive = res.IsAllInclusive,
TotalSum = res.TotalSum
}).ToList(),
Hired = item.Hired,
IsActive = item.IsActive,
Fired = item.Fired
});
return(View(model));
}
private EmployeeIndexViewModel GetIndexViewModel(EmployeeIndexViewModel currModel)
{
currModel.FilterModel = currModel.FilterModel ?? new EmployeeFilterModel();
return(currModel);
}
