Exemple #1
0
        public void UpdatePlayer(System.Xml.XmlNode _PlayerNode, Contributor _Contributor, Func <int, VF.SQLUploadID> _GetSQLUploadIDFunc)
        {
            string   playerName = PlayerData.DataParser.ParsePlayerName(_PlayerNode);
            DateTime lastSeen   = PlayerData.DataParser.ParseLastSeenUTC(_PlayerNode);

            if (lastSeen > DateTime.UtcNow)
            {
                if (lastSeen > DateTime.UtcNow.AddMinutes(2))
                {
                    //Tillåt inte data som är från framtiden(wtf) flagga Contributor som opålitlig
                    _Contributor.SetWarningFlag(Contributor.WarningFlag.DataFromFuture);
                    return;
                }
                lastSeen = DateTime.UtcNow;                 //Om det är OK så sätter vi LastSeen till UtcNow istället.
            }
            if ((DateTime.UtcNow - lastSeen).TotalDays > 5) //Tillåt inte data som är äldre än 5 dagar
            {
                return;
            }
            //if (lastSeen < DATE_HONOR_CORRUPTION)// Honor corruption occured the 16th January, uncomment this line after 5 days have passed!
            //{
            //    Logger.ConsoleWriteLine("Someone submitted data that was during the Honor Corruption. Good thing i implemented this code!!!", ConsoleColor.Red);
            //    return;
            //}
            var uploadID = _Contributor.GetUploadID(lastSeen);

            PlayerData.Player        currPlayer        = GetPlayer(playerName);
            PlayerData.PlayerHistory currPlayerHistory = GetPlayerHistory(playerName);
            currPlayer.Update(_PlayerNode, uploadID, lastSeen, currPlayerHistory, WowVersion, _GetSQLUploadIDFunc);
            try
            {
                //ANVÄND INTE = tecken innuti savedvariables data!!!!!!!!! då buggar det ur totalt
                string extraData = XMLUtility.GetChildValue(_PlayerNode, "ExtraData", "");
                if (extraData != "")
                {
                    VF.SQLPlayerID playerID;
                    using (VF.SQLComm comm = new VF.SQLComm())
                    {
                        if (comm.GetPlayerID(Realm, playerName, out playerID) == false)
                        {
                            Logger.ConsoleWriteLine("Could not find SQL PlayerID for Player \"" + playerName + "\"");
                        }
                    }
                    var currPlayerExtraData = GetPlayerExtraData(playerName);
                    currPlayerExtraData.AddData(uploadID, extraData, playerID, _GetSQLUploadIDFunc);
                }
            }
            catch (NpgsqlException ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                Logger.LogException(ex);
            }
            Updated = true;
        }
        public void MigrateToSQL()
        {
            Dictionary <ulong, VF.SQLPlayerID> playerIDConverter = new Dictionary <ulong, VF.SQLPlayerID>();

            using (VF.SQLComm comm = new VF.SQLComm())
            {
                int      totalItemsCount       = m_Items.Count;
                int      itemsProcessedCounter = 0;
                DateTime startTime             = DateTime.UtcNow;
                DateTime prevLogTime           = DateTime.UtcNow;
                foreach (var itemSummary in m_Items)
                {
                    ++itemsProcessedCounter;
                    foreach (var itemOwner in itemSummary.Value.m_ItemOwners)
                    {
                        VF.SQLPlayerID playerID;
                        if (playerIDConverter.TryGetValue(itemOwner.Item1, out playerID) == false)
                        {
                            string   playerName = GetPlayerName(itemOwner.Item1);
                            WowRealm realm      = GetPlayerRealm(itemOwner.Item1);

                            if (comm.GetPlayerID(realm, playerName, out playerID) == true)
                            {
                                playerIDConverter.Add(itemOwner.Item1, playerID);
                            }
                            else
                            {
                                VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("playerID was not valid for player \"" + playerName + "\"", ConsoleColor.Red);
                            }
                        }
                        if (playerID.IsValid() == true)
                        {
                            if (comm.UpsertItemOwner(itemSummary.Value.m_ItemID, itemSummary.Value.m_SuffixID, playerID, null, itemOwner.Item2) == false)
                            {
                                VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("UpsertItemOwner Failed???", ConsoleColor.Red);
                            }
                        }
                    }
                    if ((DateTime.UtcNow - prevLogTime).TotalSeconds > 5)
                    {
                        VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Processed " + itemsProcessedCounter + " / " + totalItemsCount + " items");
                        prevLogTime = DateTime.UtcNow;
                    }
                }
                VF_RealmPlayersDatabase.Logger.ConsoleWriteLine("Done with processing " + totalItemsCount + " items, it took " + (DateTime.UtcNow - startTime).ToString());
            }
        }
