public Task <TResult> ExecuteAsync <TCommand, TResult>(TCommand query, SimpleQAIdentity user, CancellationToken cancel)
where TCommand : ICommand <TResult>
{
var instance = DependencyResolver.Current.GetService <ICommandExecuter <TCommand, TResult> >();
return(instance.ExecuteAsync(query, user, cancel));
}
public async Task <QuestionViewModel> BuildAsync(QuestionRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"QuestionRequest {question} @id @userId",
new
{
id = request.Id,
userId = user.Id
})
.ConfigureAwait(false);
CheckException(result);
var complex = result[0].AsResults();
var question = new QuestionViewModel();
complex[0].AsObjectCollation(question);
question.User = complex[1].GetString();
question.Tags = complex[2].GetStringArray();
question.Id = request.Id;
question.AuthoredByUser = question.User == user.Name;
question.UpVoted = GetVote(complex[3].GetString());
question.UserVotedClose = complex[4].AsInteger() == 1;
question.Answers = ExtractAnswers(user, complex[5].AsResults(), question);
return(question);
}
public Task <UserModel> BuildAsync(UserModelRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
return(Task.FromResult(new UserModel()
{
Name = request.User
}));
}
public async Task <AnswerViewModel> BuildAsync(AnswerRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"GetAnswer {question} @answerId @userId",
new
{
answerId = request.AnswerId,
userId = user.Id
})
.ConfigureAwait(false);
result = result[0].AsResults();
var questionStatus = result[3].AsEnum <QuestionStatus>();
var answer = new AnswerViewModel();
result[0].AsObjectCollation(answer);
answer.User = result[1].GetString();
answer.QuestionId = request.QuestionId;
answer.Editable = questionStatus == QuestionStatus.Open;
answer.Votable = questionStatus == QuestionStatus.Open;
answer.AuthoredByUser = answer.User == user.Name;
answer.UpVoted = GetVote(result[2].GetString());
return(answer);
}
public Task <TResult> ExecuteAsync <TCommand, TResult>(TCommand query, SimpleQAIdentity user, CancellationToken cancel)
where TCommand : ICommand <TResult>
{
var instance = _container.GetInstance <ICommandExecuter <TCommand, TResult> >();
return(instance.ExecuteAsync(query, user, cancel));
}
private void VotePost(XElement vote, IDictionary <String, String> usermap, IDictionary <String, String> postmap)
{
var userId = vote.Attribute("UserId").Value;
var user = new SimpleQAIdentity(usermap[userId], "whatever", "", 0);
if (!postmap.ContainsKey(vote.Attribute("PostId").Value))
{
return;
}
try
{
var post = postmap[vote.Attribute("PostId").Value];
if (post.Contains("@"))
{
var parts = post.Split('@');
VoteAnswer(user, parts[0], parts[1]);
Console.WriteLine("Answer " + post + " voted.");
}
else
{
VoteQuestion(user, post);
Console.WriteLine("Question " + post + " voted.");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.GetBaseException().Message);
}
}
public Task <TModel> BuildAsync <TRequest, TModel>(TRequest request, SimpleQAIdentity user, CancellationToken cancel)
where TRequest : IModelRequest <TModel>
where TModel : IModel
{
var instance = DependencyResolver.Current.GetService <IModelBuilder <TRequest, TModel> >();
return(instance.BuildAsync(request, user, cancel));
}
public IDictionary <String, String> Process(XDocument doc)
{
var users = doc.Element("users").Elements();
var idmap = new ConcurrentDictionary <String, String>();
var anonymous = new SimpleQAIdentity("", "dumpprocessor", "", 0);
Parallel.ForEach(users, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
}, user =>
{
var command = new AuthenticateCommand(user.Attribute("DisplayName").Value, "whatever");
var result = _mediator.ExecuteAsync <AuthenticateCommand, AuthenticateCommandResult>(command, anonymous, CancellationToken.None).Result;
idmap.TryAdd(user.Attribute("Id").Value, _channel.Execute("HGET {user}:namemapping @Username", new { command.Username })[0].GetString());
_channel.Execute("sadd {user}:builtin @user", new { user = command.Username }).ThrowErrorIfAny();
Console.WriteLine("Added user: " + command.Username);
});
return(idmap);
}
private static List <AnswerViewModel> ExtractAnswers(SimpleQAIdentity user, IRedisResults results, QuestionViewModel question)
{
var answers = new List <AnswerViewModel>();
foreach (var answerData in results)
{
var answerResult = answerData.AsResults();
var answer = new AnswerViewModel();
answerResult[0].AsObjectCollation(answer);
answer.User = answerResult[1].GetString();
answer.QuestionId = question.Id;
answer.Editable = question.Status == QuestionStatus.Open;
answer.Votable = question.Votable;
answer.AuthoredByUser = answer.User == user.Name;
answer.UpVoted = GetVote(answerResult[2].GetString());
answers.Add(answer);
}
return(answers);
}
public async Task <UserInboxModel> BuildAsync(UserInboxRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"GetInboxNotifications {user} @userId",
new { userId = user.Id })
.ConfigureAwait(false);
result.ThrowErrorIfAny();
var ids = result[0].GetStringArray();
List <QuestionNotification> list;
if (ids.Any())
{
list = await GetQuestions(ids).ConfigureAwait(false);
}
else
{
list = new List <QuestionNotification>();
}
return(new UserInboxModel(list));
}
static IEnumerable <String> GetQuestionData(QuestionCreateCommand command, SimpleQAIdentity user, String id, String slug, Int64 initialScore)
{
var data = Parameter.SequenceProperties(new
{
Id = id,
Title = command.Title,
Content = command.Content,
HtmlContent = command.HtmlContent,
CreatedOn = command.CreationDate,
UserId = user.Id,
Slug = slug,
Score = initialScore,
UpVotes = 0,
DownVotes = 0,
AnswerCount = 0,
ViewCount = 0,
Status = QuestionStatus.Open,
ContentExcerpt = GetExcerpt(command.Content, 150)
});
return(data);
}
public async Task <HomeByTagViewModel> BuildAsync(HomeByTagRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var model = new HomeByTagViewModel();
var sorting = request.Sorting.HasValue ? request.Sorting.Value : QuestionSorting.ByScore;
var result =
await _channel.ExecuteAsync(
"PaginateTag {tag} @tag @page @items @orderBy",
new
{
tag = request.Tag,
page = request.Page - 1,
items = Constant.ItemsPerPage,
orderBy = sorting.ToString()
})
.ConfigureAwait(false);
result.ThrowErrorIfAny();
result = result[0].AsResults();
model.Page = request.Page;
model.TotalPages = (Int32)Math.Ceiling(result[0].AsInteger() / (Constant.ItemsPerPage * 1.0));
model.Sorting = sorting;
model.Tag = request.Tag;
var ids = result.Skip(1).Select(r => r.GetString()).ToArray();
if (ids.Any())
{
model.Questions = await GetQuestions(ids).ConfigureAwait(false);
}
else
{
model.Questions = new List <QuestionExcerptViewModel>();
}
return(model);
}
public async Task <ValidateSessionCommandResult> ExecuteAsync(ValidateSessionCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var sessionDuration = TimeSpan.FromMinutes(5).TotalSeconds;
var result = await _channel.ExecuteAsync(
"ValidateSession {user} @SessionId @sessionDuration",
new { command.SessionId, sessionDuration })
.ConfigureAwait(false);
var error = result[0].GetException();
if (error != null)
{
switch (error.Prefix)
{
case "NOTVALID":
return(ValidateSessionCommandResult.NonValid);
default: throw error;
}
}
result = result[0].AsResults();
return(new ValidateSessionCommandResult(result[0].GetString(), result[1].GetString(), (Int32)result[2].GetInteger()));
}
public async Task <QuestionEditCommandResult> ExecuteAsync(QuestionEditCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var data = GetPatchData(command);
var result = await _channel.ExecuteAsync(@"
UpdateQuestion {question} @id @userId @data @tags @topic",
new
{
id = command.Id,
userId = user.Id,
data,
tags = command.Tags,
topic = "question-" + command.Id
})
.ConfigureAwait(false);
CheckException(result);
result = result[0].AsResults();
var slug = result[0].GetString();
var addedTags = result[1].GetStringArray();
var removedTags = result[2].GetStringArray();
return(new QuestionEditCommandResult(command.Id, slug));
}
public Task <EndSessionCommandResult> ExecuteAsync(EndSessionCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
_channel.Dispatch("EndSession {user} @SessionId", new { command.SessionId });
return(Task.FromResult(EndSessionCommandResult.Instance));
}
static IEnumerable <String> GetAnswerData(AnswerCreateCommand command, String questionId, SimpleQAIdentity user)
{
var data = Parameter.SequenceProperties(new
{
QuestionId = questionId,
UserId = user.Id,
Content = command.Content,
HtmlContent = command.HtmlContent,
CreatedOn = command.CreationDate,
Score = 0,
UpVotes = 0,
DownVotes = 0
});
return(data);
}
public async Task <AnswerCreateCommandResult> ExecuteAsync(AnswerCreateCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"CreateAnswer {question} @qid @data",
new
{
qid = command.QuestionId,
data = GetAnswerData(command, command.QuestionId, user)
}).ConfigureAwait(false);
result = result[0].AsResults();
var aid = result[0].GetString();
var quesionData = result[1].GetStringArray();
var slug = quesionData[0];
var ownerId = quesionData[1];
if (ownerId != user.Id)
{
_channel.Dispatch("NotifyQuestionUpdate {user} @qid @uid",
new
{
qid = command.QuestionId,
uid = user.Id
});
}
return(new AnswerCreateCommandResult(command.QuestionId, slug, aid));
}
public async Task <QuestionVoteCommandResult> ExecuteAsync(QuestionVoteCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var result =
await _channel.ExecuteAsync(
"VoteQuestion {question} @id @userId @score @upvote",
new
{
id = command.QuestionId,
userId = user.Id,
score = command.Upvote ? Constant.VoteScore : 0 - Constant.VoteScore,
upvote = command.Upvote ? 1 : 0
})
.ConfigureAwait(false);
CheckExceptions(result);
result = result[0].AsResults();
var votes = result[0].AsIntegerArray();
var tags = result[1].AsStringArray();
result = await _channel.ExecuteAsync(@"
VoteQuestionGlobally {questions} @id @score
VoteTags {tag} @id @tags @score",
new
{
id = command.QuestionId,
score = command.Upvote ? Constant.VoteScore : 0 - Constant.VoteScore,
tags
})
.ConfigureAwait(false);
result.ThrowErrorIfAny();
return(new QuestionVoteCommandResult(votes[0] - votes[1]));
}
public Task <QuestionDeleteFormViewModel> BuildAsync(QuestionDeleteFormRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
return(Task.FromResult(new QuestionDeleteFormViewModel()
{
Id = request.Id
}));
}
public async Task <QuestionCloseFormViewModel> BuildAsync(QuestionCloseFormRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"QuestionCloseForm {question} @id",
new
{
id = request.Id
})
.ConfigureAwait(false);
result.ThrowErrorIfAny();
return(new QuestionCloseFormViewModel()
{
Id = request.Id, Votes = result[0].AsInteger()
});
}
public Task <VisitQuestionCommandResult> ExecuteAsync(VisitQuestionCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
_channel.Dispatch("VisitQuestion {question} @QuestionId @Views", command);
return(Task.FromResult(VisitQuestionCommandResult.Nothing));
}
private void VoteQuestion(SimpleQAIdentity user, String questionId)
{
var command = new QuestionVoteCommand(questionId, true);
var result = _mediator.ExecuteAsync <QuestionVoteCommand, QuestionVoteCommandResult>(command, user, CancellationToken.None).Result;
}
public async Task <QuestionEditFormViewModel> BuildAsync(QuestionEditFormRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"QuestionEditForm {question} @id @userId",
new
{
id = request.Id,
userId = user.Id
})
.ConfigureAwait(false);
CheckException(result);
result = result[0].AsResults();
var model = new QuestionEditFormViewModel();
model.Content = result[0].GetString();
model.Title = result[1].GetString();
model.Tags = result[2].GetStringArray();
model.Id = request.Id;
return(model);
}
// Dummy authentication
public async Task <AuthenticateCommandResult> ExecuteAsync(AuthenticateCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
// Preventing user from login in with a user from a data dump
// because markdown code is missing and cannto be edited
if (user.Name != "dumpprocessor")
{
var ismember = await _channel.ExecuteAsync("SISMEMBER {user}:builtin @user", new { user = command.Username }).ConfigureAwait(false);
if (ismember[0].GetInteger() == 1)
{
throw new SimpleQAAuthenticationException("It is a built-in user.");
}
}
var session = GenerateLOLRandomIdentifier();
var newid = GenerateLOLRandomIdentifier();
var sessionDuration = TimeSpan.FromMinutes(5).TotalSeconds;
var result = await _channel.ExecuteAsync(
"Authenticate {user} @username @newid @session @sessionduration",
new
{
username = command.Username,
newid,
session,
sessionDuration
})
.ConfigureAwait(false);
result.ThrowErrorIfAny();
var userId = result[0].GetString();
// This should be done during registration
// but since this demo uses dummy authenticaion
// is done here.
await _channel.ExecuteAsync(
"HSET {question}:uidmapping @userId @username",
new { userId, username = command.Username })
.ConfigureAwait(false);
return(new AuthenticateCommandResult(session));
}
public async Task <AnswerEditFormViewModel> BuildAsync(AnswerEditFormRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"GetAnswerEditData {question} @answerId @userID",
new
{
answerId = request.AnswerId,
userId = user.Id
})
.ConfigureAwait(false);
CheckException(result);
return(new AnswerEditFormViewModel()
{
AnswerId = request.AnswerId,
QuestionId = request.QuestionId,
Content = result[0].GetString()
});
}
public Task <AnswerDeleteFormViewModel> BuildAsync(AnswerDeleteFormRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
return(Task.FromResult(new AnswerDeleteFormViewModel()
{
QuestionId = request.QuestionId, AnswerId = request.AnswerId
}));
}
public async Task <AnswerEditCommandResult> ExecuteAsync(AnswerEditCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"AnswerEdit {question} @answerId @userId @data",
new
{
answerId = command.AnswerId,
userId = user.Id,
data = GetData(command)
})
.ConfigureAwait(false);
CheckException(result);
var slug = result[0].GetString();
return(new AnswerEditCommandResult(command.QuestionId, slug, command.AnswerId));
}
public async Task <QuestionCloseCommandResult> ExecuteAsync(QuestionCloseCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var votesToClose = Constant.CloseVotesRequired;
var result = await _channel.ExecuteAsync(
"QuestionClose {question} @id @userId @votesToClose",
new
{
id = command.Id,
userId = user.Id,
votesToClose
})
.ConfigureAwait(false);
CheckException(result);
return(new QuestionCloseCommandResult(command.Id, result[0].GetString()));
}
public async Task <TagSuggestionsModel> BuildAsync(TagSuggestionRequest request, SimpleQAIdentity user, CancellationToken cancel)
{
var result = await _channel.ExecuteAsync(
"SuggestTags {tag} @prefix @max",
new
{
prefix = request.Query,
max = 100
}).ConfigureAwait(false);
result.ThrowErrorIfAny();
return(new TagSuggestionsModel(result[0].GetStringArray().Take(10).ToArray()));
}
public async Task <QuestionDeleteCommandResult> ExecuteAsync(QuestionDeleteCommand command, SimpleQAIdentity user, CancellationToken cancel)
{
var result =
await _channel.ExecuteAsync(
"QuestionDelete {question} @id @userId",
new
{
id = command.Id,
userId = user.Id
})
.ConfigureAwait(false);
CheckException(result);
result = result[0].AsResults();
var slug = result[0].GetString();
var tags = result[1].GetStringArray();
result = await _channel.ExecuteAsync(@"
UnindexQuestion {questions} @id
UnindexQuestionTags {tag} @id @score @tags",
new
{
id = command.Id,
tags,
score = Constant.VoteScore
}).ConfigureAwait(false);
return(new QuestionDeleteCommandResult(command.Id, slug));
}
