public async Task <StandardResponse> UpdateAnswerMetadata(ClaimsPrincipal identity, AnswerMetadataUpdateViewModel model,
ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var metadata = await _answerService.UpdateAnswerMetadata(db, user, new UpdateAnswerMeta()
{
AnswerId = model.AnswerId,
RowVersion = model.RowVersion,
Votes = model.Votes,
});
await db.SaveChangesAsync();
return(StandardResponse.For(AnswerMetaViewModel.From(metadata)));
}
}
}
public async Task <StandardResponse> AskQuestion(ClaimsPrincipal identity, QuestionAddViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var question = await _questionService.CreateQuestion(db, user, new CreateNewQuestion()
{
Title = model.Title,
Body = model.Body, Tags = model.Tags,
Topic = model.Topic ?? Topic.DefaultTopic
});
await db.SaveChangesAsync();
return(StandardResponse.For(new
{
question.QuestionId
}));
}
}
}
public async Task <StandardResponse> UpdateQuestion(ClaimsPrincipal identity, QuestionUpdateViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity))
{
await _questionService.UpdateQuestion(db, user, new UpdateQuestion()
{
QuestionId = model.QuestionId,
RowVersion = model.RowVersion,
Body = model.Body,
Tags = model.Tags ?? new string[] { },
Title = model.Title,
Topic = model.Topic
});
await db.SaveChangesAsync();
var question = await _questionService.GetQuestion(db, user, model.QuestionId);
return(StandardResponse.For(QuestionViewModel.From(question)));
}
}
}
public async Task <StandardResponse> UpdateTopic(ClaimsPrincipal identity, TopicUpdateViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity))
{
var result = await _topicService.UpdateTopic(db, user, new UpdateTopic()
{
TopicId = model.TopicId,
Description = model.Description,
Icon = PangulStringEncoding.GetBytesFromDataUrl(model.Icon),
IconType = PangulStringEncoding.GetTypeFromDataUrl(model.Icon),
RowVersion = model.RowVersion
});
await db.SaveChangesAsync();
return(StandardResponse.For(new { result.TopicId }));
}
}
}
public StandardResponse GetClaims(ClaimsPrincipal identity)
{
return(StandardResponse.For(new
{
Token = identity.Identity.Name,
Authenticated = identity.Identity.IsAuthenticated,
Claims = identity.Claims.Select(i => $"{i.Type}:{i.Value}").ToArray()
}));
}
public async Task <StandardResponse> GetAnswer(ClaimsPrincipal identity, GetAnswerViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var answer = await _answerService.GetAnswer(db, user, model.Id);
return(StandardResponse.For(AnswerViewModel.From(answer)));
}
}
}
public async Task <StandardResponse> FindAnswers(ClaimsPrincipal identity, SearchAnswersViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var matches = await _searchService.FindAnswersForQuestion(db, user, model.QuestionId, model.Offset, model.Limit);
return(StandardResponse.For(matches));
}
}
}
public async Task <StandardResponse> FindQuestions(ClaimsPrincipal identity, PerformSearchViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var result = await _searchService.SearchForQuestions(db, user, model.Query, model.Offset, model.Limit);
return(StandardResponse.For(result));
}
}
}
public async Task <StandardResponse> GetQuestionMetadata(ClaimsPrincipal identity, GetQuestionViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var meta = await _questionService.GetQuestionMetadata(db, user, model.Id);
return(StandardResponse.For(QuestionMetaViewModel.From(meta)));
}
}
}
public async Task <StandardResponse> GetTopic(ClaimsPrincipal identity, TopicGetViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity))
{
var result = !string.IsNullOrWhiteSpace(model.TopicName)
? await _topicService.RequireTopic(db, user, model.TopicName)
: await _topicService.GetTopic(db, user, model.TopicId);
return(StandardResponse.For(new TopicViewModel(result)));
}
}
}
public async Task <StandardResponse> AddAnswerToQuestion(ClaimsPrincipal identity, AddAnswerViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var answer = await _answerService.CreateAnswer(db, user, model.QuestionId, model.Body);
await db.SaveChangesAsync();
return(StandardResponse.For(new
{
answer.AnswerId
}));
}
}
}
public async Task <StandardResponse> GetQuestionSummary(ClaimsPrincipal identity, GetQuestionViewModel model, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
return(modelState.StandardError());
}
using (var db = new ServiceDb())
{
using (var user = await _userService.Become(db, identity, null))
{
var question = await _questionService.GetQuestion(db, user, model.Id);
var results = await _searchService.FindAnswersForQuestion(db, user, model.Id, 0, 1);
var bestAnswer = results.HasResults
? Option.Some(await _answerService.GetAnswer(db, user, results.IdentityList[0].ToString()))
: Option.None <Answer>();
return(StandardResponse.For(QuestionSummaryViewModel.From(question, bestAnswer)));
}
}
}
