public OperationResult <List <IQuestionDTO> > Search(IQuestionDTO questionDTO)
{
OperationResult <List <IQuestionDTO> > retVal = null;
try
{
IQuestionDAC questionDAC = (IQuestionDAC)DACFactory.Instance.Create(DACType.QuestionDAC);
List <IQuestionDTO> resultDTO = questionDAC.Search(questionDTO);
if (resultDTO != null)
{
retVal = OperationResult <List <IQuestionDTO> > .CreateSuccessResult(resultDTO);
}
else
{
retVal = OperationResult <List <IQuestionDTO> > .CreateFailureResult("Not found!");
}
}
catch (DACException dacEx)
{
retVal = OperationResult <List <IQuestionDTO> > .CreateErrorResult(dacEx.Message, dacEx.StackTrace);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
retVal = OperationResult <List <IQuestionDTO> > .CreateErrorResult(ex.Message, ex.StackTrace);
}
return(retVal);
}
public OperationResult <IDataDTO> Details(IQuestionDTO questionDTO)
{
OperationResult <IDataDTO> retVal = null;
try
{
IQuestionDAC questionDAC = (IQuestionDAC)DACFactory.Instance.Create(DACType.QuestionDAC);
IDataDTO resultDTO = questionDAC.Details(questionDTO);
if (resultDTO != null)
{
retVal = OperationResult <IDataDTO> .CreateSuccessResult(resultDTO);
}
else
{
retVal = OperationResult <IDataDTO> .CreateFailureResult("Failed to get details!");
}
}
catch (DACException dacEx)
{
retVal = OperationResult <IDataDTO> .CreateErrorResult(dacEx.Message, dacEx.StackTrace);
}
catch (Exception ex)
{
ExceptionManager.HandleException(ex);
retVal = OperationResult <IDataDTO> .CreateErrorResult(ex.Message, ex.StackTrace);
}
return(retVal);
}
public IHttpActionResult Create([FromBody] Questions data)
{
IQuestionDTO dataDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(data, dataDTO);
dataDTO.Created = DateTime.Now;
IQuestionFacade questionFacade = (IQuestionFacade)FacadeFactory.Instance.Create(FacadeType.QuestionFacade);
OperationResult <IQuestionDTO> result = questionFacade.Create(dataDTO);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
Questions question = new Questions();
EntityConverter.FillEntityFromDTO(result.Data, question);
string success = JsonConvert.SerializeObject(new { success = true, data = question });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public void SaveQuestion(IQuestionDTO questionDTO)
{
var portalDb = new QuestionnaireEntities();
Question questionE = null;
if (questionDTO.QuestionId == -1)
{
questionE = new Question();
questionE.Text = questionDTO.Text;
questionE.Marks = questionDTO.Marks;
questionE.QuestionPaperNo = questionDTO.QuestionPaperNo;
portalDb.Questions.Add(questionE);
}
else
{
questionE = portalDb.Questions.SingleOrDefault(n => n.Id == questionDTO.QuestionId);
questionE.Text = questionDTO.Text;
questionE.Marks = questionDTO.Marks;
questionE.QuestionPaperNo = questionDTO.QuestionPaperNo;
}
portalDb.SaveChanges();
questionDTO.QuestionId = questionE.Id;
}
public IEnumerable <QuestionsDTO> Search(string title)
{
IQuestionDTO question = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
question.Title = title;
IQuestionFacade questionFacade = (IQuestionFacade)FacadeFactory.Instance.Create(FacadeType.QuestionFacade);
OperationResult <List <IQuestionDTO> > result = questionFacade.Search(question);
return((IEnumerable <QuestionsDTO>)result.Data);
}
public OperationResult <IQuestionDTO> GetQuestionById(int questionId)
{
try
{
IQuestionDAC questionDAC = DACFactory.Create <IQuestionDAC>();
IQuestionDTO questionDTO = questionDAC.GetQuestionById(questionId);
return(OperationResult <IQuestionDTO> .CreateSuccessResult(questionDTO, "Success"));
}
catch (Exception ex)
{
return(OperationResult <IQuestionDTO> .CreateErrorResult(null, ex.Message));
}
}
public IQuestionDTO GetQuestionById(int questionId)
{
IQuestionDTO rv = DTOFactory.Create <IQuestionDTO>();
var portalDb = new QuestionnaireEntities();
var question = portalDb.Questions.SingleOrDefault(n => n.Id == questionId);
rv.QuestionId = question.Id;
rv.Text = question.Text;
rv.Marks = question.Marks;
rv.QuestionPaperNo = question.QuestionPaperNo;
return(rv);
}
public OperationResult <bool> SaveQuestion(IQuestionDTO questionDTO)
{
try
{
IQuestionDAC questionDAC = DACFactory.Create <IQuestionDAC>();
questionDAC.SaveQuestion(questionDTO);
return(OperationResult <bool> .CreateSuccessResult(true, "Success"));
}
catch (Exception ex)
{
return(OperationResult <bool> .CreateErrorResult(false, ex.Message));
}
}
public ActionResult SaveQuestion(QuestionVM question)
{
if (ModelState.IsValid)
{
IQuestionFacade questionFacade = FacadeFactory.Instance.Create <IQuestionFacade>();
IQuestionDTO questionDTO = DTOFactory.Instance.Create <IQuestionDTO>();
questionDTO.QuestionId = question.QuestionId;
questionDTO.Text = question.Text;
questionDTO.Marks = question.Marks;
questionDTO.QuestionPaperNo = question.QuestionPaperNo;
//paperDTO.QuestionCount = paper.QuestionCount;
var saveResult = questionFacade.SaveQuestion(questionDTO);
if (saveResult.IsValid())
{
return(new JsonResult()
{
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
Data = new
{
msg = "Saved",
questionId = questionDTO.QuestionId
}
});
}
else
{
if (saveResult.HasFailed())
{
ModelState.AddModelError("Name", saveResult.Message);
return(PartialView("LoadQuestionForm", question));
}
else
{
return(new RedirectResult("Error/"));
}
}
}
else
{
return(PartialView("LoadQuestionForm", question));
}
}
/// <summary>
/// Method to get all questions
/// </summary>
/// <returns></returns>
public List <IDataDTO> GetQuestions()
{
using (var context = new BufferOverflowDBEntities())
{
List <IDataDTO> listOfQuestions = null;
var questionEntityList = context.Questions.OrderByDescending(e => e.Created).ToList();
if (questionEntityList != null)
{
listOfQuestions = new List <IDataDTO>();
foreach (var questionEntity in questionEntityList)
{
IQuestionDTO questionDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(questionEntity, questionDTO);
// Getting Question tags
var tagsEntityList = context.TagRelation.Where(t => t.QuestionId == questionEntity.Id).ToList();
List <ITagsDTO> tagName = new List <ITagsDTO>();
foreach (var tags in tagsEntityList)
{
ITagsDTO tagDTO = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
var tag = context.Tags.SingleOrDefault(t => t.Id == tags.TagId);
EntityConverter.FillDTOFromEntity(tag, tagDTO);
tagName.Add(tagDTO);
}
// Getting User
IUserDTO userDTO = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
var userEntity = context.User.SingleOrDefault(u => u.Id == questionEntity.UserId);
EntityConverter.FillDTOFromEntity(userEntity, userDTO);
IDataDTO dataDTO = (IDataDTO)DTOFactory.Instance.Create(DTOType.DataDTO);
dataDTO.QuestionDetail = questionDTO;
dataDTO.TagDetail = tagName;
dataDTO.UserDetail = userDTO;
listOfQuestions.Add(dataDTO);
}
}
return(listOfQuestions);
}
}
/// <summary>
/// Method to edit question
/// </summary>
/// <param name="questionDTO"></param>
/// <returns></returns>
public IQuestionDTO Edit(IQuestionDTO questionDTO)
{
using (var context = new BufferOverflowDBEntities())
{
var questionEntity = context.Questions.SingleOrDefault(q => q.Id == questionDTO.Id);
if (questionEntity != null)
{
EntityConverter.FillEntityFromDTO(questionDTO, questionEntity);
context.SaveChanges();
}
else
{
questionDTO.Id = 0;
}
return((questionDTO.Id != 0) ? questionDTO : null);
}
}
/// <summary>
/// Method to create question
/// </summary>
/// <param name="questionDTO"></param>
/// <returns></returns>
public IQuestionDTO Create(IQuestionDTO dataDTO)
{
using (var context = new BufferOverflowDBEntities())
{
Questions questionEntity = new Questions();
EntityConverter.FillEntityFromDTO(dataDTO, questionEntity);
var question = context.Questions.Add(questionEntity);
context.SaveChanges();
IQuestionDTO questionDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
if (question != null)
{
EntityConverter.FillDTOFromEntity(question, dataDTO);
}
return((dataDTO.Id != 0) ? dataDTO : null);;
}
}
public IList <IQuestionDTO> GetAllQuestions()
{
IList <IQuestionDTO> rv = new List <IQuestionDTO>();
var portalDb = new QuestionnaireEntities();
var questions = portalDb.Questions.ToList();
foreach (var question in questions)
{
IQuestionDTO questionDTO = DTOFactory.Create <IQuestionDTO>();
questionDTO.QuestionId = question.Id;
questionDTO.Text = question.Text;
questionDTO.Marks = question.Marks;
questionDTO.QuestionPaperNo = question.QuestionPaperNo;
rv.Add(questionDTO);
}
return(rv);
}
public IList <IQuestionDTO> GetQuestionsOfPaper(int paperId)
{
IList <IQuestionDTO> questionsOfPaper = new List <IQuestionDTO>();
var portalDb = new QuestionnaireEntities();
var paper = portalDb.QuestionPapers.SingleOrDefault(n => n.Id == paperId);
ICollection <Question> questions = paper.Questions;
foreach (var question in questions)
{
IQuestionDTO questionDTO = DTOFactory.Create <IQuestionDTO>();
questionDTO.QuestionId = question.Id;
questionDTO.Text = question.Text;
questionDTO.Marks = question.Marks;
questionsOfPaper.Add(questionDTO);
}
return(questionsOfPaper);
}
/// <summary>
/// Method to search question with given title
/// </summary>
/// <param name="questionDTO"></param>
/// <returns></returns>
public List <IQuestionDTO> Search(IQuestionDTO questionDTO)
{
using (var context = new BufferOverflowDBEntities())
{
var questionEntityList = context.Questions.OrderByDescending(e => e.Created).Where(q => q.Title == questionDTO.Title).ToList();
List <IQuestionDTO> listOfQuestions = null;
if (questionEntityList != null)
{
listOfQuestions = new List <IQuestionDTO>();
foreach (var questionEntity in questionEntityList)
{
IQuestionDTO quesDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(questionEntity, quesDTO);
listOfQuestions.Add(quesDTO);
}
}
return(listOfQuestions);
}
}
/// <summary>
/// Method to search question with given tag
/// </summary>
/// <param name="tagDTO"></param>
/// <returns></returns>
public List <IQuestionDTO> SearchQuestion(ITagsDTO tagDTO)
{
using (var context = new BufferOverflowDBEntities())
{
var questionIds = context.TagRelation.Where(t => t.Id == tagDTO.Id).ToList();
List <IQuestionDTO> listOfQuestions = null;
if (questionIds != null)
{
foreach (var question in questionIds)
{
var questionEntity = context.Questions.SingleOrDefault(q => q.Id == question.QuestionId);
IQuestionDTO questionDTO = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(questionEntity, questionDTO);
listOfQuestions.Add(questionDTO);
}
}
return(listOfQuestions);
}
}
public IHttpActionResult Details([FromUri] int id)
{
IQuestionDTO question = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
question.Id = id;
IQuestionFacade questionFacade = (IQuestionFacade)FacadeFactory.Instance.Create(FacadeType.QuestionFacade);
OperationResult <IDataDTO> result = questionFacade.Details(question);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
Data dataModel = new Data();
EntityConverter.FillEntityFromDTO(result.Data.QuestionDetail, dataModel.QuestionDetail);
EntityConverter.FillEntityFromDTO(result.Data.UserDetail, dataModel.UserDetail);
List <ITagsDTO> tagsDTOList = result.Data.TagDetail;
List <Tags> tagsModel = new List <Tags>();
foreach (var tagDTO in tagsDTOList)
{
Tags tag = new Tags();
EntityConverter.FillEntityFromDTO(tagDTO, tag);
tagsModel.Add(tag);
}
dataModel.TagDetail = tagsModel;
string success = JsonConvert.SerializeObject(new { success = true, data = dataModel });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
/// <summary>
/// Method to delete question
/// </summary>
/// <param name="questionDTO"></param>
/// <returns></returns>
public IQuestionDTO Delete(IQuestionDTO questionDTO)
{
using (var context = new BufferOverflowDBEntities())
{
var deleteQuestion = context.Questions
.SingleOrDefault(q => q.Id == questionDTO.Id);
if (deleteQuestion != null)
{
// Deleting Answer
var deleteAnswers = context.Answers.Where(a => a.QuestionId == questionDTO.Id).ToList();
foreach (var answer in deleteAnswers)
{
var votesEntity = context.Votes.Where(v => v.AnswerId == answer.Id).ToList();
foreach (var vote in votesEntity)
{
context.Votes.Remove(vote);
context.SaveChanges();
}
context.Answers.Remove(answer);
context.SaveChanges();
}
// Deleting from Tag Relation
var deleteTagRelation = context.TagRelation.Where(t => t.QuestionId == questionDTO.Id).ToList();
foreach (var tag in deleteTagRelation)
{
context.TagRelation.Remove(tag);
context.SaveChanges();
}
// Deleting Question
var question = context.Questions.Remove(deleteQuestion);
context.SaveChanges();
EntityConverter.FillDTOFromEntity(question, questionDTO);
}
return(questionDTO);
}
}
/// <summary>
/// Method to get question detail
/// </summary>
/// <param name="questionDTO"></param>
/// <returns></returns>
public IDataDTO Details(IQuestionDTO questionDTO)
{
using (var context = new BufferOverflowDBEntities())
{
IDataDTO dataDTO = (IDataDTO)DTOFactory.Instance.Create(DTOType.DataDTO);
var questionDetail = context.Questions.SingleOrDefault(q => q.Id == questionDTO.Id);
if (questionDetail != null)
{
dataDTO.QuestionDetail = (IQuestionDTO)DTOFactory.Instance.Create(DTOType.QuestionDTO);
EntityConverter.FillDTOFromEntity(questionDetail, dataDTO.QuestionDetail);
// Geting Question tags
var tagRelationEntity = context.TagRelation.Where(t => t.QuestionId == questionDetail.Id).ToList();
List <ITagsDTO> tags = new List <ITagsDTO>();
foreach (var tag in tagRelationEntity)
{
var tagEntity = context.Tags.SingleOrDefault(t => t.Id == tag.TagId);
ITagsDTO tagsDTO = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
EntityConverter.FillDTOFromEntity(tagEntity, tagsDTO);
tags.Add(tagsDTO);
}
dataDTO.TagDetail = tags;
// Getting User Detail
var userEntity = context.User.SingleOrDefault(u => u.Id == questionDetail.UserId);
dataDTO.UserDetail = (IUserDTO)DTOFactory.Instance.Create(DTOType.UserDTO);
EntityConverter.FillDTOFromEntity(userEntity, dataDTO.UserDetail);
}
else
{
dataDTO.QuestionDetail.Id = 0;
}
return((dataDTO.QuestionDetail.Id != 0) ? dataDTO : null);
}
}
public OperationResult <IDataDTO> Details(IQuestionDTO questionDTO)
{
IQuestionBDC questionBDC = (IQuestionBDC)BDCFactory.Instance.Create(BDCType.QuestionBDC);
return(questionBDC.Details(questionDTO));
}
public OperationResult <IQuestionDTO> Edit(IQuestionDTO questionDTO)
{
IQuestionBDC questionBDC = (IQuestionBDC)BDCFactory.Instance.Create(BDCType.QuestionBDC);
return(questionBDC.Edit(questionDTO));
}
public OperationResult <List <IQuestionDTO> > Search(IQuestionDTO questionDTO)
{
IQuestionBDC questionBDC = (IQuestionBDC)BDCFactory.Instance.Create(BDCType.QuestionBDC);
return(questionBDC.Search(questionDTO));
}
public OperationResult <bool> SaveQuestion(IQuestionDTO questionId)
{
IQuestionBDC questionBDC = BDCFactory.Create <IQuestionBDC>();
return(questionBDC.SaveQuestion(questionId));
}
