public async Task <DiseaseDTO> AddDiseaseAsync(DiseaseDTO disease)
{
var d = _diseaseFactory.Transform(disease);
await _diseaseRepository.AddAsync(d);
return(_diseaseFactory.Transform(await _diseaseRepository.FindWithSymptomsAsync(d.Id)));
}
/// <summary>
/// Returns all the previous answers along with a questionnaire object
/// containing the symptom that needs a YES/NO answer or the resulting disease.
/// </summary>
/// <param name="questionnaire">Previously answered questions</param>
/// <returns>Questionnaire with a new question or the answer</returns>
public async Task <Questionnaire> DiagnoseInteractiveAsync(Questionnaire questionnaire)
{
if (questionnaire.NewQuestion != null)
{
questionnaire.PreviousAnswers.Add(questionnaire.NewQuestion);
}
var diseases = await FilterDiseasesAsync(questionnaire.PreviousAnswers);
if (diseases.Count > 1)
{
questionnaire.NewQuestion = new Question()
{
Symptom = GetSymptomForQuestionAsync(diseases)
}
}
;
else if (diseases.Count == 1)
{
questionnaire.Result = DiseaseDTO.CreateFromDomain(diseases.Single());
}
else
{
throw new ArgumentException("Previous questions don't match any disease in the database");
}
return(questionnaire);
}
public async Task <DiseaseDTO> AddAsync(DiseaseDTO dto)
{
var disease = DiseaseDTO.CreateFromDTO(dto);
await _uow.Diseases.AddAsync(disease);
if (dto.Symptoms.Any())
{
foreach (var dtoSymptom in dto.Symptoms)
{
var symptom = await _uow.Symptoms.FindAsync(dtoSymptom.SymptomId);
if (symptom == null)
{
symptom = new Symptom()
{
SymptomName = dtoSymptom.SymptomName
};
await _uow.Symptoms.AddAsync(symptom);
}
await _uow.DiseaseSymptoms.AddAsync(new DiseaseSymptom()
{
Disease = disease, Symptom = symptom
});
}
}
await _uow.SaveChangesAsync();
return(DiseaseDTO.CreateFromDomain(disease));
}
public static Disease DTOtoDisease(DiseaseDTO diseaseDTO)
{
return(new Disease
{
Name = diseaseDTO.Name,
Description = diseaseDTO.Description
});
}
public static Disease Map(DiseaseDTO itemDTO)
{
return(new Disease()
{
Id = itemDTO.Id,
Name = itemDTO.Name,
Description = itemDTO.Description
});
}
public static DiseaseViewModel DTOtoDiseaseVM(DiseaseDTO diseaseDTO)
{
return(new DiseaseViewModel
{
Id = diseaseDTO.Id,
Name = diseaseDTO.Name,
Description = diseaseDTO.Description
});
}
public async Task <IActionResult> UploadFile()
{
#region Code that needs a better place
if (Request.Form.Files.Count != 1)
{
return(BadRequest(new FeedbackDTO("only one file allowed at a time")));
}
var file = Request.Form.Files.First();
var streamReader = new StreamReader(file.OpenReadStream());
var symptomList = new List <string>();
while (!streamReader.EndOfStream)
{
var strings = (await streamReader.ReadLineAsync()).Split(',').ToList().Skip(1).ToList();
symptomList.AddRange(strings);
}
streamReader.Close();
symptomList = symptomList.GroupBy(s => s).Select(x => x.First()).ToList();
var symptomsDictionary = new Dictionary <string, SymptomDTO>();
foreach (string symptomName in symptomList)
{
symptomsDictionary.Add(symptomName, await _symptomService.AddSymptomAsync(new SymptomDTO {
Name = symptomName
}));
}
streamReader = new StreamReader(file.OpenReadStream());
while (!streamReader.EndOfStream)
{
var line = (await streamReader.ReadLineAsync()).Split(',');
var newDisease = new DiseaseDTO {
Name = line.First(), Symptoms = new List <SymptomDTO>()
};
var diseaseSymptoms = line.Skip(1).ToList();
foreach (var symptom in diseaseSymptoms)
{
SymptomDTO foundSymptom;
if (symptomsDictionary.TryGetValue(symptom, out foundSymptom))
{
newDisease.Symptoms.Add(foundSymptom);
}
}
await _diseaseService.AddDiseaseAsync(newDisease);
}
streamReader.Close();
#endregion
return(Ok());
}
// [Authorize(Roles = "Worker,Admin")]
public async Task <IActionResult> Create([FromBody] DiseaseDTO item)
{
var result = await _diseaseService.Create(item);
if (!result.Success)
{
return(BadRequest(result.Messages));
}
return(CreatedAtAction("GetAll", result.disease));
}
public Disease Transform(DiseaseDTO dto)
{
return(new Disease
{
Id = dto.Id ?? 0,
Name = dto.Name,
DiseaseSymptoms = dto.Symptoms.Select(s => new DiseaseSymptom {
DiseaseId = dto.Id ?? 0, SymptomId = s.Id ?? 0
}).ToList()
});
}
public async Task <IActionResult> PostDisease([FromBody] DiseaseDTO disease)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
disease = await _diseaseService.AddAsync(disease);
return(CreatedAtAction("GetDisease", new { id = disease.DiseaseId }, disease));
}
/// <summary>
/// This method is used to get all Diseases with symptoms.
/// SymptomsInDiseases are already included from the database
/// but here we will also will the symptoms list itself.
/// </summary>
/// <returns>IEnumerable of diseases with symptoms list filled</returns>
public IEnumerable <DiseaseDTO> AllWithSymptoms()
{
/* First we everything from diseasesRepo which includes SymptomsInDiseases
* Then we Select the SymptomsInDiseases, take out the symptom object and add
* it to the original object symptoms List and we do it with everything in
* SymptomsInDiseases.
* Then we make it into a list and return it.
*/
return(_diseasesRepo
.AllWithSymptoms()
.Select(x => { x.Symptoms = x.SymptomsInDiseases.Select(s => s.Symptom).ToList(); return x; })
.Select(s => DiseaseDTO.Transform(s)));
}
// [Authorize(Roles = "Worker,Admin")]
public async Task <ActionResult> Update(int id, [FromBody] DiseaseDTO disease)
{
try
{
var result = await _diseaseService.Update(id, disease);
if (!result.Success)
{
return(BadRequest(result.Messages));
}
}
catch (KeyNotFoundException)
{
Error e = new Error();
e.Message = "Disease not found.";
return(NotFound(e));
}
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] DiseaseDTO disease)
{
if (disease.Id != null)
{
return(BadRequest(new FeedbackDTO("ID can not be set when posting")));
}
if (disease?.Symptoms == null || disease.Symptoms.Count < 1)
{
return(BadRequest(new FeedbackDTO("Disease must have symptoms")));
}
if (!disease.Symptoms.TrueForAll(s => s.Id != null))
{
return(BadRequest(new FeedbackDTO("Symptoms must have IDs")));
}
return(Ok(await _diseaseService.AddDiseaseAsync(disease)));
}
public async Task <DiseaseDTO> Update(DiseaseDTO dto)
{
var disease = await _uow.Diseases.FindAsync(dto.DiseaseId);
if (disease == null)
{
return(null);
}
disease.DiseaseName = dto.DiseaseName;
disease = _uow.Diseases.Update(disease);
// Change Symptoms
await _uow.DiseaseSymptoms.RemoveByDiseaseAsync(disease.DiseaseId);
if (dto.Symptoms.Any())
{
foreach (var dtoSymptom in dto.Symptoms)
{
var symptom = await _uow.Symptoms.FindAsync(dtoSymptom.SymptomId);
if (symptom == null)
{
symptom = new Symptom()
{
SymptomName = dtoSymptom.SymptomName
};
await _uow.Symptoms.AddAsync(symptom);
}
await _uow.DiseaseSymptoms.AddAsync(new DiseaseSymptom()
{
Disease = disease, Symptom = symptom
});
}
}
await _uow.SaveChangesAsync();
return(DiseaseDTO.CreateFromDomain(disease));
}
public DiseaseDTO AddDisease(DiseaseDTO diseaseDTO)
{
var diseases = new Disease()
{
DiseaseName = diseaseDTO.DiseaseName,
DiseaseType = diseaseDTO.DiseaseType
};
_context.Diseases.Add(diseases);
_context.SaveChanges();
int diseaseid = diseases.DiseaseId;
diseaseDTO.Diseaseid = diseaseid;
//_context.Diseases.Add(new Disease()
//{
// DiseaseName = disease.DiseaseName,
// DiseaseType = disease.DiseaseType
//});
return(diseaseDTO);
}
public async Task <DiseaseResponse> Update(int id, DiseaseDTO updatedDisease)
{
var disease = await _diseaseRepository.GetById(id);
if (disease == null)
{
throw new KeyNotFoundException();
}
//disease.Id = updatedDisease.Id;
disease.Name = updatedDisease.Name;
disease.Description = updatedDisease.Description;
if (disease.Name == null)
{
string errorMessage3 = "Disease name not found.";
Log.Error(errorMessage3);
return(new DiseaseResponse(errorMessage3));
}
if (disease.Description == null)
{
string errorMessage3 = "Disease description not found.";
Log.Error(errorMessage3);
return(new DiseaseResponse(errorMessage3));
}
try
{
_diseaseRepository.Update(disease);
await _context.SaveChangesAsync();
return(new DiseaseResponse());
}
catch (Exception exception)
{
string errorMessage = $"An error occured when updating the item: {exception.Message}";
return(new DiseaseResponse(errorMessage));
}
}
public async Task <DiseaseResponse> Create(DiseaseDTO newDisease)
{
var disease = DiseaseMapper.Map(newDisease);
if (disease == null)
{
string errorMessage = "Disease not found.";
Log.Error(errorMessage);
return(new DiseaseResponse(errorMessage));
}
if (disease.Name == null)
{
string errorMessage2 = "Disease name not found.";
Log.Error(errorMessage2);
return(new DiseaseResponse(errorMessage2));
}
if (disease.Description == null)
{
string errorMessage3 = "Disease description not found.";
Log.Error(errorMessage3);
return(new DiseaseResponse(errorMessage3));
}
try
{
await _diseaseRepository.Create(disease);
await _context.SaveChangesAsync();
return(new DiseaseResponse(DiseaseMapper.Map(disease)));
}
catch (Exception exception)
{
string errorMessage = $"An error occured when creating the item: {exception.Message}";
return(new DiseaseResponse(errorMessage));
}
}
public async Task <IActionResult> PutDisease([FromRoute] int id, [FromBody] DiseaseDTO disease)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != disease.DiseaseId)
{
return(BadRequest());
}
var dbDisease = await _diseaseService.GetByIdAsync(disease.DiseaseId);
if (dbDisease == null)
{
return(NotFound());
}
try
{
await _diseaseService.Update(disease);
}
catch (DbUpdateConcurrencyException)
{
if (!await DiseaseExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ActionResult <List <DiseaseDTO> > Post(DiseaseDTO diseaseDTO)
{
dr.AddDisease(diseaseDTO);
return(Ok(diseaseDTO.Diseaseid));
}
public async Task <DiseaseDTO> GetByIdAsync(int id)
{
var disease = await _uow.Diseases.GetByIdWithSymptomsAsync(id);
return(DiseaseDTO.CreateFromDomainWithDiseases(disease));
}
public DiseaseResponse(DiseaseDTO disease) : base(string.Empty, true)
{
this.disease = disease;
}