Exemple #3
0
        public void UpdatePlayer(System.Xml.XmlNode _PlayerNode, Contributor _Contributor, Func <int, VF.SQLUploadID> _GetSQLUploadIDFunc)
        {
            string   playerName = PlayerData.DataParser.ParsePlayerName(_PlayerNode);
            DateTime lastSeen   = PlayerData.DataParser.ParseLastSeenUTC(_PlayerNode);

            if (lastSeen > DateTime.UtcNow)
            {
                if (lastSeen > DateTime.UtcNow.AddMinutes(2))
                {
                    //Tillåt inte data som är från framtiden(wtf) flagga Contributor som opålitlig
                    _Contributor.SetWarningFlag(Contributor.WarningFlag.DataFromFuture);
                    return;
                }
                lastSeen = DateTime.UtcNow;                                                        //Om det är OK så sätter vi LastSeen till UtcNow istället.
            }
            if ((DateTime.UtcNow - lastSeen).TotalDays > 5)                                        //Tillåt inte data som är äldre än 5 dagar
            {
                if (Realm == WowRealm.Northdale && lastSeen < new DateTime(2018, 6, 23, 12, 0, 0)) //Do not allow inspects before server even opened...
                {
                    return;
                }
                if (DateTime.UtcNow < new DateTime(2018, 9, 1) && lastSeen > new DateTime(2018, 4, 1))
                {
                    //Special case, allow this! We are temporary allowing adding some old data!
                }
                else
                {
                    return;
                }
            }
            //if (lastSeen < DATE_HONOR_CORRUPTION)// Honor corruption occured the 16th January, uncomment this line after 5 days have passed!
            //{
            //    Logger.ConsoleWriteLine("Someone submitted data that was during the Honor Corruption. Good thing i implemented this code!!!", ConsoleColor.Red);
            //    return;
            //}
            var uploadID = _Contributor.GetUploadID(lastSeen);

            PlayerData.Player        currPlayer        = GetPlayer(playerName);
            PlayerData.PlayerHistory currPlayerHistory = GetPlayerHistory(playerName);
            currPlayer.Update(_PlayerNode, uploadID, lastSeen, currPlayerHistory, WowVersion, _GetSQLUploadIDFunc);
            try
            {
                //ANVÄND INTE = tecken innuti savedvariables data!!!!!!!!! då buggar det ur totalt
                string extraData = XMLUtility.GetChildValue(_PlayerNode, "ExtraData", "");
                if (extraData != "")
                {
#if UPDATE_SQL_DB
                    VF.SQLPlayerID playerID;
                    using (VF.SQLComm comm = new VF.SQLComm())
                    {
                        if (comm.GetPlayerID(Realm, playerName, out playerID) == false)
                        {
                            Logger.ConsoleWriteLine("Could not find SQL PlayerID for Player \"" + playerName + "\"");
                        }
                    }
                    var currPlayerExtraData = GetPlayerExtraData(playerName);
                    currPlayerExtraData.AddData(uploadID, extraData, playerID, _GetSQLUploadIDFunc);
#else
                    if (_GetSQLUploadIDFunc != null)
                    {
                        while (true)
                        {
                            Console.WriteLine("ERROR, SQL USAGE CONFUSION"); System.Threading.Thread.Sleep(5000);
                        }
                    }
                    var currPlayerExtraData = GetPlayerExtraData(playerName);
                    currPlayerExtraData.AddData(uploadID, extraData, null, null);
#endif
                }
            }
            catch (NpgsqlException ex)
            {
                throw ex;
            }
            catch (Exception ex)
            {
                Logger.LogException(ex);
            }
            Updated = true;
        }
