public async Task <IActionResult> UpdateEmployeeForCompany(Guid companyId,
Guid employeeId,
EmployeeUpdateDto employeeUpdateDto)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
//不允许客户端生成 Guid
//return NotFound();
//允许客户端生成 Guid
var employeeToAddEntity = _mapper.Map <Employee>(employeeUpdateDto);
employeeToAddEntity.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAsync();
var returnDto = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtAction(nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = employeeId },
returnDto));
}
//把 updateDto 映射到 entity
_mapper.Map(employeeUpdateDto, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent()); //返回状态码204
}
public async Task <ActionResult> Put([FromQuery] Guid id, [FromBody] EmployeeUpdateDto value)
{
if (id == Guid.Empty)
{
return(BadRequest($"Invalid {nameof(Employee)} Id"));
}
var obj = await _ctx.Employees
.Include(t => t.EmployeeCertifications)
.Include(t => t.EmployeeCompetencies)
.Include(t => t.EmployeeHealthItems)
.FirstOrDefaultAsync(t => t.Id == id);
if (null == obj)
{
return(NotFound($"{nameof(Employee)} Not Found"));
}
obj.UpdateFromDto(value);
ContextCollectionSyncer.SyncCollections(_ctx, value.EmployeeCompetencies, obj.EmployeeCompetencies);
ContextCollectionSyncer.SyncCollections(_ctx, value.EmployeeCertifications, obj.EmployeeCertifications);
ContextCollectionSyncer.SyncCollections(_ctx, value.EmployeeHealthItems, obj.EmployeeHealthItems);
if (0 < await _ctx.SaveChangesAsync())
{
await _updatedPublisher.PublishAsync(obj);
}
return(Ok(obj));
}
public ActionResult UpdateEmployee(int id, EmployeeUpdateDto employeeUpdateDto)
{
// Call GET-employee by ID to return the requested resource from the repository
var employeeModelFromRepo = _repository.GetEmployeeById(id);
if (employeeModelFromRepo == null)
{
return(NotFound());
}
// Take data from employee update DTO, that has been supplied by a client then apply it on top of the employee model
// USES: EmployeeProfile.cs
// Uses existing sources, EmployeeUpdateDto (which we map data from) and we want to map to our employee model from the repository
_mapper.Map(employeeUpdateDto, employeeModelFromRepo);
// Not necessary, but good practice
_repository.UpdateEmployee(employeeModelFromRepo);
// Flushes the changes that has been done back to the database
_repository.SaveChanges();
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
EmployeeUpdateDto employee)
{
if (!await companyRepository.Where(t => t.Id.Equals(companyId)).AnyAsync())
{
return(NotFound());
}
var entity = await employeeRepository.Where(t => t.Id.Equals(employeeId)).ToOneAsync();
// 若不存在，则创建
if (entity is null)
{
entity = mapper.Map <Employee>(employee);
entity.Id = employeeId;
var result = await employeeRepository.AddEmployeeAsync(companyId, entity);
var resultDto = mapper.Map <EmployeeDto>(result);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId, employeeId = resultDto.Id },
resultDto));
}
mapper.Map(employee, entity);
await employeeRepository.UpdateAsync(entity);
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(Guid companyId, Guid employeeId,
EmployeeUpdateDto employee)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
//如果没有查找到直接创建
var employeeToAddEntity = _mapper.Map <Employee>(employee);
employeeToAddEntity.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAsync();
var returnDto = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtRoute(nameof(GetEmployeeForCompany), new { companyId = companyId, employeeId = returnDto.Id },
returnDto));
}
//entity转化为updateDto
//把传过来employee的值更新到updatedto
//吧updateDto影射回entity
_mapper.Map(employee, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployee(Guid companyId, Guid employeeId
, EmployeeUpdateDto employeeUpdate)
{
if (!await _service.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employee = await _service.GetEmployeeAsync(companyId, employeeId);
if (employee == null)
{
var res = EmployeeProfile.InitializeAutoMapper().Map <Employee>(employeeUpdate);
res.Id = employeeId;
_service.AddEmployee(companyId, res);
await _service.SaveAsync();
var employeeDto = EmployeeProfile.InitializeAutoMapper().Map <EmployeeDto>(res);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId, employeeId = res.Id }, employeeDto));
}
EmployeeProfile.InitializeAutoMapper().Map(employeeUpdate, employee);
await _service.SaveAsync();
return(NoContent());
}
public async Task <ActionResult> UpdatedUserInfo(string username, EmployeeUpdateDto employeeUpdateDto)
{
var user = await _userManager.FindByNameAsync(username);
if (user == null)
{
return(NotFound("Could not find user"));
}
if (User.GetUsername() != username.ToLower())
{
var userRoles = await _userManager.GetRolesAsync(user);
if (userRoles.Contains("Admin"))
{
return(StatusCode((int)HttpStatusCode.Forbidden, "You cannot update another admin's profile"));
}
if (userRoles.Contains("Manager") && !(User.IsInRole("Admin")))
{
return(StatusCode((int)HttpStatusCode.Forbidden, "You cannot update another manager's profile"));
}
}
_mapper.Map(employeeUpdateDto, user);
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult <CompanyDto> > UpdateEmployeeForCompany(
[FromRoute] Guid companyId,
[FromRoute] Guid employeeId,
[FromBody] EmployeeUpdateDto employeeUpdateDto
)
{
if (!await _companyRepository.CompanyExistAsync(companyId))
{
return(NotFound());
}
var employeeEtity = await _companyRepository.GetEmployeeAsync(employeeId, companyId);
if (employeeEtity == null)
{
var employee = _mapper.Map <Employee>(employeeUpdateDto);
employee.Id = employeeId;
_companyRepository.AddEmployee(companyId, employee);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <EmployeeDto>(employee);
return(CreatedAtRoute(nameof(GetEmployee), new { companyId = companyId, employeeId = employeeId }, dtoToReturn));
}
_mapper.Map(employeeUpdateDto, employeeEtity);
_companyRepository.UpdateEmployee(employeeEtity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(Guid companyId, Guid employeeId,
EmployeeUpdateDto employee)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
var employeeToAddEntity = _mapper.Map <Employee>(employee);
employeeToAddEntity.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId, employeeId = dtoToReturn.Id }, dtoToReturn));
}
//需要整体更新的是资源，不是Entity
//1.entity 转化为updateDto
//2.把传进来的employee的值更新到updateDto
//3.把updateDto映射回entity
_mapper.Map(employee, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity); //值都是跟踪的
await _companyRepository.SaveAsync();
return(NoContent());//需要更新后的资源返回Ok，不需要就204
}
public HttpResponseMessage UpdateEmployee([FromBody] EmployeeUpdateDto employeeUpdateDto)
{
try
{
// check the valdation of the date
if (employeeUpdateDto.EmployeeBirthdate >= DateTime.Today)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Birthday less than today"));
}
// check the model state
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
using (var ctx = new ClientContext(webUrl))
{
//get user from token
var claims = (ClaimsIdentity)ClaimsPrincipal.Current.Identity;
//check user permission on the Item
ClientResult <BasePermissions> permissions = ctx.Web.Lists.GetByTitle(listTitle).GetItemById(employeeUpdateDto.ID).GetUserEffectivePermissions(claims.Name);
ctx.ExecuteQuery();
Boolean hasPermission = permissions.Value.Has(PermissionKind.AddListItems);
if (!hasPermission)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "you're not allow to update employee"));
}
//Get Item
ListItem oListItem = ctx.Web.Lists.GetByTitle(listTitle).GetItemById(employeeUpdateDto.ID);
foreach (var property in typeof(EmployeeUpdateDto).GetProperties())
{
if (property.Name != "ID" & property.Name != "ProfileURL" & property.Name != "Description" & property.GetValue(employeeUpdateDto) != null)
{
oListItem[property.Name] = property.GetValue(employeeUpdateDto);
}
}
if (!String.IsNullOrWhiteSpace(employeeUpdateDto.ProfileURL))
{
FieldUrlValue fieldUrl = new FieldUrlValue();
fieldUrl.Url = employeeUpdateDto.ProfileURL;
if (!String.IsNullOrWhiteSpace(employeeUpdateDto.Description))
{
fieldUrl.Description = employeeUpdateDto.Description;
}
oListItem["ProfileURL"] = fieldUrl;
}
oListItem.Update();
ctx.ExecuteQuery();
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> PartiallyUpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> patchDocument)
{
//判断该公司是否存在
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
//该公司没有这个员工
if (employeeEntity == null)
{
var employeeDto = new EmployeeUpdateDto();
patchDocument.ApplyTo(employeeDto, ModelState);
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));
}
var employeeToAdd = _mapper.Map <Employee>(employeeDto);
employeeToAdd.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAdd);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <EmployeeDto>(employeeToAdd);
return(CreatedAtRoute(nameof(GetEmployeeForCompany), new
{
companyId,
employeeId = dtoToReturn.Id
}, dtoToReturn));
}
var dtoToPatch = _mapper.Map <EmployeeUpdateDto>(employeeEntity);
//需要处理验证错误
patchDocument.ApplyTo(dtoToPatch);
if (!TryValidateModel(dtoToPatch))
{
return(UnprocessableEntity(ModelState));
}
_mapper.Map(dtoToPatch, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> PartiallyUpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> patchDocument)
{
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
//patch新增
if (employeeEntity == null)
{
//不允许客户端生成 Guid
//return NotFound();
//允许客户端生成 Guid
var employeeDto = new EmployeeUpdateDto();
//传入 ModelState 进行验证
patchDocument.ApplyTo(employeeDto, ModelState);
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));
}
var employeeToAdd = _mapper.Map <Employee>(employeeDto);
employeeToAdd.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAdd);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <Employee>(employeeToAdd);
return(CreatedAtAction(nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = employeeId },
dtoToReturn));
}
var dtoToPatch = _mapper.Map <EmployeeUpdateDto>(employeeEntity);
//将 Patch 应用到 dtoToPatch（EmployeeUpdateDto）
patchDocument.ApplyTo(dtoToPatch);
//验证模型
if (!TryValidateModel(dtoToPatch))
{
return(ValidationProblem(ModelState)); //返回状态码与错误信息
//return new UnprocessableEntityObjectResult(ModelState);
}
_mapper.Map(dtoToPatch, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent()); //返回状态码204
}
public ActionResult UpdateCommand(int id, EmployeeUpdateDto employeeUpdateDto)
{
var employeeModelFromRepo = _repository.GetEmployeeById(id);
if (employeeModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(employeeUpdateDto, employeeModelFromRepo);
_repository.UpdateEmployee(employeeModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public async Task <ActionResult> PartiallyUpdateEmployee(Guid companyId, Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> patchDocument)
{
if (!await _service.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employee = await _service.GetEmployeeAsync(companyId, employeeId);
if (employee == null)
{
var emp = new EmployeeUpdateDto();
patchDocument.ApplyTo(emp, ModelState);
if (!TryValidateModel(emp))
{
return(ValidationProblem(ModelState));
}
var tem = EmployeeProfile.InitializeAutoMapper().Map <Employee>(emp);
tem.Id = employeeId;
_service.AddEmployee(companyId, tem);
await _service.SaveAsync();
var returnDto = EmployeeProfile.InitializeAutoMapper().Map <EmployeeDto>(tem);
return(CreatedAtRoute(nameof(GetEmployeeForCompany)
, new { companyId, employeeId }, returnDto));
}
var employeeDto = EmployeeProfile.InitializeAutoMapper().Map <EmployeeUpdateDto>(employee);
//patch数据映射
patchDocument.ApplyTo(employeeDto, ModelState);
//如果不符合数据约束
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));//返回422数据错误
}
EmployeeProfile.InitializeAutoMapper().Map(employeeDto, employee);
await _service.SaveAsync();
return(NoContent());
}
public ActionResult UpdateEmployee(int id, EmployeeUpdateDto employeeUpdateDto)
{
var employeeModelFromRepo = _repository.GetEmployeeById(id);
if (employeeModelFromRepo == null)
{
return(NotFound(new { message = "Employee not found!", error = true }));
}
_mapper.Map(employeeUpdateDto, employeeModelFromRepo);
_repository.UpdateEmployee(employeeModelFromRepo);
_repository.SaveChanges();
return(NoContent());
}
public virtual async Task <EmployeeListDto> UpdateAsync(Guid id, EmployeeUpdateDto input)
{
if (await _employeeRepository.AnyAsync(e => e.PhoneNumber == input.PhoneNumber && e.Id != id))
{
throw new UserFriendlyException(L["Existed", L["Employee"]]);
}
Employee entity = await _employeeRepository.GetAsync(id);
entity = ObjectMapper.Map(input, entity);
entity.Age = input.Birthday.GetAgeByBirthday();
entity = await _employeeRepository.UpdateAsync(entity);
return(ObjectMapper.Map <Employee, EmployeeListDto>(entity));
}
public async Task <ActionResult> UpdateUser(EmployeeUpdateDto memberUpdateDto)
{
var user = await _userRepository.GetUserByUsernameAsync(User.GetUsername());
_mapper.Map(memberUpdateDto, user);
_userRepository.Update(user);
if (await _userRepository.SaveAllAsync())
{
return(NoContent());
}
return(BadRequest("Failed to update user"));
}
public async Task <ActionResult> UpdateEmployee(int id, EmployeeUpdateDto emp)
{
var empl = await _repository.GetEmployeeById(id);
if (empl == null)
{
return(NotFound());
}
_mapper.Map(emp, empl);
_repository.UpdateEmployee(empl);
_repository.SaveChanges();
return(NoContent());
}
public async Task <IActionResult> PartiallyUpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> patchDocument)
{
if (!await companyRepository.Where(t => t.Id.Equals(companyId)).AnyAsync())
{
return(NotFound());
}
var entity = await employeeRepository.Where(t => t.Id.Equals(employeeId)).ToOneAsync();
// 若不存在，则创建
if (entity is null)
{
var employeeDto = new EmployeeUpdateDto();
patchDocument.ApplyTo(employeeDto, ModelState);
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));
}
var employeeToAdd = mapper.Map <Employee>(entity);
employeeToAdd.Id = employeeId;
var result = await employeeRepository.AddEmployeeAsync(companyId, employeeToAdd);
var resultDto = mapper.Map <EmployeeDto>(result);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId, employeeId = resultDto.Id },
resultDto));
}
var dtoToPatch = mapper.Map <EmployeeUpdateDto>(entity);
patchDocument.ApplyTo(dtoToPatch, ModelState);
if (!TryValidateModel(dtoToPatch))
{
return(ValidationProblem(ModelState));
}
mapper.Map(dtoToPatch, entity);
await employeeRepository.UpdateAsync(entity);
return(NoContent());
}
public async Task <ActionResult> UpdateEmployee(int id, EmployeeUpdateDto employeeUpdateDto)
{
var employeeModelFromRepo = await _repository.GetByIdAsync(id);
if (employeeModelFromRepo == null)
{
return(NotFound());
}
_mapper.Map(employeeUpdateDto, employeeModelFromRepo);
await _repository.UpdateAsync(employeeModelFromRepo);
return(NoContent());
}
public IActionResult UpdateEmployee(int employeeId, [FromBody] EmployeeUpdateDto employeeDto)
{
if (employeeDto == null || employeeId != employeeDto.Id)
{
return(BadRequest(ModelState));
}
var employeeObj = _mapper.Map <Employee>(employeeDto);
if (!_employeeRepo.UpdateEmployee(employeeObj))
{
ModelState.AddModelError("", $"Something went wrong when updating the record {employeeObj.Name}");
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public async Task <IActionResult> UpdateEmployee(int id, EmployeeUpdateDto employeeUpdateDto)
{
var employee = await _unitOfWork.Employees.GetByIdAsync(id);
if (employee == null)
{
return(NotFound());
}
_mapper.Map(employeeUpdateDto, employee);
if (await _unitOfWork.SaveAsync())
{
return(NoContent());
}
throw new Exception($"Updating user {id} failed on save");
}
public async Task CanUpdateEmployee()
{
// Get first employee
/* Create Employee */
var newEmployee = new EmployeeUpdateDto()
{
EmployeeId = 1,
FirstName = "Johnny",
LastName = "Holt",
BirthDate = new DateTime(1995, 8, 7)
};
// Update employee
var updatedEmployee = await _httpClientHelper.PutAsync <EmployeeUpdateDto, EmployeeDto>(_baseUrl + "update", newEmployee).ConfigureAwait(false);
// First name should be a new one
Assert.Equal("Johnny", updatedEmployee.FirstName);
}
public async Task <ActionResult <EmployeeDto> > PartiallyUpdateEmployeeForCompany(Guid companyId, Guid employeeId, JsonPatchDocument <EmployeeUpdateDto> patchDocument)
{
if (!await this.companyRespository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await this.companyRespository.GetEmployeeAsync(companyId, employeeId);
if (employeeEntity == null)
{
var employeeDto = new EmployeeUpdateDto();
patchDocument.ApplyTo(employeeDto, ModelState);
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));
}
else
{
var employeeToAdd = this.mapper.Map <Employee>(employeeDto);
employeeToAdd.Id = employeeId;
this.companyRespository.AddEmployee(companyId, employeeToAdd);
await this.companyRespository.SaveAsync();
var dto = this.mapper.Map <EmployeeDto>(employeeToAdd);
return(CreatedAtRoute(nameof(GetEmployeeForCompany),
new { companyId = companyId, employeeId = dto.Id }, dto));
}
}
var dtoToPatch = this.mapper.Map <EmployeeUpdateDto>(employeeEntity);
patchDocument.ApplyTo(dtoToPatch, ModelState);
if (!TryValidateModel(dtoToPatch))
{
//return UnprocessableEntity(ModelState);
//return new UnprocessableEntityObjectResult(ModelState);
return(ValidationProblem(ModelState));
}
this.mapper.Map(dtoToPatch, employeeEntity);
this.companyRespository.UpdateEmployee(employeeEntity);
await this.companyRespository.SaveAsync();
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > UpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
EmployeeUpdateDto employee
)
{
//判断该公司是否存在
if (!await _companyRepository.CompanyExistsAsync(companyId))
{
return(NotFound());
}
var employeeEntity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
//该公司没有这个员工
if (employeeEntity == null)
{
//创建员工
var employeeToAddEntity = _mapper.Map <Employee>(employee);
employeeToAddEntity.Id = employeeId;
_companyRepository.AddEmployee(companyId, employeeToAddEntity);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <EmployeeDto>(employeeToAddEntity);
return(CreatedAtRoute(nameof(GetEmployeeForCompany), new
{
companyId,
employeeId = dtoToReturn.Id
}, dtoToReturn));
}
//entity 转化为 updateDto
//把传进来的employee的值更新到updateDto
//把updateDto映射回entity
_mapper.Map(employee, employeeEntity);
_companyRepository.UpdateEmployee(employeeEntity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <ActionResult <EmployeeDto> > PartiallyUpdateEmloyeeForCompany(
[FromRoute] Guid companyId,
[FromRoute] Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> patchDocument
)
{
if (!await _companyRepository.CompanyExistAsync(companyId))
{
return(NotFound());
}
var employeeEtity = await _companyRepository.GetEmployeeAsync(employeeId, companyId);
if (employeeEtity == null)
{
var employeeDto = new EmployeeUpdateDto();
patchDocument.ApplyTo(employeeDto, ModelState);
if (!TryValidateModel(employeeDto))
{
return(ValidationProblem(ModelState));
}
var dtoToAdd = _mapper.Map <Employee>(employeeDto);
dtoToAdd.Id = employeeId;
_companyRepository.AddEmployee(companyId, dtoToAdd);
await _companyRepository.SaveAsync();
var dtoToReturn = _mapper.Map <EmployeeDto>(dtoToAdd);
return(CreatedAtRoute(nameof(GetEmployee), new { companyId, employeeId }, dtoToReturn));
}
var dtoToPatch = _mapper.Map <EmployeeUpdateDto>(employeeEtity);
patchDocument.ApplyTo(dtoToPatch, ModelState);
if (!TryValidateModel(dtoToPatch))
{
return(ValidationProblem(ModelState));
}
_mapper.Map(dtoToPatch, employeeEtity);
_companyRepository.UpdateEmployee(employeeEtity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> PartiallyUpdateEmployeeForCompany(
Guid companyId,
Guid employeeId,
JsonPatchDocument <EmployeeUpdateDto> jsonPatchDocument)
{
if (!await _companyRepository.CompanyExitsAsync(companyId))
{
return(NotFound());
}
var employentity = await _companyRepository.GetEmployeeAsync(companyId, employeeId);
if (employentity == null)
{
var employeeedto = new EmployeeUpdateDto();
jsonPatchDocument.ApplyTo(employeeedto, ModelState);
if (!TryValidateModel(employeeedto))
{
return(ValidationProblem(ModelState));
}
var employeeToadd = _mapper.Map <Emloyee>(employeeedto);
employeeToadd.Id = employeeId;
_companyRepository.AddEmployee(employeeToadd, companyId);
await _companyRepository.SaveAsync();
var retdto = _mapper.Map <EmployeeDto>(employeeToadd);
return(CreatedAtRoute(nameof(GetEmployeeForCanpany), new { companyid = companyId, empolyid = retdto.Id }, retdto));//调用getcompany方达，填写路由
}
var dtoToPatch = _mapper.Map <EmployeeUpdateDto>(employentity);
//需要处理验证
jsonPatchDocument.ApplyTo(dtoToPatch, ModelState); //第二个参数是验证jsonPatchDocument传入的值是否合法使其不报500服务器错误
if (!TryValidateModel(dtoToPatch)) //验证数据可以进去我们设置的验证
{
return(ValidationProblem(ModelState));
}
_mapper.Map(dtoToPatch, employentity);
_companyRepository.UpdataEmloyee(employentity);
await _companyRepository.SaveAsync();
return(NoContent());
}
public async Task <IActionResult> UpdateEmployeeAsync(
[FromRoute, SwaggerParameter("Id of the employee to update", Required = true)] Guid employeeId,
[FromBody, SwaggerParameter("object with the updates", Required = true)] EmployeeUpdateDto employeeToUpdate,
[FromHeader(Name = "accept"), SwaggerParameter("Request Hateoas")] string mediaType)
{
var employeeFromRepo = await _employeeRepository.GetFirstByConditionAsync(x => x.Id == employeeId);
// upserting if doesnt exist
if (employeeFromRepo == null)
{
var employeeEntity = Mapper.Map <Employee>(employeeToUpdate);
employeeEntity.Id = employeeId;
_employeeRepository.Create(employeeEntity);
if (!await _employeeRepository.SaveChangesAsync())
{
throw new Exception("Failed to save on upserting");
}
var employeeToReturn = Mapper.Map <EmployeeDto>(await _employeeRepository.GetFirstByConditionAsync(h => h.Id == employeeId));
if (mediaType == "application/vnd.AO.json+hateoas")
{
var shapedEmployee = _controllerHelper.ShapeAndAddLinkToObject(employeeToReturn, "Employee", null);
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, shapedEmployee));
}
return(CreatedAtRoute("GetEmployee", new { employeeId = employeeToReturn.Id }, employeeToReturn));
}
Mapper.Map(employeeToUpdate, employeeFromRepo);
_employeeRepository.Update(employeeFromRepo);
if (!await _employeeRepository.SaveChangesAsync())
{
throw new Exception("Failed to save on updating");
}
return(NoContent());
}
public async Task <IActionResult> UpdateEmployee(string employeeId, [FromBody] EmployeeUpdateDto employee)
{
if (employee == null)
{
throw new ArgumentNullException(nameof(employee));
}
var entity = await _employeeRepository.GetSingleAsync(employeeId);
if (entity == null)
{
return(NotFound($"id:{employeeId}没有查到数据"));
}
_mapper.Map(employee, entity);
_employeeRepository.Update(entity);
_employeeRepository.SaveChanges();
return(NoContent());
}
public async Task UpdateEmployeeNotFoundTest()
{
var objA = new EmployeeUpdateDto
{
FirstName = Guid.NewGuid().ToString(),
HireDate = DateTime.UtcNow.AddMonths(-6),
Id = Guid.NewGuid(),
};
using var srv = new TestServer(TestHostBuilder <Startup, UnigrationWebApiTestStartup>());
var client = srv.CreateClient();
GenerateAuthHeader(client, GenerateTestToken());
var resp = await client.PutAsJsonAsync($"api/v1/Employees.json?id={objA.Id}", objA);
Assert.AreEqual(HttpStatusCode.NotFound, resp.StatusCode);
Assert.AreEqual($"\"{nameof(Employee)} Not Found\"", await resp.Content.ReadAsStringAsync());
}
