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."))); }