public IHttpActionResult AddQuestion(AddQuestionDto addQuestionDto)
{
if (string.IsNullOrWhiteSpace(addQuestionDto.Title))
{
return(Json(new { Success = false, Msg = "标题不能为空！", Data = "" }));
}
if (string.IsNullOrWhiteSpace(addQuestionDto.Content))
{
return(Json(new { Success = false, Msg = "内容不能为空！", Data = "" }));
}
if (addQuestionDto.UserInfoId == 0)
{
return(Json(new { Success = false, Msg = "用户不能为空！", Data = "" }));
}
var model = _questionService.Insert(new Domain.Model.Question
{
Content = addQuestionDto.Content,
Sort = 0,
CTime = DateTime.Now,
IsHot = 0,
IsTop = 0,
Reads = 0,
Title = addQuestionDto.Title,
UserInfoId = addQuestionDto.UserInfoId,
IsEnable = 1
});
return(Json(new { Success = true, Msg = "OK", Data = model }));
}
public async Task AddQuestionAsync(AddQuestionDto questionDto)
{
Domain.Entity.Question question = _mapper.Map <Domain.Entity.Question>(questionDto);
await _context.Question.AddAsync(question);
await _context.SaveChangesAsync();
}
public async Task AddQuestionAsync(AddQuestionDto questionDto)
{
if (questionDto == null)
{
throw new InvalidOperationException("Question mustn't be null");
}
await _repository.AddQuestionAsync(questionDto);
}
public void AddQuestionDtoConverterTheory(string jsonString, AddQuestionDto expectedDto)
{
var dto = JsonSerializer.Deserialize<AddQuestionDto>(jsonString, options);
dto.Should().BeEquivalentTo(expectedDto);
var json = JsonSerializer.Serialize(dto, options);
json.Should().Be(jsonString);
json = JsonSerializer.Serialize<object>(dto, options);
json.Should().Be(jsonString);
}
public async Task <IActionResult> AddQuestion([FromBody] AddQuestionDto questionDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _serivce.AddQuestionAsync(questionDto);
return(Ok());
}
public async Task <OperationResult <int> > CreateQuestion(AddQuestionDto questionDto)
{
Answer answer = questionMapper.MapToAnswer(questionDto);
var areCategoriesProvided = questionDto.Categories.Count > 0;
if (areCategoriesProvided && !categoryService.DoCategoriesExist(questionDto.Categories))
{
return(new BadRequestError());
}
return(await questionService.CreateQuestion(questionDto.Question, answer, questionDto.Categories));
}
public async Task <ActionResult <QuestionDto> > UpdateQuestion(int id, [FromBody] AddQuestionDto questionDto)
{
Question question = await unitOfWork.Questions.GetById(id);
if (question == null)
{
return(NotFound());
}
Organization organization = await unitOfWork.Organizations.GetById(question.OrganizationId);
if (organization == null)
{
return(BadRequest());
}
AppUser user = await userManager.GetUserAsync(User);
user = unitOfWork.AppUsers.GetUserWithOrgs(user.Id);
if (!(user.IsOwnerOfOrg(organization.Id) || user.IsExaminerOfOrg(organization.Id) || user.IsExamineeOfOrg(organization.Id)))
{
return(Forbid());
}
unitOfWork.QuestionOptions.RemoveRange(await unitOfWork.QuestionOptions.Find(qo => qo.QuestionId == question.Id));
IEnumerable <Option> options = questionDto.Options;
Mapper.Map(questionDto, question);
question.QuestionOptions = new List <QuestionOption>();
foreach (Option item in options)
{
Option option = await unitOfWork.Options.SingleOrDefault(o => o.Name == item.Name);
if (option == null)
{
option = item;
await unitOfWork.Options.Add(option);
}
await unitOfWork.SaveAsync();
question.QuestionOptions.Add(new QuestionOption {
OptionId = item.Id, Option = option
});
}
unitOfWork.Questions.Update(question);
if (await unitOfWork.SaveAsync() < 1)
{
return(BadRequest());
}
else
{
return(Ok(Mapper.Map <QuestionDto>(question)));
}
}
public Result ValidateAddQuestionDto(AddQuestionDto questionDto)
{
if (string.IsNullOrWhiteSpace(questionDto.QuestionText))
{
return(Result.Fail(-3));
}
if (!questionDto.Answers.Any())
{
return(Result.Fail(-4));
}
return(answerValidator.ValidateAddAnswerDtos(questionDto.Answers));
}
public async Task <IActionResult> Question(AddQuestionDto addQuestionDto)
{
try
{
var question = _mapper.Map <Question>(addQuestionDto);
question.Id = new Guid();
question.CreatedDate = DateTime.Now;
_questionRepository.Add(question);
var status = await _unitOfWork.Commit();
if (status)
{
var questionToReturn = _mapper.Map <AddQuestionDto>(question);
return(Ok(questionToReturn));
}
return(BadRequest());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ReturnQuestionDto> AddQuestion(string orgId, AddQuestionDto question)
{
try
{
bool isOrgValid = Guid.TryParse(orgId, out Guid orgPublicId);
if (!isOrgValid)
{
_customExceptionValidationService.CustomValidation("Invalid Organization Id.", HttpStatusCode.BadRequest);
}
if (question.Question == null || question.Options.Count < 2 || question.SubjectId == null)
{
_customExceptionValidationService.CustomValidation("PLease provide correct data.", HttpStatusCode.BadRequest);
}
bool isSubjectValid = Guid.TryParse(question.SubjectId, out Guid subjectPublicId);
if (!isSubjectValid)
{
_customExceptionValidationService.CustomValidation("Invalid Subject Id.", HttpStatusCode.BadRequest);
}
var orgData = _orgRepository.GetOrganizationByPublicId(orgPublicId);
if (orgData == null)
{
_customExceptionValidationService.CustomValidation("No Organization Registered.", HttpStatusCode.NotFound);
}
var subjectdata = _subjectRepository.GetSubjectByPublicId(subjectPublicId);
if (subjectdata == null)
{
_customExceptionValidationService.CustomValidation("Incorrect Subject.", HttpStatusCode.NotFound);
}
var dbQuestionModel = new OrgQuestion
{
Question = question.Question,
SubjectId = subjectdata.Id,
PublicId = Guid.NewGuid(),
CreatedDate = System.DateTime.UtcNow,
LastUpdatedDateTime = System.DateTime.UtcNow,
OrganizationId = orgData.Id
};
var questionOptions = new List <QuestionOption>();
foreach (var option in question.Options)
{
var q = new QuestionOption
{
QOption = option.Option,
IsCorrect = option.IsCorrect,
QuestionId = dbQuestionModel.Id,
OrgQuestion = dbQuestionModel,
PublicId = Guid.NewGuid()
};
questionOptions.Add(q);
}
dbQuestionModel.QuestionOption = questionOptions;
await _questinRepository.AddQuestion(dbQuestionModel);
return(new ReturnQuestionDto {
QuestionId = dbQuestionModel.PublicId
});
}
catch (Exception)
{
throw;
}
}
public async Task <HttpResponseMessage> AddQuestion(AddQuestionDto question, string orgId)
{
var data = await _questionService.AddQuestion(orgId, question);
return(Request.CreateResponse(HttpStatusCode.Created, data));
}
public async Task <IActionResult> AddQuestion(AddQuestionDto questionDto)
{
var result = await questionOrchestrator.CreateQuestion(questionDto);
return(ActionResult(result));
}
