public async Task SubmitAnswer_PollIsAnonymous_PollResultsHasNoTranslationTable()
{
// arrange
var (connection, _) = await ConnectToOpenedConference();
var createDto = new CreatePollDto(new SingleChoiceInstruction(new[] {"A", "B"}),
new PollConfig("A or B?", true, false), new PollState(true, false), null);
var pollId = await CreatePollReturnId(connection, createDto);
// act
AssertSuccess(await connection.Hub.InvokeAsync<SuccessOrError<Unit>>(nameof(CoreHub.SubmitPollAnswer),
new SubmitPollAnswerDto(pollId, new SingleChoiceAnswer("A"))));
// assert
await connection.SyncObjects.AssertSyncObject<SynchronizedPollResult>(
SynchronizedPollResult.SyncObjId(pollId), results =>
{
Assert.Equal(1, results.ParticipantsAnswered);
var pollResults = Assert.IsType<SelectionPollResults>(results.Results);
Assert.Equal(1, pollResults.Options["A"].Count);
Assert.Null(results.TokenIdToParticipant);
});
}
private async Task<string> CreatePollReturnId(UserConnection connection, CreatePollDto dto)
{
var result = await connection.Hub.InvokeAsync<SuccessOrError<string>>(nameof(CoreHub.CreatePoll), dto);
AssertSuccess(result);
return result.Response!;
}
public async Task SubmitAnswer_AnswerAlreadySubmitted_UpdateAnswer()
{
// arrange
var (connection, _) = await ConnectToOpenedConference();
var createDto = new CreatePollDto(new SingleChoiceInstruction(new[] {"A", "B"}),
new PollConfig("A or B?", true, false), new PollState(true, false), null);
var pollId = await CreatePollReturnId(connection, createDto);
AssertSuccess(await connection.Hub.InvokeAsync<SuccessOrError<Unit>>(nameof(CoreHub.SubmitPollAnswer),
new SubmitPollAnswerDto(pollId, new SingleChoiceAnswer("A"))));
// act
AssertSuccess(await connection.Hub.InvokeAsync<SuccessOrError<Unit>>(nameof(CoreHub.SubmitPollAnswer),
new SubmitPollAnswerDto(pollId, new SingleChoiceAnswer("B"))));
// assert
await connection.SyncObjects.AssertSyncObject<SynchronizedPollResult>(
SynchronizedPollResult.SyncObjId(pollId), results =>
{
var pollResults = Assert.IsType<SelectionPollResults>(results.Results);
Assert.Empty(pollResults.Options["A"]);
Assert.Single(pollResults.Options["B"]);
});
}
public IActionResult Create(CreatePollDto createPollDto)
{
if (createPollDto.title == null || createPollDto.title == "")
{
return(View());
}
else
{
var poll = new Poll();
poll.Name = createPollDto.title;
poll.UserName = GetADUserName();
poll = _pollDataRepository.AddPoll(poll);
foreach (var o in createPollDto.options)
{
if (o != null && o != "")
{
var option = new Option();
option.Name = o;
option.Votes = 0;
option = _pollDataRepository.AddOption(option, poll.Id);
}
}
return(RedirectToAction(nameof(Details), poll));
}
}
public async Task <ActionResult <GetPollDto> > CreatePoll([FromBody] CreatePollDto dto)
{
long userID = Convert.ToInt64(User.Claims.FirstOrDefault(c => c.Type == "UserID").Value);
Poll poll = new Poll()
{
Name = dto.Name,
OwnerID = userID,
Answers = new List <PollAnswer>()
};
dto.Answers.ForEach(a => poll.Answers.Add(new PollAnswer()
{
Answer = a
}));
_context.Polls.Add(poll);
await _context.SaveChangesAsync();
return(Ok(new GetPollDto()
{
PollID = poll.PollID,
Name = poll.Name
}));
}
public async Task <SuccessOrError <string> > CreatePoll(CreatePollDto dto)
{
var participant = GetContextParticipant();
return(await GetInvoker().Create(new CreatePollRequest(participant.ConferenceId, dto.Instruction,
dto.Config, dto.InitialState, dto.RoomId)).RequirePermissions(DefinedPermissions.Poll.CanOpenPoll)
.ValidateObject(dto).Send());
}
public async Task CreatePoll_Moderator_ReceiveEmptyResults()
{
// arrange
var (connection, _) = await ConnectToOpenedConference();
// act
var createDto = new CreatePollDto(new SingleChoiceInstruction(new[] {"A", "B"}),
new PollConfig("A or B?", true, false), PollState.Default, null);
var pollId = await CreatePollReturnId(connection, createDto);
// assert
await connection.SyncObjects.AssertSyncObject<SynchronizedPollResult>(
SynchronizedPollResult.SyncObjId(pollId), results =>
{
Assert.Equal(pollId, results.PollId);
Assert.Equal(0, results.ParticipantsAnswered);
var pollResults = Assert.IsType<SelectionPollResults>(results.Results);
Assert.DoesNotContain(pollResults.Options, x => x.Value.Any());
});
}
public async Task CreatePoll_Global_ReceiveSyncPollObj()
{
// arrange
var (connection, _) = await ConnectToOpenedConference();
// act
var instruction = new SingleChoiceInstruction(new[] {"A", "B"});
var createDto = new CreatePollDto(instruction, new PollConfig("A or B?", true, false), PollState.Default,
null);
var pollId = await CreatePollReturnId(connection, createDto);
await connection.SyncObjects.AssertSyncObject<SynchronizedPoll>(SynchronizedPoll.SyncObjId(pollId), poll =>
{
Assert.Equal(pollId, poll.Id);
Assert.Equal(createDto.Config, poll.Config);
Assert.Equal(createDto.InitialState, poll.State);
var actualInstruction = Assert.IsType<SingleChoiceInstruction>(poll.Instruction);
Assert.Equal(instruction.Options, actualInstruction.Options);
});
}
