// GET: Votes
public async Task <IActionResult> Index()
{
List <Vote> votes = _context.Vote.OrderByDescending(m => m.Id).ToList();
List <VoteViewModel> displayedVotes = new List <VoteViewModel>();
foreach (Vote vote in votes)
{
Expression expression = _context.Expression.Find(vote.ExpressionId);
ExpressionViewModel viewExpression = new ExpressionViewModel();
viewExpression.Id = expression.Id;
viewExpression.Original = expression.Original;
viewExpression.Regional = expression.Regional;
viewExpression.User = _context.User.Find(expression.UserId);
viewExpression.Region = _context.Region.Find(expression.RegionId);
VoteViewModel displayVote = new VoteViewModel();
displayVote.Id = vote.Id;
displayVote.User = _context.User.Find(vote.UserId);
displayVote.Expression = viewExpression;
displayedVotes.Add(displayVote);
}
return(View(displayedVotes));
}
public async Task <IActionResult> Index([FromServices] BattleGenerator battleGenerator)
{
var battle = await battleGenerator.GenerateBattleAsync();
if (battle == null)
{
_logger.LogWarning("No battle found");
return(View("Empty"));
}
_logger.LogInformation($"Requesting {battle.Dog.Name} vs {battle.Cat.Name}");
var model = new VoteViewModel
{
DogId = battle.Dog.Id,
DogName = battle.Dog.Name,
DogImagePath = battle.Dog.Image,
CatId = battle.Cat.Id,
CatName = battle.Cat.Name,
CatImagePath = battle.Cat.Image
};
return(View(model));
}
public void Has_readable_and_settable_properties()
{
// Act
var vm = new VoteViewModel()
{
Id = 1,
Title = "Title",
ApprovalPercentage = "60",
ShortDescription = "Short",
ApprovalPercentageColor = "text-success",
VoteCount = 1460,
UpvoteButtonColor = "btn-success",
DownvoteButtonColor = "btn-danger",
};
// Assert
Assert.AreEqual(1, vm.Id);
Assert.AreEqual("Title", vm.Title);
Assert.AreEqual("60", vm.ApprovalPercentage);
Assert.AreEqual("Short", vm.ShortDescription);
Assert.AreEqual("text-success", vm.ApprovalPercentageColor);
Assert.AreEqual(1460, vm.VoteCount);
Assert.AreEqual("btn-success", vm.UpvoteButtonColor);
Assert.AreEqual("btn-danger", vm.DownvoteButtonColor);
}
public ActionResult PostVote(VoteViewModel voteUpViewModel)
{
if (Request.IsAjaxRequest())
{
// Quick check to see if user is locked out, when logged in
if (CurrentMember.IsLockedOut | !CurrentMember.IsApproved)
{
ServiceFactory.MemberService.LogOff();
throw new Exception(Lang("Errors.NoAccess"));
}
using (var unitOfWork = UnitOfWorkManager.NewUnitOfWork())
{
// Firstly get the post
var post = ServiceFactory.PostService.Get(voteUpViewModel.Post);
var allowedToVote = (CurrentMember.Id != post.MemberId &&
CurrentMember.TotalPoints > Settings.AmountOfPointsBeforeAUserCanVote &&
post.Votes.All(x => x.MemberId != CurrentMember.Id));
if (allowedToVote)
{
// Now get the current user
var voter = CurrentMember;
// Also get the user that wrote the post
var postWriter = ServiceFactory.MemberService.Get(post.MemberId);
// Mark the post up or down
var returnValue = string.Empty;
if (voteUpViewModel.IsVoteUp)
{
returnValue = MarkPostUpOrDown(post, postWriter, voter, PostType.Positive);
}
else
{
returnValue = MarkPostUpOrDown(post, postWriter, voter, PostType.Negative);
}
try
{
unitOfWork.Commit();
return(Content(returnValue));
}
catch (Exception ex)
{
unitOfWork.Rollback();
LogError(ex);
}
}
else
{
//return Content(post.VoteCount.ToString());
return(Content(string.Empty));
}
}
}
throw new Exception("Something went wrong. Please try again");
}
private async void Vote(object sender, EventArgs e)
{
Button btn = sender as Button;
VoteViewModel vote = new VoteViewModel()
{
ProjectId = Model.Id.ToString(),
Value = btn.Text
};
var result = await ApiService.Transactions.Vote(vote);
if (result.IsSuccess)
{
Alert.Send("Vot enviat");
Contributions.Remove(btn);
btn.IsEnabled = false;
btn.IsVisible = false;
}
else
{
Alert.Send("Hi ha hagut un error al processar el vot");
btn.IsEnabled = true;
}
}
public IHttpActionResult Post(VoteViewModel voteViewModel)
{
try
{
var identityClaims = (ClaimsIdentity)HttpContext.Current.User.Identity;
string userObj = identityClaims.FindFirst("userObject").Value;
var userLogged = JsonConvert.DeserializeObject <UserBE>(userObj);
var uvm = Mapper.Map <UserBE, UserViewModel>(userLogged);
voteViewModel.User = uvm;
var result = this.voteBLL.Add(voteViewModel);
if (result == Guid.Empty)
{
throw new Exception(Messages.Generic_Error);
}
var response = Request.CreateResponse(System.Net.HttpStatusCode.OK, Messages.SuccessfulUperationCrud);
return(this.ResponseMessage(response));
}
catch (Exception ex)
{
var response = Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, Messages.Generic_Error);
return(this.ResponseMessage(response));
}
}
public ActionResult Index(int?surveyId = null)
{
ViewBag.surveyId = surveyId;
if (surveyId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//活动信息
var activitySurvey = db.Activity_Surveys.Find(surveyId);
if (activitySurvey == null)
{
return(HttpNotFound());
}
var Activity_SurveyChoiceTopic = db.Activity_SurveyChoiceTopics.Include("Options").FirstOrDefault(p => p.SurveyId == surveyId);
VoteViewModel vote = new VoteViewModel();
//foreach (var option in Activity_SurveyChoiceTopic.Options)
//{
// vote.VoteOption.Add(option as Activity_SurveyOption);
//}
//取出投票活动的所有选项
vote.VoteOption = Activity_SurveyChoiceTopic.Options;
vote.AllowNumberPerDay = activitySurvey.AllowNumberPerDay;
vote.AllowNumberPerPerson = activitySurvey.AllowNumberPerPerson;
vote.Title = activitySurvey.Title;
vote.StartTime = activitySurvey.StartTime;
vote.EndTime = activitySurvey.EndTime;
vote.Voter = WeiChatApplicationContext.Current.WeiChatUser.NickName;
return(View(vote));
}
/// <summary>
/// Saves vote information to database
/// </summary>
/// <param name="vm">The VoteViewModel containing all the info</param>
/// <returns>True if the SQL command ran successfully, False otherwise</returns>
public bool Vote(VoteViewModel vm)
{
bool inserted = false;
try
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
//Command To Vote For A specified Park
SqlCommand command = new SqlCommand("UPDATE parkVotes SET votes = votes + 1 WHERE parkCode = @parkCode", connection);
command.Parameters.AddWithValue("@parkCode", vm.Code);
command.ExecuteNonQuery();
//Second Command to save survey information
SqlCommand command2 = new SqlCommand("INSERT INTO survey (parkCode, email, stateAbbreviation, activity) VALUES (@parkCode, @email, @stateAbbreviation, @activity)" + _getLastIdSQL, connection);
command2.Parameters.AddWithValue("@parkCode", vm.Code);
command2.Parameters.AddWithValue("@email", vm.Email);
command2.Parameters.AddWithValue("@stateAbbreviation", vm.State);
command2.Parameters.AddWithValue("@activity", vm.Activity);
command2.ExecuteScalar();
inserted = true;
}
}
catch (SqlException ex)
{
Console.Error.WriteLine($"An error occurred voting");
throw;
}
return(inserted);
}
public void Update(VoteViewModel model)
{
var mapper = CustomMapperConfiguration.ConfigCreateMapper <VoteViewModel, Vote>();
var vote = mapper.Map <VoteViewModel, Vote>(model);
_votesRepository.Update(vote);
}
private Vote GetVoteFromDatabase(string userId, VoteViewModel model)
{
var vote = this.votes.All()
.Where(v => v.AuthorId == userId && v.PostId == model.PostId)
.FirstOrDefault();
return vote;
}
public async Task <IActionResult> Index(VoteViewModel vote)
{
try
{
vote.Restaurants = await RestService.For <IAPIVotingSystemRestaurant>("https://localhost:44381/APISystemVoting/").GetRestaurantsAvailableAsync();
vote.Users = await RestService.For <IAPIVotingSystemUser>("https://localhost:44381/APISystemVoting/").GetUsersAsync();
if (string.IsNullOrEmpty(vote.SelectedIdUser))
{
ViewBag.Message = "Select User Please!";
return(View(vote));
}
if (string.IsNullOrEmpty(vote.SelectedIdRestaurant))
{
ViewBag.Message = "Select Restaurant Please!";
return(View(vote));
}
vote.DateVote = DateTime.UtcNow.AddHours(-3);
var IdUser = Convert.ToInt32(vote.SelectedIdUser);
var IdRestaurant = Convert.ToInt32(vote.SelectedIdRestaurant);
//Verificar se valida antes das 11:45
ViewBag.Message = await RestService.For <IAPIVotingSystemVote>("https://localhost:44381/APISystemVoting/")
.InsertVoteAsync(IdUser, IdRestaurant);
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
}
return(View(vote));
}
public QuestionViewModel GetQuestionByQuestionID(int QuestionID, int UserID = 0)
{
Question q = qr.GetQuestionByQuestionID(QuestionID).FirstOrDefault();
QuestionViewModel qvm = null;
if (q != null)
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <Question, QuestionViewModel>();
cfg.CreateMap <User, UserViewModel>();
cfg.CreateMap <Category, CategoryViewModel>();
cfg.CreateMap <Answer, AnswerViewModel>();
cfg.CreateMap <Vote, VoteViewModel>();
cfg.IgnoreUnmapped();
});
IMapper mapper = config.CreateMapper();
qvm = mapper.Map <Question, QuestionViewModel>(q);
foreach (var item in qvm.Answers)
{
item.CurrentUserVoteType = 0;
VoteViewModel vote = item.Votes.Where(temp => temp.UserID == UserID).FirstOrDefault();
if (vote != null)
{
item.CurrentUserVoteType = vote.VoteValue;
}
}
}
return(qvm);
}
public ActionResult Post([FromBody] VoteViewModel vote)
{
if (vote == null)
{
return(BadRequest("Object to create is missing"));
}
if (vote.Feeling == null)
{
return(BadRequest("Feeling property missing"));
}
if (vote.Work == null)
{
return(BadRequest("Work property missing"));
}
var finalVote = Mapper.Map <Entities.Vote>(vote);
_votesRepository.AddVote(finalVote);
if (!_votesRepository.Save())
{
return(StatusCode(500, "A problem happened while handling your request."));
}
var createdVote = Mapper.Map <Models.VoteViewModel>(finalVote);
return(Ok(finalVote));
}
public ActionResult Vote(bool voteValue, int feedbackId)
{
VoteViewModel voteViewModel = new VoteViewModel
{
Value = voteValue,
FeedbackId = feedbackId,
OwnerId = User.Identity.GetUserId()
};
Mapper.Initialize(cfg => cfg.CreateMap <VoteViewModel, VoteDto>());
var voteDto = Mapper.Map <VoteViewModel, VoteDto>(voteViewModel);
bool successVote = _feedbackService.Vote(voteDto);
ViewBag.successVote = successVote;
var feedbackDto = _feedbackService.GetFeedbackById(feedbackId);
var feedbackViewModel = new FeedbackViewModel {
Id = feedbackId,
Text = feedbackDto.Text,
Date = feedbackDto.Date,
Rating = feedbackDto.Rating,
OwnerId = feedbackDto.OwnerId,
Owner = feedbackDto.Owner
};
return(PartialView("VoteBar", feedbackViewModel));
}
public ActionResult Vote(VoteViewModel model, IFormFile photo)
{
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(model.Name) && model.IsAttend)
{
string filename = null;
if (photo != null)
{
var ext = Path.GetExtension(photo.FileName);
filename = $@"{Guid.NewGuid()}{ext}";
var path = Path.Combine(_env.WebRootPath, "images", filename);
using (var fileStream = new FileStream(path, FileMode.Create))
{
photo.CopyTo(fileStream);
}
}
PartyService.Vote(model.PartyId, model.Name, model.IsAttend, filename);
Logger.Info($"{model.Name} -> {PartyService.GetParty(model.PartyId).Name} : {model.IsAttend}");
}
return(RedirectToAction("Index", new { id = model.PartyId }));
}
var party = PartyService.GetParty(model.PartyId);
var attendants = PartyService.ListAttendants(party.Id).Select(x => (x.Name, x.Avatar)).ToList();
var partyModel = new PartyDetailsViewModel {
PartyId = party.Id, Date = party.Date, Title = party.Name, Location = party.Location, Attendants = attendants
};
return(View("Index", partyModel));
}
public async Task <IActionResult> Index(VoteFilterViewModel viewModel)
{
var votes = new List <Vote>();
if (viewModel.DateToShow == DateTime.MinValue)
{
votes = await _context.Votes.OrderBy(x => x.Date).ToListAsync();
}
else
{
votes = await _context.Votes.Where(x => x.Date == viewModel.DateToShow).OrderBy(x => x.VoteNumberOfTheDay).ToListAsync();
}
var voteFilterViewModel = new VoteFilterViewModel()
{
Votes = new List <VoteViewModel>(),
DateToShow = viewModel.DateToShow
};
foreach (var vote in votes)
{
var voteViewModel = new VoteViewModel
{
VoteId = vote.VoteId,
Name = vote.Name,
Code = vote.Code,
Date = vote.Date,
VoteNumberOfTheDay = vote.VoteNumberOfTheDay,
VoteResults = _context.VoteResults.Where(x => x.VoteId == vote.VoteId).Include(x => x.Parliamentarian).ToList()
};
voteFilterViewModel.Votes.Add(voteViewModel);
}
return(View(voteFilterViewModel));
}
// GET: Votes/Details/5
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var vote = await _context.Votes
.FirstOrDefaultAsync(m => m.VoteId == id);
if (vote == null)
{
return(NotFound());
}
var voteViewModel = new VoteViewModel
{
VoteId = vote.VoteId,
Name = vote.Name,
Code = vote.Code,
Date = vote.Date,
VoteNumberOfTheDay = vote.VoteNumberOfTheDay,
VoteResults = _context.VoteResults.Where(x => x.VoteId == vote.VoteId).Include(x => x.Parliamentarian).ToList()
};
return(View(voteViewModel));
}
private ActionResult LikeOrDIslikeMovie(VoteViewModel vote, bool isItLike)
{
if (vote == null || vote.MovieId == default(Guid))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, Constants.MovieNotExists));
}
if (string.IsNullOrWhiteSpace(vote.UserName))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, Constants.UserNotExists));
}
var userName = vote.UserName;
var movieId = vote.MovieId;
var result = this.voteSv.LikeOrDislikeAMovie(userName, movieId, isItLike);
HttpStatusCode stCode = HttpStatusCode.OK;
if (result.ResulType != ResultType.Success)
{
stCode = HttpStatusCode.InternalServerError;
}
return(new HttpStatusCodeResult(stCode, result.ErrorMsg));
}
public async Task <Guid> AddOrUpdate(VoteViewModel model)
{
var userId = (await applicationUserService.GetAsQueriable()).Where(x => x.UserId == model.ApplicationUserId).Select(x => x.Id).FirstOrDefault();
if (userId == Guid.Empty)
{
userId = await applicationUserService.Add(new ApplicationUser
{
UserId = model.ApplicationUserId,
Username = model.ApplicationUserId,
CredibilityScore = 50
});
}
var newsArtileId = (await newsArticleService.GetAsQueriable()).Where(n => n.Source == model.NewsArticleUrl).Select(q => q.Id).FirstOrDefault();
if (newsArtileId == Guid.Empty)
{
throw new Exception("Invalid Article Url");
}
var vote = (await GetAsQueriable()).Where(x => x.ApplicationUserId == userId).FirstOrDefault();
if (vote == null)
{
return(await Add(new Vote { ApplicationUserId = userId, NewsArticleId = newsArtileId, IsTrue = model.IsTrue }));
}
else
{
vote.IsTrue = model.IsTrue;
return(await Update(vote));
}
}
public async Task <ActionResult> VoteOnNomination(VoteViewModel voteViewModel)
{
if (voteViewModel.Vote.Id != 0)
{
VoteAPI.Update(voteViewModel.Vote);
}
else if (voteViewModel.Vote.Id == 0)
{
VoteAPI.Create(voteViewModel.Vote);
}
;
Nomination nomination = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
YearCategoryModel returnParameters = new YearCategoryModel(nomination.Year, nomination.AwardCategory);
Nomination nominationVotedFor = await NominationAPI.GetById(voteViewModel.Vote.NominationId);
RecommendationViewModel recommendationViewModel = new RecommendationViewModel()
{
Year = nominationVotedFor.Year,
Category = nominationVotedFor.AwardCategory
};
recommendationViewModel.Movie = await MovieAPI.GetById(nominationVotedFor.MovieId);
recommendationViewModel.MovieId = recommendationViewModel.Movie.Id;
return(RedirectToAction(nameof(MovieRecommendation), recommendationViewModel));
}
/// <summary>
/// Register Vote
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
public async Task RegisterVote(VoteRequestViewModel record)
{
Campaign campaign = await campaignRepository.Retrieve(record.CompanyId, record.CampaignId);
if (campaign == null)
{
throw new NotFoundException();
}
VoteViewModel vote = new VoteViewModel();
vote.CampaignId = record.CampaignId;
vote.CompanyId = record.CompanyId;
vote.CampaignOptionId = record.CampaignOptionId;
if (campaign.Auth)
{
string identity = Encryptor.Encrypt(string.Join(Environment.NewLine, record.VoterIdentity));
if (await HasAlreadyVoted(vote.CampaignId, identity))
{
throw new NonUniqueRecordException();
}
vote.VoterIdentity = identity;
}
await voteRepository.RegisterVote(Mapper.Map <Vote>(vote));
}
public async Task <IActionResult> Vote([FromRoute] string id)
{
//return Redirect(urlToRedirect);
if (string.IsNullOrEmpty(id))
{
return(RedirectToAction("Index"));
}
var token = await _voteTokensRepository.FindTokenAsync(id);
if (token == null)
{
return(RedirectToAction("Index"));
}
var vote = await _votesRepository.GetAsync(token.Email);
if (vote != null)
{
return(RedirectToAction("Success"));
}
var viewModel = new VoteViewModel
{
Token = id,
User = token.FullName
};
return(View("Vote", viewModel));
}
public void TestSubmitCommandEmptyCollection()
{
var voteToSubmit = new Vote {
Questionnaire = new Questionnaire {
Deadline = DateTime.MaxValue
}
};
var dialogShown = false;
var messageShown = "";
var stubIDialogService = new StubIDialogService();
stubIDialogService.ShowAsync(async message => {
dialogShown = true;
messageShown = message;
});
var voteViewModel =
new VoteViewModel(stubIDialogService, null, null, null);
voteViewModel.Vote = voteToSubmit;
voteViewModel.SubmitCommand.Execute(null);
Assert.IsTrue(dialogShown);
Assert.AreEqual(VoteViewModel.AnswerCollectionEmptyErrorMessage,
messageShown);
}
/// <summary>
/// 儲存投票最後一筆資訊
/// </summary>
public VoteViewModel SaveLastVoteData(string outerKey)
{
var motionDeviceService = new MotionDeviceService();
var lastData = motionDeviceService.GetInteractiveData();
var response = new VoteViewModel();
if (lastData == null || lastData.Data.FirstOrDefault() == null)
{
return(null);
}
var eventId = Utility.OuterKeyHelper.CheckOuterKey(outerKey);
var participateCount = 0.00;
if (eventId != null && eventId != Guid.Empty)
{
var voteData = _uow.ActVoteRepo.GetFirst(t => t.EventId == eventId);
if (voteData != null)
{
voteData.PresentCount = Convert.ToInt32(lastData.PresentCount);
var voteItemData = _uow.ActVoteItemRepo.Get(t => t.ActVoteId == voteData.Id).ToList().OrderBy(t => t.Sort);
if (voteItemData.FirstOrDefault() != null)
{
voteItemData = ItemCalculateProxy(voteItemData, lastData, out participateCount);
}
_uow.SaveChanges();
}
response = GetDetail(outerKey);
}
return(response);
}
public IActionResult Vote([FromBody] VoteViewModel model)
{
Project ProjectToSearch = db.Projects.Where(x => x.Id.ToString() == model.ProjectId).Include(x => x.Forum).FirstOrDefault();
if (ProjectToSearch is null)
{
return(BadRequest(Message.GetMessage("Aquest projecte no existeix.")));
}
Forum ForumToSearch = ProjectToSearch.Forum;
if (ForumToSearch is null)
{
return(BadRequest(Message.GetMessage("Aquest projecte no esta inscrit a cap forum per poder votar-lo.")));
}
User user = userGetter.GetUser();
if (user is null)
{
return(BadRequest(Message.GetMessage("T'has de loguejar per poder votar.")));
}
Wallet WalletToSearch = db.Wallets.Where(x => x.ForumId == ForumToSearch.Id && x.UserId == user.Id).FirstOrDefault();
if (WalletToSearch is null)
{
return(BadRequest(Message.GetMessage("El usuari no participa en el forum per podar votar en el projecte.")));
}
BillOption BillToSearch = db.BillOptions.Where(x => x.Value == int.Parse(model.Value) && x.WalletId == WalletToSearch.Id).FirstOrDefault();
if (BillToSearch is null)
{
return(BadRequest(Message.GetMessage("El usuari no te aquesta opció de vot.")));
}
/*if (ForumToSearch.DateBeginsVote.Date >= DateTime.Now.Date && DateTime.Now.Date <= ForumToSearch.DateEndsVote.Date)
* {*/
Vote vote = new Vote
{
ImgUri = BillToSearch.ImgUri,
Name = BillToSearch.Name,
Value = BillToSearch.Value,
Project = ProjectToSearch
};
ProjectToSearch.TotalMoney += vote.Value;
db.Remove(BillToSearch);
db.Votes.Add(vote);
db.Projects.Update(ProjectToSearch);
db.SaveChanges();
return(new JsonResult(Message.GetMessage("El vot s'ha realitzat correctament.")));
//}
return(BadRequest(Message.GetMessage("No s'ha pogut realitzar el vot perquè la data actual no està dintre del termini de vot del Forum.")));
}
public void UpdateVote(VoteViewModel voteModel)
{
Vote voteEntityToUpdate = this._voteRepository.GetVoteById(voteModel.Id);
voteEntityToUpdate.VoteValue = voteModel.VoteValue;
this._voteRepository.SaveChanges();
}
public ActionResult Vote(VoteViewModel model)
{
PartyService.Vote(model.PartyId, model.Name, model.IsAttend == "on");
Logger.Info($"{model.Name} -> {PartyService.GetParty(model.PartyId).Title} : {model.IsAttend == "on"}");
return(RedirectToAction("Index", new { id = model.PartyId }));
}
/// <summary>
/// Convert VoteViewModel to Vote and cast vote to the DB
/// </summary>
/// <param name="vote">VoteViewModel to be mapped and added</param>
public async Task <VoteViewModel> CastVote(VoteViewModel vote)
{
var voteId = await _voteRepository.AddVote(VoteViewModel.ToDataModel(vote));
Vote voteVM = _voteRepository.GetVote(voteId);
return(VoteViewModel.ToViewModel(voteVM));
}
internal VoteWindow(Voter voter)
{
_voteViewModel = new VoteViewModel();
this.DataContext = _voteViewModel;
InitializeComponent();
_voter = voter;
}
public async Task Put(VoteViewModel model)
{
try
{
await VoteService.AddOrUpdate(model);
}
catch { Response.StatusCode = StatusCodes.Status400BadRequest; }
}
