public async Task <IActionResult> Edit(string id, EmployeeEditInputModel employeeEdit)
{
if (!this.ModelState.IsValid)
{
var errorModel = AutoMapper.Mapper.Map <EmployeeEditViewModel>(employeeEdit);
var roles = await this.rolesService.GetAllWithoutAdministratorAsync().Select(x => new SelectListItem {
Value = x.Name, Text = x.Name
}).ToListAsync();
errorModel.RoleList = roles;
return(this.View(errorModel));
}
string pictureFileName = employeeEdit.PhoneNumber + "_" + DateTime.UtcNow.ToString("dd.MM.yyyy");
string pictureUrl = null;
if (employeeEdit.PictureLink != null)
{
pictureUrl = await this.cloudinaryService.UploadPictureAsync(
employeeEdit.PictureLink,
pictureFileName);
}
var result = await this.employeesService.EditByIdAsync(id, employeeEdit, pictureUrl);
return(this.RedirectToAction(nameof(this.Index)));
}
public ActionResult Edit(int id, EmployeeEditInputModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var employee = this.employeesService.GetEmployeeById(id);
if (employee == null)
{
return(HttpNotFound());
}
if (employee.Position > CompanyRoleType.TeamLeader)
{
this.employeesService.UpdateEmployee(id, model.Phone, model.Salary, model.Email, model.Workplace, model.Position);
}
else
{
this.employeesService.UpdateEmployee(id, model.Phone, model.Salary, model.Email, model.Workplace, null);
}
return(RedirectToAction(Constants.Index));
}
public async Task <IActionResult> Edit(EmployeeEditInputModel model)
{
User user = await userManager.FindByIdAsync(model.Id);
user.Email = model.Email;
user.UserName = model.Username;
user.Address = model.Address;
user.Name = model.Name;
user.Surname = model.Surname;
user.PhoneNumber = model.PhoneNumber;
user.PersonalNumber = model.PersonalNumber;
await userManager.UpdateAsync(user);
return(RedirectToAction(nameof(Details), new { model.Id }));
}
public async Task <IActionResult> Edit(EmployeeEditInputModel inputModel)
{
if (!this.ModelState.IsValid)
{
this.ViewData["Message"] = NotBeenSaved;
return(this.Edit(inputModel.Id));
}
inputModel.ModifiedFrom = this.userManager.GetUserAsync(this.User).Result.FullName;
var userId = await this.userService.Update(inputModel);
var messageContent = SuccessfullyUpdated;
return(this.RedirectToAction("Details", "Employees", new { id = userId, message = messageContent }));
}
public async Task <EmployeeEditViewModel> EditByIdAsync(string id, EmployeeEditInputModel employeeFromView, string pictureUrl)
{
var employeeFromDb = await this.employeeRepository.All().FirstOrDefaultAsync(x => x.Id == employeeFromView.Id);
if (employeeFromDb == null)
{
throw new NullReferenceException(string.Format(EmployeeConstants.NullReferenceId, employeeFromView.Id));
}
var user = await this.context.Users.FirstOrDefaultAsync(x => x.PhoneNumber == employeeFromView.PhoneNumber);
if (user == null)
{
throw new ArgumentNullException(string.Format(EmployeeConstants.ArgumentExceptionPhoneNumberNotExist, employeeFromView.PhoneNumber), new Exception(nameof(employeeFromView.PhoneNumber)));
}
var role = await this.context.Roles.Where(x => x.Name != GlobalConstants.AdministratorRoleName).FirstOrDefaultAsync(x => x.Name == employeeFromView.RoleName);
if (role == null)
{
throw new ArgumentNullException(string.Format(EmployeeConstants.ArgumentExceptionRoleNotExist, employeeFromView.RoleName), new Exception(nameof(employeeFromView.RoleName)));
}
if (employeeFromDb.RoleName != GlobalConstants.AdministratorRoleName)
{
user.Roles.Clear();
}
user.Roles.Add(new IdentityUserRole <string> {
RoleId = role.Id, UserId = user.Id
});
employeeFromDb.User = user;
employeeFromDb.FirstName = employeeFromView.FirstName;
employeeFromDb.LastName = employeeFromView.LastName;
employeeFromDb.PhoneNumber = employeeFromView.PhoneNumber;
employeeFromDb.RoleName = employeeFromView.RoleName;
employeeFromDb.Salary = employeeFromView.Salary;
employeeFromDb.Picture = pictureUrl;
this.employeeRepository.Update(employeeFromDb);
await this.employeeRepository.SaveChangesAsync();
return(employeeFromDb.To <EmployeeEditViewModel>());
}
public async Task <IActionResult> Edit(EmployeeEditInputModel input)
{
if (this.ModelState.IsValid == false)
{
return(this.View(input));
}
if (input.Offices != null)
{
for (int i = 0; i < input.Offices.Count; i++)
{
await this.employeeOfficeServices.CreateAsync(input.Id, input.Offices[i]);
}
}
await this.employeesService.Edit(input.Id, input.FirstName, input.LastName, input.Salary, input.VacationDays, (int)input.ExpirenceLevel);
var companyNameCurrent = this.companiesService.GetById <CompanyViewModel>(input.CompanyId).Name;
this.TempData["InfoMessage"] = "Employee successfully edited!";
return(this.RedirectToRoute("TaskDotNetCompany", new { name = companyNameCurrent }));
}
public async Task <string> Update(EmployeeEditInputModel inputModel)
{
var userId = inputModel.Id;
var user = this.applicationUserRepository.All().FirstOrDefault(x => x.Id == userId);
if (user != null)
{
user.FullName = inputModel.FullName;
user.Position = inputModel.Position;
user.TeamId = inputModel.TeamId;
user.AddressId = inputModel.AddressId;
user.SectionId = inputModel.SectionId;
user.CompanyId = inputModel.CompanyId;
user.ManagerId = inputModel.ManagerId;
user.ModifiedFrom = inputModel.ModifiedFrom;
this.applicationUserRepository.Update(user);
await this.applicationUserRepository.SaveChangesAsync();
}
return(user?.Id);
}
public async Task EditByIdAsyncReturnsCorrect()
{
var id = Guid.NewGuid().ToString();
var user = new CarpetUser
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Email = "*****@*****.**",
UserName = "******",
};
var roleAdminId = Guid.NewGuid().ToString();
var role = new CarpetRole {
Id = roleAdminId, Name = GlobalConstants.AdministratorRoleName
};
var roleOperatorId = Guid.NewGuid().ToString();
var roleOperator = new CarpetRole {
Id = roleOperatorId, Name = GlobalConstants.OperatorRoleName
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "EditByIdAsyncReturnsCorrect")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.Roles.Add(roleOperator);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Employee>(dbContext);
var service = new EmployeesService(repository, dbContext);
var wrongId = Guid.NewGuid().ToString();
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var result = await service.CreateAsync(employee, string.Empty);
var employeeEdit = new EmployeeEditInputModel
{
Id = result.Id,
FirstName = "Edit",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var actual = await service.EditByIdAsync(result.Id, employeeEdit, string.Empty);
Assert.Equal(actual.FirstName, employeeEdit.FirstName);
}
public async Task EditByIdAsyncWithWrongRoleReturnsError()
{
var id = Guid.NewGuid().ToString();
var user = new CarpetUser
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Email = "*****@*****.**",
UserName = "******",
};
var roleAdminId = Guid.NewGuid().ToString();
var role = new CarpetRole {
Id = roleAdminId, Name = GlobalConstants.AdministratorRoleName
};
var roleOperatorId = Guid.NewGuid().ToString();
var roleOperator = new CarpetRole {
Id = roleOperatorId, Name = GlobalConstants.OperatorRoleName
};
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "EditByIdAsyncWithWrongRoleReturnsError")
.Options;
var dbContext = new ApplicationDbContext(options);
dbContext.Users.Add(user);
dbContext.Roles.Add(role);
dbContext.Roles.Add(roleOperator);
await dbContext.SaveChangesAsync();
var repository = new EfDeletableEntityRepository <Employee>(dbContext);
var service = new EmployeesService(repository, dbContext);
var wrongId = Guid.NewGuid().ToString();
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var result = await service.CreateAsync(employee, string.Empty);
var employeeEdit = new EmployeeEditInputModel
{
Id = result.Id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = "Wrong",
};
var exception = await Assert.ThrowsAsync <ArgumentNullException>(() => service.EditByIdAsync(result.Id, employeeEdit, string.Empty));
Assert.Equal(string.Format(EmployeeConstants.ArgumentExceptionRoleNotExist, employeeEdit.RoleName), exception.Message);
}
