protected override void UpdateCache(VoteResponse result)
{
if (result.Success)
{
//update cache somehow
}
}
/// <summary>
/// Vote Implementation
/// </summary>
/// <param name="vote"></param>
/// <returns></returns>
internal async Task <VoteResponse> VoteAction(VoteMessage vote)
{
return(await Task.Run(async() =>
{
var data_req = JsonConvert.SerializeObject(vote);
var content = new StringContent(data_req, Encoding.UTF8, "application/json");
var handler = new HttpClientHandler();
handler.ServerCertificateCustomValidationCallback =
HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
handler.AllowAutoRedirect = true;
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri("https://localhost:44380/");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var response = await client.PostAsync("api/Identity/Vote", content);
var voteresponse = new VoteResponse();
try
{
var data_resp = await response.Content.ReadAsStringAsync();
voteresponse = JsonConvert.DeserializeObject <VoteResponse>(data_resp);
}
catch (Exception e)
{
logger.Error(e, "Vote error");
}
return voteresponse;
}
}));
}
private void rejectVote(VoteRequest request, AcceptorState state)
{
VoteStatus voteStatus = VoteStatus.Rejected;
VoteResponse response = generateVoteResponse(state, request, voteStatus);
sendVoteResponse(request.MessageSender, response);
}
private void storePreviousAcceptedValuesFromAcceptors(LeaderState state, VoteResponse responseDecision)
{
if (responseDecision != null)
{
state.ValuesAcceptedByAcceptors.Add(responseDecision);
}
}
private static ManageVoteResponseModel CreateManageVoteResponse(Ballot ballot)
{
var model = new ManageVoteResponseModel
{
BallotManageGuid = ballot.ManageGuid,
Votes = new List <VoteResponse>()
};
if (ballot.VoterName != null)
{
model.VoterName = ballot.VoterName;
}
foreach (Vote vote in ballot.Votes)
{
var voteResponse = new VoteResponse
{
ChoiceNumber = vote.Choice.PollChoiceNumber,
Value = vote.VoteValue,
ChoiceName = vote.Choice.Name
};
model.Votes.Add(voteResponse);
}
return(model);
}
public void VoteOnResponse(VoteResponse v)
{
Response r = _ctx.Responses.FirstOrDefault(x => x.Id == v.ResponseId);
r.Popularity += v.Value;
_ctx.Responses.Update(r);
_ctx.SaveChanges();
}
public void PollWithBallotsWithVotes_ReturnsAll()
{
var manageGuid = new Guid("A76287F6-BC56-421C-9294-A477D1E9C4B3");
const string voterName = "Derek";
const int optionNumber = 1;
const string optionName = "Value?";
const int optionValue = 23;
IDbSet <Poll> existingPolls = DbSetTestHelper.CreateMockDbSet <Poll>();
var poll = new Poll()
{
ManageId = PollManageGuid
};
var ballot = new Ballot()
{
ManageGuid = manageGuid,
VoterName = voterName,
TokenGuid = new Guid("1AC3FABB-A077-4EF3-84DC-62074BA8FDF1")
};
var vote = new Vote()
{
Choice = new Choice()
{
PollChoiceNumber = optionNumber,
Name = optionName
},
VoteValue = optionValue
};
ballot.Votes.Add(vote);
poll.Ballots.Add(ballot);
existingPolls.Add(poll);
IContextFactory contextFactory = ContextFactoryTestHelper.CreateContextFactory(existingPolls);
ManageVoterController controller = CreateManageVoteController(contextFactory);
List <ManageVoteResponseModel> response = controller.Get(PollManageGuid);
Assert.AreEqual(1, response.Count);
ManageVoteResponseModel responseBallot = response[0];
Assert.AreEqual(manageGuid, responseBallot.BallotManageGuid);
Assert.AreEqual(voterName, responseBallot.VoterName);
Assert.AreEqual(1, responseBallot.Votes.Count);
VoteResponse responseVote = responseBallot.Votes[0];
Assert.AreEqual(optionName, responseVote.ChoiceName);
Assert.AreEqual(optionValue, responseVote.Value);
Assert.AreEqual(optionNumber, responseVote.ChoiceNumber);
}
public override void Handle(DhtEngine engine, Node node)
{
base.Handle(engine, node);
BEncodedString token = engine.TokenManager.GenerateToken(node);
VoteResponse response = new VoteResponse(engine.RoutingTable.LocalNode.Id, TransactionId, token);
engine.MessageLoop.EnqueueSend(response, node.EndPoint);
}
/// <summary>
/// Gets the vote for a user-survey pair. Returns null if the user hasnt voted on this survey
/// </summary>
/// <returns>The vote. Null if not-existing</returns>
/// <param name="survey">The survey.</param>
/// <param name="user">The User</param>
public async static Task <Vote> GetVoteForUserAsync(Survey survey, User user)
{
VoteResponse res = await CallBackendAsync <VoteResponse>("getvoteforuser", new GetVoteForUserRequest(survey, user));
if (!string.IsNullOrEmpty(res.ExceptionMessage))
{
throw new Exception(res.ExceptionMessage);
}
return(res.Vote);
}
private void notifyAllReplicasOfElectedValue(VoteResponse message)
{
ProposalDecision decision = new ProposalDecision(message);
decision.Command = this.currentState.ProposalsBySlotId[message.SlotNumber];
foreach (MessageSender replica in this.currentState.Replicas)
{
this.MessageBroker.SendMessage(replica.UniqueId, decision);
}
}
private VoteResponse generateVoteResponse(AcceptorState state, VoteRequest request, VoteStatus voteStatus)
{
VoteResponse response = new VoteResponse
{
BallotNumber = state.BallotNumber,
MessageSender = state.MessageSender,
SlotNumber = request.SlotNumber,
VoteStatus = voteStatus
};
return(response);
}
public void Upvote(int tabIndex)
{
if (!this.PreCheck())
{
return;
}
if (this.Upvoting)
{
MsgController.ShowMsg(SFST.T.Sharing_Wait_Request);
return;
}
string ID = this.pages[tabIndex].ID;
this.Upvoting = true;
VotePacket toSend = new VotePacket
{
vote = true,
voteOn = ID
};
GameTracker.Tracker.client.AuthedRequest(toSend, delegate(DefaultPacket r)
{
SyncContext.RunOnUI(delegate
{
if (r.Success)
{
VoteResponse voteResponse = r.ToTargetPacket <VoteResponse>();
Debug.Log(voteResponse.Action);
if (voteResponse.Action == "VOTE_PLACED")
{
MsgController.ShowMsg(SFST.T.Sharing_Vote_Placed);
}
else
{
MsgController.ShowMsg(SFST.T.Sharing_Vote_Revoked);
}
this.ReloadPage(delegate
{
RocketPost post = this.GetPost(ID);
if (post != null)
{
post.PlayAnimation();
}
});
}
else
{
MsgController.ShowMsg(SFST.T.Sharing_Vote_Failed);
}
this.Upvoting = false;
});
});
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)]
VoteRequest Request,
HttpRequest req,
ILogger log
)
{
string Error = "";
string Content = "";
try
{
IPAddress result = null;
if (req.Headers.TryGetValue("X-Forwarded-For", out StringValues values))
{
var ipn = values.FirstOrDefault().Split(new char[] { ',' }).FirstOrDefault().Split(new char[] { ':' }).FirstOrDefault();
IPAddress.TryParse(ipn, out result);
}
if (result == null)
{
result = req.HttpContext.Connection.RemoteIpAddress;
}
string IP = result?.ToString();
var VoteSuccessful = ComicRepository.Vote(Request.EpisodeNumber, Request.EpisodeSubNumber, Request.StarRating, IP);
return(new JsonResult(new VoteResponse()
{
Successful = VoteSuccessful
}));
}
catch (UnsupportedMediaTypeException ex)
{
log.LogError(ex, "Unsupported media type returned");
Error = "Unsupported Media Type: " + ex.Message + "|" + ex.StackTrace;
}
catch (Exception ex)
{
log.LogError(ex.Message);
Error = "Error. Content: " + Content + ", " + ex.Message + "|" + ex.StackTrace;
}
var ErrorResponse = new VoteResponse()
{
Successful = false,
Error = Error
};
return(new JsonResult(ErrorResponse));
}
public async Task UnVote_ShouldReturnResponceSuccessFalse_WhenPostDoesNotExist()
{
//Arange
var postId = Guid.NewGuid().ToString();
var userId = Guid.NewGuid().ToString();
_postRepoMock.Setup(x => x.GetAsync(postId)).ReturnsAsync(() => null);
//Act
VoteResponse vr = await _sut.UnVote(postId, userId);
//Assert
Assert.False(vr.Success);
Assert.Equal("Post not found.", vr.Message);
}
private void acceptVote(VoteRequest request, AcceptorState state)
{
VoteResponse vote = new VoteResponse()
{
BallotNumber = request.BallotNumber,
SlotNumber = request.SlotNumber,
Command = request.Command
};
state.LastAcceptedVote = vote;
VoteStatus voteStatus = VoteStatus.Accepted;
VoteResponse response = generateVoteResponse(state, request, voteStatus);
sendVoteResponse(request.MessageSender, response);
}
public IActionResult MarkSolution([FromForm] VoteResponse r)
{
_service.MarkSolution(r.ResponseId);
var origQ = _service.GetQuestionById(r.QuestionId);
var qResponses = _service.GetRelatedResponses(origQ.Id);
var viewQuestion = new QuestionForView
{
Id = origQ.Id,
Title = origQ.Title,
Body = origQ.Body,
UserId = origQ.UserId,
Popularity = origQ.Popularity,
Responses = qResponses
};
return(View("Details", viewQuestion));
}
public static void QueryVotes(bool eventChoice)
{
ParseQuery <ParseObject> query = ParseObject.GetQuery("Vote")
.WhereGreaterThan("createdAt", instance._lastTime);
query.FindAsync().ContinueWith(t =>
{
instance.ResetVotes();
instance.winningVote = VoteResponse.Tie;
int mostVotes = 0;
IEnumerable <ParseObject> results = t.Result;
foreach (ParseObject vote in results)
{
if (!instance._countedVotes.Contains(vote.ObjectId))
{
instance._countedVotes.Add(vote.ObjectId);
VoteResponse voteType = (VoteResponse)Enum.Parse(typeof(VoteResponse), vote.Get <String>("vote"));
if ((eventChoice && (voteType != VoteResponse.Yes || voteType != VoteResponse.No)) ||
(!eventChoice && (voteType != VoteResponse.No && voteType != VoteResponse.Yes)))
{
++instance._votes[voteType];
int voteCount = instance._votes[voteType];
if (voteCount > mostVotes)
{
instance.winningVote = voteType;
mostVotes = voteCount;
}
else if (voteCount == mostVotes)
{
instance.winningVote = VoteResponse.Tie;
}
}
}
}
instance._votesDirty = true;
});
}
//辩题详情
public VoteResponse Detail(int id)
{
VoteResponse response = null;
try
{
var detail = _dbContext.Get <t_sys_vote>(id);
if (detail != null)
{
response = new VoteResponse
{
Id = detail.id,
UpdateTime = detail.updatetime,
CreateTime = detail.createtime,
Remark = detail.remark,
Title = detail.title,
VoteEndTime = detail.voteEndTime,
VoteStartTime = detail.voteStartTime
};
var votedetail = _dbContext.Select <t_sys_vote_detail>(c => c.voteId == id).ToList();
if (votedetail != null && votedetail.Count > 0)
{
foreach (var item in votedetail)
{
response.VoteDetail.Add(new VoteDetailResponse
{
Id = item.id,
NumberOfVotes = item.numberOfVotes,
Title = item.title,
VoteId = item.voteId
});
}
}
}
}
catch (Exception ex)
{
LogUtils.LogError("VoteService.Detail", ex);
}
return(response);
}
public async Task <JsonResult> Vote(Domain.Models.ContentType contentType, int id, int voteStatus)
{
VoteResponse result = null;
switch (contentType)
{
case Domain.Models.ContentType.Submission:
var cmdV = new SubmissionVoteCommand(id, voteStatus, IpHash.CreateHash(Request.RemoteAddress())).SetUserContext(User);
result = await cmdV.Execute();
break;
case Domain.Models.ContentType.Comment:
var cmdC = new CommentVoteCommand(id, voteStatus, IpHash.CreateHash(Request.RemoteAddress())).SetUserContext(User);
result = await cmdC.Execute();
break;
}
return(Json(result));
}
public async Task UnVote_ShouldReturnResponseSuccessFalse_WhenUserDidNotVote()
{
//Arange
var postId = Guid.NewGuid().ToString();
var userId = Guid.NewGuid().ToString();
Vote vote = new Vote
{
Id = Guid.NewGuid().ToString(),
UserId = userId,
PostId = postId
};
_postRepoMock.Setup(x => x.GetAsync(postId)).ReturnsAsync(new Post());
_voteRepoMock.Setup(x => x.FindInstance(postId, userId)).ReturnsAsync(() => null);
//Act
VoteResponse vr = await _sut.UnVote(postId, userId);
//Assert
Assert.False(vr.Success);
Assert.Equal("You did not vote.", vr.Message);
}
public async Task UnVote_ShouldReturnResponseSuccessTrue_WhenUserSuccessfulyUnVote()
{
//Arange
var postId = Guid.NewGuid().ToString();
var userId = Guid.NewGuid().ToString();
Vote vote = new Vote
{
Id = Guid.NewGuid().ToString(),
UserId = userId,
PostId = postId
};
_postRepoMock.Setup(x => x.GetAsync(postId)).ReturnsAsync(new Post());
_voteRepoMock.Setup(x => x.FindInstance(postId, userId)).ReturnsAsync(vote);
//Act
VoteResponse vr = await _sut.UnVote(postId, userId);
//Assert
Assert.True(vr.Success);
Assert.Equal(postId, vr.Resource.PostId);
Assert.Equal(userId, vr.Resource.UserId);
}
public void Execute(MessageStrategyExecuteArg <IMessage> obj)
{
if (!(obj.Message is VoteResponse))
{
throw new MessageStrategyException("This strategy shouldn't be invoked with this message type");
}
VoteResponse response = obj.Message as VoteResponse;
LeaderState state = obj.RoleState as LeaderState;
state.VoteRequestPendingDecisionPerSlot[response.SlotNumber].Remove(response.MessageSender);
if (isBallotValid(response.BallotNumber, state.BallotNumber))
{
if (isElected(response, state))
{
OnApprovalElected?.Invoke(this, response);
}
}
else
{
OnApprovalPreempted?.Invoke(this, EventArgs.Empty);
}
}
private Vote ToModel(VoteResponse obj) => new Vote(
count: obj.Count,
optionName: obj.OptionName
);
private bool isElected(VoteResponse response, LeaderState state)
{
return(state.VoteRequestPendingDecisionPerSlot[response.SlotNumber].Count < state.Acceptors.Count / 2);
}
public void MultiplePolls_ReturnsOnlyRequested()
{
Guid otherManageGuid = new Guid("35FC553F-2F0E-49E0-A919-802900262046");
const string expectedVoterName = "Expected Voter";
const string otherVoterName = "Someone else voting";
const string expectedChoiceName = "SomeChoice";
const int expectedChoiceNumber = 3;
var expectedChoice = new Choice()
{
PollChoiceNumber = expectedChoiceNumber, Name = expectedChoiceName
};
const int expectedVoteValue = 42;
const int otherChoiceNumber = 1;
var otherChoice = new Choice()
{
PollChoiceNumber = otherChoiceNumber, Name = "Some Other Choice"
};
const int otherVoteValue = 16;
IDbSet <Poll> existingPolls = DbSetTestHelper.CreateMockDbSet <Poll>();
var poll1 = new Poll()
{
ManageId = PollManageGuid,
Ballots = new List <Ballot>()
{
CreateBallot(expectedVoterName, CreateVote(expectedChoice, expectedVoteValue))
}
};
var poll2 =
new Poll()
{
ManageId = otherManageGuid,
Ballots = new List <Ballot>()
{
CreateBallot(otherVoterName, CreateVote(otherChoice, otherVoteValue))
}
};
existingPolls.Add(poll1);
existingPolls.Add(poll2);
IContextFactory contextFactory = ContextFactoryTestHelper.CreateContextFactory(existingPolls);
ManageVoterController controller = CreateManageVoteController(contextFactory);
List <ManageVoteResponseModel> response = controller.Get(PollManageGuid);
Assert.AreEqual(1, response.Count);
ManageVoteResponseModel responseBallot = response[0];
Assert.AreEqual(expectedVoterName, responseBallot.VoterName);
Assert.AreEqual(1, responseBallot.Votes.Count);
VoteResponse responseVote = responseBallot.Votes[0];
Assert.AreEqual(expectedChoiceName, responseVote.ChoiceName);
Assert.AreEqual(expectedVoteValue, responseVote.Value);
Assert.AreEqual(expectedChoiceNumber, responseVote.ChoiceNumber);
}
private void sendVoteResponse(MessageSender sendTo, VoteResponse response)
{
this.broker.SendMessage(sendTo.UniqueId, response);
}
public object Any(Vote request)
{
Guid userId = UserSession.GetUserId();
VoteResponse response = new VoteResponse
{
Result = ErrorCode.OK,
};
TableRepository tableRepository = new TableRepository();
UserQuestionEntry userQuestionEntry = tableRepository.Get <UserQuestionEntry>(Tables.UserQuestion, request.QuestionId, userId);
// Création d'un nouveau vote
if (userQuestionEntry == null)
{
DateTime dateTime = DateTime.UtcNow;
userQuestionEntry = new UserQuestionEntry(request.QuestionId, userId)
{
Creation = dateTime,
Modification = dateTime
};
}
else
{
userQuestionEntry.Modification = DateTime.UtcNow;
}
Guid target = request.VoteTarget == VoteTarget.Question ? request.QuestionId : request.OwnerId;
HashSet <string> votesUp = new HashSet <string>(userQuestionEntry.VotesUp?.Split('|') ?? new string[] { });
HashSet <string> votesDown = new HashSet <string>(userQuestionEntry.VotesDown?.Split('|') ?? new string[] { });
VoteKind oldValue = VoteKind.None;
if (votesUp.Contains(target.ToString()))
{
oldValue = VoteKind.Up;
}
else if (votesDown.Contains(target.ToString()))
{
oldValue = VoteKind.Down;
}
response.VoteKind = request.VoteKind;
votesUp.Remove(target.ToString());
votesDown.Remove(target.ToString());
if (response.VoteKind == oldValue)
{
response.VoteKind = VoteKind.None;
}
else
{
switch (response.VoteKind)
{
case VoteKind.Up:
votesUp.Add(target.ToString());
break;
case VoteKind.Down:
votesDown.Add(target.ToString());
break;
}
}
userQuestionEntry.VotesUp = votesUp.Join("|");
userQuestionEntry.VotesDown = votesDown.Join("|");
if (request.VoteTarget == VoteTarget.Answer)
{
AnswerEntry answerEntry = tableRepository.Get <AnswerEntry>(Tables.Answers, request.QuestionId, request.OwnerId);
answerEntry.Votes -= (int)oldValue;
answerEntry.Votes += (int)response.VoteKind;
tableRepository.InsertOrMerge(answerEntry, Tables.Answers);
response.VoteValue = answerEntry.Votes;
// badges
if (response.VoteKind == VoteKind.Up)
{
switch (answerEntry.Votes)
{
case 1: AllBadges.Approved.CreateIfNotExist(tableRepository, answerEntry.GetAnswerOwnerId()); break;
case 10: AllBadges.NiceAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
case 25: AllBadges.GoodAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
case 100: AllBadges.GreatAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
}
}
}
else
{
QuestionEntry questionEntry = tableRepository.Get <QuestionEntry>(Tables.Questions, request.OwnerId, request.QuestionId);
questionEntry.Votes -= (int)oldValue;
questionEntry.Votes += (int)response.VoteKind;
tableRepository.InsertOrMerge(questionEntry, Tables.Questions);
response.VoteValue = questionEntry.Votes;
// badges
if (response.VoteKind == VoteKind.Up)
{
switch (questionEntry.Votes)
{
case 1: AllBadges.Padawan.CreateIfNotExist(tableRepository, questionEntry.GetOwnerId()); break;
case 10: AllBadges.NiceQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
case 25: AllBadges.GoodQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
case 100: AllBadges.GreatQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
}
}
}
// insert le vote
tableRepository.InsertOrReplace(userQuestionEntry, Tables.UserQuestion);
// badges
if (response.VoteKind == VoteKind.Up)
{
AllBadges.Supporter.CreateIfNotExist(tableRepository, userId);
}
else if (response.VoteKind == VoteKind.Down)
{
AllBadges.Critic.CreateIfNotExist(tableRepository, userId);
}
return(response);
}
public object Any(Vote request)
{
Guid userId = UserSession.GetUserId();
VoteResponse response = new VoteResponse
{
Result = ErrorCode.OK,
};
TableRepository tableRepository = new TableRepository();
UserQuestionEntry userQuestionEntry = tableRepository.Get<UserQuestionEntry>(Tables.UserQuestion, request.QuestionId, userId);
// Création d'un nouveau vote
if (userQuestionEntry == null)
{
DateTime dateTime = DateTime.UtcNow;
userQuestionEntry = new UserQuestionEntry(request.QuestionId, userId)
{
Creation = dateTime,
Modification = dateTime
};
}
else
{
userQuestionEntry.Modification = DateTime.UtcNow;
}
Guid target = request.VoteTarget == VoteTarget.Question ? request.QuestionId : request.OwnerId;
HashSet<string> votesUp = new HashSet<string>(userQuestionEntry.VotesUp?.Split('|') ?? new string[] { });
HashSet<string> votesDown = new HashSet<string>(userQuestionEntry.VotesDown?.Split('|') ?? new string[] { });
VoteKind oldValue = VoteKind.None;
if (votesUp.Contains(target.ToString()))
oldValue = VoteKind.Up;
else if (votesDown.Contains(target.ToString()))
oldValue = VoteKind.Down;
response.VoteKind = request.VoteKind;
votesUp.Remove(target.ToString());
votesDown.Remove(target.ToString());
if (response.VoteKind == oldValue) response.VoteKind = VoteKind.None;
else
{
switch (response.VoteKind)
{
case VoteKind.Up:
votesUp.Add(target.ToString());
break;
case VoteKind.Down:
votesDown.Add(target.ToString());
break;
}
}
userQuestionEntry.VotesUp = votesUp.Join("|");
userQuestionEntry.VotesDown = votesDown.Join("|");
if (request.VoteTarget == VoteTarget.Answer)
{
AnswerEntry answerEntry = tableRepository.Get<AnswerEntry>(Tables.Answers, request.QuestionId, request.OwnerId);
answerEntry.Votes -= (int)oldValue;
answerEntry.Votes += (int)response.VoteKind;
tableRepository.InsertOrMerge(answerEntry, Tables.Answers);
response.VoteValue = answerEntry.Votes;
// badges
if (response.VoteKind == VoteKind.Up)
{
switch (answerEntry.Votes)
{
case 1: AllBadges.Approved.CreateIfNotExist(tableRepository, answerEntry.GetAnswerOwnerId()); break;
case 10: AllBadges.NiceAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
case 25: AllBadges.GoodAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
case 100: AllBadges.GreatAnswer.CreateForQuestion(tableRepository, answerEntry.GetAnswerOwnerId(), request.QuestionId); break;
}
}
}
else
{
QuestionEntry questionEntry = tableRepository.Get<QuestionEntry>(Tables.Questions, request.OwnerId, request.QuestionId);
questionEntry.Votes -= (int)oldValue;
questionEntry.Votes += (int)response.VoteKind;
tableRepository.InsertOrMerge(questionEntry, Tables.Questions);
response.VoteValue = questionEntry.Votes;
// badges
if (response.VoteKind == VoteKind.Up)
{
switch (questionEntry.Votes)
{
case 1: AllBadges.Padawan.CreateIfNotExist(tableRepository, questionEntry.GetOwnerId()); break;
case 10: AllBadges.NiceQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
case 25: AllBadges.GoodQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
case 100: AllBadges.GreatQuestion.CreateForQuestion(tableRepository, questionEntry.GetOwnerId(), request.QuestionId); break;
}
}
}
// insert le vote
tableRepository.InsertOrReplace(userQuestionEntry, Tables.UserQuestion);
// badges
if (response.VoteKind == VoteKind.Up)
AllBadges.Supporter.CreateIfNotExist(tableRepository, userId);
else if (response.VoteKind == VoteKind.Down)
AllBadges.Critic.CreateIfNotExist(tableRepository, userId);
return response;
}
private Vote ToModel(VoteResponse obj) => new Vote
{
Count = obj.Count,
OptionName = obj.OptionName
};
