public async Task <IActionResult> Create(EmployeeCreateInputModel employeeCreate)
{
if (!this.ModelState.IsValid)
{
var errorModel = AutoMapper.Mapper.Map <EmployeeCreateViewModel>(employeeCreate);
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 = employeeCreate.PhoneNumber + "_" + DateTime.UtcNow.ToString("dd.MM.yyyy");
string pictureUrl = null;
if (employeeCreate.PictureLink != null)
{
pictureUrl = await this.cloudinaryService.UploadPictureAsync(
employeeCreate.PictureLink,
pictureFileName);
}
var result = await this.employeesService.CreateAsync(employeeCreate, pictureUrl);
return(this.RedirectToAction(nameof(this.Index)));
}
public async Task CreateAsyncReturnsCorrect()
{
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: "CreateAsyncReturnsCorrect")
.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 userFrom = dbContext.Users.First();
var employeeId = Guid.NewGuid().ToString();
var employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var employeeFromDbFirst = await service.CreateAsync(employee, string.Empty);
await service.DeleteByIdAsync(employeeFromDbFirst.Id);
var employeeFromDb = await service.CreateAsync(employee, string.Empty);
Assert.NotEqual(employeeFromDb.Id, employeeFromDbFirst.Id);
Assert.Equal(employeeFromDb.PhoneNumber, employeeFromDbFirst.PhoneNumber);
Assert.Equal(employeeFromDb.PhoneNumber, employeeFromDbFirst.PhoneNumber);
Assert.Equal(employee.PhoneNumber, employeeFromDb.PhoneNumber);
}
public async Task DeleteByIdAsyncWithWrongIdReturnsError()
{
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: "DeleteByIdAsyncWithWrongIdReturnsError")
.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 employeeDelete = new EmployeeDeleteInputModel
{
Id = wrongId,
};
var result = await service.CreateAsync(employee, string.Empty);
var exception = await Assert.ThrowsAsync <NullReferenceException>(() => service.DeleteByIdAsync(employeeDelete.Id));
Assert.Equal(string.Format(string.Format(EmployeeConstants.NullReferenceId, wrongId)), exception.Message);
}
public async Task GetByUsernameAsyncReturnsCorrect()
{
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: "GetByUsernameAsyncReturnsCorrect")
.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 employee = new EmployeeCreateInputModel
{
Id = id,
FirstName = "Иван",
LastName = "Иванов",
PhoneNumber = "0888777444",
Salary = 1000m,
RoleName = GlobalConstants.OperatorRoleName,
};
var result = await service.CreateAsync(employee, string.Empty);
var username = await dbContext.Employees.FirstOrDefaultAsync(x => x.Id == result.Id);
var actual = await service.GetIdByUserNameAsync(username.User.UserName);
var employees = await service.GetAllAsync <EmployeeIndexViewModel>().ToListAsync();
Assert.Equal(result.Id, actual);
Assert.Single(employees);
}
public async Task <IActionResult> Create(EmployeeCreateInputModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
User user = model.To <User>();
await userManager.CreateAsync(user, model.Password);
await userManager.AddToRoleAsync(user, Roles.Employee);
return(RedirectToAction(nameof(All)));
}
public IActionResult Create(int companyId)
{
if (this.ModelState.IsValid == false)
{
return(this.View());
}
var officesCurrent = this.officesService.GetAllByCompanyId <OfficeDropDownViewModel>(companyId);
var viewModel = new EmployeeCreateInputModel
{
CompanyId = companyId,
OfficesDropDown = officesCurrent,
};
return(this.View(viewModel));
}
public async Task <EmployeeCreateViewModel> CreateAsync(EmployeeCreateInputModel employeeFromView, string pictureUrl)
{
var checkForId = await this.employeeRepository.All().FirstOrDefaultAsync(x => x.PhoneNumber == employeeFromView.PhoneNumber);
// If customer with phone number exists return existing view model
if (checkForId != null)
{
throw new ArgumentException(string.Format(EmployeeConstants.ArgumentExceptionPhoneNumberExist, employeeFromView.PhoneNumber));
}
var user = await this.context.Users.FirstOrDefaultAsync(x => x.Id == employeeFromView.Id);
if (user == null)
{
throw new NullReferenceException(string.Format(EmployeeConstants.NullReferenceUserId, employeeFromView.Id));
}
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)));
}
user.Roles.Add(new IdentityUserRole <string> {
RoleId = role.Id, UserId = user.Id
});
var employeeToDb = employeeFromView.To <Employee>();
employeeToDb.Id = Guid.NewGuid().ToString();
employeeToDb.User = user;
employeeToDb.Picture = pictureUrl;
await this.employeeRepository.AddAsync(employeeToDb);
await this.employeeRepository.SaveChangesAsync();
return(employeeToDb.To <EmployeeCreateViewModel>());
}
public async Task <IActionResult> Create(EmployeeCreateInputModel input)
{
if (this.ModelState.IsValid == false)
{
return(this.View());
}
var employeeId = await this.employeesService.CreateAsync(input.FirstName, input.LastName, input.Salary, input.VacationDays, input.ExpirenceLevel, input.CompanyId);
if (input.Offices != null)
{
for (int i = 0; i < input.Offices.Count; i++)
{
await this.employeeOfficeServices.CreateAsync(employeeId, input.Offices[i]);
}
}
var companyCurrent = this.companiesService.GetById <CompanyViewModel>(input.CompanyId);
this.TempData["InfoMessage"] = "Employee successfully created!";
return(this.RedirectToRoute("TaskDotNetCompany", new { name = companyCurrent.Name }));
}
