/// <summary>
/// Handless poll format to wanted format
/// </summary>
/// <param name="poll">Poll from backend</param>
/// <returns>JSON poll</returns>
private IActionResult HandlePoll(Poll poll)
{
// If poll wasn't found
if (poll == null)
{
return(NotFound());
}
// Return poll and hadnling it
var pollDto = new PollDto
{
id = poll.Id,
title = poll.Title,
};
string jsonPoll = JsonConvert.SerializeObject(pollDto);
JObject jPoll = JObject.Parse(jsonPoll);
// Poll options
var options = poll.Option.OrderBy(x => x.AnswerId).Select(p => new OptionDto
{
id = p.AnswerId,
title = p.Title,
votes = p.Votes,
});
string jsonOptions = JsonConvert.SerializeObject(options);
JArray jOptions = JArray.Parse(jsonOptions);
jPoll.Add("options", jOptions);
return(Ok(jPoll));
}
public static PollVm GetPollVm(PollDto poll, long userId)
{
if (poll == null)
{
return(null);
}
PollVm result = new PollVm
{
ConversationType = poll.ConversationType,
ConversationId = poll.ConversationId,
MultipleSelection = poll.MultipleSelection,
PollId = poll.PollId,
ResultsVisibility = poll.ResultsVisibility,
Title = poll.Title,
SignRequired = poll.SignRequired
};
if (poll.CreatorId == userId || poll.ResultsVisibility)
{
result.PollOptions = GetPollOptionsVm(poll.Options, userId, true);
}
else if (poll.CreatorId != userId && !poll.ResultsVisibility)
{
result.PollOptions = GetPollOptionsVm(poll.Options, userId, false);
}
result.Voted = result.PollOptions?.Any(opt => opt.Voted.GetValueOrDefault());
return(result);
}
public async Task <ActionResult <Poll> > PostPoll([FromBody] PollDto pollDto)
{
List <Antwoord> antwoorden = new List <Antwoord>();
List <PollGebruiker> pollgebruikers = new List <PollGebruiker>();
Poll poll = new Poll {
Naam = pollDto.Naam
};
_context.Polls.Add(poll);
_context.SaveChanges();
poll = _context.Polls.Last();
foreach (var a in pollDto.Antwoorden)
{
Antwoord antwoord = new Antwoord {
AntwoordP = a.AntwoordP, PollID = poll.PollID
};
antwoorden.Add(antwoord);
}
foreach (var v in pollDto.Vrienden)
{
PollGebruiker pollGebruiker = new PollGebruiker {
GebruikerID = v.GebruikerID, PollID = poll.PollID, gemaaktDoor = pollDto.gemaaktDoor
};
pollgebruikers.Add(pollGebruiker);
}
_context.Antwoorden.AddRange(antwoorden);
_context.PollGebruikers.AddRange(pollgebruikers);
await _context.SaveChangesAsync();
return(Ok());
}
public static Poll Convert(PollDto item) =>
new Poll
{
Id = item.Id,
RoomId = item.RoomId,
Title = item.Title
};
public async Task <ActionResult <PollDto> > PostPollUser([FromBody] PollDto pollDto)
{
Console.WriteLine(pollDto.PollName);
var vPollToInsert = new Poll()
{
Naam = pollDto.PollName
};
_context.Poll.Add(vPollToInsert);
await _context.SaveChangesAsync();
_context.PollUsers.Add(new PollUser()
{
PollID = vPollToInsert.PollID, UserID = pollDto.UserID
});
await _context.SaveChangesAsync();
foreach (var o in pollDto.Opties)
{
_context.Opties.Add(new Optie()
{
Naam = o.Naam, PollID = vPollToInsert.PollID, AantalStemmen = 0
});
}
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPollUser", new { id = pollDto.UserID }, pollDto));
}
public async Task GetPoll()
{
var chat = fillTestDbHelper.Chats.FirstOrDefault();
var chatUser = chat.ChatUsers.FirstOrDefault();
var poll = new PollDto
{
ConversationId = chat.Id,
ConversationType = ConversationType.Chat,
Title = "Poll",
CreatorId = chatUser.UserId,
Options = new List<PollOptionDto>
{
new PollOptionDto
{
Description = "desc",
OptionId = 1
},
new PollOptionDto
{
Description = "desc 2",
OptionId = 2
}
}
};
var expectedPoll = await pollsService.SavePollAsync(poll);
var actualPoll = await pollsService.GetPollAsync(poll.PollId, poll.ConversationId, poll.ConversationType);
Assert.True(expectedPoll.ConversationId == actualPoll.ConversationId
&& expectedPoll.ConversationType == actualPoll.ConversationType
&& expectedPoll.Title == actualPoll.Title
&& expectedPoll.CreatorId == actualPoll.CreatorId);
}
public async Task Submit_ReturnsNotFoundIfPollWasNotFound()
{
string pollId = "someId";
_requestHeaderHandler.GetCookie(_pollRendererController.ControllerContext, pollId).Returns("");
PollDto pollDto = null;
_pollRepository.Select(pollId).Returns(pollDto);
var result = await _pollRendererController.SubmitVote(new VoteRequest()
{
PollId = pollId,
SelectedVotes = new List <VoteDto>()
{
new VoteDto()
{
Count = 1,
Value = "test"
}
}
});
await _pollRepository.Select(pollId);
Assert.IsInstanceOf <NotFoundResult>(result);
}
public async Task GetPollVotedUsers()
{
var chat = fillTestDbHelper.Chats.FirstOrDefault();
var chatUser = chat.ChatUsers.FirstOrDefault();
var poll = new PollDto
{
ConversationId = chat.Id,
ConversationType = ConversationType.Chat,
Title = "Poll",
CreatorId = chatUser.UserId,
Options = new List<PollOptionDto>
{
new PollOptionDto
{
Description = "desc",
OptionId = 1
},
new PollOptionDto
{
Description = "desc 2",
OptionId = 2
}
}
};
poll = await pollsService.SavePollAsync(poll);
poll = await pollsService.VotePollAsync(poll.PollId, poll.ConversationId, poll.ConversationType, new List<byte> { 1 }, chatUser.UserId);
var votedUsers = await pollsService.GetPollVotedUsersAsync(poll.PollId, poll.ConversationId, poll.ConversationType, 1, chatUser.UserId);
Assert.True(votedUsers.Count == 1 && votedUsers.Any(opt => opt.FirstValue.Id == chatUser.UserId));
}
public async Task VotePoll()
{
var chat = fillTestDbHelper.Chats.FirstOrDefault();
var chatUser = chat.ChatUsers.LastOrDefault();
var poll = new PollDto
{
ConversationId = chat.Id,
ConversationType = ConversationType.Chat,
Title = "Poll",
CreatorId = chatUser.UserId,
Options = new List<PollOptionDto>
{
new PollOptionDto
{
Description = "desc",
OptionId = 1
},
new PollOptionDto
{
Description = "desc 2",
OptionId = 2
}
}
};
poll = await pollsService.SavePollAsync(poll);
var votedPoll = await pollsService.VotePollAsync(poll.PollId, poll.ConversationId, poll.ConversationType, new List<byte> { 1 }, chatUser.UserId);
Assert.NotNull(votedPoll.Options.FirstOrDefault(opt => opt.OptionId == 1).Votes.FirstOrDefault(opt => opt.UserId == chatUser.UserId));
}
public IActionResult Edit(PollDto model)
{
if (ModelState.IsValid)
{
}
return(View(model));
}
public async Task Publish_PollRepositoriesReceivingCallsIfModelInDataBase()
{
string tokenString = "tokenString";
_tokenService.GetRandomToken(Arg.Any <int>()).Returns(tokenString);
PollDto pollDto = new PollDto()
{
PollId = tokenString,
IsPublished = false
};
_pollRepository.Select(tokenString).Returns(pollDto);
var pollPublishRequest = new PollPublishRequest()
{
EditorToken = tokenString,
Options = new List <PollOptionDto>(),
IsSingleOption = true,
PollId = tokenString,
Title = "test"
};
await _pollBuilderController.Publish(pollPublishRequest);
var result = await _pollRepository.Select(pollDto.PollId);
if (!pollDto.IsPublished)
{
await _pollRepository.Received().Update(pollDto);
await _pollOptionRepository.Received().Insert(pollPublishRequest.Options, pollDto.PrimaryKey);
}
}
public async Task CreateAsync_NotFoundAsync()
{
PollDto pollDto = null;
var actualResult = await _pollController.CreateAsync(pollDto);
actualResult.Should().BeOfType <NotFoundResult>();
}
/// <summary>
/// Получить опрос по идентификатору
/// </summary>
/// <param name="id">Идентификатор опроса</param>
/// <returns></returns>
public PollDto GetPoll(int id)
{
PollDto pollDto = _mapper.Map <PollDto>(_pollRepository.GetPollWithOptions(id));
pollDto.State = GetPollState(pollDto);
return(pollDto ?? new PollDto());
}
public Task <int> CreateAsync(PollDto poll)
{
return(_databaseRepository.GetAsync <int>(Functions.Poll.Create,
DbParameterInfoHelper.Create(nameof(poll.Title), poll.Title),
DbParameterInfoHelper.Create(nameof(poll.Status), poll.Status),
DbParameterInfoHelper.Create(nameof(poll.Type), poll.Type),
DbParameterInfoHelper.CreateJsonb(nameof(poll.Options), poll.Options)));
}
public async Task Create(PollDto eventDto)
{
var eventDb = _mapper.Map <Poll>(eventDto);
var userId = _httpContext.GetUserId();
eventDb.CreatedById = userId;
_unitOfWork.GetRepository <Poll, int>().Create(eventDb);
await _unitOfWork.Save();
}
public async Task Update(int id, PollDto eventDto)
{
var oldPoll = _mapper.Map <Poll>(eventDto);
await UpdateQuestions(id, oldPoll.Questions);
_unitOfWork.GetRepository <Poll, int>().Update(oldPoll);
await _unitOfWork.Save();
}
public async Task RenderVotePage_ReturnsNotFoundIfPollDoesNotExist()
{
string pollId = "someId";
PollDto pollDto = null;
_pollRepository.Select(pollId).Returns(pollDto);
var result = await _pollRendererController.RenderVotePage(pollId);
Assert.IsInstanceOf <NotFoundResult>(result);
}
private StateEnum GetPollState(PollDto poll)
{
//Если дата начала в прошлом - опрос начался, иначе дата начала в будущем и опрос ещё не начался
StateEnum result = poll.StartDate <= DateTime.Now ? StateEnum.Active : StateEnum.NotStarted;
if (poll.EndDate <= DateTime.Now) //Если дата конца в прошлом - опрос закончился
{
result = StateEnum.Ended;
}
return(result);
}
public async Task <ActionResult <Poll> > PostPoll(PollDto pollDto)
{
var poll = new Poll
{
Naam = pollDto.Naam
};
_context.Polls.Add(poll);
await _context.SaveChangesAsync();
foreach (var optie in pollDto.Opties)
{
_context.Antwoorden
.Add(
new Antwoord
{
PollID = poll.PollID,
Optie = optie.Optie
});
}
await _context.SaveChangesAsync();
foreach (int item in pollDto.VriendenIDs)
{
_context.PollGebruikers
.Add(
new PollGebruiker
{
PollID = poll.PollID,
GebruikerID = item,
Gestemd = false,
IsAdmin = false,
IsActief = true
});
}
await _context.SaveChangesAsync();
_context.PollGebruikers
.Add(
new PollGebruiker
{
PollID = poll.PollID,
GebruikerID = pollDto.MakerID,
Gestemd = false,
IsAdmin = true,
IsActief = true
});
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPoll", new { id = poll.PollID }, poll));
}
public async Task <ActionResult <PollDto> > Adicionar(PollDto pollViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var pollAtualizada = await _pollService.Adicionar(_mapper.Map <Business.Models.Poll>(pollViewModel));
return(CustomResponse(_mapper.Map <PollDto>(pollAtualizada).Id));
}
public async Task Create_PollRepositoryInsertReceivedCall()
{
string tokenString = "tokenString";
PollDto pollDto = new PollDto();
_tokenService.GetRandomToken(Arg.Any <int>()).Returns(tokenString);
await _pollRepository.Insert(pollDto);
var result = await _pollBuilderController.Create();
await _pollRepository.Received().Insert(pollDto);
}
private async Task DownloadPollAttachmentAsync(AttachmentVm attachment, NodeConnection connection)
{
if (attachment.Payload is PollVm pollVm)
{
PollDto pollDto = await _nodeRequestSender.GetPollInformationAsync(
pollVm.ConversationId.Value,
pollVm.ConversationType.Value,
pollVm.PollId.Value,
connection).ConfigureAwait(false);
await _pollsService.SavePollAsync(pollDto).ConfigureAwait(false);
}
}
public bool UpdatePoll(PollDto dto)
{
try
{
dto.State = GetPollState(dto);
_pollRepository.Update(_mapper.Map <Poll>(dto));
}
catch (Exception)
{
return(false);
}
return(true);
}
public IActionResult Create([FromBody] PollDto pollDto)
{
var poll = _mapper.Map <Poll>(pollDto);
try
{
_pollService.Create(poll);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task Edit_PollRenderViewModelIsNotNull()
{
string tokenString = "tokenString";
_tokenService.GetRandomToken(Arg.Any <int>()).Returns(tokenString);
PollDto pollRenderModel = new PollDto()
{
EditorToken = tokenString
};
_pollRepository.Select(tokenString).Returns(pollRenderModel);
await _pollRepository.Select(tokenString);
await _pollBuilderController.Edit(tokenString, tokenString);
await _pollRepository.Received().Select(tokenString);
}
public async Task RenderPieChart_ReturnsJsonResultIfPollWasFound()
{
string pollId = "someId";
PollDto pollDto = new PollDto();
_requestHeaderHandler.GetCookie(_pollRendererController.ControllerContext, pollId).Returns(pollId);
_pollRepository.Select(pollId).Returns(pollDto);
var result = await _pollRendererController.RenderPieChart(new PieChartRequest()
{
PollId = pollId
});
await _pollRepository.Select(pollId);
Assert.IsInstanceOf <JsonResult>(result);
}
public async Task <ActionResult <PollDto> > Atualizar(int id, PollDto pollViewModel)
{
if (id != pollViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na chamada");
return(CustomResponse(pollViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _pollService.Atualizar(_mapper.Map <Business.Models.Poll>(pollViewModel));
return(CustomResponse(pollViewModel));
}
public async Task <PollDto> SavePollAsync(PollDto pollDto)
{
using (MessengerDbContext context = contextFactory.Create())
{
Poll poll = PollConverter.GetPoll(pollDto);
bool isPollExists = await context.Polls.AnyAsync(opt => opt.PollId == poll.PollId &&
opt.ConvertsationId == poll.ConvertsationId && opt.ConversationType == poll.ConversationType)
.ConfigureAwait(false);
if (!isPollExists)
{
await context.Polls.AddAsync(poll).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
}
return(PollConverter.GetPollDto(poll));
}
}
public async Task Update(PollDto poll)
{
using (var command = await CreateCommand())
{
var sqlText = new StringBuilder();
sqlText.Append(
"Update ct_poll SET title = @title, is_single_option = @is_single_option, is_published = @is_published, date_of_creation = @date_of_creation ");
sqlText.Append("Where poll_id = @poll_id");
command.CommandType = CommandType.Text;
command.CommandText = sqlText.ToString();
command.Parameters.AddWithValue("@title", poll.Title);
command.Parameters.AddWithValue("@is_single_option", poll.IsSingleOption);
command.Parameters.AddWithValue("@is_published", poll.IsPublished);
command.Parameters.AddWithValue("@poll_id", poll.PollId);
command.Parameters.AddWithValue("@date_of_creation", poll.DateOfCreation);
await command.ExecuteNonQueryAsync();
}
}
public IActionResult Update(int id, [FromBody] PollDto pollDto)
{
// map dto to entity and set id
var poll = _mapper.Map <Poll>(pollDto);
poll.Id = id;
try
{
// save
_pollService.Update(poll);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