Exemple #4
0
        public void UpdateSQL(Func <int, VF.SQLUploadID> _GetSQLUploadIDFunc, UploadID _Uploader /*Contains LastSeen*/, DateTime _LastSeen, PlayerHistory _PlayerHistory, WowVersionEnum _WowVersion
                              , PlayerData.CharacterData _NewCharacter, PlayerData.GuildData _NewGuild, PlayerData.GearData _NewGear, PlayerData.HonorData _NewHonor, PlayerData.ArenaData _NewArena = null, string _NewTalents = null)
        {
            using (VF.SQLComm comm = new VF.SQLComm())
            {
                VF.SQLPlayerData playerData      = VF.SQLPlayerData.Invalid();
                bool             validPlayerData = false;

                VF.SQLPlayerID playerID;
                bool           validPlayerID = false;
                if (comm.GetPlayerID(Realm, Name, out playerID) == true)
                {
                    validPlayerID = true;
                    if (_LastSeen < LastSeen)
                    {
                        if (comm.GetPlayerDataAtTime(playerID, _LastSeen, out playerData) == true)
                        {
                            validPlayerData = true;
                        }
                    }

                    if (validPlayerData == false)
                    {
                        if (comm.GetLatestPlayerData(playerID, out playerData) == true)
                        {
                            validPlayerData = true;
                        }
                    }
                }

                if (validPlayerData == true)
                {
                    bool playerDataChanged = false;
                    if (playerData.PlayerCharacter.IsSame(_NewCharacter) == false)
                    {
                        playerData.PlayerCharacter = _NewCharacter;
                        playerDataChanged          = true;
                    }

                    PlayerData.GuildData playerDataGuildData;
                    if (comm.GetPlayerGuildData(playerData, out playerDataGuildData) == true)
                    {
                        if (playerDataGuildData.IsSame(_NewGuild) == false)
                        {
                            playerData.PlayerGuildID = comm.GenerateNewPlayerGuildDataEntry(_NewGuild);
                            playerDataChanged        = true;
                        }
                    }
                    else if (playerData.PlayerGuildID == 0)
                    {
                        playerData.PlayerGuildID = comm.GenerateNewPlayerGuildDataEntry(_NewGuild);
                        if (playerData.PlayerGuildID != 0)
                        {
                            playerDataChanged = true;
                        }
                    }

                    PlayerData.GearData playerDataGearData;
                    if (comm.GetPlayerGearData(playerData, out playerDataGearData) == true)
                    {
                        if (playerDataGearData.IsSame(_NewGear) == false)
                        {
                            playerData.PlayerGearID = comm.GenerateNewPlayerGearDataEntry(_NewGear, _WowVersion);
                            playerDataChanged       = true;
                        }
                    }
                    else if (playerData.PlayerGearID == 0)
                    {
                        playerData.PlayerGearID = comm.GenerateNewPlayerGearDataEntry(_NewGear, _WowVersion);
                        if (playerData.PlayerGearID != 0)
                        {
                            playerDataChanged = true;
                        }
                    }

                    PlayerData.HonorData playerDataHonorData;
                    if (comm.GetPlayerHonorData(playerData, out playerDataHonorData) == true)
                    {
                        if (playerDataHonorData.IsSame(_NewHonor, _WowVersion) == false)
                        {
                            playerData.PlayerHonorID = comm.GenerateNewPlayerHonorDataEntry(_NewHonor, _WowVersion);
                            playerDataChanged        = true;
                        }
                    }
                    else if (playerData.PlayerHonorID == 0)
                    {
                        playerData.PlayerHonorID = comm.GenerateNewPlayerHonorDataEntry(_NewHonor, _WowVersion);
                        if (playerData.PlayerHonorID != 0)
                        {
                            playerDataChanged = true;
                        }
                    }

                    if (_WowVersion == WowVersionEnum.TBC)
                    {
                        PlayerData.ArenaData playerDataArenaData;
                        if (comm.GetPlayerArenaData(playerData, out playerDataArenaData) == true)
                        {
                            if (playerDataArenaData.IsSame(_NewArena) == false)
                            {
                                playerData.PlayerArenaID = comm.GenerateNewPlayerArenaInfoEntry(_NewArena);
                                playerDataChanged        = true;
                            }
                        }
                        else if (playerData.PlayerArenaID == 0)
                        {
                            playerData.PlayerArenaID = comm.GenerateNewPlayerArenaInfoEntry(_NewArena);
                            if (playerData.PlayerArenaID != 0)
                            {
                                playerDataChanged = true;
                            }
                        }

                        string playerDataTalentsData;
                        if (comm.GetPlayerTalentsData(playerData, out playerDataTalentsData) == true)
                        {
                            if (playerDataTalentsData == _NewTalents)
                            {
                                playerData.PlayerTalentsID = comm.GenerateNewPlayerTalentsDataEntry(_NewTalents);
                                playerDataChanged          = true;
                            }
                        }
                        else if (playerData.PlayerTalentsID == 0)
                        {
                            playerData.PlayerTalentsID = comm.GenerateNewPlayerTalentsDataEntry(_NewTalents);
                            if (playerData.PlayerTalentsID != 0)
                            {
                                playerDataChanged = true;
                            }
                        }
                    }

                    if (playerDataChanged == true)
                    {
                        playerData.UpdateTime = _LastSeen;
                        playerData.UploadID   = _GetSQLUploadIDFunc(0);

                        if (comm.GenerateNewPlayerDataEntry(playerData) == false)
                        {
                            Logger.ConsoleWriteLine("Failed to update PlayerData for player \"" + Name + "\"", ConsoleColor.Red);
                        }

                        if (_LastSeen > LastSeen)
                        {
                            //Also update the latestupdateid in playertable since this is the latest available data!
                            if (comm.UpdatePlayerEntry(playerData.PlayerID, playerData.UploadID) == false)
                            {
                                Logger.ConsoleWriteLine("Failed to update LatestUploadID for player \"" + Name + "\"", ConsoleColor.Red);
                            }
                        }
                    }
                }
                else
                {
                    Player newPlayer = new Player();
                    newPlayer.Name             = Name;
                    newPlayer.Realm            = Realm;
                    newPlayer.Character        = _NewCharacter;
                    newPlayer.Guild            = _NewGuild;
                    newPlayer.Gear             = _NewGear;
                    newPlayer.Honor            = _NewHonor;
                    newPlayer.Arena            = _NewArena;
                    newPlayer.TalentPointsData = _NewTalents;
                    newPlayer.LastSeen         = _LastSeen;

                    //Assume PlayerID did not exist!!!
                    if (validPlayerID == true)
                    {
                        //OK PlayerID exists, so maybe this is just an earlier data than currently exists at all for player.
                        //This case should be handled above though, so if this happens something is very weird and unexpected!
                        //This issue can be resolved automatically, it should never happen normally. But if it does...
                        Logger.ConsoleWriteLine("Unexpected problem when updating PlayerData for player \"" + Name + "\"", ConsoleColor.Red);
                        if (comm.UpdateLatestPlayerDataEntry(playerID, _GetSQLUploadIDFunc(0), newPlayer).ID == playerID.ID)
                        {
                            Logger.ConsoleWriteLine("Unexpected problem was resolved successfully!", ConsoleColor.Green);
                        }
                        else
                        {
                            Logger.ConsoleWriteLine("\n--------------------------------------------\nERROR ERROR ERRO ERROR ERROR\nWhen attempting to fix unexpected problem for player \"" + Name + "\" it did not work!!!\n--------------------------------------------\n", ConsoleColor.Red);
                        }
                    }
                    else
                    {
                        if (comm.GenerateNewPlayerEntry(_GetSQLUploadIDFunc(0), newPlayer).IsValid() == false)
                        {
                            Logger.ConsoleWriteLine("Unexpected problem when creating new SQLPlayerID for player \"" + Name + "\"", ConsoleColor.Red);
                        }
                    }
                }
            }
        }