Пример #1
0
        public void RefreshBallotStatuses()
        {
            new BallotCacher(Db).DropThisCache();
            new VoteCacher(Db).DropThisCache();

            // first refresh person vote statuses
            new PeopleModel().EnsureFlagsAreRight(People, _hub, Savers.PersonSaver);

            // then refresh all votes
            _hub.StatusUpdate("Reviewing votes");
            VoteAnalyzer.UpdateAllStatuses(VoteInfos, Votes, Savers.VoteSaver);

            // then refresh all ballots
            _hub.StatusUpdate("Reviewing ballots");
            var ballotAnalyzer = new BallotAnalyzer(TargetElection, Savers.BallotSaver);

            ballotAnalyzer.UpdateAllBallotStatuses(Ballots, VoteInfos);

            Db.SaveChanges();
        }
    public JsonResult DeleteVote(int vid)
    {
      var voteInfo =
        Db.vVoteInfoes.SingleOrDefault(vi => vi.ElectionGuid == UserSession.CurrentElectionGuid && vi.VoteId == vid);
      if (voteInfo == null)
      {
        return new { Message = "Not found" }.AsJsonResult();
      }

      var vote = Db.Votes.Single(v => v.C_RowId == vid);
      Db.Votes.Remove(vote);
      Db.SaveChanges();

      UpdateVotePositions(voteInfo.BallotGuid);

      var ballotAnalyzer = new BallotAnalyzer();
      var ballotStatusInfo = ballotAnalyzer.UpdateBallotStatus(CurrentRawBallot(), VoteInfosForCurrentBallot());
      var isSingleName = UserSession.CurrentElection.IsSingleNameElection;
      var sum = isSingleName
            ? Db.vVoteInfoes.Where(vi => vi.LocationId == voteInfo.LocationId).Sum(vi => vi.SingleNameElectionCount)
            : Db.vBallotInfoes.Count(b => b.LocationId == voteInfo.LocationId);

      return new
               {
                 Deleted = true,
                 Votes = CurrentVotesForJs(),
                 BallotStatus = ballotStatusInfo.Status.Value,
                 BallotStatusText = ballotStatusInfo.Status.DisplayText,
                 ballotStatusInfo.SpoiledCount,
                 LocationBallotsEntered = sum
               }.AsJsonResult();
    }
    public JsonResult SaveVote(int personId, int voteId, int count, Guid invalidReason)
    {
      var currentElectionGuid = UserSession.CurrentElectionGuid;
      var isSingleName = UserSession.CurrentElection.IsSingleNameElection;

      if (voteId != 0)
      {
        // update existing record

        // find info about the existing Vote
        var voteInfo =
          Db.vVoteInfoes.SingleOrDefault(vi => vi.VoteId == voteId && vi.ElectionGuid == currentElectionGuid);

        if (voteInfo == null)
        {
          // problem... client has a vote number, but we didn't find...
          return new { Updated = false, Error = "Invalid vote id" }.AsJsonResult();
        }

        Db.Detach(voteInfo);

        var rawVote = Db.Votes.Single(v => v.C_RowId == voteInfo.VoteId);

        voteInfo.SingleNameElectionCount = count;
        rawVote.SingleNameElectionCount = count;

        rawVote.PersonCombinedInfo = voteInfo.PersonCombinedInfo;

        DetermineInvalidReasonGuid(invalidReason, rawVote);

        Db.SaveChanges();

        var ballotAnalyzer = new BallotAnalyzer();
        var ballotStatusInfo = ballotAnalyzer.UpdateBallotStatus(CurrentRawBallot(), VoteInfosForCurrentBallot());
        var sum = isSingleName
                    ? Db.vVoteInfoes.Where(vi => vi.LocationId == voteInfo.LocationId).Sum(vi => vi.SingleNameElectionCount)
                    : Db.vBallotInfoes.Count(b => b.LocationId == voteInfo.LocationId);

        return new
                 {
                   Updated = true,
                   BallotStatus = ballotStatusInfo.Status.Value,
                   BallotStatusText = ballotStatusInfo.Status.DisplayText,
                   ballotStatusInfo.SpoiledCount,
                   LocationBallotsEntered = sum
                 }.AsJsonResult();
      }

      var ballot = GetCurrentBallotInfo();
      if (ballot == null)
      {
        return new { Updated = false, Error = "Invalid ballot" }.AsJsonResult();
      }

      // don't have an active Ballot!
      // make a new Vote record

      var invalidReasonGuid = DetermineInvalidReasonGuid(invalidReason);

      var person = Db.People.SingleOrDefault(p => p.C_RowId == personId && p.ElectionGuid == currentElectionGuid);

      var ok = person != null || invalidReasonGuid != Guid.Empty;

      if (ok)
      {
        var nextVoteNum = 1 + Db.Votes.Where(v => v.BallotGuid == ballot.BallotGuid)
                                .OrderByDescending(v => v.PositionOnBallot)
                                .Take(1)
                                .Select(b => b.PositionOnBallot)
                                .SingleOrDefault();

        var vote = new Vote
                     {
                       BallotGuid = ballot.BallotGuid,
                       PositionOnBallot = nextVoteNum,
                       StatusCode = VoteHelper.VoteStatusCode.Ok,
                       SingleNameElectionCount = count
                     };
        if (person != null)
        {
          vote.PersonGuid = person.PersonGuid;
          vote.PersonCombinedInfo = person.CombinedInfo;
          vote.InvalidReasonGuid = VoteHelperLocal.IneligibleToReceiveVotes(person.IneligibleReasonGuid, person.CanReceiveVotes);
        }
        if (invalidReasonGuid != Guid.Empty)
        {
          vote.InvalidReasonGuid = invalidReasonGuid.AsNullableGuid();
        }
        Db.Votes.Add(vote);
        Db.SaveChanges();

        var ballotAnalyzer = new BallotAnalyzer();
        var ballotStatusInfo = ballotAnalyzer.UpdateBallotStatus(CurrentRawBallot(), VoteInfosForCurrentBallot());

        var sum = isSingleName
                    ? Db.vVoteInfoes.Where(vi => vi.LocationId == ballot.LocationId).Sum(vi => vi.SingleNameElectionCount)
                    : Db.vBallotInfoes.Count(b => b.LocationId == ballot.LocationId);

        return new
                 {
                   Updated = true,
                   VoteId = vote.C_RowId,
                   pos = vote.PositionOnBallot,
                   BallotStatus = ballotStatusInfo.Status.Value,
                   BallotStatusText = ballotStatusInfo.Status.DisplayText,
                   ballotStatusInfo.SpoiledCount,
                   LocationBallotsEntered = sum
                 }.AsJsonResult();
      }

      // don't recognize person id
      return new { Updated = false, Error = "Invalid person" }.AsJsonResult();
    }
    public JsonResult SetNeedsReview(bool needsReview)
    {
      var ballot = CurrentRawBallot();

      ballot.StatusCode = needsReview ? BallotStatusEnum.Review : BallotStatusEnum.Ok;

      var ballotAnalyzer = new BallotAnalyzer();
      var ballotStatusInfo = ballotAnalyzer.UpdateBallotStatus(ballot, VoteInfosForCurrentBallot());

      Db.SaveChanges();

      return new
               {
                 BallotStatus = ballotStatusInfo.Status.Value,
                 BallotStatusText = ballotStatusInfo.Status.DisplayText,
                 ballotStatusInfo.SpoiledCount
               }.AsJsonResult();
    }
    public void HasDuplicates2_KeepStatusCode_Test()
    {
      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };


      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;

      // keep Review
      int spoiledCount;
      model.DetermineStatusFromVotesList(BallotStatusEnum.Review, votes, out newStatus, out spoiledCount).ShouldEqual(false);
      newStatus.ShouldEqual(BallotStatusEnum.Review);
      spoiledCount.ShouldEqual(0);

      // override OK
      model.DetermineStatusFromVotesList(BallotStatusEnum.Ok, votes, out newStatus, out spoiledCount).ShouldEqual(true);
      newStatus.ShouldEqual(BallotStatusEnum.TooFew);
      spoiledCount.ShouldEqual(0);
    }
    public void AllSpoiled_Test()
    {
      var dupPersonGuid = Guid.NewGuid();

      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonIneligibleReasonGuid = Guid.NewGuid()},
                      new vVoteInfo {VoteIneligibleReasonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonIneligibleReasonGuid = Guid.NewGuid()},
                    };

      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(BallotStatusEnum.Ok, votes, out newStatus, out spoiledCount).ShouldEqual(false);

      newStatus.ShouldEqual(BallotStatusEnum.Ok);
      spoiledCount.ShouldEqual(3);
    }
    public void HasDuplicates_and_Too_Many_Test()
    {
      var dupPersonGuid = Guid.NewGuid();

      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = dupPersonGuid},
                      new vVoteInfo {PersonGuid = dupPersonGuid},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };

      var model = new BallotAnalyzer(5, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(BallotStatusEnum.Ok, votes, out newStatus, out spoiledCount).ShouldEqual(true);

      newStatus.ShouldEqual(BallotStatusEnum.TooMany);
    }
    public void KeepReviewStatus_Test()
    {
      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };

      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(BallotStatusEnum.Review, votes, out newStatus, out spoiledCount).ShouldEqual(false);
      newStatus.ShouldEqual(BallotStatusEnum.Review);


      votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };

      model.DetermineStatusFromVotesList(BallotStatusEnum.Review, votes, out newStatus, out spoiledCount).ShouldEqual(false);
      newStatus.ShouldEqual(BallotStatusEnum.Review);
    }
    public void TooFewNumberOfVotesWithBlank_Test()
    {
      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo {VoteIneligibleReasonGuid = IneligibleReasonEnum.Unreadable_Vote_is_blank},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };

      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(null, votes, out newStatus, out spoiledCount).ShouldEqual(true);

      newStatus.ShouldEqual(BallotStatusEnum.TooFew);
      spoiledCount.ShouldEqual(0);
    }
    public void EmptyNumberOfVotes_Test()
    {
      var votes = new List<vVoteInfo>
                    {
                    };

      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(null, votes, out newStatus, out spoiledCount).ShouldEqual(true);

      newStatus.ShouldEqual(BallotStatusEnum.Empty);
    }
    public void SingleIneligible_Test()
    {
      var votes = new List<vVoteInfo>
                    {
                      new vVoteInfo
                        {
                          VoteIneligibleReasonGuid = IneligibleReasonEnum.Unreadable_Not_a_complete_name,
                          SingleNameElectionCount = 4
                        },
                    };

      var model = new BallotAnalyzer(1, _fakes.SaveChanges, true);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(null, votes, out newStatus, out spoiledCount).ShouldEqual(true);

      newStatus.ShouldEqual(BallotStatusEnum.Ok);
    }
    public void TooManyNumberOfVotes_Test()
    {
      var voteInfos = new List<vVoteInfo>
                    {
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                      new vVoteInfo {PersonGuid = Guid.NewGuid()},
                    };

      var model = new BallotAnalyzer(3, _fakes.SaveChanges, false);

      string newStatus;
      int spoiledCount;
      model.DetermineStatusFromVotesList(null, voteInfos, out newStatus, out spoiledCount).ShouldEqual(true);

      newStatus.ShouldEqual(BallotStatusEnum.TooMany);
      spoiledCount.ShouldEqual(0);
    }