public async Task <IActionResult> OnDeleteAsync(DeveloperDto model)
{
try
{
var devEntity = await _repository.Developer.GetDeveloperByIdAsync(model.Id);
if (devEntity == null)
{
_logger.LogError("Developer object sent from client could not be tied to an existing developer.");
return(BadRequest("Developer is null"));
}
_repository.Developer.Delete(devEntity);
await _repository.SaveAsync();
_logger.LogInfo($"Developer {model.Name} was successfully deleted.");
StatusMessage = $"Developer {model.Name} was successfully deleted.";
return(new OkResult());
}
catch (Exception ex)
{
_logger.LogError($"Something went wrong inside OnDeleteAsync action: {ex.Message}");
StatusMessage = $"Error: Could not deleted developer {model.Name}.";
return(StatusCode(500, "Internal Server Error"));
}
}
public virtual DeveloperDto Find(params object[] keys)
{
Developer developer = this.DbSet.Find(keys);
DeveloperDto developerDto = Mapper.Map <Developer, DeveloperDto>(developer);
return(developerDto);
}
static IEnumerable <DeveloperDto> MapDto(List <object> objs) => objs.Select(obj =>
{
if (obj.GetType().Name == "SelectAllAndExpand`1")
{
var entityProperty = obj.GetType().GetProperty("Instance");
return(DeveloperDto.Map((Developer)entityProperty.GetValue(obj)));
}
return(DeveloperDto.Map((Developer)obj));
});
public void Create(DeveloperDto dto)
{
Developer entity = new Developer();
entity = _mapper.Map <Developer>(dto);
_unitOfWork.GetRepository <Developer>().Add(entity);
_unitOfWork.Commit();
}
public int Save(DeveloperDto developerDto)
{
if (developerDto?.Developer?.DeveloperId == 0)
{
return(_developerService.Add(developerDto));
}
else
{
return(_developerService.Update(developerDto));
}
}
public async Task <IActionResult> Post([FromBody] DeveloperDto developerDto)
{
var result = await _developerService.ApplyADeveloper(developerDto);
if (_developerService.Errors.Count > 0)
{
return(BadRequest(_developerService.Errors));
}
return(Ok(result));
}
public async Task <IActionResult> Put([FromBody] DeveloperDto developerDto)
{
await _developerService.UpdateAnApplicant(developerDto);
if (_developerService.Errors.Count > 0)
{
return(BadRequest(_developerService.Errors));
}
return(Ok(developerDto));
}
public DeveloperDto AddDeveloper(AddDeveloperDto developerToAdd)
{
Developer developer = Mapper.Map <AddDeveloperDto, Developer>(developerToAdd);
this.context.Developers.Add(developer);
this.context.SaveChanges();
DeveloperDto addedDeveloper = Mapper.Map <Developer, DeveloperDto>(developer);
return(addedDeveloper);
}
public async Task <long> ApplyADeveloper(DeveloperDto developerDto)
{
var entity = _mapper.Map <Developer>(developerDto);
if (entity.Validate())
{
return(await _developerRepository.Insert(entity));
}
Errors = entity.Errors;
return(0);
}
public static DeveloperDto ToDto(this Developer entity)
{
DeveloperDto developerDto = new DeveloperDto
{
Id = entity.Id,
Name = entity.Name,
Description = entity.Description,
YearOfFoundation = entity.YearOfFoundation,
Games = entity.Games.ToDtoCollection().ToList()
};
return(developerDto);
}
public static Developer ToEntity(this DeveloperDto dto)
{
Developer developer = new Developer
{
Id = dto.Id,
Name = dto.Name,
Description = dto.Description,
YearOfFoundation = dto.YearOfFoundation,
Games = dto.Games.ToEntityCollection().ToList()
};
return(developer);
}
private void ValidateDeveloper(DeveloperDto developerDto)
{
var developersDto = _uow._developerRepository.GetEntities(UserCompanyId());
bool hasDeveloperNameAndPosition = developersDto
.Any(dd => dd.Id != developerDto.Id &&
dd.Name == developerDto.Name &&
dd.Position == developerDto.Position);
if (hasDeveloperNameAndPosition)
{
ModelState.AddModelError(string.Empty,
"The provided name and position is in use by another developer");
}
}
public int Update(DeveloperDto developerDto)
{
try
{
_dataAnnotationValidator.Validate(developerDto?.Developer);
_repository.Detach(developerDto?.Developer);
var existingDeveloper = _repository.GetByKey <Developer>(developerDto.Developer.DeveloperId);
_repository.Overwrite(existingDeveloper, developerDto.Developer);
_repository.Delete <DeveloperAvailability>
(da => existingDeveloper.Equals(da.Developer));
int index = 0;
do
{
var availability =
developerDto.Availabilities?.ElementAtOrDefault(index++);
Add(existingDeveloper, availability);
} while (index < developerDto.Availabilities?.Count);
_repository.Delete <DeveloperWorkingTime>
(da => existingDeveloper.Equals(da.Developer));
index = 0;
do
{
var workingTime =
developerDto.WorkingTimes?.ElementAtOrDefault(index++);
Add(existingDeveloper, workingTime);
} while (index < developerDto.WorkingTimes?.Count);
_repository.Delete <DeveloperKnowledge>
(dk => existingDeveloper.Equals(dk.Developer));
index = 0;
do
{
var knowledge =
developerDto.KnowledgeDtos?.ElementAtOrDefault(index++);
Add(existingDeveloper, knowledge);
} while (index < developerDto.KnowledgeDtos?.Count);
}
catch (Exception)
{
_repository.RollBack();
throw;
}
return(_repository.Commit());
}
public async Task UpdateAsync(DeveloperDto dto)
{
Developer entity = GetById(dto.Id);
entity.FirstName = dto.FirstName;
entity.LastName = dto.LastName;
entity.Grade = dto.Grade;
entity.Location = dto.Location;
entity.Room = dto.Room;
entity.Skype = dto.Skype;
entity.Email = dto.Email;
entity.HomePhone = dto.HomePhone;
entity.CellPhone = dto.CellPhone;
entity.Schedule = dto.Schedule;
_unitOfWork.GetRepository <Developer>().Update(entity);
_unitOfWork.Commit();
}
public ActionResult Add(DeveloperDto developerDto)
{
if (ModelState.IsValid)
{
ValidateDeveloper(developerDto);
developerDto.CompanyId = UserCompanyId();
_uow._developerRepository.Add(developerDto);
_uow.SaveChanges();
TempData["Message"] = "Developer has been added successfully";
}
else
{
return(View());
}
return(RedirectToAction("Index"));
}
public async Task UpdateAnApplicant(DeveloperDto developerDto)
{
var entity = _mapper.Map <Developer>(developerDto);
var entityPreference = _mapper.Map <DeveloperPreference>(developerDto.Preference);
var entitySkills = _mapper.Map <DeveloperSkills>(developerDto.Skills);
if (entity.Validate() && entityPreference.Validate() && entitySkills.Validate())
{
await _developerRepository.Update(entity);
await _developerRepository.UpdatePreference(entityPreference);
await _developerRepository.UpdateSkills(entitySkills);
}
else
{
Errors = entity.Errors;
}
await Task.CompletedTask;
}
public ActionResult Edit(DeveloperDto developerDto)
{
if (ModelState.IsValid)
{
ValidateDeveloper(developerDto);
developerDto.CompanyId = UserCompanyId();
_uow._developerRepository.Update(developerDto);
_uow.SaveChanges();
}
else
{
var viewModel = new DeveloperAddEditViewModel()
{
Developer = developerDto
};
return(View(viewModel));
}
TempData["Message"] = "Developer has been edited successfully";
return(RedirectToAction("Index"));
}
public int Add(DeveloperDto developerDto)
{
try
{
_dataAnnotationValidator.Validate(developerDto?.Developer);
_repository.Add(developerDto.Developer);
int index = 0;
do
{
var availability =
developerDto.Availabilities?.ElementAtOrDefault(index++);
Add(developerDto.Developer, availability);
} while (index < developerDto.Availabilities?.Count);
index = 0;
do
{
var workingTime =
developerDto.WorkingTimes?.ElementAtOrDefault(index++);
Add(developerDto.Developer, workingTime);
} while (index < developerDto.WorkingTimes?.Count);
index = 0;
do
{
var knowledgeDto =
developerDto.KnowledgeDtos?.ElementAtOrDefault(index++);
Add(developerDto.Developer, knowledgeDto);
} while (index < developerDto.KnowledgeDtos?.Count);
}
catch (Exception)
{
_repository.RollBack();
throw;
}
return(_repository.Commit());
}
public static Developer Convert(DeveloperDto dto)
{
return(ConvertToDeveloper.Compile().Invoke(dto));
}
public void Update(DeveloperDto developer)
{
_repository.Update(developer.ToEntity());
_repository.SaveChanges();
}
