public IActionResult Edit(int id)
{
Employee employee = _employeeRepository.GetEmployee(id);
EditEmployeeViewModel editEmployee = new EditEmployeeViewModel
{
Id = employee.Id,
Name = employee.Name,
Email = employee.Email,
Department = employee.Department,
ExistingPhotoPath = employee.PhotoPath
};
return(View(editEmployee));
}
public ActionResult Delete(int id)
{
Employee employee = _employeeRepository.GetEmployee(id);
EditEmployeeViewModel deleteEmployeeViewModel = new EditEmployeeViewModel()
{
Id = employee.Id,
Name = employee.Name,
Email = employee.Email,
Department = employee.Department,
ExistingPhotoPath = employee.PhotoPath
};
return(View(deleteEmployeeViewModel));
}
public ViewResult Edit(int id)
{
EmployeeModel employeeModel = _employeeRepository.GetEmployee(id);
EditEmployeeViewModel editEmployeeViewModel = new EditEmployeeViewModel
{
Id = employeeModel.Id,
Name = employeeModel.Name,
Email = employeeModel.Email,
Department = employeeModel.Department,
ExistingPhotoPath = employeeModel.PhotoPath,
};
return(View(editEmployeeViewModel));
}
public ViewResult Edit(int?id)
{
Employee employee = _employeeREpository.GtEmployee(id ?? 1);
EditEmployeeViewModel editEmployeeViewModel = new EditEmployeeViewModel()
{
Id = employee.Id,
Name = employee.Name,
Department = employee.Department,
Email = employee.Email,
ExtistinPhoto = employee.PhotoPath
};
return(View(editEmployeeViewModel));
}
public async Task <IActionResult> EditEmployee(EditEmployeeViewModel employeeModel)
{
var employee = await _employeeRepository.GetEmployeeById(employeeModel.Id);
if (employee == null)
{
return(View("Error", new ErrorViewModel {
Error = "Wrong employee model sent to edit"
}));
}
await _employeeRepository.EditEmployee(employeeModel);
return(RedirectToAction("Index"));
}
public ActionResult Edit(int id)
{
var employee = EmployeeRepo.Get(id);
var model = new EditEmployeeViewModel();
model.FirstName = employee.FirstName;
model.LastName = employee.LastName;
model.DepartmentId = employee.DepartmentId;
model.Phone = employee.Phone;
model.EmployeeId = employee.EmployeeId;
model.Departments = GetDepartmentSelectList();
return(View(model));
}
public IActionResult Edit(int Id)
{
Employee employee = _employeerepo.GetEmployee(Id);
EditEmployeeViewModel editEmployeeViewModel = new EditEmployeeViewModel
{
Id = employee.Id,
Name = employee.Name,
EmailId = employee.EmailId,
Number = employee.Number,
Department = employee.Department,
PhotoPath = employee.Photo
};
return(View(editEmployeeViewModel));
}
public ViewResult Edit(int id = 0)
{
Employee employee = _employeerepository.GetEmployee(id);
EditEmployeeViewModel editEmployeeViewModel = new EditEmployeeViewModel()
{
id = employee.id,
Name = employee.Name,
Department = employee.Department,
Email = employee.Email,
Contact = employee.Contact,
existingpath = employee.photopath,
};
return(View(editEmployeeViewModel));
}
public ViewResult Update(int id)
{
Employee employee = _employeeRepository.GetEmployeeDetails(id);
EditEmployeeViewModel vm = new EditEmployeeViewModel()
{
Id = employee.Id,
Name = employee.Name,
Email = employee.Email,
Department = employee.Department,
ExistingPhotoPath = employee.PhotoPath,
PageTitle = "Update Employee"
};
return(View(vm));
}
public IActionResult Edit([FromForm] EditEmployeeViewModel viewModel)
{
try
{
employeeService.Update(viewModel.Id,
viewModel.Name,
viewModel.Email,
viewModel.PhoneNumber,
viewModel.HolidayDays);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private string ProcessUploadedFile(EditEmployeeViewModel model)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(_ihosting.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Photo.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public IActionResult Edit(EditEmployeeViewModel employee)
{
if (ModelState.IsValid)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <EditEmployeeViewModel, EmployeeFullDTO>()
).CreateMapper();
var employeeDto = mapper.Map <EditEmployeeViewModel, EmployeeFullDTO>(employee);
projectService.EditEmployee(employeeDto);
return(RedirectToAction("Employee", new { id = employee.ID }));
}
return(View(employee));
}
public IActionResult Edit(EditEmployeeViewModel model)
{
Employee employee = employees.Get(model.Id);
if (ModelState.IsValid)
{
employee.FirstName = model.FirstName;
employee.LastName = model.LastName;
employee.City = model.City;
employee.HireDate = model.HireDate;
employee.Title = model.Title;
employees.Update(employee);
return(View("Details", employee));
}
return(View("Details", employee));
}
public ViewResult Edit(int id)
{
Employee employee = _employeeRepository.GetEmployee(id);
EditEmployeeViewModel employeeEditViewModel = new EditEmployeeViewModel
{
Id = employee.Id,
Name = employee.Name,
Gender = employee.Gender,
Role = employee.Role,
Email = employee.Email,
Contact = employee.Contact,
Office = employee.Office,
ExistingImagePath = employee.ImagePath
};
return(View(employeeEditViewModel));
}
public async Task <IActionResult> Edit(EditEmployeeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var data = await _context.Employees.FirstOrDefaultAsync(x => x.EmployeeId == viewModel.Id);
data.FirstName = viewModel.FirstName;
data.LastName = viewModel.LastName;
data.HireDate = viewModel.HireDate;
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public IActionResult Edit(int id)
{
Employee oldEmployee = _employeeRepository.GetEmployee(id);
EditEmployeeViewModel editEmployee = null;
if (oldEmployee != null)
{
editEmployee = new EditEmployeeViewModel
{
Id = oldEmployee.Id,
Name = oldEmployee.Name,
Department = oldEmployee.Department,
Email = oldEmployee.Email,
ExistingPath = oldEmployee.PhotoPath,
};
}
return(View(editEmployee));
}
public ActionResult EditEmployee()
{
var user = UserManager.FindById(User.Identity.GetUserId());
Employee employee = GetCurrentEmployee();
var employeeService = GetEmployeeService();
var model = new EditEmployeeViewModel();
model.Username = employee.UserName;
model.EmailAddress = employee.EmailAddress;
model.FullName = employee.FullName;
model.EmployeeType = employee.EmployeeType;
model.LocationCentreId = employee.LocationCentreId;
model.DistributionCentres = employeeService.GetAllDistributionCentres();
return(View(model));
}
public ActionResult EditEmployee(EditEmployeeViewModel model)
{
var employeeService = GetEmployeeService();
var distributionCentres = employeeService.GetAllDistributionCentres();
if (ModelState.IsValid)
{
DistributionCentre locationCentre =
distributionCentres.FirstOrDefault(d => d.CentreId == model.LocationCentreId);
var user = UserManager.FindById(User.Identity.GetUserId());
Employee employee = GetCurrentEmployee();
user.Fullname = model.FullName;
var result = UserManager.Update(user);
int written = 0;
if (result.Succeeded)
{
var employeeResult = employeeService.Update(employee.UserName,
model.FullName,
model.EmailAddress,
locationCentre,
employee.EmployeeType);
if (employeeResult.Success)
{
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", employeeResult.ErrorMessage);
}
}
else
{
AddErrors(result);
}
}
model.DistributionCentres = distributionCentres;
return(View(model));
}
// GET: Employee/Edit/5
public ActionResult Edit(string id)
{
if (db.Users.Find(User.Identity.GetUserId()).Disabled == true)
{
return(Content("<script language'javascript' type = 'text/javascript'> alert('Access Denied: You have been terminated. Hasta la vista.'); window.location='../Home/Index';</script>"));
}
AppUser user = db.Users.Find(User.Identity.GetUserId());
EditEmployeeViewModel eevm = new EditEmployeeViewModel();
eevm.City = user.City;
eevm.Email = user.Email;
eevm.PhoneNumber = user.PhoneNumber;
eevm.State = user.State;
eevm.Street = user.Street;
eevm.ZipCode = user.ZipCode;
return(View(eevm));
}
public IActionResult Edit(int id)
{
if (id != 0)
{
ViewBag.Title = "Edit Employee";
Employee employee = _employeeRepository.GetEmployeeById(id);
EditEmployeeViewModel editEmployeeViewModel = new EditEmployeeViewModel();
mapper.Map(employee, editEmployeeViewModel);
return(View(editEmployeeViewModel));
}
ViewBag.Title = "Create Employee";
EditEmployeeViewModel editEmployeeViewModel_Create = new EditEmployeeViewModel()
{
Department = Department.CS,
PhotoPath = "noimage.jpg"
};
return(View(editEmployeeViewModel_Create));
}
/* goes to selected user's profile page with option to edit */
public ActionResult Edit(Guid EmployeeID)
{
var employee = _Context.Employees.SingleOrDefault(e => e.EmployeeID == EmployeeID);
if (employee == null)
{
return(RedirectToAction("BadRequest", "Error"));
}
var editEmployeeViewModel = new EditEmployeeViewModel();
editEmployeeViewModel.Employee = employee;
editEmployeeViewModel.ListOfPositions = _Context.Positions.Select(p => new SelectListItem {
Value = p.PositionID.ToString(), Text = p.PositionName
});
editEmployeeViewModel.HasAdminPrivileges = (employee.Permissions % (int)PermissionsEnum.Admin) == 0;
ViewData["name"] = User;
return(View(editEmployeeViewModel));
}
public ActionResult Edit(EditEmployeeViewModel model)
{
if (ModelState.IsValid)
{
Employee employee = new Employee();
employee.EmployeeId = model.EmployeeId;
employee.FirstName = model.FirstName;
employee.LastName = model.LastName;
employee.Phone = model.Phone;
employee.DepartmentId = model.DepartmentId;
EmployeeRepository.Edit(employee);
return(RedirectToAction("List"));
}
else
{
model.Departments = GetDepartmentSelectList();
return(View(model));
}
}
public IActionResult Edit(EditEmployeeViewModel model)
{
if (ModelState.IsValid)
{
Employee emp = _employeeRepository.GetEmployee(model.Id);
emp.Name = model.Name;
emp.Department = model.Department;
emp.Email = model.Email;
emp.PhotoPath = GetUniqueName(model, model.ExistingPath);
Employee employee = _employeeRepository.Upadate(emp);
//Redirect to another controller action method
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public ActionResult Edit([Bind(Include = "Street,City,State,ZipCode,Email,PhoneNumber")] EditEmployeeViewModel eevm)
{
if (ModelState.IsValid)
{
//Get the db record for the user who is logged in
AppUser user = db.Users.Find(User.Identity.GetUserId());
user.Street = eevm.Street;
user.City = eevm.City;
user.State = eevm.State;
user.ZipCode = eevm.ZipCode;
user.Email = eevm.Email;
user.PhoneNumber = eevm.PhoneNumber;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Home"));
}
return(View(eevm));
}
public async Task <IActionResult> EditEmployee(EditEmployeeViewModel model)
{
if (ModelState.IsValid)
{
ViewBag.Title = "Edytuj pracownika";
var employee = await userManager.FindByIdAsync(model.Id);
if (employee == null)
{
ViewBag.ErrorMessage = "Nie znaleziono pracownika o danym identyfikatorze";
return(View("Error"));
}
else if (employee.UserName == "admin" && employee.UserName != model.Login)
{
ModelState.AddModelError("login", "Nie można zmienić loginu administratora");
}
else
{
employee.UserName = model.Login;
employee.Email = model.Email;
employee.FirstName = model.FirstName;
employee.LastName = model.LastName;
var result = await userManager.UpdateAsync(employee);
if (result.Succeeded)
{
return(RedirectToAction("ListEmployees"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
public async Task <IHttpActionResult> Edit(EditEmployeeViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (model.JobId != model.NewJobId || model.DepartamentId != model.NewDepartamentId)
{
await _service.ChangeJob(model.Id, model.NewJobId, DateTime.Now, model.NewDepartamentId, model.NewSalary);
return(Ok());
}
if (model.Salary != model.NewSalary)
{
await _service.ChangeSalary(model.Id, model.NewSalary);
}
return(Ok());
}
public IActionResult Edit(EditEmployeeViewModel updatedemployee)
{
if (ModelState.IsValid)
{
string uniqueName = null;
if (updatedemployee.Photo != null)
{
uniqueName = ProcessUploadedImage(updatedemployee);
}
Employee employee = new Employee();
mapper.Map(updatedemployee, employee);
employee.PhotoPath = string.IsNullOrEmpty(uniqueName) ? updatedemployee.PhotoPath : uniqueName;
if (updatedemployee.EmployeeId != 0)
{
_employeeRepository.UpdateEmployee(employee);
}
_employeeRepository.CreateEmployee(employee);
return(RedirectToAction("details", new { id = employee.EmployeeId }));
}
return(View(updatedemployee));
}
// GET: Employee/Edit
public ActionResult Edit(EditEmployeeViewModel employeeViewModel)
{
var updatedEmployee = employeeViewModel.Employee;
var existingEmployee = _EmployeeRepository.GetEmployeeByID(employeeViewModel.Employee.EmployeeID);
if (existingEmployee == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
existingEmployee.Email = updatedEmployee.Email;
existingEmployee.FirstName = updatedEmployee.FirstName;
existingEmployee.LastName = updatedEmployee.LastName;
existingEmployee.positionID = updatedEmployee.positionID;
existingEmployee.StartDate = updatedEmployee.StartDate;
existingEmployee.EndDate = updatedEmployee.EndDate;
existingEmployee.Permissions = (employeeViewModel.HasAdminPrivileges ? (int)PermissionsEnum.Admin : (int)PermissionsEnum.User);
_EmployeeRepository.UpdateStaff(existingEmployee);
return(RedirectToAction("Index", "Staff"));
}
public async Task <ActionResult> Edit(EditEmployeeViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Edit", model));
}
if (model.JobId != model.NewJobId || model.DepartamentId != model.NewDepartamentId)
{
await _service.ChangeJob(model.Id, model.NewJobId, DateTime.Now, model.NewDepartamentId, model.NewSalary);
return(RedirectToAction("Index"));
}
if (model.Salary != model.NewSalary)
{
await _service.ChangeSalary(model.Id, model.NewSalary);
}
return(RedirectToAction("Index"));
}
public IActionResult Edit(EditEmployeeViewModel editEmployeeViewModel)
{
if (ModelState.IsValid)
{
Employee employeeToEdit = new Employee
{
EmployeeID = editEmployeeViewModel.EmployeeID,
FirstName = editEmployeeViewModel.FirstName,
MiddleName = editEmployeeViewModel.MiddleName,
LastName = editEmployeeViewModel.LastName,
StreetNumber = editEmployeeViewModel.StreetNumber,
StreetName = editEmployeeViewModel.StreetName,
City = editEmployeeViewModel.City,
ZipCode = editEmployeeViewModel.ZipCode,
SSN = editEmployeeViewModel.SSN,
SsnConfirm = editEmployeeViewModel.SsnConfirm,
Dob = editEmployeeViewModel.Dob,
Title = editEmployeeViewModel.Title,
LicNumber = editEmployeeViewModel.LicNumber,
LicIssue = editEmployeeViewModel.LicIssue,
LicExpire = editEmployeeViewModel.LicExpire,
MedCardNumber = editEmployeeViewModel.MedCardNumber,
MedIssue = editEmployeeViewModel.MedIssue,
MedExpire = editEmployeeViewModel.MedExpire,
UserName = editEmployeeViewModel.UserName,
Password = editEmployeeViewModel.Password,
PasswordConf = editEmployeeViewModel.PasswordConf,
//Order = null,
//WorkStatus = "Unavailable",
//LoginStatus = false,
//DotCompliant = false,
};
empRepo.Edit(employeeToEdit);
return(Redirect("/Employee"));
}
return(View(editEmployeeViewModel));
}
