public async Task <object> InsertVote(VoteDto voteDto)
{
try
{
var vote = DtoToVote(voteDto);
await _votes.InsertOneAsync(vote);
var voteDtoRes = await GetVote(vote.Id);
if (voteDtoRes == null)
{
return(null);
}
var voter_election = DtoToVoter_Election(voteDto);
await _voter_elections.InsertOneAsync(voter_election);
return(new { ElectionId = voter_election.ElectionId, BallotTime = voter_election.BallotTime, VoteId = vote.Id });
}
catch (MongoWriteException e)
{
return(null);
}
catch (Exception e)
{
return(null);
}
}
private static Vote DtoToVote(VoteDto voteDto) =>
new Vote
{
CandidateId = voteDto.CandidateId,
ElectionId = voteDto.ElectionId,
ConstituencyId = voteDto.ConstituencyId
};
private static Voter_Election DtoToVoter_Election(VoteDto voteDto) =>
new Voter_Election
{
VoterId = voteDto.VoterId,
ElectionId = voteDto.ElectionId,
BallotTime = voteDto.BallotTime
};
public IActionResult PutVote([FromBody] VoteDto vote)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//if (id != vote.Id)
//{
// return BadRequest();
//}
var updatedVote = _voteRepository.AddorUpdateVote(vote);
//try
//{
// await _context.SaveChangesAsync();
//}
//catch (DbUpdateConcurrencyException)
//{
// if (!VoteExists(id))
// {
// return NotFound();
// }
// else
// {
// throw;
// }
//}
return(Ok(updatedVote));
}
public List <VoteDto> GetAllVote(VoteDto input)
{
var query = (from votes in _context.Vote.ToList()
join topic in _context.Topic.ToList()
on votes.TopicId equals topic.Id
select new VoteDto
{
TopicName = topic.Name,
TopicId = topic.Id,
UpVoteCount = votes.UpVoteCount,
DownVoteCount = votes.DownVoteCount,
Id = votes.Id,
DateCreated = votes.DateCreated,
Status = votes.Status,
UserId = votes.UserId
}).ToList().Skip((input.PagedResultDto.Page - 1) * input.PagedResultDto.SkipCount).Take(input.PagedResultDto.MaxResultCount);
// Map Records
List <VoteDto> ratingDto = MappingProfile.MappingConfigurationSetups().Map <List <VoteDto> >(query);
//Apply Sort
ratingDto = Sort(input.PagedResultDto.Sort, input.PagedResultDto.SortOrder, ratingDto);
// Apply search
if (!string.IsNullOrEmpty(input.PagedResultDto.Search))
{
ratingDto = ratingDto.Where(p => p.Status != null && p.Status.ToLower().ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.TopicName != null && p.TopicName.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.DateCreated != null && p.DateCreated.ToString().ToLower().Contains(input.PagedResultDto.Search.ToLower()) ||
p.UpVoteCount != null && p.UpVoteCount.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower()) ||
p.DownVoteCount != null && p.DownVoteCount.ToString().ToLower().ToString().Contains(input.PagedResultDto.Search.ToLower())
).ToList();
}
return(ratingDto);
}
protected virtual async Task Create(VoteDto input)
{
Vote voteDto = MappingProfile.MappingConfigurationSetups().Map <Vote>(input);
_context.Vote.Add(voteDto);
await _context.SaveChangesAsync();
}
public async Task UpdateCalculationMethodAsync(VoteDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
if (!Guid.TryParse(dto.Id, out var uid))
{
throw new NotImplementedException("投票Id信息不正确！");
}
var vote = await db.Votes.Where(x => x.Id == uid).FirstOrDefaultAsync(token);
if (vote == null)
{
throw new NotImplementedException("该投票不存在！");
}
if (vote.VoteTypeValue == VoteTypes.VipOwnerElection.Value)
{
throw new NotImplementedException("业委会改选不能进行此操作");
}
vote.CalculationMethodValue = CalculationMethod.Opposition.Value;
vote.CalculationMethodName = CalculationMethod.Opposition.Name;
vote.LastOperationTime = dto.OperationTime;
vote.LastOperationUserId = dto.OperationUserId;
await db.SaveChangesAsync(token);
}
}
/// <summary>Vote +1 pour un chat, -1 pour un autre.</summary>
/// <param name="vote">Le vote</param>
/// <returns>Vrai si l'opération a réussi</returns>
public async Task <bool> Vote(VoteDto vote)
{
await InitIfNecessary();
if (vote == null)
{
return(false);
}
Cat catDown = await _context.Cats.FirstOrDefaultAsync(c => c.Id == vote.IdDown);
if (catDown == null)
{
return(false);
}
Cat catUp = await _context.Cats.FirstOrDefaultAsync(c => c.Id == vote.IdUp);
if (catUp == null)
{
return(false);
}
catDown.VoteDown++;
catUp.VoteUp++;
await _context.SaveChangesAsync();
return(true);
}
public static Vote ToModel(this VoteDto vote) =>
new Vote
{
Id = Guid.Parse(vote.Id),
UserId = Guid.Parse(vote.UserId),
SuggestionId = Guid.Parse(vote.SuggestionId)
};
public async Task UpvoteTrack(VoteDto dto)
{
var playlistTrack = await _context.PlaylistTracks.SingleOrDefaultAsync(x => x.PlaylistId == dto.PlaylistId && x.TrackId == dto.TrackId);
playlistTrack.Votes++;
_context.PlaylistTracks.Update(playlistTrack);
await _context.SaveChangesAsync();
}
public async Task <List <Vote> > GetDeadListAsync(VoteDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var list = await db.Votes.Where(x => x.IsDeleted == false && x.StatusValue == VoteStatus.Processing.Value && x.Deadline < dto.OperationTime).ToListAsync(token);
return(list);
}
}
public Vote Add(VoteDto addedVote)
{
var vote = new Vote()
{
Name = addedVote.Name ?? "",
};
_domainContext.Votes.Add(vote);
return(vote);
}
public async Task UpdateAsync(Guid currentVoteId, VoteDto newVote)
{
var vote = await _domainContext.Votes.FirstOrDefaultAsync(e => e.Id == currentVoteId);
if (vote != null)
{
vote.Name = newVote.Name ?? "";
_domainContext.Votes.Update(vote);
}
}
public IActionResult PostVote([FromBody] VoteDto vote)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var currentVote = _voteRepository.AddorUpdateVote(vote);
return(Ok(currentVote));
}
public VoteDto AddorUpdateVote(VoteDto incomingVote)
{
try
{
var post = _applicationDbContext.Posts.Where(p => p.PostId == incomingVote.PostId).FirstOrDefault();
// did user vote on this post? No
if (!VoteExists(incomingVote.PostId, incomingVote.UserId))
{
if (incomingVote.UserVote == 1)
{
post.Likes++;
}
else if (incomingVote.UserVote == -1)
{
post.Likes--;
}
// add new vote
_applicationDbContext.Votes.Add(new Vote {
PostId = incomingVote.PostId, UserId = incomingVote.UserId, UserVote = incomingVote.UserVote
});
}
else
{
// get the user vote.
var previousVote = _applicationDbContext.Votes.Where(v => v.UserId == incomingVote.UserId).FirstOrDefault();
// check it.
if (incomingVote.UserVote > previousVote.UserVote)
{
post.Likes++;
post.DisLikes--;
}
else if (incomingVote.UserVote < previousVote.UserVote)
{
post.Likes--;
post.DisLikes++;// = post.DisLikes++;
}
previousVote.UserVote = incomingVote.UserVote;
// update vote
_applicationDbContext.Update(previousVote);
}
// update post
_applicationDbContext.Update(post);
_applicationDbContext.SaveChanges();
return(incomingVote);
}
catch (Exception ex)
{
_loggerRepository.Write(ex);
return(null);
}
}
public async Task CreateOrEditVote(VoteDto input)
{
if (input.Id == null || input.Id == 0)
{
await Create(input);
}
else
{
await Update(input);
}
}
protected virtual async Task Update(VoteDto input)
{
var votes = await _context.Vote.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (votes != null)
{
Vote votesDto = MappingProfile.MappingConfigurationSetups().Map <Vote>(input);
_context.Vote.Update(votesDto);
await _context.SaveChangesAsync();
}
}
public async Task <IActionResult> Create(VoteDto request)
{
var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var user = await _dbContext.Users.FindAsync(userId);
user.Vote(request.MovieId, request.Type);
await _dbContext.SaveChangesAsync();
return(Created(string.Empty, default));
}
public async Task <long> UpdateVote(VoteDto input)
{
var result = _voteRepository.GetAll().Where(x => x.Id == input.Id).FirstOrDefault();
result.FilmAndSeriesId = input.FilmAndSeriesId;
result.IsVoting = input.IsVoting;
result.Point = input.Point;
result.Description = input.Description;
await _voteRepository.UpdateAsync(result);
return(input.Id);
}
public async Task <long> AddVote(VoteDto input)
{
Vote vote = new Vote();
vote.FilmAndSeriesId = input.FilmAndSeriesId;
vote.Point = input.Point;
vote.Description = input.Description;
vote.IsVoting = true;
long id = await _voteRepository.InsertAndGetIdAsync(vote);
return(id);
}
public async Task <List <Vote> > GetAllForVipOwnerAsync(VoteDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var list = await db.Votes.Where(x => x.IsDeleted == false && x.DepartmentValue == Department.YeZhuWeiYuanHui.Value && x.StreetOfficeId == dto.StreetOfficeId && x.CommunityId == dto.CommunityId && x.SmallDistrictId == dto.SmallDistrictId).ToListAsync(token);
if (!string.IsNullOrWhiteSpace(dto.Title))
{
list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
}
return(list);
}
}
public async Task <VoteDto> GetVoteForEdit(VoteDto input)
{
var votes = await _context.Vote.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (votes != null)
{
Vote voteDto = MappingProfile.MappingConfigurationSetups().Map <Vote>(input);
_context.Vote.Update(voteDto);
await _context.SaveChangesAsync();
return(MappingProfile.MappingConfigurationSetups().Map <VoteDto>(voteDto));
}
return(new VoteDto());
}
public async Task <IActionResult> Post([FromBody] VoteDto model, int id)
{
var exists = await this.books.ExistsAsync(id);
if (!exists)
{
return(BadRequest(VoteErrorConstants.ErrorProcessingVoteMessage));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
await this.votes.VoteAsync(userId, id, model.Vote);
return(Ok());
}
public async Task <IActionResult> Change(int id, VoteDto request)
{
var vote = await _dbContext.Votes.FindAsync(id);
if (vote is null)
{
return(NotFound());
}
vote.SetVoteType(request.Type);
await _dbContext.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Vote([FromBody] VoteDto voteDto, CancellationToken ct)
{
var vote = await _context.Votes
.FirstOrDefaultAsync(v => v.CommentId == voteDto.CommentId && v.User == voteDto.User, ct)
.ConfigureAwait(false);
if (vote != null)
{
await UpdateExistingVote(voteDto, vote, ct);
}
else
{
await AddNewVote(voteDto, ct);
}
return(Accepted());
}
public async Task <Round> ExpeditonVote(VoteDto model)
{
Game g = GameStore.GetGame(model.GameId);
g.CurrentRound.ExpeditionVote(model.Vote);
if (g.CurrentRound.TotalMissionVotes >= g.CurrentRound.CurrentTeam.Count)
{
await ExpeditionResults(g);
}
else
{
GameStore.AddOrUpdateGame(g);
await _gameHub.Clients.Group(model.GameId.ToString()).SendAsync("UpdateHost");
}
return(g.CurrentRound);
}
public async Task <Round> VoteForTeam(VoteDto model)
{
Game g = GameStore.GetGame(model.GameId);
g.CurrentRound.TeamVote(model.Vote);
if (g.CurrentRound.TotalTeamVotes >= g.Players.Count)
{
await VoteForTeamResults(g);
}
else
{
GameStore.AddOrUpdateGame(g);
await _gameHub.Clients.Group(model.GameId.ToString()).SendAsync("UpdateHost");
}
return(g.CurrentRound);
}
public IActionResult GetVote([FromBody] VoteDto vote)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Vote checkVote = new Vote { PostId = postId, UserId = userId };
var castVote = _voteRepository.GetVote(vote);
//if (castVote == null)
//{
// return NotFound();
//}
return(Ok(castVote));
}
private async Task AddNewVote(VoteDto voteDto, CancellationToken ct)
{
var vote = _mapper.Map <Vote>(voteDto);
_context.Votes.Add(vote);
await _context.SaveChangesAsync(ct);
if (vote.Value > 0)
{
await _context.AddUpVoteAsync(voteDto.CommentId, ct).ConfigureAwait(false);
}
else
{
await _context.AddDownVoteAsync(voteDto.CommentId, ct).ConfigureAwait(false);
}
}
public IHttpActionResult VoteAction(VoteDto voteDto)
{
var userId = User.Identity.GetUserId();
var question = _unitOfWork.Questions.GetQuestionByQuestionId(voteDto.QuestionId);
var isVote = question != null && question.Votes.Any(v => v.UserId == userId);
if (isVote)
{
var userVote = question.Votes.SingleOrDefault(v => v.UserId == userId);
if (userVote == null)
{
return(Ok());
}
var userVoteState = userVote.VoteState;
var canVote = userVoteState + voteDto.VoteAction == 0 || userVoteState == 0;
if (!canVote)
{
return(Json(new { isVoteUp = true }));
}
userVote.VoteState += voteDto.VoteAction;
_unitOfWork.Complete();
if (userVote.VoteState == 0)
{
return(Json(new { isRollBack = true }));
}
return(Ok());
}
var vote = new Vote()
{
QuestionId = voteDto.QuestionId,
UserId = userId,
DateTime = DateTime.Now,
VoteState = voteDto.VoteAction
};
_unitOfWork.Votes.Add(vote);
_unitOfWork.Complete();
return(Ok());
}