public void ContainsSite()
{
using (var context = new AsynchronusTestContext(this))
{
SiteStats received = null;
ApiException exception = null;
bool completed = false;
EnqueueCallback(() =>
{
Client.GetSiteStats(results =>
{
received = results;
completed = true;
},
error =>
{
exception = error;
completed = true;
});
});
EnqueueConditional(() => completed);
EnqueueCallback(() => Assert.IsNull(exception));
EnqueueCallback(() => Assert.IsNotNull(received));
EnqueueCallback(() => Assert.IsNotNull(received.Site));
}
}
/// <summary>
/// Gets Site Stats
/// </summary>
public SiteStats GetSiteStats()
{
var siteStats = new SiteStats();
// Recipe Count
siteStats.RecipeCount = this.Repository.GetSet <Recipe>().Count(x => x.IsActive && x.User.UserAdmin == null);
// Brew Session Count
siteStats.BrewSessionCount = this.Repository.GetSet <BrewSession>().Count(x => x.IsActive && x.BrewedByUser.UserAdmin == null);
// User Count
siteStats.UserCount = this.Repository.GetSet <User>().Count(x => x.IsActive && x.UserAdmin == null);
// Comment Count
siteStats.CommentCount = this.Repository.GetSet <RecipeComment>().Count(x => x.IsActive && x.User.UserAdmin == null);
// Tasting Note Count
siteStats.TastingNoteCount = this.Repository.GetSet <TastingNote>().Count(x => x.IsActive && x.IsPublic && x.User.UserAdmin == null);
var loginDateStart = DateTime.Now.AddDays(-1);
siteStats.LoginCountLast24Hours = this.Repository.GetSet <UserLogin>().Count(x => x.LoginDate >= loginDateStart && x.User.UserAdmin == null);
// Custom Ingredient Count
siteStats.CustomIngredientCount =
this.Repository.GetSet <Fermentable>().Count(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null) +
this.Repository.GetSet <Hop>().Count(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null) +
this.Repository.GetSet <Yeast>().Count(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null) +
this.Repository.GetSet <Adjunct>().Count(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null);
// RecentCustom Ingredients
var customIngredients = new List <IIngredient>();
customIngredients.AddRange(this.Repository.GetSet <Fermentable>().Where(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null).OrderByDescending(x => x.DateCreated).Take(5).ToList());
customIngredients.AddRange(this.Repository.GetSet <Hop>().Where(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null).OrderByDescending(x => x.DateCreated).Take(5).ToList());
customIngredients.AddRange(this.Repository.GetSet <Yeast>().Where(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null).OrderByDescending(x => x.DateCreated).Take(5).ToList());
customIngredients.AddRange(this.Repository.GetSet <Adjunct>().Where(x => x.IsActive && x.CreatedByUserId != null && x.User.UserAdmin == null).OrderByDescending(x => x.DateCreated).Take(5).ToList());
siteStats.RecentCustomIngredients = customIngredients;
// Last 25 Users
siteStats.Last25Users = Mapper.Map(this.Repository.GetSet <User>().Where(x => x.IsActive && x.UserAdmin == null).OrderByDescending(x => x.DateCreated).Take(25).ToList(), new List <UserSummary>());
// Last 25 Recipes
siteStats.Last25Recipes = this.Repository.GetSet <RecipeSummary>().Where(x => x.IsActive && !x.UserIsAdmin).OrderByDescending(x => x.DateCreated).Take(25).ToList();
// Last 25 recipe comments
siteStats.Last25RecipeComments = this.Repository.GetSet <RecipeComment>().Where(x => x.IsActive).OrderByDescending(x => x.DateCreated).Take(25).ToList();
// Last 25 recipe brew comments
siteStats.Last25BrewSessionComments = this.Repository.GetSet <BrewSessionComment>().Where(x => x.IsActive).OrderByDescending(x => x.DateCreated).Take(25).ToList();
return(siteStats);
}
public void Start()
{
this.Stats = new SessionStats(true);
this.SiteStats = CopyHelper.CreateCopy <SiteStats>(Site.Stats);
SiteStats.Balance = Balance;
Running = true;
Stop = false;
if (DiceStrategy is Strategies.ProgrammerMode)
{
(DiceStrategy as Strategies.ProgrammerMode).LoadScript();
}
new Thread(new ThreadStart(SimulationThread)).Start();
}
public SiteStats GetSiteStats()
{
try
{
var stats = new SiteStats();
Stopwatch sw = new Stopwatch();
sw.Start();
using (var connection = OpenConnection())
{
stats.TotalUsers = connection.Query <long>(MySQL.StatisticsSql.TotalUsers).SingleOrDefault();
stats.TotalCharacters = connection.Query <long>(MySQL.StatisticsSql.TotalCharacters).SingleOrDefault();
stats.TotalGuilds = connection.Query <long>(MySQL.StatisticsSql.TotalGuilds).SingleOrDefault();
stats.TotalSessions = connection.Query <long>(MySQL.StatisticsSql.TotalSessions).SingleOrDefault();
stats.TotalEncounters = connection.Query <long>(MySQL.StatisticsSql.TotalEncounters).SingleOrDefault();
var encNotRemoved = connection.Query <long>(MySQL.StatisticsSql.TotalEncountersNotRemoved).SingleOrDefault();
var dmgRows = (IDictionary <string, object>)connection.Query(MySQL.StatisticsSql.TotalDamageRows).Single();
stats.TotalDamageRecords = Convert.ToInt64(dmgRows.First().Value);
var healRows = (IDictionary <string, object>)connection.Query(MySQL.StatisticsSql.TotalHealingRows).Single();
stats.TotalHealingRecords = Convert.ToInt64(healRows.First().Value);
var shieldRows = (IDictionary <string, object>)connection.Query(MySQL.StatisticsSql.TotalShieldingRows).Single();
stats.TotalShieldingRecords = Convert.ToInt64(shieldRows.First().Value);
stats.AverageDamageRecords = stats.TotalEncounters > 0 ? stats.TotalDamageRecords / encNotRemoved : 0;
stats.AverageHealingRecords = stats.TotalEncounters > 0 ? stats.TotalHealingRecords / encNotRemoved : 0;
stats.AverageShieldingRecords = stats.TotalEncounters > 0 ? stats.TotalShieldingRecords / encNotRemoved : 0;
var allDurations = connection.Query <TimeSpan>(MySQL.StatisticsSql.TotalDurationNotSum).ToList();
stats.TotalDuration = new TimeSpan(allDurations.Sum(d => d.Ticks));
stats.TotalLogSize = Convert.ToInt64(connection.Query <decimal>(MySQL.StatisticsSql.TotalLogSize).SingleOrDefault());
stats.TotalPlayedTimeTicks = Convert.ToInt64(connection.Query <decimal>(MySQL.StatisticsSql.TotalPlayedTimeTicks).SingleOrDefault());
stats.TotalLogLines = Convert.ToInt64(connection.Query <decimal>(MySQL.StatisticsSql.TotalLogLines).SingleOrDefault());
stats.TotalPlayers = connection.Query <long>(MySQL.StatisticsSql.TotalPlayers).SingleOrDefault();
}
sw.Stop();
_logger.Debug(string.Format("Returned stats in {0}", sw.Elapsed));
return(stats);
}
catch (Exception ex)
{
_logger.Debug(string.Format("Error while getting site statistics: {0}", ex.Message));
return(null);
}
}
public static void GetSiteStatistics(string subdomain, string apiKey, Action <SiteStats> callback)
{
SiteStats retVal = null;
HttpWebRequest request = WebRequest.Create(string.Format("https://{0}.chargify.com/stats.json", subdomain)) as HttpWebRequest;
NetworkCredential credentials = new NetworkCredential(apiKey, "X");
request.Credentials = credentials;
request.Method = "GET";
request.Accept = "application/json";
request.BeginGetResponse(result =>
{
using (var response = request.EndGetResponse(result))
{
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
string stats = reader.ReadToEnd();
retVal = Json.Deserialize <SiteStats>(stats);
callback(retVal);
}
}
}, request);
//return retVal; // you can't return here
}
public bool CheckResetSeed(Bet NewBet, bool win, SessionStats Stats, SiteStats siteStats)
{
if (EnableResetSeedBets && Stats.Bets % ResetSeedBets == 0)
{
return(true);
}
if (EnableResetSeedWins && Stats.Wins % ResetSeedWins == 0)
{
return(true);
}
if (EnableResetSeedLosses && Stats.Losses % ResetSeedLosses == 0)
{
return(true);
}
if (EnableResetSeedWinStreak && Stats.WinStreak % ResetSeedWinStreak == 0 && win)
{
return(true);
}
if (EnableResetSeedLossStreak && Stats.LossStreak % ResetSeedLossStreak == 0 && !win)
{
return(true);
}
return(false);
}
public void UpdateSiteStats(SiteStats Stats)
{
Scope.SetVariable("SiteStats", Stats);
}
public void UpdateSiteStats(SiteStats Stats)
{
CurrentRuntime.Globals["SiteStats"] = Stats;
}
public bool CheckBank(Bet NewBet, bool win, SessionStats Stats, out decimal Amount, SiteStats siteStats)
{
Amount = 0;
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Bank)
{
if (siteStats.Balance >= UpperLimit)
{
Amount = UpperLimitActionAmount;
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Bank)
{
if (siteStats.Balance <= LowerLimit)
{
Amount = LowerLimitActionAmount;
return(true);
}
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Bank)
{
if (Stats.Profit >= UpperLimit)
{
Amount = UpperLimitActionAmount;
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Bank)
{
if (Stats.Profit <= LowerLimit)
{
Amount = LowerLimitActionAmount;
return(true);
}
}
return(false);
}
public bool CheckHighLow(DiceBet NewBet, bool win, SessionStats Stats, out bool NewHigh, SiteStats siteStats)
{
NewHigh = false;
if (EnableSwitchWins && Stats.Wins % SwitchWins == 0)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchWinStreak && Stats.WinStreak % SwitchWinStreak == 0 && win)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchLosses && Stats.Losses % SwitchLosses == 0)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchLossStreak && Stats.LossStreak % SwitchLossStreak == 0 && !win)
{
NewHigh = !NewBet.High;
return(true);
}
if (EnableSwitchBets && Stats.Bets % SwitchBets == 0)
{
NewHigh = !NewBet.High;
return(true);
}
return(false);
}
public bool CheckStopPOstStats(Bet NewBet, bool win, SessionStats Stats, out string reason, SiteStats siteStats)
{
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Stop)
{
if (siteStats.Balance >= UpperLimit)
{
reason = "Upper balance limit reached.";
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Stop)
{
if (siteStats.Balance <= LowerLimit)
{
reason = "lower balance limit reached.";
return(true);
}
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Stop)
{
if (Stats.Profit >= UpperLimit)
{
reason = "Upper profit limit reached. Stopping.";
return(true);
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Stop)
{
if (Stats.Profit <= LowerLimit)
{
reason = "Lower profit limit reached. Stopping.";
return(true);
}
}
if (EnableStopAfterBets && Stats.Bets >= StopAfterBets)
{
reason = "Stop after " + StopAfterBets + " bets condition triggered with " + Stats.Bets + " bets, Stopping.";
return(true);
}
if (EnableStopAfterTime && (Stats.RunningTime + (long)(DateTime.Now - Stats.StartTime).TotalMilliseconds) > StopAfterTime)
{
reason = "Stop after " + StopAfterTime.ToString("HH:mm:ss") + " run time condition triggered with " + (new TimeSpan(0, 0, 0, 0, (int)(Stats.RunningTime + (long)(DateTime.Now - Stats.StartTime).TotalMilliseconds))).ToString("HH:mm:ss") + " running time, Stopping.";
return(true);
}
if (win)
{
if (EnableStopAfterWinStreak && Stats.WinStreak >= StopAfterWinStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterWinStreak, "Wines in a row", Stats.WinStreak);
return(true);
}
if (EnableStopAfterBtcWin && Stats.Profit >= StopAfterBtcWin)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcWin, "Currency Win", Stats.Profit);
return(true);
}
if (EnableStopAfterBtcWinStreak && Stats.CurrentProfit >= StopAfterBtcWinStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcWinStreak, "Currency Streak Win", Stats.CurrentProfit);
return(true);
}
if (EnableStopAfterWins && Stats.Wins % StopAfterWins == 0)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterWins, "Wins", Stats.Wins);
return(true);
}
if (EnableStopWinFromMinProfit && Stats.Profit - Stats.MinProfit >= StopWinFromMinProfit)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopWinFromMinProfit, "profit since min profit", Stats.Profit - Stats.MinProfit);
return(true);
}
}
else
{
if (EnableStopAfterLoseStreak && Stats.LossStreak >= StopAfterLoseStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterLoseStreak, "Losses in a row", Stats.LossStreak);
return(true);
}
if (EnableStopAfterBtcLoss && -Stats.Profit >= StopAfterBtcLoss)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcLoss, "Currency Loss", Stats.Profit);
return(true);
}
if (EnableStopAfterBtcLoseStreak && Stats.CurrentProfit <= -StopAfterBtcLoseStreak)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterBtcLoseStreak, "Currency Streak Loss", Stats.CurrentProfit);
return(true);
}
if (EnableStopAfterLosses && Stats.Losses % StopAfterLosses == 0)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopAfterLosses, "Losses", Stats.Losses);
return(true);
}
if (EnableStopLossFromMaxProfit && Stats.MaxProfit - Stats.Profit >= StopLossFromMaxProfit)
{
reason = string.Format("Stop after {0} {1} conditino triggered with {2} {1}, Stopping", StopLossFromMaxProfit, "loss since max profit", Stats.MaxProfit - Stats.Profit);
return(true);
}
}
reason = "";
return(false);
}
public bool CheckStopPreStats(Bet NewBet, bool win, SessionStats Stats, out string reason, SiteStats siteStats)
{
reason = "";
return(false);
}
public bool CheckResetPostStats(Bet NewBet, bool win, SessionStats Statsn, SiteStats siteStats)
{
bool reset = false;
if (EnableResetAfterBets && Statsn.Bets % ResetAfterBets == 0)
{
reset = true;
}
if (EnableUpperLimit && UpperLimitCompare == "Balance" && UpperLimitAction == LimitAction.Reset)
{
reset = reset || (siteStats.Balance >= UpperLimit);
}
if (EnableLowerLimit && UpperLimitCompare == "Balance" && LowerLimitAction == LimitAction.Reset)
{
reset = reset || (siteStats.Balance <= LowerLimit);
}
if (EnableUpperLimit && UpperLimitCompare == "Profit" && UpperLimitAction == LimitAction.Reset)
{
if (Statsn.PorfitSinceLimitAction >= UpperLimit)
{
reset = true;
Statsn.PorfitSinceLimitAction = 0;
}
}
if (EnableLowerLimit && UpperLimitCompare == "Profit" && LowerLimitAction == LimitAction.Reset)
{
if (Statsn.PorfitSinceLimitAction >= LowerLimit)
{
reset = true;
Statsn.PorfitSinceLimitAction = 0;
}
}
if (win)
{
if (EnableResetAfterWinStreak && Statsn.WinStreak % ResetAfterWinStreak == 0)
{
reset = true;
}
if (EnableResetAfterBtcStreakWin && Statsn.StreakProfitSinceLastReset >= ResetAfterBtcStreakWin)
{
reset = true;
Statsn.StreakProfitSinceLastReset = 0;
}
if (EnableResetAfterBtcWin && Statsn.ProfitSinceLastReset >= ResetAfterBtcWin)
{
reset = true;
Statsn.ProfitSinceLastReset = 0;
}
if (EnableResetAfterWins && Statsn.Wins % ResetAfterWins == 0)
{
reset = true;
}
if (EnableResetWinFromMinProfit && Statsn.Profit - Statsn.MinProfitSinceReset >= ResetWinFromMinProfit)
{
Statsn.MinProfitSinceReset = Statsn.Profit;
reset = true;
}
}
else
{
if (EnableResetAfterLoseStreak && Statsn.LossStreak % ResetAfterLoseStreak == 0)
{
reset = true;
}
if (EnableResetAfterBtcStreakLoss && Statsn.StreakLossSinceLastReset <= -ResetAfterBtcStreakLoss)
{
reset = true;
Statsn.StreakLossSinceLastReset = 0;
}
if (EnableResetAfterBtcLoss && Statsn.ProfitSinceLastReset <= -ResetAfterBtcLoss)
{
reset = true;
Statsn.ProfitSinceLastReset = 0;
}
if (EnableResetAfterLosses && Statsn.Losses % ResetAfterLosses == 0)
{
reset = true;
}
if (EnableResetLossFromMaxProfit && Statsn.MaxProfitSinceReset - Statsn.Profit >= ResetLossFromMaxProfit)
{
Statsn.MaxProfitSinceReset = Statsn.Profit;
reset = true;
}
}
return(reset);
}
public bool CheckResetPreStats(Bet NewBet, bool win, SessionStats Stats, SiteStats siteStats)
{
return(false);
}
public void UpdateSiteStats(SiteStats Stats)
{
Runtime.SetValue("SiteStats", Stats);
}
public void UpdateSiteStats(SiteStats Stats)
{
globals.SiteStats = Stats;
}
