public IHttpActionResult Create([FromBody] List <Tags> tags, int questionId)
{
List <ITagsDTO> tagsDTO = new List <ITagsDTO>();
foreach (var tag in tags)
{
ITagsDTO tagDTO = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
EntityConverter.FillDTOFromEntity(tag, tagDTO);
tagsDTO.Add(tagDTO);
}
ITagFacade tagsFacade = (ITagFacade)FacadeFactory.Instance.Create(FacadeType.TagFacade);
OperationResult <bool> result = tagsFacade.Create(tagsDTO, questionId);
if (result.ResultType == OperationResultType.Failure)
{
string failed = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(failed));
}
if (result.IsValid())
{
string success = JsonConvert.SerializeObject(new { success = true, data = true });
return(Ok(success));
}
string jsonObj = JsonConvert.SerializeObject(new { success = false, data = result.Message });
return(BadRequest(jsonObj));
}
public OperationResult <List <IQuestionDTO> > SearchQuestion(ITagsDTO tagDTO)
{
OperationResult <List <IQuestionDTO> > retVal = null;
try
{
ITagDAC tagDAC = (ITagDAC)DACFactory.Instance.Create(DACType.UserDAC);
List <IQuestionDTO> resultDTO = tagDAC.SearchQuestion(tagDTO);
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 IEnumerable <QuestionsDTO> SearchQuestion(string tags)
{
ITagsDTO tag = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
tag.Tag = tags;
ITagFacade questionFacade = (ITagFacade)FacadeFactory.Instance.Create(FacadeType.TagFacade);
OperationResult <List <IQuestionDTO> > result = questionFacade.SearchQuestion(tag);
return((IEnumerable <QuestionsDTO>)result.Data);
}
/// <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 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);
}
}
/// <summary>
/// Method get all tags in table
/// </summary>
/// <returns></returns>
public List <ITagsDTO> GetTags()
{
using (var context = new BufferOverflowDBEntities())
{
var tagsEntity = context.Tags.ToList();
List <ITagsDTO> listOfTags = null;
if (tagsEntity != null)
{
foreach (var tags in tagsEntity)
{
ITagsDTO tagsDTO = (ITagsDTO)DTOFactory.Instance.Create(DTOType.TagsDTO);
EntityConverter.FillDTOFromEntity(tagsEntity, tagsDTO);
listOfTags.Add(tagsDTO);
}
}
return(listOfTags);
}
}
/// <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 <List <IQuestionDTO> > SearchQuestion(ITagsDTO tagDTO)
{
ITagBDC userBDC = (ITagBDC)BDCFactory.Instance.Create(BDCType.TagBDC);
return(userBDC.SearchQuestion(tagDTO));
}
