public async Task AddDepartmentAsync(DepartmentCreateDto departmentCreateDto, string email)
{
using (unitOfWork)
{
var familyOfferingRepository = unitOfWork.FamilyOfferingRepository;
var departmentRepository = unitOfWork.DepartmentRepository;
var familyOffering = await familyOfferingRepository.FindAsync(x =>
x.Id == departmentCreateDto.OfferingId &&
x.BusinessFamily.CountryBusiness.Country.Organization.User.Email == email
);
if (familyOffering == null)
{
throw new HttpStatusCodeException(404, $"Not found offering with id \"{departmentCreateDto.OfferingId}\" or user with email {email} don't have permisson to manage this organization");
}
try
{
departmentRepository.Add(new Department
{
Name = departmentCreateDto.Name,
FamilyOffering = familyOffering
});
await unitOfWork.SaveAsync();
}
catch (DALException ex)
{
throw new HttpStatusCodeException(400, ex.Message);
}
}
}
/// <summary>
/// this method is used to add new department in the database
/// </summary>
/// <param name="departmentDetails">data of new department</param>
/// <returns>returns newly added object</returns>
public async Task <DepartmentUpdateDto> AddDepartmentsAsync(DepartmentCreateDto departmentDetails)
{
var getDepartment = await _departmentRepository.GetDepartmentByNameAsync(departmentDetails.Name);
if (getDepartment == null)
{
var newDepartment = new Department
{
Name = departmentDetails.Name,
IsDeleted = false
};
_departmentRepository.AddDepartments(newDepartment);
await _departmentRepository.SaveChangesAsync();
return(new DepartmentUpdateDto {
Name = newDepartment.Name, Id = newDepartment.Id
});
}
else
{
if (getDepartment.IsDeleted == true)
{
getDepartment.IsDeleted = false;
await _departmentRepository.SaveChangesAsync();
return(new DepartmentUpdateDto {
Name = getDepartment.Name, Id = getDepartment.Id
});
}
else
{
return(null);
}
}
}
public Result <ApplicationResult <DepartmentDto> > Create(DepartmentCreateDto departmentDto)
{
var applicationResult = new ApplicationResult <DepartmentDto>();
_codeBuilder.Build("DE1", "DE")
.OnSuccess(resultCode => DepartmentEdit.Create(resultCode, departmentDto.Name, departmentDto.Description))
.OnSuccess(resultDepartment => {
if (resultDepartment.IsValid)
{
_departmentRepository.Create(resultDepartment)
.OnSuccess(() =>
{
var dto = Mapper.Map <DepartmentDto>(resultDepartment);
applicationResult.IsValid = true;
applicationResult.Entity = dto;
});
}
else
{
applicationResult.IsValid = false;
foreach (var error in resultDepartment.BrokenRules.Errors)
{
applicationResult.ErrorMessages.Add(new ErrorMessage {
Code = error.ErrorCode, Message = error.ErrorMessage
});
}
}
});
return(applicationResult.ToResult());
}
public async Task <ActionResult> Create([FromBody] DepartmentCreateDto departmentCreateDto)
{
var mapperDepartment = _mapper.Map <Department>(departmentCreateDto);
await _departmentRepository.CreateDepartmentAsync(mapperDepartment);
return(Ok(mapperDepartment));
}
public void Post(DepartmentCreateDto department)
{
var departmentDT = new Department();
departmentDT.Title = department.Title;
_db.Departments.Add(departmentDT);
_db.SaveChanges();
}
public async Task <ActionResult <DepartmentUpdateDto> > AddDepartmentsAsync([FromBody] DepartmentCreateDto departmentDetails)
{
var result = await _departmentService.AddDepartmentsAsync(departmentDetails);
if (result != null)
{
return(Created("", result));
}
return(BadRequest("Department already exists."));
}
public async Task CanCreateAndDelete()
{
var newDepartment = new DepartmentCreateDto
{
CompanyId = 1, Name = "Test Department"
};
var department = await _httpClientHelper.PostAsync <DepartmentCreateDto, DepartmentDto>(_baseUrl + "create", newDepartment).ConfigureAwait(false);
Assert.Equal(newDepartment.Name, department.Name);
await _httpClientHelper.DeleteAsync(_baseUrl + $"DeleteDepartmentById{API_VERSION}/{department.DepartmentId}").ConfigureAwait(false);
}
public async Task <IActionResult> Create(DepartmentCreateDto departmentDto)
{
if (await _departmentService.CheckExists(departmentDto.ID))
{
return(BadRequest("Department ID already exists!"));
}
//var username = User.FindFirst(ClaimTypes.Name).Value;
//glueIngredientDto.Updated_By = username;
if (await _departmentService.Add(departmentDto))
{
return(NoContent());
}
throw new Exception("Creating the department failed on save");
}
public async Task <ActionResult <DepartmentDto> > PostDepartment(DepartmentCreateDto departmentCreateDto)
{
if (await DepartmentNameExists(departmentCreateDto.DepartmentName))
{
return(StatusCode(StatusCodes.Status400BadRequest,
new Response {
Success = false, Message = "A department with that name already exists"
}));
}
var department = _mapper.Map <Department>(departmentCreateDto);
await _departmentsRepo.CreateDepartmentAsync(department);
await _departmentsRepo.SaveChangesAsync();
var departmentReadDto = _mapper.Map <DepartmentDto>(department);
return(CreatedAtAction("GetDepartment", new { id = departmentReadDto.DepartmentId }, departmentReadDto));
}
public async Task <bool> Add(DepartmentCreateDto model)
{
try
{
var cat = _mapper.Map <Department>(model);
_repoDepartment.Add(cat);
await _repoDepartment.SaveAll();
var langs = model.Langs.Select(x => new DepartmentLang {
DepartmentID = cat.DepartmentID, Name = x.Name, LanguageID = x.LanguageID
}).ToList();
await _repoDepartment.AddDepartmentLang(langs);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public IActionResult CreateDepartment(DepartmentCreateDto departmentCreateDto)
{
if (departmentCreateDto == null)
{
return(BadRequest(ModelState));
}
if (_departmentRepo.isDepartmentExists(departmentCreateDto.Name))
{
ModelState.AddModelError("", "Department Exists!");
return(StatusCode(404, ModelState));
}
var departmentObj = _mapper.Map <Department>(departmentCreateDto);
if (!_departmentRepo.CreateDepartment(departmentObj))
{
ModelState.AddModelError("", $"Something went wrong when saving the record {departmentObj.Name}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetDepartment", new { departmentId = departmentObj.Id }, departmentObj));
}
public async Task <IActionResult> CreateAsync([FromBody] DepartmentCreateDto department, ApiVersion version)
{
Logger.LogDebug("CreateAsync");
if (!await _repositoryFactory.CompanyRepository.ExistsAsync(c => c.CompanyId == department.CompanyId).ConfigureAwait(false))
{
return(NotFound(new { message = $"The Company with id {department.CompanyId} was not found" }));
}
var newDepartment = new Department()
{
CompanyId = department.CompanyId,
Name = department.Name
};
var repoDepartment = await _repositoryFactory.DepartmentRepository.AddDepartmentAsync(newDepartment).ConfigureAwait(false);
var result = _departmentToDtoConverter.Convert(repoDepartment);
return(new ObjectResult(result)
{
StatusCode = StatusCodes.Status201Created
});
}
public async Task <ActionResult <DepartmentDto> > PostDepartments(DepartmentCreateDto departmentDto)
{
Department departments = new Department {
Name = departmentDto.Name,
Description = departmentDto.Description,
};
try
{
_context.Departments.Add(departments);
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
throw;
}
return(CreatedAtAction("GetDepartments", new { id = departments.IdDep }, new DepartmentDto {
IdDep = departments.IdDep,
Name = departments.Name,
Description = departments.Description,
Projects = new List <ProjectDto>()
}));
}
public Task <bool> Update(DepartmentCreateDto model)
{
throw new NotImplementedException();
}
public IActionResult Post([FromBody] DepartmentCreateDto departmentDto)
{
return(_departmentApplication.Create(departmentDto)
.Return(result => Ok(result), (string[] errors) => StatusCode(500, ErrorMessageHelper.BuildSystemErrorMessage(errors))));
}
