385 lines
19 KiB
C#
385 lines
19 KiB
C#
using AutoMapper;
|
|
using DamageAssesment.Api.Questions.Db;
|
|
using DamageAssesment.Api.Questions.Interfaces;
|
|
using DamageAssesment.Api.Questions.Models;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.EntityFrameworkCore.Metadata.Internal;
|
|
|
|
namespace DamageAssesment.Api.Questions.Providers
|
|
{
|
|
|
|
|
|
public class QuestionsProvider : IQuestionsProvider, IQuestionTypesProvider
|
|
{
|
|
private QuestionDbContext questionDbContext;
|
|
private ILogger<QuestionsProvider> logger;
|
|
private IMapper mapper;
|
|
|
|
public QuestionsProvider(QuestionDbContext questionDbContext, ILogger<QuestionsProvider> logger, IMapper mapper)
|
|
{
|
|
this.questionDbContext = questionDbContext;
|
|
this.logger = logger;
|
|
this.mapper = mapper;
|
|
SeedData();
|
|
}
|
|
|
|
|
|
|
|
private void SeedData()
|
|
{
|
|
|
|
if (!questionDbContext.QuestionCategories.Any())
|
|
{
|
|
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Electrical", CategoryImage = "img1" });
|
|
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Flooding", CategoryImage = "img1" });
|
|
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Structural", CategoryImage = "img1" });
|
|
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Utility", CategoryImage = "img1" });
|
|
questionDbContext.QuestionCategories.Add(new Db.QuestionCategory() { CategoryName = "Debris", CategoryImage = "img1" });
|
|
questionDbContext.SaveChanges();
|
|
}
|
|
if (!questionDbContext.QuestionTypes.Any())
|
|
{
|
|
questionDbContext.QuestionTypes.Add(new Db.QuestionType() { TypeText = "RadioButton" });
|
|
questionDbContext.QuestionTypes.Add(new Db.QuestionType() { TypeText = "CheckBox" });
|
|
questionDbContext.QuestionTypes.Add(new Db.QuestionType() { TypeText = "TextBox" });
|
|
questionDbContext.SaveChanges();
|
|
}
|
|
if (!questionDbContext.Questions.Any())
|
|
{
|
|
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 2, SurveyId = 1, QuestionNumber = 1, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1",CategoryId=1 });
|
|
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 3, SurveyId = 1, QuestionNumber = 2, IsRequired = false, Comment = true, Key = false, QuestionGroup = "group1", CategoryId = 1 });
|
|
questionDbContext.Questions.Add(new Db.Question() { QuestionTypeId = 1, SurveyId = 1, QuestionNumber = 3, IsRequired = true, Comment = false, Key = true, QuestionGroup = "group1", CategoryId = 2 });
|
|
questionDbContext.SaveChanges();
|
|
}
|
|
if (!questionDbContext.QuestionsTranslations.Any())
|
|
{
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 1, QuestionText = "Can You Open ?", Language = "en" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 1, QuestionText = "Peux-tu ouvrir ?", Language = "fr" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 2, QuestionText = "Are the grounds flodded ?", Language = "en" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 2, QuestionText = "Les terrains sont-ils inondés ?", Language = "fr" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 3, QuestionText = "Is the access blocked by flooding ?", Language = "en" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 3, QuestionText = "L'accès est-il bloqué par les inondations ?", Language = "fr" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 1, QuestionText = "Puedes abrir ?", Language = "sp" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 2, QuestionText = "¿Están inundados los terrenos?", Language = "sp" });
|
|
questionDbContext.QuestionsTranslations.Add(new Db.QuestionsTranslation() { QuestionId = 3, QuestionText = "¿El acceso está bloqueado por inundaciones?", Language = "sp" });
|
|
questionDbContext.SaveChanges();
|
|
}
|
|
|
|
}
|
|
|
|
public async Task<(bool IsSuccess, IEnumerable<Models.Question> Questions, string ErrorMessage)> GetQuestionsAsync()
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questions = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().ToListAsync();
|
|
if (questions != null)
|
|
{
|
|
|
|
//logger?.LogInformation($"{question} customer(s) found");
|
|
var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.Question>>(questions);
|
|
foreach (var question in result)
|
|
{
|
|
question.Questions=mapper.Map<List<Db.QuestionsTranslation>,List<Models.QuestionsTranslation>>(
|
|
questionDbContext.QuestionsTranslations.Where(a=>a.QuestionId==question.Id).ToList());
|
|
}
|
|
return (true, result, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> GetQuestionAsync(int Id)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var question = await questionDbContext.Questions.Include("QuestionType").AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
|
|
if (question != null)
|
|
{
|
|
logger?.LogInformation($"{question} customer(s) found");
|
|
var result = mapper.Map<Db.Question, Models.Question>(question);
|
|
result.Questions = mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
|
|
questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == result.Id).ToList());
|
|
return (true, result, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public List<Models.Question> GetSurveyQuestion(List<Models.Question> questions,string Language)
|
|
{
|
|
foreach (var item in questions)
|
|
{
|
|
item.Questions= mapper.Map<List<Db.QuestionsTranslation>, List<Models.QuestionsTranslation>>(
|
|
questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == item.Id && a.Language== Language).ToList());
|
|
}
|
|
return questions;
|
|
}
|
|
public async Task<(bool IsSuccess, List<SurveyQuestions> SurveyQuestions, string ErrorMessage)> GetSurveyQuestionAsync(int SurveyId, string Language)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questions = await questionDbContext.Questions.Include("QuestionType").Where(a=>a.SurveyId==SurveyId).AsNoTracking().ToListAsync();
|
|
if (questions != null)
|
|
{
|
|
List<SurveyQuestions> surveyQuestionsList = new List<SurveyQuestions>();
|
|
List<int> CategoryIds=questions.Select(a=>a.CategoryId).Distinct().ToList();
|
|
var questioncategories = await questionDbContext.QuestionCategories.Where(a =>CategoryIds.Contains(a.Id)).ToListAsync();
|
|
//logger?.LogInformation($"{question} customer(s) found");
|
|
foreach (var item in questioncategories)
|
|
{
|
|
surveyQuestionsList.Add(new SurveyQuestions()
|
|
{
|
|
CategoryId = item.Id,
|
|
CategoryImage = item.CategoryImage,
|
|
CategoryName = item.CategoryName,
|
|
Questions = GetSurveyQuestion(mapper.Map<List<Db.Question>, List<Models.Question>>(questions.Where(a => a.CategoryId == item.Id).ToList()), Language)
|
|
});
|
|
}
|
|
|
|
//var result = mapper.Map<IEnumerable<Db.Question>, IEnumerable<Models.Question>>(questions);
|
|
return (true, surveyQuestionsList, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> PostQuestionAsync(Models.Question Question)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var dbquestion = mapper.Map<Models.Question, Db.Question>(Question);
|
|
var dbquestiontranslation = mapper.Map<List<Models.QuestionsTranslation>, List<Db.QuestionsTranslation>>(Question.Questions);
|
|
dbquestion.QuestionTypeId=questionDbContext.QuestionTypes.Where(a=>a.TypeText==Question.TypeText).Select(a=>a.Id).FirstOrDefault();
|
|
questionDbContext.Questions.Add(dbquestion);
|
|
dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
|
|
questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
|
|
questionDbContext.SaveChanges();
|
|
Question.Id = dbquestion.Id;
|
|
return (true, Question, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> UpdateQuestionAsync(Models.Question Question)
|
|
{
|
|
try
|
|
{
|
|
var dbquestion = mapper.Map<Models.Question, Db.Question>(Question);
|
|
var dbquestiontranslation = mapper.Map<List<Models.QuestionsTranslation>, List<Db.QuestionsTranslation>>(Question.Questions);
|
|
dbquestion.QuestionTypeId = questionDbContext.QuestionTypes.Where(a => a.TypeText == Question.TypeText).Select(a => a.Id).FirstOrDefault();
|
|
questionDbContext.Entry(dbquestion).State = EntityState.Modified;
|
|
var oldquestions = questionDbContext.QuestionsTranslations.Where(a => a.QuestionId == dbquestion.Id).ToList();
|
|
if(oldquestions!=null)
|
|
questionDbContext.QuestionsTranslations.RemoveRange(oldquestions);
|
|
dbquestiontranslation.ForEach(i => i.QuestionId = dbquestion.Id);
|
|
questionDbContext.QuestionsTranslations.AddRange(dbquestiontranslation);
|
|
questionDbContext.SaveChanges();
|
|
return (true, Question, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.Question Question, string ErrorMessage)> DeleteQuestionAsync(int Id)
|
|
{
|
|
try
|
|
{
|
|
var question = await questionDbContext.Questions.Where(x => x.Id == Id).FirstOrDefaultAsync();
|
|
|
|
if (question != null)
|
|
{
|
|
questionDbContext.Questions.Remove(question);
|
|
questionDbContext.SaveChanges();
|
|
return (true, mapper.Map<Db.Question, Models.Question>(question), $"QuestionID {Id} deleted Successfuly");
|
|
}
|
|
else
|
|
{
|
|
logger?.LogInformation($"QuestionID: {Id} Not found");
|
|
return (false, null, "Not Found");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Question Category Logic
|
|
|
|
public async Task<(bool IsSuccess, IEnumerable<Models.QuestionCategory> QuestionCategories, string ErrorMessage)> GetQuestionCategoriesAsync()
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questionCategories = await questionDbContext.QuestionCategories.AsNoTracking().ToListAsync();
|
|
if (questionCategories != null)
|
|
{
|
|
//logger?.LogInformation($"{question} customer(s) found");
|
|
var result = mapper.Map<IEnumerable<Db.QuestionCategory>, IEnumerable<Models.QuestionCategory>>(questionCategories);
|
|
return (true, result, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> GetQuestionCategoryAsync(int Id)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questioncategory = await questionDbContext.QuestionCategories.AsNoTracking().FirstOrDefaultAsync(q => q.Id == Id);
|
|
if (questioncategory != null)
|
|
{
|
|
logger?.LogInformation($"{questioncategory} customer(s) found");
|
|
var result = mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory);
|
|
return (true, result, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> PostQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
|
|
// Question.QuestionType = GetQuestionType(Question.QuestionTypeId);
|
|
questionDbContext.QuestionCategories.Add(dbQuestionCategory);
|
|
questionDbContext.SaveChanges();
|
|
QuestionCategory.Id=dbQuestionCategory.Id;
|
|
return (true, QuestionCategory, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> UpdateQuestionCategoryAsync(Models.QuestionCategory QuestionCategory)
|
|
{
|
|
try
|
|
{
|
|
var dbQuestionCategory = mapper.Map<Models.QuestionCategory, Db.QuestionCategory>(QuestionCategory);
|
|
questionDbContext.Entry(dbQuestionCategory).State = EntityState.Modified;
|
|
|
|
questionDbContext.SaveChanges();
|
|
return (true, QuestionCategory, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
public async Task<(bool IsSuccess, Models.QuestionCategory QuestionCategory, string ErrorMessage)> DeleteQuestionCategoryAsync(int Id)
|
|
{
|
|
try
|
|
{
|
|
var questioncategory = await questionDbContext.QuestionCategories.Where(x => x.Id == Id).FirstOrDefaultAsync();
|
|
if (questioncategory != null)
|
|
{
|
|
var question = await questionDbContext.Questions.Where(x => x.Id == Id).ToListAsync();
|
|
questionDbContext.Questions.RemoveRange(question);
|
|
questionDbContext.QuestionCategories.Remove(questioncategory);
|
|
questionDbContext.SaveChanges();
|
|
return (true, mapper.Map<Db.QuestionCategory, Models.QuestionCategory>(questioncategory), $"QuestionID {Id} deleted Successfuly");
|
|
}
|
|
else
|
|
{
|
|
logger?.LogInformation($"QuestionID: {Id} Not found");
|
|
return (false, null, "Not Found");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
private bool QuestionExists(int id)
|
|
{
|
|
return questionDbContext.Questions.AsNoTracking().Count(e => e.Id == id) > 0;
|
|
}
|
|
private QuestionType GetQuestionType(int Id)
|
|
{
|
|
return questionDbContext.QuestionTypes.Where(a => a.Id == Id).FirstOrDefault();
|
|
}
|
|
|
|
public async Task<(bool IsSuccess, QuestionType QuestionType, string ErrorMessage)> GetQuestionTypeAsync(int Id)
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questiontype = await questionDbContext.QuestionTypes.FirstOrDefaultAsync(q => q.Id == Id);
|
|
if (questiontype != null)
|
|
{
|
|
logger?.LogInformation($"{questiontype} customer(s) found");
|
|
return (true, questiontype, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
|
|
public async Task<(bool IsSuccess, IEnumerable<QuestionType> QuestionTypes, string ErrorMessage)> GetQuestionTypesAsync()
|
|
{
|
|
try
|
|
{
|
|
logger?.LogInformation("Query Question");
|
|
var questionTypes = await questionDbContext.QuestionTypes.ToListAsync();
|
|
if (questionTypes != null)
|
|
{
|
|
//logger?.LogInformation($"{question} customer(s) found");
|
|
return (true, questionTypes, null);
|
|
}
|
|
return (false, null, "Not found");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger?.LogError(ex.ToString());
|
|
return (false, null, ex.Message);
|
|
}
|
|
}
|
|
}
|
|
}
|