public IActionResult Create(EmployeeCreateDto model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photos != null && model.Photos.Count > 0)
{
foreach (IFormFile photo in model.Photos)
{
string uploadsFolder = Path.Combine(_hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
}
Employee newEmployee = new Employee
{
Name = model.Name,
Email = model.Email,
Departament = model.Departament,
PhotoPath = uniqueFileName
};
_employeeRepository.Add(newEmployee);
return(RedirectToAction("details", new { id = newEmployee.Id }));
}
return(View());
}
public async Task <IActionResult> Add(EmployeeCreateDto employeeCreateDto)
{
ApiResponse <EmployeeReadDto> response;
var employee = _mapper.Map <Employee>(employeeCreateDto);
try
{
var emailExist = await _employeeRepository.GetByEmail(employee.Email);
if (emailExist != null)
{
response = new ApiResponse <EmployeeReadDto>(null)
{
Message = "Useer Already exist"
};
return(Conflict(response));
}
await _employeeRepository.Add(employee);
}
catch (Exception ex)
{
response = new ApiResponse <EmployeeReadDto>(null)
{
Message = ex.Message
};
return(StatusCode(StatusCodes.Status500InternalServerError, response));
}
var employeeReadDto = _mapper.Map <EmployeeReadDto>(employee);
response = new ApiResponse <EmployeeReadDto>(employeeReadDto)
{
Message = "Created"
};
return(Ok(response));
}
public async Task CanCreateAndDeleteUsers()
{
var newEmployee = new EmployeeCreateDto()
{
CompanyId = 1,
DepartmentId = 1,
FirstName = "TestFirstName",
LastName = "TestLastName",
BirthDate = new DateTime(1991, 8, 7),
Address = "TestAddress"
};
// Save test employee
var employee = await _httpClientHelper.PostAsync <EmployeeCreateDto, EmployeeDto>(_employeesBaseUrl + "create", newEmployee).ConfigureAwait(false);
// Create test user
var newUser = new UserCreateDto()
{
EmployeeId = employee.EmployeeId,
Username = "******",
Password = "******"
};
var user = await _httpClientHelper.PostAsync <UserCreateDto, UserDto>(_usersBaseUrl + "create", newUser).ConfigureAwait(false);
Assert.Equal("testuser", user.Username);
// Delete test user
await _httpClientHelper.DeleteAsync(_usersBaseUrl + $"DeleteUserByEmployeeIdAsync{API_VERSION}/{user.EmployeeId}").ConfigureAwait(false);
// Delete test employee
await _httpClientHelper.DeleteAsync(_employeesBaseUrl + $"DeleteEmployeeById{API_VERSION}/{employee.EmployeeId}").ConfigureAwait(false);
}
public async Task <ActionResult <EmployeeDto> > PostEmployees(EmployeeCreateDto employeeDto)
{
Employee employee = new Employee {
Name = employeeDto.Name,
BirthDate = employeeDto.BirthDate.Date,
Salary = employeeDto.Salary,
Sex = employeeDto.Sex
};
try
{
_context.Employees.Add(employee);
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
throw;
}
return(CreatedAtAction("GetEmployees", new { id = employee.IdEmployee }, new EmployeeDto {
IdEmployee = employee.IdEmployee,
Name = employee.Name,
BirthDate = employee.BirthDate.Date,
Salary = employee.Salary,
Sex = employee.Sex
}));
}
public async Task <IActionResult> EditCustomersAsync(string id, [FromForm] EmployeeCreateDto editDto)
{
var oldEmployee = await context.Employees.FindAsync(Convert.ToInt32(id)); //原先的对象
if (oldEmployee == null)
{
return(NotFound());
}
//Auto映射 由于有的数据没有值默认是0 .在映射时都是0 ，所以的自己初始化一下
if (editDto.UploadFile == null)
{
oldEmployee.HeadImage = oldEmployee.HeadImage;
}
oldEmployee.Name = editDto.Name;
oldEmployee.Phone = editDto.Phone;
oldEmployee.Email = editDto.Email;
//文件上传
{
if (editDto.UploadFile != null)
{
if (editDto.UploadFile.Length > 25165824)
{
return(Ok(new { code = 1, msg = "文件不能大于3M！" }));
}
//文件名复杂，避免重复覆盖
string fileName = oldEmployee.Name + oldEmployee.Email + oldEmployee.Phone + editDto.UploadFile.FileName;
//设置文件存储的路劲
string filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "CustomerImg", fileName);
//服务端保存文件
using (var stream = System.IO.File.Create(filePath))
{
await editDto.UploadFile.CopyToAsync(stream);
}
oldEmployee.HeadImage = Request.Scheme + "://" + Request.Host + "/CustomerImg/" + fileName;
}
}
try
{
context.Employees.Update(oldEmployee);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
throw;
}
return(Ok());
}
public async Task <IActionResult> CreateEmployee([FromForm] EmployeeCreateDto createDto)
{
var id = Convert.ToInt32(User.Identity.Name);
//生成密钥
SymmetricSecurityKey key = new SymmetricSecurityKey(System.Text.Encoding.ASCII.GetBytes("asdadhajhdkjahsdkjahdkj9au8d9adasidoad89asu813e"));
//Auto映射
var employee = mapper.Map <Employees>(createDto);
employee.CreateID = id;
employee.Code = Guid.NewGuid().ToString();
employee.CreateTime = DateTime.Now;
employee.HeadImage = "https://www.zhangqueque.top:5001/UserImg/1_1_1.png";
employee.IsDel = 0;
employee.EmployeePID = 1;
//employee.Password = "******";
employee.Password = MD5Encrypt.Encrypt(employee.Password);
if (createDto.UploadFile != null)
{
if (createDto.UploadFile.Length > 25165824)
{
return(Ok(new { code = 1, msg = "文件不能大于3M！" }));
}
//文件名复杂，避免重复覆盖
string fileName = employee.Name + employee.Email + employee.Phone + createDto.UploadFile.FileName;
//设置文件存储的路劲
string filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "CustomerImg", fileName);
//服务端保存文件
using (var stream = System.IO.File.Create(filePath))
{
await createDto.UploadFile.CopyToAsync(stream);
}
employee.HeadImage = Request.Scheme + "://" + Request.Host + "/CustomerImg/" + fileName;
}
await context.Employees.AddAsync(employee);
await context.SaveChangesAsync();
Employees_Roles employees_Roles = new Employees_Roles();
employees_Roles.EmployeeID = employee.ID;
employees_Roles.EmployeeName = employee.Name;
employees_Roles.RoleID = 3;
employees_Roles.RoleName = "员工";
await context.Employees_Roles.AddAsync(employees_Roles);
await context.SaveChangesAsync();
return(Ok(new { code = 0, msg = "员工添加成功！" }));
}
public Guid Create(EmployeeCreateDto employeeCreateDto)
{
var employee = new Employee(employeeCreateDto.Name, employeeCreateDto.Position);
_employeeRepository.Insert(employee);
_unitOfWork.Save();
return(employee.Id);
}
public async Task CreateEmployee(EmployeeCreateDto employeeCreateDto)
{
var employeeModel = _mapper.Map <Employee>(employeeCreateDto);
_repository.CreateEmployee(employeeModel);
_repository.SaveChanges(); // VIKTIG!!
var employeeReadDto = _mapper.Map <EmployeeReadDto>(employeeModel);
}
public async Task <ActionResult> Post([FromBody] EmployeeCreateDto employeeCreateDto)
{
var employee = mapper.Map <Employee>(employeeCreateDto);
context.Add(employee);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <EmployeeReadDto> > CreateEmployee(EmployeeCreateDto employeeCreateDto)
{
var employeeModel = _mapper.Map <Employee>(employeeCreateDto);
await _repository.CreateAsync(employeeModel);
var employeeReadDto = _mapper.Map <EmployeeReadDto>(employeeModel);
return(CreatedAtRoute(nameof(GetEmployeeById), new { Id = employeeReadDto.Id }, employeeReadDto));
}
public ActionResult <EmployeeReadDto> CreateEmployee(EmployeeCreateDto employeeCreateDto)
{
var employeeModel = _mapper.Map <EmployeeModel>(employeeCreateDto);
_repository.CreateEmployee(employeeModel);
_repository.SaveChanges();
var employeeReadDto = _mapper.Map <EmployeeReadDto>(employeeModel);
return(CreatedAtRoute(nameof(GetEmployeeById), new { Id = employeeReadDto.EmployeeId }, employeeReadDto));
}
public ActionResult <EmployeeReadDto> Create(EmployeeCreateDto employeeCreateDto)
{
var employeeModel = _mapper.Map <Employee>(employeeCreateDto);
_employeeRepo.CreateNewEmployee(employeeModel);
_employeeRepo.SaveChanges();
var empReadDto = _mapper.Map <EmployeeReadDto>(employeeModel);
return(CreatedAtRoute(nameof(GetEmployee), new { Id = empReadDto.Id }, empReadDto));
}
public ActionResult <EmployeeReadDto> CreateEmployee(EmployeeCreateDto emp)
{
var empl = _mapper.Map <Employee>(emp);
_repository.CreateEmployee(empl);
_repository.SaveChanges();
var emplRead = _mapper.Map <EmployeeReadDto>(empl);
return(CreatedAtAction(nameof(GetEmployeeById), new { id = emplRead.Id }, emplRead));
}
public async Task <int> Create(EmployeeCreateDto dto, string userId)
{
var createdEmployee = _mapper.Map <EmployeeDbEntity>(dto);
createdEmployee.CreatedBy = userId;
await _dbContext.Employees.AddAsync(createdEmployee);
await _dbContext.SaveChangesAsync();
return(createdEmployee.Id);
}
public async Task <IActionResult> CreateEmployee(EmployeeCreateDto employeeCreateDto)
{
var employee = _mapper.Map <Employee>(employeeCreateDto);
await _unitOfWork.Employees.AddAsync(employee);
if (await _unitOfWork.SaveAsync())
{
return(StatusCode(201));
}
throw new Exception("Creating employee failed on save");
}
public async Task <ActionResult> Put(int Id, [FromBody] EmployeeCreateDto employeeCreateDto)
{
var employee = await context.Employees.FirstOrDefaultAsync(x => x.Id == Id);
if (employee == null)
{
return(NotFound());
}
employee = mapper.Map(employeeCreateDto, employee);
await context.SaveChangesAsync();
return(NoContent());
}
public async Task RegisterCompanyWithOwner(NewCustomerDto customer)
{
using (var uow = UnitOfWorkProvider.Create())
{
try
{
var company = new CompanyDto
{
Ico = customer.Ico,
JoinDate = DateTime.Now,
Name = customer.Name
};
var employee = new EmployeeCreateDto()
{
Email = customer.Email,
FirstName = customer.FirstName,
LastName = customer.LastName,
PasswordHash = customer.Password,
Company = company,
Role = Role.Owner
};
// no need to create company as it is created in employee service by default
await _employeeService.RegisterCustomerAsync(employee);
await uow.Commit();
int companyId = (await _companyService.GetByIco(customer.Ico)).Id;
var payment = new PaymentDto
{
Amount = 300,
CompanyId = companyId,
DueDate = DateTime.Now.AddDays(30),
VariableNumber = "1212100" + companyId
};
_paymentService.Create(payment);
await uow.Commit();
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
}
}
public async Task RegisterCustomerAsync(EmployeeCreateDto employeeCreateDto)
{
var customer = Mapper.Map <Employee>(employeeCreateDto);
if (await GetEmployeeByEmail(customer.Email) != null)
{
throw new ArgumentException();
}
var password = CreateHash(employeeCreateDto.PasswordHash);
customer.PasswordHash = password.Item1;
customer.PasswordSalt = password.Item2;
_repository.Create(customer);
}
public virtual async Task <EmployeeListDto> CreateAsync(EmployeeCreateDto input)
{
// TODO:计算农历生日并保存
if (await _employeeRepository.AnyAsync(e => e.IdCardNumber == input.IdCardNumber || e.PhoneNumber == input.PhoneNumber))
{
throw new UserFriendlyException(L["Existed", L["Employee"]]);
}
var entity = ObjectMapper.Map <EmployeeCreateDto, Employee>(input);
entity.Age = input.Birthday.GetAgeByBirthday();
entity.EmployeeNumber = GuidGenerator.Create().ToString("N");
entity.JoinDate = DateTime.Now;
entity = await _employeeRepository.InsertAsync(entity);
return(ObjectMapper.Map <Employee, EmployeeListDto>(entity));
}
public async Task CanCreateAndDeleteEmployee()
{
var newEmployee = new EmployeeCreateDto
{
FirstName = "Sylvester",
LastName = "Holt",
BirthDate = new DateTime(1995, 8, 7),
CompanyId = 1,
DepartmentId = 1,
Address = "New Address",
Password = "******",
Username = "******"
};
var employee = await _httpClientHelper.PostAsync <EmployeeCreateDto, EmployeeDto>(_baseUrl + "create", newEmployee).ConfigureAwait(false);
Assert.Equal(newEmployee.FirstName, employee.FirstName);
await _httpClientHelper.DeleteAsync(_baseUrl + $"DeleteEmployeeById{API_VERSION}/{employee.EmployeeId}").ConfigureAwait(false);
}
public ActionResult <EmployeeCreateDto> CreateEmployee(EmployeeCreateDto employeeCreateDto)
{
try
{
var employeeModel = _mapper.Map <Employee>(employeeCreateDto);
_repository.CreateEmployee(employeeModel);
_repository.SaveChanges();
var employeeReadDto = _mapper.Map <EmployeeReadDto>(employeeModel);
return(CreatedAtRoute(nameof(GetEmployee), new { id = employeeReadDto.id }, employeeReadDto));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(StatusCode(500));
}
}
public IActionResult CreateTrail([FromBody] EmployeeCreateDto employeeDto)
{
if (employeeDto == null)
{
return(BadRequest(ModelState));
}
if (_employeeRepo.EmployeeExists(employeeDto.Name))
{
ModelState.AddModelError("", "Employee Exists!");
return(StatusCode(404, ModelState));
}
var employeeObj = _mapper.Map <Employee>(employeeDto);
if (!_employeeRepo.CreateEmployee(employeeObj))
{
ModelState.AddModelError("", $"Something went wrong when saving the record {employeeObj.Name}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeObj.Id }, employeeObj));
}
public async Task <IActionResult> CreateEmployeeAsync(
[FromBody, SwaggerParameter("Employee to create", Required = true)] EmployeeCreateDto employeeToCreate,
[FromQuery, SwaggerParameter("Request which fields you want returned")] string fields,
[FromHeader(Name = "accept"), SwaggerParameter("Request Hateoas")] string mediaType)
{
var employeeEntity = Mapper.Map <Employee>(employeeToCreate);
employeeEntity.Id = Guid.NewGuid();
_employeeRepository.Create(employeeEntity);
if (!await _employeeRepository.SaveChangesAsync())
{
// change to logging
throw new Exception("Failed to save employee");
// consider to return an error to notify user of failed save
}
var employeeFromRepo = await _employeeRepository.GetFirstByConditionAsync(x => x.Id == employeeEntity.Id);
var employeeToReturn = Mapper.Map <EmployeeDto>(employeeFromRepo);
if (mediaType == "application/vnd.AO.json+hateoas")
{
var shapedEmployee = _controllerHelper.ShapeAndAddLinkToObject(employeeToReturn, "Employee", fields);
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, shapedEmployee));
}
if (!string.IsNullOrWhiteSpace(fields))
{
var shapedEmployee = employeeToReturn.ShapeData(fields);
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, shapedEmployee));
}
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, employeeToReturn));
}
public async Task <IActionResult> CreateAsync([FromBody] EmployeeCreateDto employee, ApiVersion version)
{
Logger.LogDebug(nameof(CreateAsync));
var newEmployee = _employeeFromDtoConverter.Convert(employee);
if (!await _repositoryFactory.CompanyRepository.ExistsAsync(c => c.CompanyId == employee.CompanyId).ConfigureAwait(false))
{
return(NotFound(new { message = $"The Company with id {employee.CompanyId} was not found" }));
}
if (!await _repositoryFactory.DepartmentRepository.ExistsAsync(c => c.DepartmentId == employee.DepartmentId).ConfigureAwait(false))
{
return(NotFound(new { message = $"The Department with id {employee.DepartmentId} was not found" }));
}
var repoEmployee = await _repositoryFactory.EmployeeRepository.AddEmployeeAsync(newEmployee).ConfigureAwait(false);
var result = _employeeToDtoConverter.Convert(repoEmployee);
var createdResult = new ObjectResult(result)
{
StatusCode = StatusCodes.Status201Created
};
return(createdResult);
}
public async Task <ActionResult <EmployeeDto> > CreateEmployee(int companyId, EmployeeCreateDto employeeCreateDto)
{
if (!await _repository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employee = _mapper.Map <Employee>(employeeCreateDto);
_repository.AddEmployee(companyId, employee);
await _repository.SaveChangesAsync();
var employeeDto = _mapper.Map <EmployeeDto>(employee);
return(CreatedAtRoute(nameof(GetEmployee),
new
{
companyId,
employeeId = employee.Id //注意此匿名类中的参数名一定要对应正确
},
employeeDto));
}
public virtual async Task <EmployeeListDto> CreateAsync(EmployeeCreateDto input)
{
return(await _employeeAppService.CreateAsync(input));
}
public async Task <IActionResult> Create([FromBody] EmployeeCreateDto dto)
=> await GetResponse(async (userId) =>
new ApiResponseViewModel(true, "Employee Created Successfully", await _service.Create(dto, userId)));
public Guid Create([FromBody] EmployeeCreateDto employeeCreateDto)
{
return(_employeeService.Create(employeeCreateDto));
}
