public ActionResult Details(int id)
{
//Create our view model
EmployeeDetailsViewModel employee = GetEmployeeById(id);
return(View(employee));
}
public async Task <IActionResult> Details(string id)
{
if (id == null)
{
return(RedirectToAction("Error", "Home"));
}
EmployeeDetailsServiceModel employee = await this._employeeServices.GetEmployeeByIdAsync(id);
EmployeeDetailsViewModel model = new EmployeeDetailsViewModel()
{
EmployeeId = employee.EmployeeId,
FirstName = employee.FirstName,
LastName = employee.LastName,
Salary = employee.Salary,
VacationDays = employee.VacationDays,
ExperienceLevel = employee.ExperienceLevel,
EmployeesOffices = employee.EmployeesOffices,
StartingDate = employee.StartingDate.ToString("MM/dd/yyyy")
};
if (employee == null)
{
return(NotFound());
}
return(View(model));
}
public IActionResult Details(string id)
{
EmployeeServiceModel employee = this.employeesService.GetById(id);
if (employee.FullName == null)
{
return(this.BadRequest());
}
var model = new EmployeeDetailsViewModel
{
Id = employee.Id,
FullName = employee.FullName,
PhoneNumber = employee.PhoneNumber,
Email = employee.Email,
HomeAddress = employee.HomeAddress,
ImageUrl = employee.ImageUrl,
OperatingLocation = employee.OperatingLocation,
// TODO: add opLoc img
JobPosition = employee.JobPosition,
// TODO: add job position qualifications table
};
return(this.View(model));
}
public IActionResult Index()
{
var employee = new Employee
{
DateOfHire = 30,
EmployeeId = 10,
FirstName = "Filip",
Salary = 300,
LastName = "Gjorgevski",
Position = PositionEnum.Senior
};
var division = new Division
{
DivisionId = 3,
HeadOfDivision = employee,
Name = employee.FirstName
};
var EmployeeDetailsViewModel = new EmployeeDetailsViewModel
{
DateOfHire = employee.RandomNumber(1, 32),
DivisionName = "Amazon",
FullEmployeeName = employee.GetFullName(),
Position = employee.Position,
Salary = employee.salaryOfEmployee(employee.Position)
};
return(View(EmployeeDetailsViewModel));
}
public ViewResult Details()
{
//Employee Basic Details
Employee employee = new Employee()
{
EmployeeId = 101,
Name = "Aneri",
Gender = "Female",
Department = "IT",
Salary = 10000,
AddressId = 1001
};
//Employee Address
Address address = new Address()
{
AddressId = 1001,
City = "Barrie",
State = "Ontario",
Country = "Canada",
Pin = "755019"
};
//Creating the View model
EmployeeDetailsViewModel employeeDetailsViewModel = new
EmployeeDetailsViewModel()
{
Employee = employee,
Address = address,
PageTitle = "Employee Details Page",
PageHeader = "Employee Details",
};
//Pass the employeeDetailsViewModel to the view
return(View(employeeDetailsViewModel));
}
public async Task <IActionResult> OnGetAsync(int employeeId)
{
EmployeeDetailsViewModel employeeDetailsViewModel = await _employeeService.GetEmployeeDetailsAsync(employeeId);
if (employeeDetailsViewModel == null)
{
return(NotFound());
}
UpdateEmployeeViewModel = new UpdateEmployeeViewModel()
{
EmployeeId = employeeDetailsViewModel.EmployeeId,
EmployeeName = employeeDetailsViewModel.EmployeeName,
DepartmentId = employeeDetailsViewModel.DepartmentId,
DateOfBirth = employeeDetailsViewModel.DateOfBirth,
Email = employeeDetailsViewModel.Email,
PhoneNumber = employeeDetailsViewModel.PhoneNumber
};
SelectList items = await _departmentService.GetDepartmentSelectListAsync(employeeDetailsViewModel.DepartmentId);
DepartmentSelectList = items;
return(Page());
}
public ActionResult Details(int id)
{
EmployeeJobHistoryDTO Record = _jobHistoryService.GetJobHistoryById(id);
EmployeeDetailsViewModel partialData = _employeeService.GetEmployeeDetails(Record.EmpCode);
EmployeeKaazViwModel res = new EmployeeKaazViwModel();
res.LetterIssueDateNP = (NepEngDate.EngToNep(Convert.ToDateTime(Record.LetterIssueDate)));
res.KajStartDateNP = (NepEngDate.EngToNep(Convert.ToDateTime(Record.KajStartDate)));
res.KajEndDateNP = (NepEngDate.EngToNep(Convert.ToDateTime(Record.KajEndDate)));
res.Id = Record.HistoryId;
res.LetterIssueDate = Record.LetterIssueDate;
res.LetterRefNo = Record.LetterRefNo;
res.LetterChalaniNumber = Record.ChalaniNumber;
res.KajStartDate = Record.KajStartDate;
res.KajEndDate = Record.KajEndDate;
res.SadarGarneEmployeeCode = Record.SadarGarneEmployeeCode;
res.KaajType = Record.KaajType;
res.Instruction = Record.Instruction;
res.Remarks = Record.Remarks;
res.Designation = partialData.Designation;
res.JobType = partialData.JobType;
res.Department = partialData.Department;
res.OfficeName = partialData.OfficeName;
res.Rank = partialData.Rank;
res.Name = partialData.Name;
res.Section = partialData.Section;
res.Level = partialData.Level;
res.Name = partialData.Name;
res.EmpCode = Record.EmpCode;
ListOfDatas(Record.EmpCode);
return(View("../Employee/Kajmakhataune/Details", res));
}
public ViewResult Details()
{
//Employee Basic Details
Employee employee = new Employee()
{
EmployeeId = 101,
Name = "Dillip",
Gender = "Male",
Department = "IT",
Salary = 10000,
AddressId = 1001
};
//Employee Address
Address address = new Address()
{
AddressId = 1001,
City = "Bhubaneswar",
State = "Odisha",
Country = "India",
Pin = "755019"
};
//Creating the View model
EmployeeDetailsViewModel employeeDetailsViewModel = new EmployeeDetailsViewModel()
{
Employee = employee,
Address = address,
PageTitle = "Employee Details Page",
PageHeader = "Employee Details",
};
//Pass the employeeDetailsViewModel to the view
return(View(employeeDetailsViewModel));
}
public EmployeeDetailsView(EmployeeDetailsViewModel employeeDetailsViewModel)
{
InitializeComponent();
DataContext = employeeDetailsViewModel;
_employeeDetailsViewModel = employeeDetailsViewModel;
employeeDetailsViewModel.PropertyChanged += EmployeeDetailsViewModel_PropertyChanged;
}
public EmployeeDetailsPage(EmployeeItemViewModel employee)
{
InitializeComponent();
var empvm = new EmployeeDetailsViewModel(employee);
BindingContext = empvm;
}
// GET: Employee/Details/5
public async Task <IActionResult> Details(int?id)
{
try
{
if (id == null)
{
return(NotFound());
}
var employeeViewModel = await _employeeService.GetEmployeeAsync(id.Value).ConfigureAwait(false);
//////var employeeViewModel = await _context.Employees
////// .FirstOrDefaultAsync(m => m.Id == id);
if (employeeViewModel == null)
{
return(NotFound());
}
EmployeeDetailsViewModel employeeDetailsViewModel = EmployeeDetailsMapper.Map(employeeViewModel);
IEnumerable <ProjectDto> Projects = await _projectService.GetProjectsByEmployeeId(id.Value);
employeeDetailsViewModel.Projects = ProjectMapper.Map(Projects);
return(View(employeeDetailsViewModel));
}
catch (Exception)
{
ErrorViewModel model = new ErrorViewModel {
RequestId = "Medarbejderen kunne ikke vises"
};
return(View("Error", model));
}
}
public ActionResult Badhuwa(int empCode)
{
if (!ViewBag.AllowView)
{
ViewBag.Error = "You are not Authorize to use this Page";
return(PartialView("_partialviewNotFound"));
}
EmployeeDetailsViewModel partialData = _employeeService.GetEmployeeDetails(empCode);
EmployeeJobHistoryViewModel res = new EmployeeJobHistoryViewModel();
res.Designation = partialData.Designation;
res.JobType = partialData.JobType;
res.Department = partialData.Department;
res.OfficeName = partialData.OfficeName;
res.OfficeId = partialData.OfficeId;
res.Rank = partialData.Rank;
res.Name = partialData.Name;
res.Section = partialData.Section;
res.Level = partialData.Level;
ListOfDatas(empCode);
List <SelectListItem> SubGroupList = new List <SelectListItem>();
foreach (var row in _serviceEventSubGroupService.GetSubGroupById(7))
{
SubGroupList.Add(new SelectListItem
{
Text = row.ServiceEventSubGroupName,
Value = row.ServiceEventSubGroupId.ToString()
});
}
ViewBag.SubGroupList = SubGroupList;
return(View("../Employee/Badhuwa/Index", res));
}
// GET: Employee/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
string sql = $@"SELECT e.Id, e.FirstName, e.LastName, d.Id, d.Name, c.Id, c.Model, t.Id, t.Name FROM Employees e
JOIN Departments d ON e.DepartmentId = d.Id
LEFT JOIN EmployeeComputers ec ON ec.EmployeeId = e.Id AND ec.ReturnDate IS NULL
LEFT JOIN Computers c ON ec.ComputerId = c.Id
LEFT JOIN EmployeeTrainings et ON et.EmployeeId = e.Id
LEFT JOIN Trainings t ON et.TrainingId = t.Id
WHERE e.Id = {id};";
using (IDbConnection conn = Connection)
{
EmployeeDetailsViewModel model = new EmployeeDetailsViewModel(_config);
var EmployeeQuery = await conn.QueryAsync <Employee, Department, Computer, Training, Employee>(
sql, (employee, department, computer, training) =>
{
model.Employee = employee;
model.Employee.Computer = computer;
model.Employee.Department = department;
model.Trainings.Add(training);
return(employee);
});
return(View(model));
}
}
public async Task <IActionResult> GetTimesheetsByApproverId(int id)
{ //Finds employee by EmployeeID
var approver = await GetEmployeeByIdHelper(id);
//Finds employees by ApproverID
var employees = await GetEmployeeByApproverIdHelper(id);
List <TimesheetApproverViewModel> timesheetApproverViews = new List <TimesheetApproverViewModel>();
foreach (Employee item in employees)
{
//Null coalesce
//https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-coalescing-operator
var supervisor = await GetEmployeeByIdHelper((item.SupervisorId ?? 0));
var timesheets = await GetTimesheetByEmpIdHelper(item.EmployeeId);
timesheets = timesheets.Where(t => t.Status == TimesheetStatus.Pending);
Credential empCred = (await _credentialRepository.GetAll()).FirstOrDefault(c => c.EmployeeId == item.EmployeeId);
LabourGrade labourGrade = await _labourGradeRepository.Get(item.LabourGradeId);
EmployeeDetailsViewModel thisEmployee = new EmployeeDetailsViewModel(item, empCred, new LabourGradeViewModel(labourGrade),
new EmployeeNameViewModel(approver.First()), new EmployeeNameViewModel(supervisor.First()));
foreach (Timesheet timesheet in timesheets)
{
TimesheetApproverViewModel timesheetApproverView = new TimesheetApproverViewModel(timesheet, thisEmployee);
timesheetApproverViews.Add(timesheetApproverView);
}
}
return(Ok(timesheetApproverViews));
}
public void OpenEmployee(int employeeId)
{
var viewModel = new EmployeeDetailsViewModel();
var view = _container.Resolve<IModuleView>("EmployeeDetails");
// view.ViewModel = viewModel;
_regionManager.AddToRegion("WorkspaceRegion", view);
_regionManager.Regions["WorkspaceRegion"].Activate(view);
}
public EmployeeDetailsView(EmployeeDetailsViewModel employeeDetailsViewModel)
{
InitializeComponent();
DataContext = employeeDetailsViewModel;
RegionContext.GetObservableContext(this).PropertyChanged += (sender, e) =>
employeeDetailsViewModel.CurrentEmployee = RegionContext.GetObservableContext(this).Value as Employee;
}
public ViewResult Create()
{
EmployeeDetailsViewModel employeeDetailsViewModel = new EmployeeDetailsViewModel()
{
PageTitle = "Add Employee"
};
return(View(employeeDetailsViewModel));
}
public ActionResult Details(int id)
{
EmployeeDetailsViewModel viewModel = new EmployeeDetailsViewModel(id, _config.GetConnectionString("DefaultConnection"));
Employee employee = GetEmployeeById(id);
viewModel.Employee = employee;
return(View(viewModel));
}
public void SetUp()
{
_employeeService = A.Fake <IEmployeeService>();
_departmentService = A.Fake <IDepartmentService>();
_mapperWrapper = A.Fake <IMapperWrapper>();
_employeeDetailsViewModel = new EmployeeDetailsViewModel(_employeeService, _departmentService, _mapperWrapper);
Init();
}
public EmployeeDetailsPage(INavigation _navi, Employee _employee)
{
Title = _employee.Name;
InitializeComponent();
NavigationPage.SetHasNavigationBar(this, false);
BindingContext = new EmployeeDetailsViewModel(_navi, _employee, this);
GroupedView.ItemSelected += (sender, e) => {
((ListView)sender).SelectedItem = null;
};
}
public ActionResult Index()
{
EmployeeDetailsViewModel empDetails = new EmployeeDetailsViewModel();
int empCode = Convert.ToInt32(Session["EmpCode"]);
ListOfDatas(empCode);
empDetails = _employeeService.GetEmployeeDetails(empCode);
empDetails.EmployeeAppointmentDetail = _employeeService.GetEmployeeAppointmentDetails(empCode);
return(View(empDetails));
}
public ViewResult Update(int Id)
{
EmployeeDetailsViewModel employeeDetailsViewModel = new EmployeeDetailsViewModel()
{
Employee = _employeeRepository.GetEmployee(Id),
PageTitle = "Edit Employee"
};
return(View(employeeDetailsViewModel));
}
public ViewResult Details(int?Id)
{
EmployeeDetailsViewModel employeeDetailsViewModel = new EmployeeDetailsViewModel()
{
Employee = _employeeRepository.GetEmployee(Id ?? 1),
PageTitle = "Employee Details"
};
return(View(employeeDetailsViewModel));
}
// GET: User/Details/5
public ActionResult Details(EmployeeDetailsViewModel e)
{
if (TempData["error"] != null)
{
ViewBag.error = TempData["error"];
}
if (TempData["status"] != null)
{
ViewBag.status = TempData["status"];
}
return(View(e));
}
public async Task <IActionResult> OnGetAsync(int employeeId)
{
EmployeeDetailsViewModel employeeDetailsViewModel = await _employeeService.GetEmployeeDetailsAsync(employeeId);
if (employeeDetailsViewModel == null)
{
return(NotFound());
}
EmployeeDetailsViewModel = employeeDetailsViewModel;
return(Page());
}
//DETAILS
public ActionResult Details(string id)
{
var myEmployee = _employeeService.GetEmployeeById(id);
var employee = new EmployeeDetailsViewModel
{
EmployeeId = myEmployee.EmployeeId,
PersonalDetails = myEmployee.PersonalDetails,
EmploymentDetails = myEmployee.EmploymentDetails
};
return(View(employee));
}
public async Task <IActionResult> EmployeeDetails(string id)
{
bool result = int.TryParse(id, out int appId);
if (result)
{
var emp = await context.Employees
.Where(s => s.Id == Convert.ToInt32(id))
.Include(s => s.Group).ThenInclude(s => s.Department)
.Include(s => s.EmployeePositions)
.Include(s => s.MobilePhones)
.FirstOrDefaultAsync();
if (emp == null)
{
Response.StatusCode = 404;
return(View("EmployeeNotFound", id));
}
else
{
EmployeeDetailsViewModel model = new EmployeeDetailsViewModel()
{
Id = emp.Id,
FirstName = emp.FirstName,
LastName = emp.LastName,
MiddleName = emp.MiddleName,
Department = emp.Group.Department.Name,
Group = emp.Group.Name,
Login = emp.Login,
Email = emp.Email,
ExtensionPhone = emp.ExtensionPhone,
BithDate = emp.BirthDate,
EmploymentDate = emp.EmploymentDate,
MobilePhone = emp.MobilePhones.Count == 0 ? "Номер отсутствует" : string.Join(", ", emp.MobilePhones.Select(s => s.Number)),
IsActive = emp.IsActive
};
var position = await context.EmployeePositions
.Where(s => s.EmployeeId == Convert.ToInt32(id))
.Include(s => s.Position)
.ToListAsync();
if (position != null)
{
model.Position = string.Join(", ", position.Select(s => s.Position.Name));
}
return(View(model));
}
}
Response.StatusCode = 404;
return(View("EmployeeNotFound", id));
}
public IActionResult Details(int?id)
{
Employee employee = _employeeRepository.GetEmployee(id.Value);
EmployeeDetailsViewModel employeeDetailsViewModel = new EmployeeDetailsViewModel
{
Employee = employee,
PageTitle = "Employee Details"
};
return(View(employeeDetailsViewModel));
}
public ActionResult Details(int id)
{
var employee = _employeeService.Get(id);
if (employee == null)
{
return(RedirectToAction("Index"));
}
EmployeeDetailsViewModel employeeViewModel = employee;
return(View(employeeViewModel));
}
private async Task <IActionResult> SetEmployeeDetailsViewModelAsync(int employeeId)
{
EmployeeDetailsViewModel employeeDetailsViewModel = await _employeeService.GetEmployeeDetailsAsync(employeeId);
if (employeeDetailsViewModel == null)
{
return(NotFound());
}
EmployeeDetailsViewModel = employeeDetailsViewModel;
return(new NoContentResult());
}
public IHttpActionResult getEmployeeDetails(string username)
{
EmployeesDetails emp = ICompany.GetEmloyeesDetailsOnLogin(username);
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <EmployeesDetails, EmployeeDetailsViewModel> ();
});
IMapper mapper = config.CreateMapper();
EmployeeDetailsViewModel empViewModel = mapper.Map <EmployeesDetails, EmployeeDetailsViewModel>(emp);
return(Ok(empViewModel));
}
