protected void GetStats(string team1, string team2)
{
isLoadingStats = true;
isLoadingWinningStats = true;
var statsTask = StatsProvider.GetStatsAsync(team1, team2).ContinueWith(s =>
{
isLoadingStats = false;
Stats = s.Result;
Summary = new Dictionary <string, int>
();
foreach (var stat in Stats)
{
if (Summary.ContainsKey(stat.Winner))
{
Summary[stat.Winner]++;
}
else
{
Summary[stat.Winner] = 1;
}
}
StateHasChanged();
}, TaskScheduler.FromCurrentSynchronizationContext());
var winningStatsTaks = StatsProvider.GetWinningStatsAsync(team1, team2).ContinueWith(ws =>
{
isLoadingStats = false;
WinningStats = ws.Result;
StateHasChanged();
}, TaskScheduler.FromCurrentSynchronizationContext());
}
public StandingsResponseProvider(StatsProvider statsProvider)
{
if (statsProvider == null)
{
throw new ArgumentNullException("statsProvider");
}
StatsProvider = statsProvider;
}
public Form1(CoordenadasProvider coordenadasProvider, StatsProvider statsProvider, ObjetivoProvider objetivoProvider, PiedraProvider piedraProvider, AventuraProvider aventuraProvider, MapaProvider mapaProvider)
{
InitializeComponent();
this.coordenadasProvider = coordenadasProvider;
this.statsProvider = statsProvider;
this.objetivoProvider = objetivoProvider;
this.piedraProvider = piedraProvider;
this.aventuraProvider = aventuraProvider;
this.mapaProvider = mapaProvider;
}
public SystemController(JobProvider jobProvider, IndexerProvider indexerProvider,
ConfigProvider configProvider, DiskProvider diskProvider,
BackupProvider backupProvider, StatsProvider statsProvider)
{
_jobProvider = jobProvider;
_indexerProvider = indexerProvider;
_configProvider = configProvider;
_diskProvider = diskProvider;
_backupProvider = backupProvider;
_statsProvider = statsProvider;
}
public static decimal GetStatValue(this Indicators indicators, Stat stat)
{
var propertyName = StatsProvider.GetStatProperyName(stat);
Assert.IsNotNull(propertyName, $"Property for {stat} must be defined");
Assert.True(indicators.HasProperty(propertyName), $"Indicators must have property {propertyName}");
var propValue = ReflectionHelper.GetPropertyValue(indicators, propertyName);
return(Convert.ToDecimal(propValue));
}
private void LoadPlayerHudStats(ReplayerPlayerViewModel replayerPlayer, ReplayerViewModel replayerViewModel, IList <StatInfo> statInfoCollection)
{
replayerPlayer.StatInfoCollection.Clear();
HudLightIndicators hudIndicators;
if (storageModel.PlayerSelectedItem.Name == replayerPlayer.Name &&
(short?)storageModel.PlayerSelectedItem.PokerSite == replayerViewModel.CurrentHand.PokersiteId)
{
hudIndicators = new HudLightIndicators(storageModel.GetStatisticCollection());
}
else
{
hudIndicators = new HudLightIndicators();
playerStatisticRepository
.GetPlayerStatistic(replayerPlayer.Name, replayerViewModel.CurrentHand.PokersiteId)
.ForEach(stat => hudIndicators.AddStatistic(stat));
}
if (hudIndicators != null)
{
var statList = new List <StatInfo>();
var counter = 0;
foreach (var selectedStatInfo in statInfoCollection)
{
if (selectedStatInfo is StatInfoBreak)
{
continue;
}
var statInfo = selectedStatInfo.Clone();
var propertyName = StatsProvider.GetStatProperyName(statInfo.Stat);
if (!string.IsNullOrWhiteSpace(propertyName))
{
statInfo.AssignStatInfoValues(hudIndicators, propertyName);
}
replayerPlayer.StatInfoCollection.Add(statInfo);
if ((counter + 1) % 4 == 0)
{
replayerPlayer.StatInfoCollection.Add(new StatInfoBreak());
}
counter++;
}
}
}
public void Records_misses_correctly()
{
var provider = new StatsProvider("unit-test");
for (var i = 0; i < 10; i++)
{
provider.ReportCacheMiss(HttpStatusCode.OK);
provider.GetStatistics().PerStatusCode[HttpStatusCode.OK].CacheMiss.Should().Be(i + 1);
provider.ReportCacheMiss(HttpStatusCode.InternalServerError);
provider.GetStatistics().PerStatusCode[HttpStatusCode.InternalServerError].CacheMiss.Should().Be(i + 1);
provider.GetStatistics().Total.CacheMiss.Should().Be(2 * (i + 1));
provider.GetStatistics().Total.CacheHit.Should().Be(0);
}
}
public void Records_misses_correctly()
{
var provider = new StatsProvider("unit-test");
for (var i = 0; i < 10; i++)
{
provider.ReportCacheMiss(HttpStatusCode.OK);
provider.GetStatistics().PerStatusCode[HttpStatusCode.OK].CacheMiss.Should().Be(i + 1);
provider.ReportCacheMiss(HttpStatusCode.InternalServerError);
provider.GetStatistics().PerStatusCode[HttpStatusCode.InternalServerError].CacheMiss.Should().Be(i + 1);
provider.GetStatistics().Total.CacheMiss.Should().Be(2 * (i + 1));
provider.GetStatistics().Total.CacheHit.Should().Be(0);
}
}
public void Records_hits_correctly()
{
var provider = new StatsProvider("unit-test");
for (var i = 0; i < 10; i++)
{
provider.ReportCacheHit(HttpStatusCode.OK);
provider.GetStatistics().PerStatusCode[HttpStatusCode.OK].CacheHit.Should().Be(i + 1);
provider.ReportCacheHit(HttpStatusCode.BadRequest);
provider.GetStatistics().PerStatusCode[HttpStatusCode.BadRequest].CacheHit.Should().Be(i + 1);
provider.GetStatistics().Total.CacheHit.Should().Be(2 * (i + 1));
provider.GetStatistics().Total.CacheMiss.Should().Be(0);
}
}
public void Records_hits_correctly()
{
var provider = new StatsProvider("unit-test");
for (var i = 0; i < 10; i++)
{
provider.ReportCacheHit(HttpStatusCode.OK);
provider.GetStatistics().PerStatusCode[HttpStatusCode.OK].CacheHit.Should().Be(i + 1);
provider.ReportCacheHit(HttpStatusCode.BadRequest);
provider.GetStatistics().PerStatusCode[HttpStatusCode.BadRequest].CacheHit.Should().Be(i + 1);
provider.GetStatistics().Total.CacheHit.Should().Be(2 * (i + 1));
provider.GetStatistics().Total.CacheMiss.Should().Be(0);
}
}
/// <summary>
/// Creates graph view model
/// </summary>
/// <param name="creationInfo"><see cref="HudToolCreationInfo"/></param>
/// <returns>Graph view model</returns>
private HudBaseToolViewModel CreateGraphTool(HudToolCreationInfo creationInfo)
{
Check.Require(creationInfo.Layout != null, "Layout isn't defined. Graph has not been created.");
var statInfo = creationInfo.Source as StatInfo;
HudLayoutGraphTool layoutTool = null;
if (statInfo != null)
{
statInfo.IsSelected = false;
var initialStat = statInfo.Stat == Stat.PlayerInfoIcon ?
StatsProvider.GetStat(Stat.NetWon) :
statInfo.Clone();
layoutTool = new HudLayoutGraphTool
{
BaseStat = statInfo.Clone(),
Stats = new ReactiveList <StatInfo> {
initialStat
}
};
}
else
{
var parentTool = creationInfo.Source as HudBaseToolViewModel;
if (parentTool == null)
{
return(null);
}
layoutTool = new HudLayoutGraphTool
{
ParentId = parentTool.Tool.Id
};
}
var toolViewModel = layoutTool.CreateViewModel(creationInfo.HudElement);
toolViewModel.Position = creationInfo.Position;
creationInfo.Layout.LayoutTools.Add(layoutTool);
return(toolViewModel);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
StatsProvider provider = new StatsProvider();
provider.InitializeTask.ContinueWith((task) =>
{
Console.WriteLine("Stats Compiled");
});
services.AddSingleton <StatsProvider>(provider);
services.AddSingleton <IHostedService>(provider);
services.Configure <GzipCompressionProviderOptions>(options => options.Level = System.IO.Compression.CompressionLevel.Optimal);
services.AddResponseCompression();
services.AddMvc();
}
public ValuesController(StatsProvider provider)
{
statsProvider = provider;
calendarDictionary = new Dictionary <int, IDictionary <int, CalendarEntry> >();
var entries = new List <CalendarEntry>();
foreach (var year in Enumerable.Range(2014, 5))
{
var yearDict = calendarDictionary[year] = new Dictionary <int, CalendarEntry>();
foreach (var month in Enumerable.Range(1, 12))
{
yearDict[month] = new CalendarEntry(year: year, month: month);
}
}
}
public LayoutMigrator()
{
availableStats = StatsProvider.GetAllStats();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static long importData(String title, int numRunners, InputIterable data, org.neo4j.unsafe.impl.batchimport.store.BatchingNeoStores stores, System.Func<EntityImporter> visitors, org.neo4j.unsafe.impl.batchimport.staging.ExecutionMonitor executionMonitor, org.neo4j.unsafe.impl.batchimport.stats.StatsProvider memoryStatsProvider) throws java.io.IOException
private static long ImportData(string title, int numRunners, InputIterable data, BatchingNeoStores stores, System.Func <EntityImporter> visitors, ExecutionMonitor executionMonitor, StatsProvider memoryStatsProvider)
{
LongAdder roughEntityCountProgress = new LongAdder();
ExecutorService pool = Executors.newFixedThreadPool(numRunners, new NamedThreadFactory(title + "Importer"));
IoMonitor writeMonitor = new IoMonitor(stores.IoTracer);
ControllableStep step = new ControllableStep(title, roughEntityCountProgress, Configuration.DEFAULT, writeMonitor, memoryStatsProvider);
StageExecution execution = new StageExecution(title, null, Configuration.DEFAULT, Collections.singletonList(step), 0);
long startTime = currentTimeMillis();
using (InputIterator dataIterator = data.GetEnumerator())
{
executionMonitor.Start(execution);
for (int i = 0; i < numRunners; i++)
{
pool.submit(new ExhaustingEntityImporterRunnable(execution, dataIterator, visitors(), roughEntityCountProgress));
}
pool.shutdown();
long nextWait = 0;
try
{
while (!pool.awaitTermination(nextWait, TimeUnit.MILLISECONDS))
{
executionMonitor.Check(execution);
nextWait = executionMonitor.NextCheckTime() - currentTimeMillis();
}
}
catch (InterruptedException e)
{
Thread.CurrentThread.Interrupt();
throw new IOException(e);
}
}
execution.AssertHealthy();
step.MarkAsCompleted();
writeMonitor.Stop();
executionMonitor.End(execution, currentTimeMillis() - startTime);
execution.AssertHealthy();
return(roughEntityCountProgress.sum());
}
private static long Avg(StatsProvider step)
{
return(step.Stat(Keys.avg_processing_time).asLong());
}
public void SetUp()
{
_mockJobRepository = new Mock <IJobRepository>();
_classUnderTest = new StatsProvider(_mockJobRepository.Object);
}
private void InitializeHeatMaps()
{
var heatMapsStats = StatsProvider.GetHeatMapStats();
heatMapsStats.ForEach(heatMapStat => heatMaps.Add(heatMapStat, new HeatMapDto()));
}
private void LoadHUD(HudDragCanvas dgCanvas, ReplayerViewModel viewModel, HudLayoutInfoV2 activeLayout)
{
var seats = (int)CurrentCapacity;
var hudPanelService = ServiceLocator.Current.GetInstance <IHudPanelService>(ReplayerPokerSite.ToString());
var nonToolLayoutStats = activeLayout
.HudPlayerTypes
.SelectMany(x => x.Stats)
.Select(x => x.Stat)
.Concat(activeLayout
.HudBumperStickerTypes
.SelectMany(x => x.Stats)
.Select(x => x.Stat))
.Concat(new[] { Stat.TotalHands })
.Distinct()
.ToArray();
var hudElements = new List <HudElementViewModel>();
var hudElementCreator = ServiceLocator.Current.GetInstance <IHudElementViewModelCreator>();
var hudElementCreationInfo = new HudElementViewModelCreationInfo
{
GameType = EnumGameType.CashHoldem,
HudLayoutInfo = activeLayout,
PokerSite = ReplayerPokerSite
};
for (var i = 0; i < seats; i++)
{
var replayerPlayer = viewModel.PlayersCollection[i];
hudElementCreationInfo.SeatNumber = i + 1;
if ((int)activeLayout.TableType < hudElementCreationInfo.SeatNumber)
{
continue;
}
var hudElement = hudElementCreator.Create(hudElementCreationInfo);
if (string.IsNullOrEmpty(replayerPlayer.Name))
{
if (hudElement != null)
{
EmptySeats.Add(hudElement);
}
continue;
}
var player = dataService.GetPlayer(replayerPlayer.Name, viewModel.CurrentHand.PokersiteId);
if (player == null)
{
if (hudElement != null)
{
EmptySeats.Add(hudElement);
}
continue;
}
if (hudElement == null ||
!playerIndicators.TryGetValue(replayerPlayer.Name, out HudIndicators playerData))
{
continue;
}
hudElement.PlayerId = player.PlayerId;
hudElement.PlayerName = replayerPlayer.Name;
hudElement.TotalHands = playerData.TotalHands;
var playerNotes = dataService.GetPlayerNotes(player.PlayerId);
hudElement.NoteToolTip = NoteBuilder.BuildNote(playerNotes);
hudElement.IsXRayNoteVisible = playerNotes.Any(x => x.IsAutoNote);
var graphTools = hudElement.Tools.OfType <HudGraphViewModel>().ToArray();
foreach (var graphTool in graphTools)
{
graphTool.StatSessionCollection = new ReactiveList <decimal>();
}
var heatMapTools = hudElement.Tools.OfType <HudHeatMapViewModel>()
.Concat(hudElement.Tools.OfType <HudGaugeIndicatorViewModel>()
.SelectMany(x => x.GroupedStats)
.SelectMany(x => x.Stats)
.Where(x => x.HeatMapViewModel != null)
.Select(x => x.HeatMapViewModel))
.ToArray();
heatMapTools.ForEach(x =>
{
var heatMapKey = playerData.HeatMaps.Keys
.ToArray()
.FirstOrDefault(p => p.Stat == x.BaseStat.Stat);
if (heatMapKey != null)
{
x.HeatMap = playerData.HeatMaps[heatMapKey];
}
});
var gaugeIndicatorTools = hudElement.Tools.OfType <HudGaugeIndicatorViewModel>().ToArray();
hudElement.SessionMoneyWonCollection = new ObservableCollection <decimal>();
var activeLayoutHudStats = hudElement.ToolsStatInfoCollection
.Concat(heatMapTools.Select(x => x.BaseStat))
.Concat(gaugeIndicatorTools.Select(x => x.BaseStat))
.ToList();
var extraStats = (from nonToolLayoutStat in nonToolLayoutStats
join activateLayoutHudStat in activeLayoutHudStats on nonToolLayoutStat equals activateLayoutHudStat.Stat into grouped
from extraStat in grouped.DefaultIfEmpty()
where extraStat == null
select new StatInfo
{
Stat = nonToolLayoutStat
}).ToArray();
activeLayoutHudStats.AddRange(extraStats);
StatsProvider.UpdateStats(activeLayoutHudStats);
foreach (var statInfo in activeLayoutHudStats)
{
var propertyName = StatsProvider.GetStatProperyName(statInfo.Stat);
if (!string.IsNullOrEmpty(propertyName))
{
if (playerData.TotalHands < statInfo.MinSample)
{
statInfo.IsNotVisible = true;
}
statInfo.AssignStatInfoValues(playerData, propertyName);
}
else if (!(statInfo is StatInfoBreak) && statInfo.Stat != Stat.PlayerInfoIcon)
{
continue;
}
}
hudElement.StatInfoCollection = activeLayoutHudStats;
var isNoteIconSet = false;
foreach (var toolViewModel in hudElement.Tools.Where(x => x is IHudNonPopupToolViewModel).ToArray())
{
if (!isNoteIconSet && toolViewModel is HudPlainStatBoxViewModel && !(toolViewModel is HudFourStatsBoxViewModel))
{
(toolViewModel as HudPlainStatBoxViewModel).IsNoteIconEnabled = true;
isNoteIconSet = true;
}
var panel = hudPanelService.Create(toolViewModel);
if (panel != null)
{
dgCanvas.Children.Add(panel);
Canvas.SetLeft(panel, toolViewModel.Position.X);
Canvas.SetTop(panel, toolViewModel.Position.Y);
}
}
hudElements.Add(hudElement);
}
hudLayoutsService.SetPlayerTypeIcon(hudElements, activeLayout);
}
