private async Task UpdateAsync(DepartmentDto department)
{
var request = new UpdateDepartmentDto()
{
Id = department.Id,
Name = department.Name,
Description = department.Description
};
var response = await _departmentManager.UpdateAsync(request);
if (response.Succeeded)
{
await GetAllDepartmentsWithPaging();
DepartmentDialogVisible = false;
}
else
{
foreach (var message in response.Messages)
{
await _message.Error(message);
}
}
}
public async Task <bool> UpdateDepartment(Guid id, UpdateDepartmentDto model, string fields)
{
var department = await _service.Query(id, false);
department.UpdateTime = DateTime.Now;
return(await _service.Update(CommonClass.SetModelValue(model, department, fields)));
}
public async Task Update(UpdateDepartmentDto departmentDto)
{
var departmentRepository = DataContextManager.CreateRepository <IDepartmentRepository>();
var department = await departmentRepository.GetById(departmentDto.Id);
if (department == null)
{
throw new NotFoundException("Department", departmentDto.Id);
}
var clientRepository = DataContextManager.CreateRepository <IClientRepository>();
var client = await clientRepository.GetById(departmentDto.ClientId);
if (client == null)
{
throw new NotFoundDependencyObjectException("Client", departmentDto.ClientId);
}
var otherDepartment = client.Departments.FirstOrDefault(x => x.Name.Equals(departmentDto.Name) && x.IsActive);
if (otherDepartment != null && otherDepartment.Id != departmentDto.Id)
{
throw new FoundSameObjectException("Department", departmentDto.Name);
}
department.Name = departmentDto.Name;
department.UpdateDate = DateTime.UtcNow;
department.Client = client;
department.UpdateDate = DateTime.UtcNow;
await departmentRepository.Update(department);
}
public async Task <IActionResult> UpdateDepartment([FromBody] UpdateCountryModel updateDepartmentModel)
{
UpdateDepartmentDto updateDepartmentDto = _mapper.Map <UpdateDepartmentDto>(updateDepartmentModel);
await _departmentService.UpdateDepartmentAsync(updateDepartmentDto);
return(Ok());
}
public WorkJsonResult UpdateDepartment(UpdateDepartmentDto dto)
{
//dto.AccessToken = GetAccessToken(QyConfig.CorpID, QyConfig.CorpSecret);
var result = MailListApi.UpdateDepartment(dto.AccessToken, dto.ID, dto.Name, dto.ParentId, dto.Order);
return(result);
}
public async Task <IHttpActionResult> UpdateDepartment(UpdateDepartmentDto item)
{
//TODO: validate
item.ModifiedBy = CurrentUser.Id;
var result = await _departmentServices.UpdateAsync(item);
return(Ok(result));
}
/// <summary>
/// 更新部门
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <ExmailModel> UpdateDepartment(UpdateDepartmentDto dto)
{
string url = $"https://api.exmail.qq.com/cgi-bin/department/update?access_token={this.Email_token}";
ExmailModel model = await HttpHelper.PostHttpAsync <ExmailModel, UpdateDepartmentDto>(url, dto);
if (model.Errcode != 0)
{
this.Errmsg = model.Errmsg;
throw new Exception($"创建部门失败:{model.Errcode}-{this.Errmsg}");
}
return(await Task.FromResult(model));
}
public async Task <ActionResult> UdpateDepartment([FromBody] UpdateDepartmentDto departmentDto)
{
if (!IsAvailableOperation())
{
return(BadRequest());
}
await _departmentService.Update(departmentDto);
AddLog(Enums.LogType.Create, LogMessage.CreateSuccessByIdMessage(LogMessage.DepartmentEntityName, departmentDto.Id, LogMessage.UpdateAction, UserId));
return(Ok());
}
public IActionResult Update(UpdateDepartmentDto updateDepartmentDto)
{
try
{
var departmentDto = _departmentService.Update(updateDepartmentDto);
return(Ok(departmentDto));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
//[Authorize(Policy = DefaultPermissions.PermissionNameForAdministration)]
public async Task <IActionResult> UpdateDepartment(UpdateDepartmentDto department)
{
try
{
await _departmentService.UpdateDepartment(department);
}
catch (Exception ex)
{
NotFound(ex);
}
return(NoContent());
}
public async Task <bool> UpdateAsync(UpdateDepartmentDto item)
{
using (var scope = _dbContextScopeFactory.Create())
{
var model = await _deparmentRepository.FindAsync(f => f.Id == item.Id);
model.Update(item.Name, item.Code, item.OrderNumber.HasValue ? item.OrderNumber.Value : 99,
item.DeptTypeID, item.ParentID,
item.DeptGroupID, item.IsShow, item.IsPrint, item.ModifiedBy);
await scope.SaveChangesAsync();
return(true);
}
}
public async Task UpdateAsync(UpdateDepartmentDto updateDepartmentDto)
{
updateDepartmentDto.ThrowIfNull(nameof(updateDepartmentDto));
Department departmentToBeUpdated = await _repository.GetByIdAsync <Department>(updateDepartmentDto.DepartmentId);
if (departmentToBeUpdated == null)
{
throw new EntityNotFoundException(typeof(Department), updateDepartmentDto.DepartmentId);
}
departmentToBeUpdated.Name = updateDepartmentDto.DepartmentName;
departmentToBeUpdated.Description = updateDepartmentDto.Description;
departmentToBeUpdated.IsActive = updateDepartmentDto.IsActive;
await _departmentCacheRepository.UpdateAsync(departmentToBeUpdated);
}
public async Task <IActionResult> UpdateDepartment(Guid id, [FromBody] UpdateDepartmentDto model,
[FromQuery] string fields)
{
try
{
if (!await _manager.UpdateDepartment(id, model, fields))
{
return(Ok(new JsonMessageResult("修改失败！", 0, null)));
}
return(NoContent());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Ok(new JsonMessageResult(e.Message, 0, null)));
}
}
public async Task UpdateDepartmentAsync(UpdateDepartmentDto updateDepartmentDto)
{
if (updateDepartmentDto == null)
{
throw new ArgumentNullException(nameof(updateDepartmentDto));
}
Department departmentToBeUpdated = await _unitOfWork.Repository <Department>().GetEntityByIdAsync(updateDepartmentDto.DepartmentId);
if (departmentToBeUpdated != null)
{
departmentToBeUpdated.DepartmentName = updateDepartmentDto.DepartmentName;
departmentToBeUpdated.Description = updateDepartmentDto.Description;
departmentToBeUpdated.IsActive = updateDepartmentDto.IsActive;
_unitOfWork.Repository <Department>().UpdateEntity(departmentToBeUpdated);
await _unitOfWork.SaveChangesAsync();
}
}
public async Task UpdateDepartment(UpdateDepartmentDto departmentDto)
{
var departmentToUpdate = await _context.Departments.FindAsync(departmentDto.Id);
if (departmentToUpdate == null)
{
throw new Exception("Department with specified id not found");
}
if (!string.IsNullOrWhiteSpace(departmentDto.Name))
{
departmentToUpdate.Name = departmentDto.Name;
}
if (!string.IsNullOrWhiteSpace(departmentDto.Address))
{
departmentToUpdate.Address = departmentDto.Address;
}
await _context.SaveChangesAsync();
}
public async Task <int> UpdateAsync(UpdateDepartmentDto request)
{
Department editDepartment = editDepartment = await _departmentRepository.FirstOrDefaultAsync(x => x.Id.Equals(request.Id));
Department existDepartment = await _departmentRepository.FirstOrDefaultAsync(x => x.Name.Equals(request.Name));
if (editDepartment == null)
{
throw new ValidationException($"Error: Id {request.Id} does not exist.");
}
if (existDepartment != null && editDepartment.Id != existDepartment.Id)
{
throw new ValidationException($"Error: {request.Name } already exist");
}
editDepartment.Name = request.Name;
editDepartment.Description = request.Description;
_departmentRepository.Update(editDepartment);
return(await _unitOfWork.SaveChangesAsync());
}
public GetDepartmentDto Update(UpdateDepartmentDto updateDepartmentDto)
{
var department = _mapper.Map <Department>(updateDepartmentDto);
var departmentInDb = _unitOfWork.DepartmentRepository.Get(updateDepartmentDto.Id);
if (departmentInDb == null)
{
throw new Exception("Not Found");
}
departmentInDb.Fund = updateDepartmentDto.Fund;
departmentInDb.CreateDate = DateTime.Now;
departmentInDb.Area = updateDepartmentDto.Area;
departmentInDb.Name = updateDepartmentDto.Name;
departmentInDb.Order = updateDepartmentDto.Order;
departmentInDb.DepartmentsAndBranches = department.DepartmentsAndBranches;
_unitOfWork.DepartmentRepository.Update(departmentInDb);
_unitOfWork.SaveChanges();
return(_mapper.Map <GetDepartmentDto>(departmentInDb));
}
public async Task <ActionResult> UpdateDepartment(int departmentId, UpdateDepartmentModel model)
{
try
{
if (departmentId != model.DepartmentId)
{
ModelState.AddModelError(nameof(model.DepartmentId), "The DepartmentId does not match with route value.");
return(BadRequest(ModelState));
}
bool isExistent = await _departmentService.ExistsAsync(departmentId);
if (!isExistent)
{
ModelState.AddModelError(nameof(model.DepartmentId), "The Department does not exist.");
return(BadRequest(ModelState));
}
UpdateDepartmentDto updateDepartmentDto = new UpdateDepartmentDto()
{
DepartmentId = model.DepartmentId,
DepartmentName = model.DepartmentName,
Description = model.Description
};
await _departmentService.UpdateAsync(updateDepartmentDto);
return(Ok());
}
catch (Exception exception)
{
await _exceptionLogger.LogAsync(exception);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public DepartmentReturnDto UpdateDepartmentName(int id, UpdateDepartmentDto updateDepartment)
{
return(!_departmentOperations.DepartmentExists(id) ? null : Mapper.Map <DepartmentReturnDto>(_departmentOperations.UpdateDepartmentName(_departmentOperations.GetDepartmentById(id), updateDepartment.NewDepartmentName)));
}
public async Task <IResult> UpdateAsync(UpdateDepartmentDto request)
{
HttpResponseMessage response = await _httpClient.PutAsJsonAsync(Routes.DepartmentEndpoint.Update, request);
return(await response.ToResult());
}
public IActionResult UpdateDepartmentName(int id, [FromBody] UpdateDepartmentDto updateDep)
{
return(OkOrNotFound(_departmentService.UpdateDepartmentName(id, updateDep)));
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateDepartmentDto request)
{
await _departmentService.UpdateAsync(request);
return(Ok(await Result.SuccessAsync("Updated successfully.")));
}
