private void WriteAttendInfo(XmlTextWriter xmlWriter, int scannerSerialNumber, Voting.Election election)
{
foreach (var blank in _electionManager.SourceData.Blanks)
{
if (election != null &&
_electionManager.SourceData.GetBlankIdByElectionNumber(election.ElectionId) != blank.Id)
{
continue;
}
var mask = new VoteKey
{
ScannerSerialNumber = scannerSerialNumber,
BlankId = blank.Id
};
xmlWriter.WriteStartElement("Bulletin");
xmlWriter.WriteAttributeString("id", blank.Id);
xmlWriter.WriteAttributeString("n", XmlConvert.ToString(blank.Marker));
mask.BlankType = BlankType.Valid;
xmlWriter.WriteAttributeString("Valid", XmlConvert.ToString(VotingResults.VotesCount(mask)));
mask.BlankType = BlankType.NoMarks;
xmlWriter.WriteAttributeString("NoMarks", XmlConvert.ToString(VotingResults.VotesCount(mask)));
mask.BlankType = BlankType.TooManyMarks;
xmlWriter.WriteAttributeString("TooManyMarks", XmlConvert.ToString(VotingResults.VotesCount(mask)));
mask.BlankType = BlankType.BadMode;
xmlWriter.WriteAttributeString("BadMode", XmlConvert.ToString(VotingResults.VotesCount(mask)));
xmlWriter.WriteEndElement();
}
}
public override SubsystemStateAcceptanceResult AcceptNewState(object newState)
{
try
{
if (newState == null)
{
Logger.LogVerbose(Message.VotingResult_NewStateRejectedBecauseIsNull);
return(SubsystemStateAcceptanceResult.Rejected);
}
var arr = (object[])newState;
_votingResultProtocolVersion = (int)arr[VOTINGRESULTPROTOCOLVERSION_STATEINDEX];
var newVotingResults = (VotingResults)arr[VOTINGRESULTS_STATEINDEX];
var mergeResult = VotingResults.Merge(newVotingResults);
if (mergeResult == VotingResults.MergeResult.OurContainMoreVotes)
{
Logger.LogVerbose(Message.VotingResult_NewStateAcceptedByMerge);
return(SubsystemStateAcceptanceResult.AcceptedByMerge);
}
Logger.LogVerbose(Message.VotingResult_NewStateAccepted);
return(SubsystemStateAcceptanceResult.Accepted);
}
catch (Exception ex)
{
const string MSG = "Ошибка принятия нового состояния менеджера выборов";
Logger.LogError(Message.VotingResult_NewStateAссeptError, ex);
throw new Exception(MSG, ex);
}
}
private void WriteScannersInfo(XmlTextWriter xmlWriter, Voting.Election election)
{
var scannerArr = _scannersInfo.GetScannerInfos();
foreach (var scanner in scannerArr)
{
var intScannerSerialNumber = Convert.ToInt32(scanner.SerialNumber);
xmlWriter.WriteStartElement("Scanner");
xmlWriter.WriteAttributeString("n", scanner.SerialNumber);
var mask = new VoteKey
{
ScannerSerialNumber = intScannerSerialNumber,
BlankType = BlankType.Bad,
};
var nufCount = VotingResults.VotesCount(mask);
xmlWriter.WriteAttributeString("nuf", XmlConvert.ToString(nufCount));
if (election != null)
{
WriteAttendInfo(xmlWriter, intScannerSerialNumber, election);
}
else
{
foreach (var el in _electionManager.SourceData.Elections)
{
WriteAttendInfo(xmlWriter, intScannerSerialNumber, el);
}
}
xmlWriter.WriteEndElement();
}
}
public void ShowByCandidates(VotingResults votingResults, Func <Vote, bool> filter)
{
lock (_plotModel.SyncRoot)
{
_xAxis.SetAxisMinMax(TimeSpanAxis.ToDouble(votingResults.StartTime), TimeSpanAxis.ToDouble(votingResults.EndTime));
_plotModel.Series.Clear();
var candidates = votingResults.Votes.Where(x => filter(x)).Select(x => x.CandidateId).Distinct();
int max = 0;
foreach (var candidate in candidates)
{
LineSeries series = TotalCumulativeVotedByTimeUtils.CreateSeries(votingResults, x => filter(x) && (x.CandidateId == candidate), out int total);
if (total > max)
{
max = total;
}
series.Title = votingResults.Candidates[candidate].Name;
_plotModel.Series.Add(series);
}
_yAxis.SetAxisMax(max);
}
_plotModel.InvalidatePlot(true);
}
protected override void ResetStateInternal()
{
VotingResults = new VotingResults();
VotingResults.Init(Logger, _config.AddBadBlankToCounterValue.Enabled);
LastVotingResult = VotingResult.Empty;
_votingResultProtocolVersion = 0;
}
public override void RestoreState(object state)
{
var arr = (object[])state;
VotingResults = (VotingResults)arr[VOTINGRESULTS_STATEINDEX];
VotingResults.Init(Logger, _config.AddBadBlankToCounterValue.Enabled);
LastVotingResult = (VotingResult)arr[LASTVOTINGRESULT_STATEINDEX];
_votingResultProtocolVersion = (int)arr[VOTINGRESULTPROTOCOLVERSION_STATEINDEX];
}
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
UnencryptedVoteFileReader reader = new UnencryptedVoteFileReader();
_votingResults = reader.ReadFromFile("ballots_decrypted_2019-09-08.csv");
// установленные в процессе анализа аномальные зоны
_votingResults.DefineAnomalyZoneByBlocks("Зона 1А", 2046, 2525);
_votingResults.DefineAnomalyZoneByBlocks("Зона 1Б", 2525, 2651);
_votingResults.DefineAnomalyZoneByBlocks("Зона 2", 2818, 2956);
_votingResults.DefineAnomalyZoneByBlocks("Зона 3", 3543, 4803);
var statistics30 = GetStatistics();
dist30stats.ItemsSource = statistics30.Statistics;
// анализ времен вычисления блоков по блокчейну
_blockTimePlotModelHelper.ShowBlockTime(_votingResults);
_blockStartTimeModelHelper.ShowBlockStartTime(_votingResults);
// распределение всех голосов
_totalVotes.Show(_votingResults);
// распределение голосов в 30-ом
_totalCumulativeVotes30.Show(_votingResults, x => x.DistrictNumber == 30);
_totalCumulativeVotes30.AddCustomData("Проголосовало по статистике", statistics30.Statistics.Select(x => new TimeGraphItem <int>(x.Time, x.Voted)));
_plotTotalCumulativeVotesByTime.Show(_votingResults, x => true);
var districts = _votingResults.Votes.Select(x => x.DistrictNumber).Distinct().ToArray();
// 1 район
_plotModelHelperDistrict1.ShowByBlockDistributionMultiAxis(_votingResults, x => x.DistrictNumber == 1);
_plotTotalVotesByTimeDistrict1.ShowByCandidates(_votingResults, x => x.DistrictNumber == 1);
// 10 район
_plotModelHelperDistrict10.ShowByBlockDistributionMultiAxis(_votingResults, x => x.DistrictNumber == 10);
_plotTotalVotesByTimeDistrict10.ShowByCandidates(_votingResults, x => x.DistrictNumber == 10);
// 30 район
_plotModelHelperDistrict30.ShowByBlockDistributionMultiAxis(_votingResults, x => x.DistrictNumber == 30);
_plotTotalVotesByTimeDistrict30.ShowByCandidates(_votingResults, x => x.DistrictNumber == 30);
_statistics30PlotModelHelper.Show(statistics30);
// общая статистика
stats.SelectedObject = _votingResults.Statistics;
foreach (var drawer in _plotModelDrawers)
{
drawer.DrawAnomalyZones(_votingResults.Anomalies);
}
}
public void Show(VotingResults votingResults, Func <Vote, bool> filter)
{
lock (_plotModel.SyncRoot)
{
_xAxis.SetAxisMinMax(TimeSpanAxis.ToDouble(votingResults.StartTime), TimeSpanAxis.ToDouble(votingResults.EndTime));
_plotModel.Series.Clear();
LineSeries series = TotalCumulativeVotedByTimeUtils.CreateSeries(votingResults, filter, out var max);
series.Title = "Всего проголосовало";
_yAxis.SetAxisMax(max);
_plotModel.Series.Add(series);
}
_plotModel.InvalidatePlot(true);
}
public void ShowBlockStartTime(VotingResults votingResults)
{
lock (_plotModel.SyncRoot)
{
var xAxis = _plotModel.Axes.Where(x => x.Key == XAxisKey).Single();
xAxis.SetMinMaxBlocksToXAxis(votingResults);
var series = PrepareSeries();
BlockTimeVisualHelper.LoadBlockTimesToSeries(votingResults, null, series);
var yAxis = _plotModel.Axes.Where(x => x.Key == "y_axis").Single();
yAxis.SetAxisMax(TimeSpanAxis.ToDouble(votingResults.Votes.Select(x => x.Time).Max()));
}
_plotModel.InvalidatePlot(true);
}
public static VisualData <int> CreateBlockBasedVoteVisualData(VotingResults votingResults, Func <Vote, bool> filter)
{
var votes = new Dictionary <long, Dictionary <int, int> >();
int minBlock = votingResults.MinBlockNumber;
int maxBlock = votingResults.MaxBlockNumber;
var candidateNames = new Dictionary <long, string>();
foreach (var vote in votingResults.Votes)
{
if (!filter(vote))
{
continue;
}
Dictionary <int, int> candidateVotesTimeDistribution = null;
if (!votes.TryGetValue(vote.CandidateId, out candidateVotesTimeDistribution))
{
candidateVotesTimeDistribution = new Dictionary <int, int>();
votes.Add(vote.CandidateId, candidateVotesTimeDistribution);
}
if (!candidateNames.ContainsKey(vote.CandidateId))
{
candidateNames.Add(vote.CandidateId, votingResults.Candidates[vote.CandidateId].Name);
}
if (!candidateVotesTimeDistribution.TryGetValue(vote.BlockNumber, out int value))
{
candidateVotesTimeDistribution.Add(vote.BlockNumber, 1);
}
else
{
candidateVotesTimeDistribution[vote.BlockNumber] = value + 1;
}
}
VisualData <int> ret = new VisualData <int>()
{
XMin = minBlock,
XMax = maxBlock,
CandidateNames = candidateNames,
VotesDistribution = votes
};
return(ret);
}
private void WriteElectionInfo(XmlTextWriter xmlWriter, Voting.Election election)
{
xmlWriter.WriteStartElement("Election");
xmlWriter.WriteAttributeString("n", election.ExternalNumber);
xmlWriter.WriteAttributeString("parentid", election.ParentComittee.ParentID);
xmlWriter.WriteAttributeString("e-mail", election.ParentComittee.EMail);
if (!_isPreliminaryProtocol)
{
foreach (var line in election.Protocol.Lines)
{
xmlWriter.WriteStartElement("Line");
xmlWriter.WriteAttributeString("n", XmlConvert.ToString(line.Num));
if (!string.IsNullOrEmpty(line.AdditionalNum))
{
xmlWriter.WriteAttributeString("a", line.AdditionalNum);
}
xmlWriter.WriteString(XmlConvert.ToString(line.Value.GetValueOrDefault(0)));
xmlWriter.WriteEndElement();
}
}
var showDisabledCandidates = !string.IsNullOrEmpty(election.Protocol.DisabledString);
foreach (var candidate in election.Candidates)
{
if (candidate.Disabled && !showDisabledCandidates)
{
continue;
}
xmlWriter.WriteStartElement("Candidate");
xmlWriter.WriteAttributeString("n", candidate.Id);
if (candidate.Disabled)
{
xmlWriter.WriteAttributeString("disabled", XmlConvert.ToString(true));
}
var mask = new VoteKey
{
ElectionNum = election.ElectionId,
CandidateId = candidate.Id
};
var votesCount = VotingResults.VotesCount(mask);
xmlWriter.WriteString(XmlConvert.ToString(votesCount));
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
public async Task <IActionResult> OnGetAsync()
{
var votes = await votingServices
.GetVotesAsync();
var totalCount = votes.Count;
var results = votes.GroupBy(v => v.VotedFor)
.Select(g => new CandidateResult {
Name = g.Key, Count = g.Count()
});
VotingResults = new VotingResults();
VotingResults.Ronaldo = results.FirstOrDefault(c => c.Name == "Ronaldo") ?? new CandidateResult();
VotingResults.Messi = results.FirstOrDefault(c => c.Name == "Messi") ?? new CandidateResult();
return(Page());
}
private async Task UpdateStatistics()
{
ErrorMessage = String.Empty;
var messages = await _smsService.GetInboundSmsMessages(_shortCode);
await _smsVotingStorage.AddVotesAsync(messages);
IEnumerable <KeyValuePair <string, int> > statistics = await _smsVotingStorage.GetStatisticsAsync();
if (VotingResults.Count > 0)
{
VotingResults.Clear();
}
foreach (var vote in statistics)
{
VotingResults.Add(new Bar(vote.Key, vote.Value));
}
}
public void Show(VotingResults votingResults, Func <Vote, bool> filter)
{
lock (_plotModel.SyncRoot)
{
_xAxis.SetMinMaxBlocksToXAxis(votingResults);
_plotModel.Series.Clear();
var series = new LineSeries()
{
CanTrackerInterpolatePoints = false
};
_plotModel.Series.Add(series);
var points = votingResults.Votes
.Where(x => filter(x))
.GroupBy(x => x.BlockNumber, (key, votes) => (blockNumber: key, votesCount: votes.Count()))
.OrderBy(x => x.blockNumber)
.ToArray();
ref var lastPoint = ref points[0];
series.Points.Add(new DataPoint(lastPoint.blockNumber, lastPoint.votesCount));
int maxVotes = lastPoint.votesCount;
for (int i = 1; i < points.Length; i++)
{
ref var currentPoint = ref points[i];
for (int point = lastPoint.blockNumber + 1; point < currentPoint.blockNumber; point++)
{
series.Points.Add(new DataPoint(point, 0));
}
if (currentPoint.votesCount > maxVotes)
{
maxVotes = currentPoint.votesCount;
}
series.Points.Add(new DataPoint(currentPoint.blockNumber, currentPoint.votesCount));
lastPoint = currentPoint;
}
public ActionResult Index(VotingResults[] votingResults)
{
List <MatchResults> matchesList = new List <MatchResults>();
foreach (var item in db.MatchResults)
{
VotingResults vr = votingResults.Where(x => x.Id == item.Id).First();
if (vr.Value == 1)
{
item.HomeWon++;
}
if (vr.Value == 2)
{
item.GuestWon++;
}
if (vr.Value == 3)
{
item.Draw++;
}
}
db.SaveChanges();
return(RedirectToAction("Stats"));
}
public static LineSeries CreateSeries(VotingResults votingResults, Func <Vote, bool> filter, out int total)
{
LineSeries series = new LineSeries()
{
CanTrackerInterpolatePoints = false
};
var points = votingResults.Votes
.Where(x => filter(x))
.GroupBy(x => x.Time, (key, votes) => new TimeGraphItem <int>(key, votes.Count()))
.OrderBy(x => x.Time)
.ToArray();
int totalVotedByTime = 0;
for (int i = 0; i < points.Length; i++)
{
totalVotedByTime += points[i].Data;
series.Points.Add(new DataPoint(TimeSpanAxis.ToDouble(points[i].Time), totalVotedByTime));
}
total = totalVotedByTime;
return(series);
}
public void ShowByBlockDistributionMultiAxis(VotingResults votingResults, Func <Vote, bool> filter)
{
var visualData = VisualData.CreateBlockBasedVoteVisualData(votingResults, filter);
visualData.LoadToPlotModelMultiAxis(_plotModel);
}
public void Show(VotingResults votingResults)
{
Show(votingResults, x => true);
}
public static async Task ResetAsync(IHubContext <VotingHub> context, VotingResults results)
{
await context.Clients.All.SendAsync("resultsChanged", results);
}
public static void SetMinMaxBlocksToXAxis(this Axis axis, VotingResults votingResults)
{
axis.AbsoluteMinimum = axis.Minimum = votingResults.MinBlockNumber;
axis.AbsoluteMaximum = axis.Maximum = votingResults.MaxBlockNumber;
}
public void AddVotingResult(
VotingResult votingResult,
VotingMode votingMode,
int scannerSerialNumber)
{
Logger.LogVerbose(Message.Common_DebugCall);
lock (s_votingResultSync)
{
SetLastVotingResult(votingResult);
List <KeyValuePair <VoteKey, bool> > voteKeysForAdding = null;
while (true)
{
try
{
if (voteKeysForAdding == null)
{
voteKeysForAdding = GetVoteKeysForAdding(LastVotingResult, votingMode, scannerSerialNumber);
}
for (var keyIndex = 0; keyIndex < voteKeysForAdding.Count; keyIndex++)
{
var item = voteKeysForAdding[keyIndex];
if (item.Value)
{
continue;
}
var votesCount = 0;
try
{
votesCount = VotingResults.VotesCount(item.Key);
VotingResults.AddVote(item.Key);
}
catch (ThreadAbortException)
{
Logger.LogWarning(Message.VotingResult_AddVotingResultAbort);
Thread.ResetAbort();
}
catch (Exception ex)
{
Logger.LogError(Message.VotingResult_AddVotingResultError, ex);
}
finally
{
if (VotingResults.VotesCount(item.Key) != votesCount + 1)
{
keyIndex--;
}
else
{
voteKeysForAdding[keyIndex] = new KeyValuePair <VoteKey, bool>(item.Key, true);
}
}
}
break;
}
catch (ThreadAbortException)
{
Logger.LogWarning(Message.VotingResult_AddVotingResultAbort);
Thread.ResetAbort();
}
catch (Exception ex)
{
Logger.LogError(Message.VotingResult_AddVotingResultError, ex);
}
}
}
RaiseStateChanged();
}
