public void UpdateDatabase(RPPDatabase _Database, DateTime _EarliestDateTime)
{
var realmDBs = _Database.GetRealms();
foreach (var realmDB in realmDBs)
{
foreach (var playerHistory in realmDB.Value.PlayersHistory)
{
try
{
if (playerHistory.Value.GuildHistory.Count < 1)
{
continue;
}
if (playerHistory.Value.GuildHistory.Last().Uploader.GetTime() >= _EarliestDateTime)
{
List <string> guildsAffected = new List <string>();
for (int i = playerHistory.Value.GuildHistory.Count - 1; i >= 0; --i)
{
if (playerHistory.Value.GuildHistory[i].Uploader.GetTime() < _EarliestDateTime)
{
break;
}
string guildName = playerHistory.Value.GuildHistory[i].Data.GuildName;
if (guildsAffected.Contains(guildName) == false)
{
guildsAffected.Add(guildName);
}
}
foreach (string guildName in guildsAffected)
{
if (guildName == "nil" || guildName == "None")
{
continue;
}
if (GetGuildSummary(realmDB.Value.Realm, guildName) == null)
{
var newGuildSummary = new GuildSummary(guildName, realmDB.Value.Realm);
newGuildSummary.InitCache();
AddGuildSummary(newGuildSummary);
}
}
foreach (var guild in m_Guilds)
{
if (guild.Value.Realm == realmDB.Value.Realm)
{
guild.Value.Update(playerHistory.Key, playerHistory.Value, _EarliestDateTime);
}
}
}
}
catch (Exception ex)
{
VF_RealmPlayersDatabase.Logger.LogException(ex);
}
}
}
}
public static void UpdateSummaryDatabase(string _RootDirectory, RPPDatabase _Database)
{
PlayerSummaryDatabase database = null;
string databaseFile = _RootDirectory + "\\SummaryDatabase\\PlayerSummaryDatabase.dat";
database = new PlayerSummaryDatabase(_Database);
VF.Utility.SaveSerialize(databaseFile, database);
}
public PlayerSummaryDatabase(RPPDatabase _Database)
{
var realmDBs = _Database.GetRealms();
foreach (var realmDB in realmDBs)
{
UpdateRealm(realmDB.Value);
}
}
public static bool ReloadRPPDatabase(RPPDatabase _RPPDatabase, object _SynchronizationLockObject)
{
GC.Collect();
bool reloadResult = _RPPDatabase.ReloadAllRealmDBs(Constants.RPPDbDir + "Database\\"
, true, _SynchronizationLockObject);//, new DateTime(2016, 1, 1, 0, 0, 0));
GC.Collect();
return(reloadResult);
}
public static RPPDatabase LoadRPPDatabase(bool _FirstTimeLoading = false)
{
GC.Collect();
RPPDatabase database = new RPPDatabase(Constants.RPPDbDir + "Database\\");//, new DateTime(2016, 1, 1, 0, 0, 0));
database.PurgeRealmDBs(true, true, (_FirstTimeLoading == false));
GC.Collect();
return(database);
}
public RPPDatabase _GetRPPDatabase(bool _WaitUntilLoaded = true)
{
if (m_RPPDatabase == null && _WaitUntilLoaded == false)
{
if (Monitor.TryEnter(m_RealmPlayersMutex, 100) == false)
{
return(null);
}
}
else
{
Monitor.Enter(m_RealmPlayersMutex);
}
RPPDatabase rppDatabase = m_RPPDatabase;
if (rppDatabase == null)
{
if (m_LoadRealmPlayersThread == null)
{
m_LoadRealmPlayersThread = new System.Threading.Thread(ReloadRealmPlayers);
m_LoadRealmPlayersThread.Start();
}
if (_WaitUntilLoaded == false)
{
Monitor.Exit(m_RealmPlayersMutex);
return(null);
}
while (rppDatabase == null)
{
Monitor.Exit(m_RealmPlayersMutex);
System.Threading.Thread.Sleep(100);
Monitor.Enter(m_RealmPlayersMutex);
rppDatabase = m_RPPDatabase;
}
}
else if ((DateTime.UtcNow - m_LastLoadedDateTime).TotalMinutes > 10)
{
if (m_LoadRealmPlayersThread == null)
{
if (m_RPPDatabase.IsDBFilesUpdated(Constants.RPPDbDir + "Database\\", m_RealmPlayersMutex) == true)
{
m_LoadRealmPlayersThread = new System.Threading.Thread(ReloadRealmPlayers);
m_LoadRealmPlayersThread.Start();
}
else
{
m_LastLoadedDateTime = DateTime.UtcNow.AddMinutes(-5);
}
}
}
Monitor.Exit(m_RealmPlayersMutex);
ApplicationInstance.Instance.BackupItemInfos();
return(rppDatabase);
}
public static void Thread_GenerateData(RPPDatabase _Database)
{
Logger.ConsoleWriteLine("TODO: Fix this!!!!!");
for (int i = 0; i < 5; ++i)
{
var generatedContributorStatisticData = new Dictionary <WowRealm, Dictionary <int, ContributorStatisticItem> >();
try
{
ContributorStatisticItem lastUsedCSI = new ContributorStatisticItem();
foreach (var realm in _Database.GetRealms())
{
realm.Value.WaitForLoad(RealmDatabase.LoadStatus.EverythingLoaded);
if (generatedContributorStatisticData.ContainsKey(realm.Key) == false)
{
generatedContributorStatisticData.Add(realm.Key, new Dictionary <int, ContributorStatisticItem>());
}
var realmCSD = generatedContributorStatisticData[realm.Key];
foreach (var playerHistory in realm.Value.PlayersHistory)
{
var playerUpdates = playerHistory.Value.GetUpdates();
foreach (var playerUpdate in playerUpdates)
{
var currContributorID = playerUpdate.GetContributorID();
if (lastUsedCSI.m_ContributorID != currContributorID)
{
if (realmCSD.ContainsKey(currContributorID) == false)
{
realmCSD.Add(currContributorID, new ContributorStatisticItem(currContributorID));
}
lastUsedCSI = realmCSD[currContributorID];
}
lastUsedCSI.AddInspectData(playerHistory.Key, playerUpdate.GetTime());
}
}
}
sm_ContributorStatisticData = generatedContributorStatisticData;
break;
}
catch (Exception ex)
{
Logger.LogException(ex);
System.Threading.Thread.Sleep(500);
Logger.ConsoleWriteLine("Thread_GenerateData() Trying again!");
}
}
}
public static void AssertInitialize(RPPDatabase _Database, bool _WaitUntilLoaded = false)
{
lock (sm_LoadTaskMutex)
{
if (sm_LoadTask == null || (DateTime.UtcNow - sm_LastGenerationTime).TotalMinutes > 300) //5 hours
{
sm_LastGenerationTime = DateTime.UtcNow;
sm_LoadTask = new System.Threading.Tasks.Task(new Action(() => { Thread_GenerateData(_Database); }));
sm_LoadTask.Start();
}
}
if (_WaitUntilLoaded == true && sm_LoadTask.IsCompleted == false)
{
sm_LoadTask.Wait();
}
}
public static void UpdateSummaryDatabase(string _RootDirectory, RPPDatabase _Database, bool _UpdateAllHistory = false)
{
GuildSummaryDatabase database = null;
string databaseFile = _RootDirectory + "\\SummaryDatabase\\GuildSummaryDatabase.dat";
if (System.IO.File.Exists(databaseFile) == true)
{
if (Utility.LoadSerialize(databaseFile, out database, 10000, true) == false)
{
database = null;
}
if (database == null)
{
VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Armory: Failed to load GuildSummaryDatabase. Skipping update!");
return;
}
}
if (database != null)
{
foreach (var guild in database.m_Guilds)
{
guild.Value.InitCache();
}
}
if (database == null)
{
database = new GuildSummaryDatabase();
database.UpdateDatabase(_Database);
}
else
{
if (_UpdateAllHistory == true)
{
database.UpdateDatabase(_Database);
}
else
{
database.UpdateDatabase(_Database, DateTime.UtcNow.AddDays(-8));
}
}
Utility.SaveSerialize(databaseFile, database);
VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Armory: Successfully updated GuildSummaryDatabase!");
}
public static void UpdateSummaryDatabase(string _RootDirectory, RPPDatabase _Database, bool _UpdateAllHistory = false)
{
ItemSummaryDatabase database = null;
string databaseFile = _RootDirectory + "\\SummaryDatabase\\ItemSummaryDatabase.dat";
if (System.IO.File.Exists(databaseFile) == true)
{
if (VF.Utility.LoadSerialize(databaseFile, out database) == false)
{
database = null;
}
}
//if (database != null)
//{
// foreach (var guild in database.m_Guilds)
// {
// guild.Value.InitCache();
// }
//}
if (database == null)
{
database = new ItemSummaryDatabase();
database.UpdateDatabase(_Database);
}
else
{
if (_UpdateAllHistory == true)
{
database.UpdateDatabase(_Database);
}
else
{
database.UpdateDatabase(_Database, DateTime.UtcNow.AddDays(-8));
}
}
VF.Utility.SaveSerialize(databaseFile, database);
}
//public void SaveUserActivityData()
//{
// Monitor.Enter(m_RealmPlayersMutex);
// try
// {
// VF_RealmPlayersDatabase.Utility.BackupFile(Constants.RPPDbWriteDir + "VF_UsersOnSite.dat");
// m_LastUserActivitySave = DateTime.Now;
// Logger.ConsoleWriteLine("SaveUserActivityData(): Saved VF_UsersOnSite.dat", ConsoleColor.Yellow);
// }
// catch (Exception)
// { }
// Monitor.Exit(m_RealmPlayersMutex);
//}
public void ReloadRealmPlayers()
{
try
{
GC.Collect();
bool firstTimeLoading = (m_RPPDatabase == null);
DateTime startLoadTime = DateTime.UtcNow;
if (firstTimeLoading == true)
{
RPPDatabase rppDatabase = DatabaseLoader.LoadRPPDatabase(firstTimeLoading);
lock (m_RealmPlayersMutex)
{
m_RPPDatabase = rppDatabase;
m_ContributorStatistics = null;
m_LastLoadedDateTime = DateTime.UtcNow;
}
m_ThreadSafeCache.ClearCache("FindPlayersMatching");
}
else
{
if (DatabaseLoader.ReloadRPPDatabase(m_RPPDatabase, m_RealmPlayersMutex) == true)
{
m_ContributorStatistics = null;
m_ThreadSafeCache.ClearCache("FindPlayersMatching");
m_LastLoadedDateTime = DateTime.UtcNow;
}
}
m_LoadRealmPlayersThread = null;
Logger.ConsoleWriteLine("LoadRPPDatabase(): Reloaded database, it took: " + (int)(DateTime.UtcNow - startLoadTime).TotalSeconds + " seconds", ConsoleColor.Green);
GC.Collect();
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public void UpdateDatabase(RPPDatabase _Database, DateTime _EarliestDateTime)
{
List <string> failedMountItemNames = new List <string>();
List <string> failedCompanionItemNames = new List <string>();
var realmDBs = _Database.GetRealms();
foreach (var realmDB in realmDBs)
{
realmDB.Value.WaitForLoad(VF_RealmPlayersDatabase.RealmDatabase.LoadStatus.PlayersHistoryLoaded);
foreach (var playerHistory in realmDB.Value.PlayersHistory)
{
try
{
if (playerHistory.Value.GearHistory.Count < 1 || playerHistory.Value.GearHistory.Last().Uploader.GetTime() < _EarliestDateTime)
{
continue;
}
UInt64 playerID = GetEntityID(realmDB.Value.Realm, playerHistory.Key);
foreach (var gearHistory in playerHistory.Value.GearHistory)
{
if (gearHistory.Uploader.GetTime() < _EarliestDateTime)
{
continue;
}
foreach (var item in gearHistory.Data.Items)
{
var itemSummary = GetItemSummary(item.Value);
var optionalSlot = item.Value.Slot;
if (item.Value.Slot == ItemSlot.Finger_1)
{
optionalSlot = ItemSlot.Finger_2;
}
else if (item.Value.Slot == ItemSlot.Finger_2)
{
optionalSlot = ItemSlot.Finger_1;
}
else if (item.Value.Slot == ItemSlot.Trinket_1)
{
optionalSlot = ItemSlot.Trinket_2;
}
else if (item.Value.Slot == ItemSlot.Trinket_2)
{
optionalSlot = ItemSlot.Trinket_1;
}
else if (item.Value.Slot == ItemSlot.Main_Hand)
{
optionalSlot = ItemSlot.Off_Hand;
}
else if (item.Value.Slot == ItemSlot.Off_Hand)
{
optionalSlot = ItemSlot.Main_Hand;
}
if (item.Value.Slot != optionalSlot)
{
ItemInfo optionalItemInfo;
if (gearHistory.Data.Items.TryGetValue(optionalSlot, out optionalItemInfo) == true)
{
//Possible duplicate, check it out
if (optionalItemInfo.ItemID == item.Value.ItemID &&
optionalItemInfo.SuffixID == item.Value.SuffixID)
{
//Add duplicate
itemSummary.AddOwner(playerID, gearHistory.Uploader.GetTime(), true);
}
else
{
//No duplicates
itemSummary.AddOwner(playerID, gearHistory.Uploader.GetTime());
}
}
else
{
//No duplicates
itemSummary.AddOwner(playerID, gearHistory.Uploader.GetTime());
}
}
else
{
//No duplicates
itemSummary.AddOwner(playerID, gearHistory.Uploader.GetTime());
}
}
}
}
catch (Exception ex)
{
VF_RealmPlayersDatabase.Logger.LogException(ex);
}
}
foreach (var playerExtraData in realmDB.Value.PlayersExtraData)
{
try
{
UInt64 playerID = GetEntityID(realmDB.Value.Realm, playerExtraData.Key);
foreach (var mount in playerExtraData.Value.Mounts)
{
int mountID = VF.ItemTranslations.FindItemID(mount.Mount);
if (mountID > 0)
{
var itemSummary = GetItemSummary(mountID, 0);
itemSummary.AddOwner(playerID, mount.GetEarliestUpload().GetTime());
}
else
{
failedMountItemNames.AddUnique(mount.Mount);
}
}
foreach (var companion in playerExtraData.Value.Companions)
{
int companionID = VF.ItemTranslations.FindItemID(companion.Name);
if (companionID > 0)
{
var itemSummary = GetItemSummary(companionID, 0);
itemSummary.AddOwner(playerID, companion.GetEarliestUpload().GetTime());
}
else
{
failedCompanionItemNames.AddUnique(companion.Name);
}
}
}
catch (Exception ex)
{
VF_RealmPlayersDatabase.Logger.LogException(ex);
}
}
}
VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Failed to add Mounts with names: " + String.Join("\", \"", failedMountItemNames.ToArray()) + "\"");
VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Failed to add Companions with names: " + String.Join("\", \"", failedCompanionItemNames.ToArray()) + "\"");
}
public void UpdateDatabase(RPPDatabase _Database)
{
UpdateDatabase(_Database, DateTime.MinValue);
}
public static void UpdateSummaryDatabase(string _RootDirectory, RPPDatabase _Database, bool _UpdateAllHistory = false)
{
ItemSummaryDatabase database = null;
string databaseFile = _RootDirectory + "\\SummaryDatabase\\ItemSummaryDatabase.dat";
if (System.IO.File.Exists(databaseFile) == true)
{
if (VF.Utility.LoadSerialize(databaseFile, out database, 10000, true) == false)
{
database = null;
}
//Update the new dictionary realm with all the old entitycounters!
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Emerald_Dream, database.m_EntityCounter_Emerald_Dream);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Warsong, database.m_EntityCounter_Warsong);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Al_Akir, database.m_EntityCounter_Al_Akir);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Valkyrie, database.m_EntityCounter_Valkyrie);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.VanillaGaming, database.m_EntityCounter_VanillaGaming);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Rebirth, database.m_EntityCounter_Rebirth);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Archangel, database.m_EntityCounter_Archangel);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Nostalrius, database.m_EntityCounter_Nostalrius);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Kronos, database.m_EntityCounter_Kronos);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.NostalGeek, database.m_EntityCounter_NostalGeek);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Nefarian, database.m_EntityCounter_Nefarian);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.NostalriusPVE, database.m_EntityCounter_NostalriusPVE);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.WarsongTBC, database.m_EntityCounter_WarsongTBC);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.KronosII, database.m_EntityCounter_KronosII);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Vengeance_Wildhammer, database.m_EntityCounter_Vengeance_Wildhammer);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.ExcaliburTBC, database.m_EntityCounter_ExcaliburTBC);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.L4G_Hellfire, database.m_EntityCounter_L4G_Hellfire);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Warsong2, database.m_EntityCounter_Warsong2);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Vengeance_Stonetalon, database.m_EntityCounter_Vengeance_Stonetalon);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Elysium, database.m_EntityCounter_Elysium);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Elysium2, database.m_EntityCounter_Elysium2);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Zeth_Kur, database.m_EntityCounter_Zeth_Kur);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Nemesis, database.m_EntityCounter_Nemesis);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.HellGround, database.m_EntityCounter_HellGround);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Nostralia, database.m_EntityCounter_Nostralia);
database.m_EntityCounters_Realm.AddIfKeyNotExist(WowRealm.Hellfire2, database.m_EntityCounter_Hellfire2);
}
//if (database != null)
//{
// foreach (var guild in database.m_Guilds)
// {
// guild.Value.InitCache();
// }
//}
if (database == null)
{
database = new ItemSummaryDatabase();
database.UpdateDatabase(_Database);
}
else
{
if (_UpdateAllHistory == true)
{
database.UpdateDatabase(_Database);
}
else
{
database.UpdateDatabase(_Database, DateTime.UtcNow.AddDays(-8));
}
}
VF.Utility.SaveSerialize(databaseFile, database);
}
public RPPDatabase(string _DatabaseDirectory)
{
m_RPPDatabase = GetDatabase(_DatabaseDirectory);
}
private static VF_RealmPlayersDatabase.Database _NotCached_GetDatabase(string _DatabaseDirectory)
{
VF_RealmPlayersDatabase.Database rppDatabase = new VF_RealmPlayersDatabase.Database(_DatabaseDirectory);
rppDatabase.PurgeRealmDBs(true, false);
return(rppDatabase);
}
