// GET: LeaveAllocationController/Details/5
public async Task <ActionResult> Details(string id)
{
var user = await _userManager.FindByIdAsync(id);
var currentUser = _userManager.GetUserAsync(User).Result;
if ((User.IsInRole("Nhân viên") || User.IsInRole("Kế toán")) &&
currentUser.Id != id)
{
return(NotFound("Nhân viên bình thường chỉ có thể xem hồ sơ mật của mình, không thể xem hồ sơ của người khác."));
}
var employee = _mapper.Map <EmployeeVM>(user);
employee.NhanVienThemVaoHeThong = _mapper.Map <EmployeeVM>(await _userManager.FindByIdAsync(user.MaNhanVienThemVaoHeThong));
employee.ChucVu = _mapper.Map <ChucVusVM>(await _chucVuRepo.FindById(user.MaChucVu));
employee.ChuyenMon = _mapper.Map <ChuyenMonsVM>(await _chuyenMonRepo.FindById(user.MaChuyenMon));
employee.PhongBan = _mapper.Map <PhongBansVM>(await _phongBanRep.FindById(user.MaPhongBan));
var maVaiTroTrenHeThong = await userRoleRepository.FindRoleIdByUserID(employee.Id);
employee.VaiTroTrenHeThong = await _roleRepository.FindById(maVaiTroTrenHeThong);
var allocations = _mapper.Map <List <LeaveAllocationVM> >(
await _leaveallocationrepo.GetLeaveAllocationsByEmployee(id));
var model = new ViewAllocationsVM
{
Employee = employee,
LeaveAllocations = allocations,
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
Employee employee = await _userManager.GetUserAsync(User);
string employeeId = employee.Id;
ICollection <LeaveAllocation> employeeAllocations = await _leaveAllocationRepo
.GetLeaveAllocationsByEmployee(employeeId);
ICollection <LeaveRequest> employeeRequests = await _leaveRequestRepo
.GetLeaveRequestsByEmployee(employeeId);
List <LeaveAllocationViewModel> employeeAllocationsModel = _mapper
.Map <List <LeaveAllocationViewModel> >(employeeAllocations);
List <LeaveRequestViewModel> employeeRequestsModel = _mapper
.Map <List <LeaveRequestViewModel> >(employeeRequests);
EmployeeLeaveRequestViewViewModel model = new EmployeeLeaveRequestViewViewModel
{
LeaveAllocations = employeeAllocationsModel,
LeaveRequests = employeeRequestsModel
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
try
{
var user = _userManager.GetUserAsync(User).Result;
var userId = user.Id;
var allocations = await _allocationsRepo.GetLeaveAllocationsByEmployee(userId);
var employeeRequests = await _leaveRequestRepo.GetLeaveRequestsByEmployee(userId);
var employeeAllocationModel = _mapper.Map <List <LeaveAllocationViewModel> >(allocations);
var employeeRequestsModel = _mapper.Map <List <LeaveRequestViewModel> >(employeeRequests);
var model = new EmployeeViewLeaveRequestViewModel
{
LeaveAllocations = employeeAllocationModel,
LeaveRequesrts = employeeRequestsModel
};
return(View(model));
}
catch (Exception)
{
return(RedirectToAction(nameof(Index), "Home"));
}
}
public async Task <ActionResult> MyLeave()
{
try
{
var employee = await _userManager.GetUserAsync(User);
var employeeid = employee.Id;
var employeeAllocations = await _repoleaveallocation.GetLeaveAllocationsByEmployee(employeeid);
var employeeRequests = await _repoleaverequest.GetLeaveRequestsByEmployee(employeeid);
var employeeAllocationsModel = _mapper.Map <List <LeaveAllocationVM> >(employeeAllocations);
var employeeRequestsModel = _mapper.Map <List <LeaveRequestVM> >(employeeRequests);
var model = new EmployeeLeaveRequestVM
{
LeaveAllocations = employeeAllocationsModel,
LeaveRequests = employeeRequestsModel
};
return(View(model));
}
catch
{
return(View());
}
}
// GET: LeaveRequestController/Create
public async Task <ActionResult> Create()
{
var userId = _userManager.GetUserAsync(User).Result.Id;
var EmployeeAllocation = await _leaveAllocationRepo.GetLeaveAllocationsByEmployee(userId);
var list = new List <LeaveType>();
foreach (var item in EmployeeAllocation.ToList())
{
list.Add(item.LeaveType);
}
var leaveTypeItems = list.Select(q => new SelectListItem {
Text = q.Name,
Value = q.Id.ToString()
});
var model = new CreateLeaveRequestVm
{
LeaveTypes = leaveTypeItems
};
return(View(model));
}
// GET: LeaveAllocation/Details/5
public async Task <ActionResult> Details(string id)
{
var employee = _mapper.Map <EmployeeVM>(await _userManager.FindByIdAsync(id));
var allocations = _mapper.Map <List <LeaveAllocationVM> >(await _repoleaveAllocation.GetLeaveAllocationsByEmployee(id));
var model = new ViewAllocationVM {
Employee = employee, LeaveAllocationVMs = allocations
};
return(View(model));
}
// GET: LeaveAllocationsController1/Details/5
public ActionResult Details(string id)
{
var model = new ViewAllocationsVM
{
Employee = _mapper.Map <EmployeeVM>(_userManager.FindByIdAsync(id).Result),
LeaveAllocations = _mapper.Map <ICollection <LeaveAllocationVM> >(_leaveAllocationRepo.GetLeaveAllocationsByEmployee(id))
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
var EmployeeId = _userManager.GetUserAsync(User).Result.Id;
var requests = await _requestRepo.GetLeaveRequestByEmployee(EmployeeId);
var allocations = await _allocationRepo.GetLeaveAllocationsByEmployee(EmployeeId);
var MappedAllocations = _mapper.Map <List <LeaveAllocationVM> >(allocations.ToList());
var MappedRequest = _mapper.Map <List <LeaveRequestVM> >(requests.ToList());
var model = new MyEmployeeLeaveVM
{
LeaveAllocations = MappedAllocations,
LeaveRequests = MappedRequest
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
var employee = await _userManager.GetUserAsync(User);
var employeeid = employee.Id;
var employeeAllocations = await _leaveAllocRepo.GetLeaveAllocationsByEmployee(employeeid);
var employeeRequests = await _leaveRequestRepo.GetLeaveRequestsByEmployee(employeeid);
var employeeAllocationModel = _mapper.Map <List <LeaveAllocationVM> >(employeeAllocations);
var employeeRequestModel = _mapper.Map <List <LeaveRequestVM> >(employeeRequests);
var model = new EmployeeLeaveRequestViewVM
{
LeaveAllocations = employeeAllocationModel,
LeaveRequests = employeeRequestModel
};
return(View(model));
}
// GET: LeaveAllocation/Details/5
public ActionResult Details(string id)
{
var employee = _mapper.Map <EmployeeVM>(_userManager.FindByIdAsync(id).Result);
var allocations = _mapper.Map <List <LeaveAllocationVM> >(_allocationRepo.GetLeaveAllocationsByEmployee(id));
var model = new ViewAllocationVM {
Employee = employee,
LeaveAllocations = allocations
};
return(View(model));
}
// GET: LeaveAllocation/Details/5
public ActionResult Details(string id)
{
var employee = _mapper.Map <EmployeeViewModel>(_userManager.FindByIdAsync(id).Result);
var allocations = _repository.GetLeaveAllocationsByEmployee(id);
var model = new ViewAllocationsViewModel
{
Employee = employee,
LeaveAllocations = _mapper.Map <List <LeaveAllocationViewModel> >(allocations)
};
return(View(model));
}
// GET: LeaveAllocationController/Details/5
public async Task <ActionResult> Details(string id)
{
var employee = _mapper.Map <EmployeeViewModel>(_userManager.FindByIdAsync(id).Result);
var allocations = _mapper.Map <List <LeaveAllocationViewModel> >(await _allocationrepo.GetLeaveAllocationsByEmployee(id));
var model = new ViewLeaveAllocationsViewModel
{
Employee = employee,
LeaveAllocation = allocations
};
return(View(model));
}
// GET: LeaveAllocationCotroller/Details/5
public ActionResult Details(string id)
{
var employee = _mapper.Map <EmployeeViewModel>(_userManager.FindByIdAsync(id).Result);
var period = DateTime.Now;
var allocations = _mapper.Map <List <LeaveAllocationViewModel> >(_leaveallocationrepo.GetLeaveAllocationsByEmployee(id));
var model = new ViewAllocationViewModel
{
Employee = employee,
LeaveAllocations = allocations
};
return(View(model));
}
// GET: LeaveAllocation/Details/5
public async Task <ActionResult> Details(string id) //from int to string
{
var employee = _mapper.Map <EmployeeVM>(await _userManager.FindByIdAsync(id)); //whenever we get data we need map it
//retrive all the leave allocation for this employee
var allocations = _mapper.Map <List <LeaveAllocationVM> >(await _leaveallocationrepo.GetLeaveAllocationsByEmployee(id)); //list to VM
var model = new ViewAllocationVM
{
Employee = employee,
LeaveAllocations = allocations
};
return(View(model));
}
// GET: LeaveAllocations/Details/5
public ActionResult Details(string id)
{
// We need result when it's async
var employee = _mapper.Map <EmployeeViewModel>(_userManager.FindByIdAsync(id).Result);
var allocations = _mapper.Map <List <LeaveAllocationViewModel> >(_leaveAllocationrepo.GetLeaveAllocationsByEmployee(id));
var model = new ViewAllocationsVM
{
Employee = employee,
LeaveAllocations = allocations
};
return(View(model));
}
public IActionResult MyLeave()
{
var leaveRequests = _leaveRequestRepository.FindAll().Where(x => x.RequestingEmployee.Id == _userManager.GetUserAsync(User).Result.Id);
var leaveAllocations = _leaveAllocationRepository.GetLeaveAllocationsByEmployee(_userManager.GetUserAsync(User).Result.Id);
var model = new EmployeeLeaveRequestViewModel
{
leaveRequests = leaveRequests,
leaveAllocations = leaveAllocations
};
return(View(model));
}
public IActionResult MyLeave()
{
var user = _userManager.GetUserAsync(User).Result;
var employeeLeaveAllocations = _leaveAllocationRepo.GetLeaveAllocationsByEmployee(user.Id);
var employeeLeaveRequests = _leaveRequestRepo.GetLeaveRequestsByEmployee(user.Id);
var model = new EmployeeLeaveRequestViewVM
{
LeaveAllocations = _mapper.Map <List <LeaveAllocationVM> >(employeeLeaveAllocations),
LeaveRequests = _mapper.Map <List <LeaveRequestVM> >(employeeLeaveRequests)
};
return(View(model));
}
public ActionResult MyLeave()
{
var employee = _userManager.GetUserAsync(User).Result;
var employeeId = employee.Id;
var employeeAllocations = _leaveAllocRepo.GetLeaveAllocationsByEmployee(employeeId);
var employeeRequests = _leaveRequestRepo.GetLeaveRequestByEmployee(employeeId);
var employeeAllocModel = _mapper.Map <List <LeaveAllocationVM> >(employeeAllocations);
var employeeRequestModel = _mapper.Map <List <LeaveRequestVM> >(employeeRequests);
var model = new EmployeeLeaveRequestViewVM
{
LeaveAllocations = employeeAllocModel,
LeaveRequests = employeeRequestModel
};
return(View(model));
}
// GET: LeaveAllocationController/Details/5
public ActionResult Details(string id)
{
//var employee = _mapper.Map<EmployeeVM>(_userManager.FindByIdAsync(id).Result);
//var allocations = _mapper.Map <List<LeaveAllocationVM>>(_Allocationrepo.GetLeaveAllocationsByEmployee(id));
//var model = new ViewAllocationsVM
//{
// Employee = employee,
// LeaveAllocations = allocations
//};
var employee = _userManager.FindByIdAsync(id).Result;
employee.LeaveAllocations = _Allocationrepo.GetLeaveAllocationsByEmployee(id);
var model = _mapper.Map <ViewAllocationsVM>(employee);
return(View(model));
}
public async Task <ActionResult> EmployeeIndex()
{
var employeeId = _userManager.GetUserId(User);
var leaveRequestObj = await _leaveRequestRepo.GetLeaveRequestsByEmployee(employeeId);
var leaveAllocationobj = await _leaveAllocationRepo.GetLeaveAllocationsByEmployee(employeeId);
var leaveAllocationsVm = _mapper.Map <List <LeaveAllocationVM> >(leaveAllocationobj);
var leaveRequestVm = _mapper.Map <List <LeaveRequestVm> >(leaveRequestObj);
var model = new EmployeeLeaveRequestsVM
{
LeaveRequests = leaveRequestVm,
LeaveAllocations = leaveAllocationsVm
};
return(View(model));
}
// GET: LeaveAllocationController/Details/5
public async Task <ActionResult> Details(string id)
{
var employee = await _userManager.FindByIdAsync(id);
var employeeVM = _mapper.Map <EmployeeVM>(employee);
var period = DateTime.Now.Year;
var allocations = await _leaveAllocationRepository.GetLeaveAllocationsByEmployee(employee.Id);
var allocationVMs = _mapper.Map <List <LeaveAllocationVM> >(allocations);
var model = new ViewAllocationVM
{
Employee = employeeVM,
LeaveAllocationVMs = allocationVMs
};
return(View(model));
}
public ActionResult MyLeave()
{
var employee = _userManager.GetUserAsync(User).Result;
var leaveallocation = _AllocationRepo.GetLeaveAllocationsByEmployee(employee.Id);
var leaveallocationModel = _mapper.Map <List <LeaveAllocationVM> >(leaveallocation);
var leaverequest = _LeaveRequestRepo.GetLeaveRequestByEmployeeID(employee.Id);
var leaverequestModel = _mapper.Map <List <LeaveRequestVM> >(leaverequest);
var model = new MyLeaveVM
{
LeaveAllocations = leaveallocationModel,
LeaveRequests = leaverequestModel
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
var employee = await _userManager.GetUserAsync(User);
var leaveAllocations =
_mapper.Map <List <LeaveAllocationVM> >(await _leaveAllocationRepo.GetLeaveAllocationsByEmployee(employee.Id));
var leaveRequests =
_mapper.Map <List <LeaveRequestVM> >(await _leaveRequestRepo.GetLeaveRequestsByEmployee(employee.Id));
EmployeeLeaveRequestVM model = new EmployeeLeaveRequestVM
{
LeaveAllocations = leaveAllocations,
LeaveRequests = leaveRequests
};
return(View(model));
}
public ActionResult UserLeaveRequests()
{
var user = _userManager.GetUserAsync(User).Result;
var employeeId = user.Id;
var userAllocations = _leaveAllocationRepo.GetLeaveAllocationsByEmployee(employeeId);
var userRequests = _leaveRequestRepo.GetLeaveRequestsByEmployee(employeeId);
var userAllocationModel = _mapper.Map <List <LeaveAllocationViewModel> >(userAllocations);
var userRequestModel = _mapper.Map <List <LeaveRequestViewModel> >(userRequests);
var model = new EmployeeLeaveRequestsViewModel
{
LeaveAllocations = userAllocationModel,
LeaveRequests = userRequestModel
};
return(View(model));
}
public async Task <ActionResult> MyLeave(int id)
{
var employee = await _userManager.GetUserAsync(User);
var leaveRequestsTask = await _leaverequestrepo.FindAll();
var leaveRequests = leaveRequestsTask.Where(q => q.RequestingEmployeeId == employee.Id);
var leaveRequestsModel = _mapper.Map <List <LeaveRequestViewModel> >(leaveRequests);
var leaveAllocations = await _leaveallocationrepo.GetLeaveAllocationsByEmployee(employee.Id);
var leaveAllocationsModel = _mapper.Map <List <LeaveAllocationViewModel> >(leaveAllocations);
var model = new EmployeeLeaveRequestViewModel
{
LeaveAllocations = leaveAllocationsModel,
LeaveRequests = leaveRequestsModel
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
var employee = await _userManager.GetUserAsync(User);
var employeeId = employee.Id;
var leaveRequests = await _requestRepo.GetLeaveRequestsByEmployee(employeeId);
var allocations = await _leaveAllocationRepo.GetLeaveAllocationsByEmployee(employeeId);
var leaveRequestsModel = _mapper.Map <List <LeaveRequestViewModel> >(leaveRequests);
var leaveAllocationsModel = _mapper.Map <List <LeaveAllocationViewModel> >(allocations);
var model = new MyLeaveRequestViewModel
{
LeaveAllocations = leaveAllocationsModel,
LeaveRequests = leaveRequestsModel
};
return(View(model));
}
// GET: LeaveAllocationController/Details/5
public async Task <ActionResult> Details(string Id)
{
EmployeeViewModel employee = _mapper
.Map <EmployeeViewModel>(
await _userManager.FindByIdAsync(Id)
);
List <LeaveAllocationViewModel> allcations = _mapper
.Map <List <LeaveAllocationViewModel> >(
await _leaveallocationrepo.GetLeaveAllocationsByEmployee(Id)
);
ViewAllocationsViewModel model = new ViewAllocationsViewModel
{
Employee = employee,
LeaveAllocations = allcations
};
return(View(model));
}
public async Task <ActionResult> MyLeave()
{
try
{
var employee = await _userManager.GetUserAsync(User);
var employeeId = employee.Id;
var leaveAllocations = await _leaveAllocationRepo.GetLeaveAllocationsByEmployee(employeeId);
var leaveRequests = await _leaveRequestRepo.GetLeaveRequestsByEmployee(employeeId);
var model = new EmployeeLeaveRequestViewVM
{
LeaveAllocations = _mapper.Map <List <LeaveAllocationVM> >(leaveAllocations),
LeaveRequests = _mapper.Map <List <LeaveRequestVM> >(leaveRequests)
};
return(View(model));
}
catch (Exception ex)
{
return(RedirectToAction(nameof(Index)));
}
}
// GET: LeaveAllocation/Details/5
public async Task <ActionResult> Details(string id)
{
var employee = _mapper.Map <Employee, EmployeeVM>(await _userManager.FindByIdAsync(id));
var allocations = _mapper.Map <ICollection <LeaveAllocation>, List <LeaveAllocationVM> >(await _leaveallocationrepo.GetLeaveAllocationsByEmployee(employee.Id));
var model = new ViewLeaveAllocationVM
{
Employee = employee,
LeaveAllocation = allocations
};
return(View(model));
}
