public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            GD = GenericData;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            GD.ConnectToDatabase(defaultConnectionString, "Generics",
                                 source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

            DataManager.DataManager.RegisterPlugin(Name + "Local", this);

            m_maxOfflineMessages = source.Configs["AuroraConnectors"].GetInt("MaxOfflineMessages", m_maxOfflineMessages);
            m_maxGroupOfflineMessages = source.Configs["AuroraConnectors"].GetInt("MaxGroupOfflineMessages",
                                                                                  m_maxGroupOfflineMessages);
            m_saveGroupOfflineMessages = source.Configs["AuroraConnectors"].GetBoolean("SaveOfflineGroupChatMessages",
                                                                                       m_saveGroupOfflineMessages);
            if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") ==
                "LocalConnector")
            {
                DataManager.DataManager.RegisterPlugin(this);
            }
            Init(simBase, Name);
        }
        public void Initialize(IGenericData GenericData, ISimulationBase simBase, string defaultConnectionString)
        {
            IConfigSource source = simBase.ConfigSource;
            if (source.Configs["AuroraConnectors"].GetString("AgentConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString);

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
            else
            {
                //Check to make sure that something else exists
                string m_ServerURI = simBase.ApplicationRegistry.RequestModuleInterface<IAutoConfigurationService>().FindValueOf("RemoteServerURI", "AuroraData");
                if (m_ServerURI == "") //Blank, not set up
                {
                    OpenSim.Framework.Console.MainConsole.Instance.Output("[AuroraDataService]: Falling back on local connector for " + "AgentConnector", "None");
                    GD = GenericData;

                    if (source.Configs[Name] != null)
                        defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                    GD.ConnectToDatabase(defaultConnectionString);

                    DataManager.DataManager.RegisterPlugin(Name, this);
                }
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            m_gd = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];
            if (config == null || source.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
                return;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GenericData != null)
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            DataManager.RegisterPlugin(Name, this);

            m_config = new SimpleCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

            if (!m_doRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand("money add", "money add", "Adds money to a user's account.",
                                                         AddMoney);
                MainConsole.Instance.Commands.AddCommand("money set", "money set",
                                                         "Sets the amount of money a user has.",
                                                         SetMoney);
                MainConsole.Instance.Commands.AddCommand("money get", "money get",
                                                         "Gets the amount of money a user has.",
                                                         GetMoney);
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            GD = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];
            if (config == null || source.Configs["Currency"].GetString("Module", "") != "BaseCurrency")
                return;

            IConfig gridInfo = source.Configs["GridInfoService"];
            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString ("CurrencySymbol", string.Empty) + " ";
                RealCurrency = gridInfo.GetString ("RealCurrencySymbol", string.Empty) + " ";
            }

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GenericData != null)
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

        }
        public void Initialize(IGenericData GenericData, IConfigSource source, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("ProfileConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString);

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
            else
            {
                //Check to make sure that something else exists
                string m_ServerURI = source.Configs["AuroraData"].GetString("RemoteServerURI", "");
                if (m_ServerURI == "") //Blank, not set up
                {
                    OpenSim.Framework.Console.MainConsole.Instance.Output("[AuroraDataService]: Falling back on local connector for " + "ProfileConnector", "None");
                    GD = GenericData;

                    if (source.Configs[Name] != null)
                        defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                    GD.ConnectToDatabase(defaultConnectionString);

                    DataManager.DataManager.RegisterPlugin(Name, this);
                }
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            GD = GenericData;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            GD.ConnectToDatabase(defaultConnectionString, "AbuseReports",
                                 source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

            DataManager.DataManager.RegisterPlugin(Name + "Local", this);
            if (source.Configs["AuroraConnectors"].GetString("AbuseReportsConnector", "LocalConnector") ==
                "LocalConnector")
            {
                WebPassword = Util.Md5Hash(source.Configs["Handlers"].GetString("WireduxHandlerPassword", String.Empty));

                //List<string> Results = GD.Query("Method", "abusereports", "passwords", "Password");
                //if (Results.Count == 0)
                //{
                //    string newPass = MainConsole.Instance.PasswdPrompt("Password to access Abuse Reports");
                //    GD.Insert("passwords", new object[] { "abusereports", Util.Md5Hash(Util.Md5Hash(newPass)) });
                //}
                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
Esempio n. 7
0
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("UserInfoConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                string connectionString = defaultConnectionString;
                if (source.Configs[Name] != null)
                {
                    connectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                    m_allowDuplicatePresences =
                        source.Configs[Name].GetBoolean("AllowDuplicatePresences",
                                                        m_allowDuplicatePresences);
                    m_checkLastSeen =
                        source.Configs[Name].GetBoolean("CheckLastSeen",
                                                        m_checkLastSeen);
                }
                GD.ConnectToDatabase(connectionString, "UserInfo",
                                     source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

                DataManager.DataManager.RegisterPlugin(this);
            }
        }
 public void Initialize(IGenericData unneeded, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") == "SimianConnector")
     {
         m_ServerURIs = simBase.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI");
         DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
        public void Initialize(IGenericData GenericData, Nini.Config.IConfigSource source, IRegistryCore simBase, string DefaultConnectionString)
        {
            DataManager.DataManager.RegisterPlugin(this);

            string path = Util.BasePathCombine(System.IO.Path.Combine("data", "OpenRegionSettingsPage.html"));
            if(System.IO.File.Exists(path))
                HTMLPage = System.IO.File.ReadAllText(path);
        }
 public void Initialize(IGenericData unneeded, IConfigSource source, string DefaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") == "SimianConnector")
     {
         m_ServerURI = source.Configs["AuroraData"].GetString("RemoteServerURI", "");
         DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
 public void Initialize(IGenericData unneeded, ISimulationBase simBase, string DefaultConnectionString)
 {
     if (simBase.ConfigSource.Configs["AuroraConnectors"].GetString("MuteListConnector", "LocalConnector") == "SimianConnector")
     {
         m_ServerURIs = simBase.ApplicationRegistry.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI");
         DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
Esempio n. 12
0
 public void Initialize(IGenericData unneeded, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
 {
     m_registry = simBase;
     if (source.Configs["AuroraConnectors"].GetString("ProfileConnector", "LocalConnector") == "RemoteConnector")
     {
         DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
 public void Initialize(IGenericData GenericData, IConfigSource source, string DefaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString("GroupsConnector", "LocalConnector") == "RemoteConnector")
     {
         m_ServerURI = source.Configs["AuroraData"].GetString("RemoteServerURI", "");
         if (m_ServerURI != "")
             DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
 public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                        string defaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString("GroupsConnector", "LocalConnector") == "RemoteConnector")
     {
         m_registry = simBase;
         DataManager.DataManager.RegisterPlugin(this);
     }
 }
 public void Initialize(IGenericData GenericData, ISimulationBase simBase, string defaultConnectionString)
 {
     IConfigSource source = simBase.ConfigSource;
     if (source.Configs["AuroraConnectors"].GetString("GroupsConnector", "LocalConnector") == "RemoteConnector")
     {
         m_ServerURIs = simBase.ApplicationRegistry.RequestModuleInterface<IConfigurationService>().FindValueOf("RemoteServerURI");
         if (m_ServerURIs.Count != 0)
             DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
 public void Initialize(IGenericData unneeded, ISimulationBase simBase, string defaultConnectionString)
 {
     IConfigSource source = simBase.ConfigSource;
     if (source.Configs["AuroraConnectors"].GetString("OfflineMessagesConnector", "LocalConnector") == "RemoteConnector")
     {
         m_ServerURI = simBase.ApplicationRegistry.RequestModuleInterface<IAutoConfigurationService>().FindValueOf("RemoteServerURI", "AuroraData");
         if (m_ServerURI != "")
             DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
 public void Initialize(IGenericData unneeded, IConfigSource source, string DefaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString("RegionConnector", "LocalConnector") == "SimianConnector")
     {
         m_ServerURI = source.Configs["AuroraData"].GetString("RemoteServerURI", string.Empty);
         
         //If blank, no connector
         if (m_ServerURI != string.Empty)
             DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
Esempio n. 18
0
 public void Initialize (IGenericData unneeded, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
 {
     if (source.Configs["AuroraConnectors"].GetString ("ProfileConnector", "LocalConnector") == "IWCConnector")
     {
         m_localService = new LocalProfileConnector ();
         m_localService.Initialize (unneeded, source, simBase, defaultConnectionString);
         m_remoteService = new RemoteProfileConnector ();
         m_remoteService.Initialize (unneeded, source, simBase, defaultConnectionString);
         m_registry = simBase;
         DataManager.DataManager.RegisterPlugin (Name, this);
     }
 }
        /// <summary>
        ///   Starts the database plugin, performs migrations if needed
        /// </summary>
        /// <param name = "GenericData">The Database Plugin</param>
        /// <param name = "source">Config if more parameters are needed</param>
        /// <param name="simBase"></param>
        /// <param name = "DefaultConnectionString">The connection string to use</param>
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string DefaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("SchedulerConnector", "LocalConnector") != "LocalConnector")
                return;

            if (source.Configs[Name] != null)
                DefaultConnectionString = source.Configs[Name].GetString("ConnectionString", DefaultConnectionString);
            GenericData.ConnectToDatabase(DefaultConnectionString, "Scheduler",
                                          source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

            m_Gd = GenericData;
            DataManager.DataManager.RegisterPlugin(this);
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("AvatarArchiverConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString);
                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
        public void Initialize(IGenericData genericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("AssetConnector", "LocalConnector") != "LocalConnector")
                return;
            m_Gd = genericData;

            m_Log.Warn("Asset Database is using " + ((IDataConnector)genericData).Identifier);

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            genericData.ConnectToDatabase(defaultConnectionString, "Asset", source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));
            DataManager.DataManager.RegisterPlugin(Name, this);
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("WebStatsDataConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString, "Stats", source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
        /// <summary>
        ///     Starts the database plugin, performs migrations if needed
        /// </summary>
        /// <param name="genericData">The Database Plugin</param>
        /// <param name="source">Config if more parameters are needed</param>
        /// <param name="simBase"></param>
        /// <param name="defaultConnectionString">The connection string to use</param>
        public void Initialize(IGenericData genericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            if (source.Configs["WhiteCoreConnectors"].GetString("SchedulerConnector", "LocalConnector") != "LocalConnector")
                return;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
            if (genericData != null)
                genericData.ConnectToDatabase(defaultConnectionString, "Scheduler",
                                              source.Configs["WhiteCoreConnectors"].GetBoolean("ValidateTables", true));

            GD = genericData;
            Framework.Utilities.DataManager.RegisterPlugin(this);
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, string defaultConnectionString)
        {
            //Disabled for now until it is fixed
            if (source.Configs["AuroraConnectors"].GetString("RegionInfoConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString);

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry, string DefaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("PresenceInfoConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                {
                    DefaultConnectionString = source.Configs[Name].GetString("ConnectionString", DefaultConnectionString);
                    DatabaseToAuthTable = source.Configs[Name].GetString("DatabasePathToAuthTable", DatabaseToAuthTable);
                }
                GD.ConnectToDatabase(DefaultConnectionString, "PresenceInfo", true);
                DataManager.DataManager.RegisterPlugin(this);
            }
        }
        public void Initialize(IGenericData GenericData, ISimulationBase simBase, string defaultConnectionString)
        {
            IConfigSource source = simBase.ConfigSource;
            if (source.Configs["AuroraConnectors"].GetString("WebStatsDataConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                if (source.Configs[Name] != null)
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(defaultConnectionString);

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
        public void Initialize (IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            if (source.Configs ["UniverseConnectors"].GetString ("FriendsConnector", "LocalConnector") != "LocalConnector")
                return;

            GD = GenericData;

            string connectionString = defaultConnectionString;
            if (source.Configs [Name] != null)
                connectionString = source.Configs [Name].GetString ("ConnectionString", defaultConnectionString);

            if (GD != null)
                GD.ConnectToDatabase (connectionString, "Friends", source.Configs ["UniverseConnectors"].GetBoolean ("ValidateTables", true));

            Framework.Utilities.DataManager.RegisterPlugin (this);
        }
        public override void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("InventoryConnector", "LocalConnector") == "RobustConnector")
            {
                GD = GenericData;
                m_registry = simBase;

                string connectionString = defaultConnectionString;
                if (source.Configs[Name] != null)
                    connectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

                GD.ConnectToDatabase(connectionString, "Inventory", source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

                DataManager.DataManager.RegisterPlugin(Name, this);
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            GD = GenericData;

            if (source.Configs[Name] != null)
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);

            if (GD != null)
                GD.ConnectToDatabase(defaultConnectionString, "Asset", source.Configs["UniverseConnectors"].GetBoolean("ValidateTables", true));

            Framework.Utilities.DataManager.RegisterPlugin(Name + "Local", this);

            if (source.Configs["UniverseConnectors"].GetString("AssetConnector", "LocalConnector") == "LocalConnector")
            {
                Framework.Utilities.DataManager.RegisterPlugin(this);
            }
        }
 public void Initialize(IGenericData unneeded, ISimulationBase simBase, string defaultConnectionString)
 {
     IConfigSource source = simBase.ConfigSource;
     if (source.Configs["AuroraConnectors"].GetString("AssetConnector", "LocalConnector") == "RemoteConnector")
     {
         //Later thought... we really do need just the AuroraServerURI, since it won't work with the normal grid server most of the time
         //We want the grid server URL, but if we can't find it, resort to trying the default Aurora one
         /*if (source.Configs["GridService"].GetString("GridServerURI", string.Empty) != string.Empty)
             m_ServerURI = source.Configs["GridService"].GetString("GridServerURI", string.Empty);
         else */
         m_ServerURI = simBase.ApplicationRegistry.RequestModuleInterface<IAutoConfigurationService>().FindValueOf("RemoteServerURI", "AuroraData");
         
         //If both are blank, no connector
         if (m_ServerURI != string.Empty)
             DataManager.DataManager.RegisterPlugin(Name, this);
     }
 }
Esempio n. 31
0
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            GD = GenericData;

            if (source.Configs[Name] != null)
            {
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
            }

            if (GD != null)
            {
                GD.ConnectToDatabase(defaultConnectionString, "AbuseReports",
                                     source.Configs["UniverseConnectors"].GetBoolean("ValidateTables", true));
            }

            Framework.Utilities.DataManager.RegisterPlugin(Name + "Local", this);
            if (source.Configs["UniverseConnectors"].GetString("AbuseReportsConnector", "LocalConnector") ==
                "LocalConnector")
            {
                Framework.Utilities.DataManager.RegisterPlugin(this);
            }
        }
Esempio n. 32
0
        /// <summary>
        ///     Gets a list of OSDMaps from the database
        /// </summary>
        /// <param name="OwnerID"></param>
        /// <param name="Type"></param>
        /// <param name="GD"></param>
        /// <returns></returns>
        public static List <OSDMap> GetGenerics(UUID OwnerID, string Type, IGenericData GD)
        {
            QueryFilter filter = new QueryFilter();

            filter.andFilters["OwnerID"] = OwnerID;
            filter.andFilters["Type"]    = Type;
            List <string> retVal = GD.Query(new string[1] {
                "`value`"
            }, "generics", filter, null, null, null);

            List <OSDMap> Values = new List <OSDMap>();

            foreach (string ret in retVal)
            {
                OSDMap map = (OSDMap)OSDParser.DeserializeJson(ret);
                if (map != null)
                {
                    Values.Add(map);
                }
            }

            return(Values);
        }
Esempio n. 33
0
        public virtual void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase,
                                       string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("InventoryConnector", "LocalConnector") == "LocalConnector")
            {
                GD = GenericData;

                string connectionString = defaultConnectionString;
                if (source.Configs[Name] != null)
                {
                    connectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
                }

                if (GD != null)
                {
                    GD.ConnectToDatabase(connectionString, "Inventory",
                                         source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));
                }

                Framework.Utilities.DataManager.RegisterPlugin(this);
            }
            m_registry = simBase;
        }
Esempio n. 34
0
        /// <summary>
        ///   Gets a list of generic T's from the database
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <param name = "OwnerID"></param>
        /// <param name = "Type"></param>
        /// <param name = "GD"></param>
        /// <param name = "data">a default T</param>
        /// <returns></returns>
        public static List <T> GetGenerics <T>(UUID OwnerID, string Type, IGenericData GD) where T : IDataTransferable
        {
            Dictionary <string, object> where = new Dictionary <string, object>(3);
            where["OwnerID"] = OwnerID;
            where["Type"]    = Type;
            List <string> retVal = GD.Query(new string[1] {
                "`value`"
            }, "generics", new QueryFilter
            {
                andFilters = where
            }, null, null, null);

            List <T> Values = new List <T>();

            foreach (string ret in retVal)
            {
                OSDMap map  = (OSDMap)OSDParser.DeserializeJson(ret);
                T      data = (T)System.Activator.CreateInstance(typeof(T));
                data.FromOSD(map);
                Values.Add(data);
            }

            return(Values);
        }
Esempio n. 35
0
        /// <summary>
        ///   Gets a Generic type as set by T
        /// </summary>
        /// <typeparam name = "T"></typeparam>
        /// <param name = "OwnerID"></param>
        /// <param name = "Type"></param>
        /// <param name = "Key"></param>
        /// <param name = "GD"></param>
        /// <param name = "data">a default T to copy all data into</param>
        /// <returns></returns>
        public static T GetGeneric <T>(UUID OwnerID, string Type, string Key, IGenericData GD) where T : IDataTransferable
        {
            Dictionary <string, object> where = new Dictionary <string, object>(3);
            where["OwnerID"] = OwnerID;
            where["Type"]    = Type;
            where["`Key`"]   = Key;
            List <string> retVal = GD.Query(new string[1] {
                "`value`"
            }, "generics", new QueryFilter
            {
                andFilters = where
            }, null, null, null);

            if (retVal.Count == 0)
            {
                return(null);
            }

            OSDMap map  = (OSDMap)OSDParser.DeserializeJson(retVal[0]);
            T      data = (T)System.Activator.CreateInstance(typeof(T));

            data.FromOSD(map);
            return(data);
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string defaultConnectionString)
        {
            if (source.Configs["AuroraConnectors"].GetString("AbuseReportsConnector", "LocalConnector") == "LocalConnector")
            {
                WebPassword = Util.Md5Hash(source.Configs["Handlers"].GetString("WireduxHandlerPassword", String.Empty));

                GD = GenericData;

                if (source.Configs[Name] != null)
                {
                    defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
                }

                GD.ConnectToDatabase(defaultConnectionString, "AbuseReports", source.Configs["AuroraConnectors"].GetBoolean("ValidateTables", true));

                //List<string> Results = GD.Query("Method", "abusereports", "passwords", "Password");
                //if (Results.Count == 0)
                //{
                //    string newPass = MainConsole.Instance.PasswdPrompt("Password to access Abuse Reports");
                //    GD.Insert("passwords", new object[] { "abusereports", Util.Md5Hash(Util.Md5Hash(newPass)) });
                //}
                DataManager.DataManager.RegisterPlugin(Name + "Local", this);
            }
        }
Esempio n. 37
0
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            GD         = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];

            if (config == null || source.Configs["Currency"].GetString("Module", "") != "BaseCurrency")
            {
                return;
            }

            IConfig gridInfo = source.Configs["GridInfoService"];

            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString("CurrencySymbol", string.Empty) + " ";
                RealCurrency    = gridInfo.GetString("RealCurrencySymbol", string.Empty) + " ";
            }

            if (source.Configs[Name] != null)
            {
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
            }

            if (GenericData != null)
            {
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            }
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");
        }
Esempio n. 38
0
        public void Initialize(IGenericData genericData, IConfigSource source, IRegistryCore simBase,
                               string defaultConnectionString)
        {
            genData = genericData;

            if (source.Configs [Name] != null)
            {
                defaultConnectionString = source.Configs [Name].GetString("ConnectionString", defaultConnectionString);
            }

            if (genData != null)
            {
                genData.ConnectToDatabase(defaultConnectionString, "Agent",
                                          source.Configs ["WhiteCoreConnectors"].GetBoolean("ValidateTables", true));
            }
            Framework.Utilities.DataManager.RegisterPlugin(Name + "Local", this);

            if (source.Configs ["WhiteCoreConnectors"].GetString("AgentConnector", "LocalConnector") == "LocalConnector")
            {
                Framework.Utilities.DataManager.RegisterPlugin(this);
            }

            Init(simBase, Name);
        }
Esempio n. 39
0
        public void Initialise(IConfigSource config, IRegistryCore registry, List <Type> types)
        {
            IConfig m_config = config.Configs ["WhiteCoreData"];

            if (m_config != null)
            {
                storageProvider  = m_config.GetString("StorageProvider", storageProvider);
                connectionString = m_config.GetString("ConnectionString", connectionString);
            }

            IGenericData dataConnector = null;

            if (storageProvider == "MySQL")
            // Allow for fallback when WhiteCoreData isn't set
            {
                MySQLDataLoader genericData = new MySQLDataLoader();

                dataConnector = genericData;
            }

            /*else if (StorageProvider == "MSSQL2008")
             * {
             *  MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             *  DataConnector = GenericData;
             * }
             * else if (StorageProvider == "MSSQL7")
             * {
             *  MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             *  DataConnector = GenericData;
             * }*/
            else if (storageProvider == "SQLite")
            // Allow for fallback when WhiteCoreData isn't set
            {
                SQLiteLoader genericData = new SQLiteLoader();

                // set default data directory in case it is needed
                var simBase = registry.RequestModuleInterface <ISimulationBase> ();
                genericData.DefaultDataPath = simBase.DefaultDataPath;

                dataConnector = genericData;
            }

            if (dataConnector != null)      // we have a problem if so...
            {
                foreach (Type t in types)
                {
                    List <dynamic> plugins = WhiteCoreModuleLoader.PickupModules(t);
                    foreach (dynamic plugin in plugins)
                    {
                        try {
                            plugin.Initialize(dataConnector.Copy(), config, registry, connectionString);
                        } catch (Exception ex) {
                            if (MainConsole.Instance != null)
                            {
                                MainConsole.Instance.Warn("[DataService]: Exception occurred starting data plugin " +
                                                          plugin.Name + ", " + ex);
                            }
                        }
                    }
                }
            }
        }
Esempio n. 40
0
 public GenericService(IGenericData data)
 {
     this.data = data;
 }
Esempio n. 41
0
 /// <summary>
 ///     Adds a generic into the database
 /// </summary>
 /// <param name="OwnerID">ID of the entity that owns the generic data</param>
 /// <param name="Type"></param>
 /// <param name="Key"></param>
 /// <param name="Value"></param>
 /// <param name="GD"></param>
 public static void AddGeneric(UUID OwnerID, string Type, string Key, OSDMap Value, IGenericData GD)
 {
     Dictionary<string, object> row = new Dictionary<string, object>(4);
     row["OwnerID"] = OwnerID;
     row["Type"] = Type;
     row["`Key`"] = Key;
     row["`Value`"] = OSDParser.SerializeJsonString(Value);
     GD.Replace("generics", row);
 }
Esempio n. 42
0
 /// <summary>
 ///   Removes a generic from the database
 /// </summary>
 /// <param name = "AgentID"></param>
 /// <param name = "Type"></param>
 /// <param name = "GD"></param>
 public static void RemoveGeneric(UUID AgentID, string Type, IGenericData GD)
 {
     GD.Delete("generics", new[] { "OwnerID", "Type" }, new object[] { AgentID, Type });
 }
Esempio n. 43
0
 /// <summary>
 ///   Removes a generic from the database
 /// </summary>
 /// <param name = "OwnerID"></param>
 /// <param name = "Key"></param>
 /// <param name = "GD"></param>
 public static void RemoveGenericByKey(UUID OwnerID, string Key, IGenericData GD)
 {
     GD.Delete("generics", new[] { "OwnerID", "`Key`" }, new object[] { OwnerID, Key });
 }
Esempio n. 44
0
        /// <summary>
        ///     Adds a generic into the database
        /// </summary>
        /// <param name="ownerID">ID of the entity that owns the generic data</param>
        /// <param name="type"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="genData"></param>
        public static void AddGeneric(UUID ownerID, string type, string key, OSDMap value, IGenericData genData)
        {
            Dictionary <string, object> row = new Dictionary <string, object> (4);

            row ["OwnerID"] = ownerID;
            row ["Type"]    = type;
            row ["`Key`"]   = key;
            row ["`Value`"] = OSDParser.SerializeJsonString(value);

            genData.Replace("generics", row);
        }
Esempio n. 45
0
        /// <summary>
        ///     Remove generic data for the specified owner by type and key
        /// </summary>
        /// <param name="ownerID">ID of the entity that owns the generic data</param>
        /// <param name="type"></param>
        /// <param name="key"></param>
        /// <param name="genData"></param>
        public static void RemoveGenericByKeyAndType(UUID ownerID, string type, string key, IGenericData genData)
        {
            QueryFilter filter = new QueryFilter();

            filter.andFilters ["OwnerID"] = ownerID;
            filter.andFilters ["Type"]    = type;
            filter.andFilters ["`Key`"]   = key;

            genData.Delete("generics", filter);
        }
Esempio n. 46
0
 /// <summary>
 ///   Adds a generic into the database
 /// </summary>
 /// <param name = "AgentID"></param>
 /// <param name = "Type"></param>
 /// <param name = "Key"></param>
 /// <param name = "Value"></param>
 /// <param name = "GD"></param>
 public static void AddGeneric(UUID AgentID, string Type, string Key, OSDMap Value, IGenericData GD)
 {
     GD.Replace("generics", new[] { "OwnerID", "Type", "`Key`", "`Value`" },
                new object[] { AgentID, Type, Key, OSDParser.SerializeJsonString(Value) });
 }
Esempio n. 47
0
        public void Initialise(IConfigSource source, IRegistryCore simBase)
        {
            //
            // Try reading the [DatabaseService] section, if it exists
            //
            IConfig dbConfig = source.Configs["DatabaseService"];

            if (dbConfig != null)
            {
                StorageProvider  = dbConfig.GetString("StorageProvider", String.Empty);
                ConnectionString = dbConfig.GetString("ConnectionString", String.Empty);
            }

            //
            // [AuroraData] section overrides [DatabaseService], if it exists
            //
            IConfig m_config = source.Configs["AuroraData"];

            if (m_config != null)
            {
                StorageProvider  = m_config.GetString("StorageProvider", StorageProvider);
                ConnectionString = m_config.GetString("ConnectionString", ConnectionString);
            }

            IGenericData DataConnector = null;

            if (StorageProvider == "MySQL" || StorageProvider == "Aurora.DataManager.MySQL.dll")
            //Allow for fallback when AuroraData isn't set
            {
                MySQLDataLoader GenericData = new MySQLDataLoader();

                DataConnector = GenericData;
            }

            /*else if (StorageProvider == "MSSQL2008")
             * {
             *  MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             *  DataConnector = GenericData;
             * }
             * else if (StorageProvider == "MSSQL7")
             * {
             *  MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             *  DataConnector = GenericData;
             * }*/
            else if (StorageProvider == "SQLite" || StorageProvider == "Aurora.DataManager.SQLite.dll")
            //Allow for fallback when AuroraData isn't set
            {
                SQLiteLoader GenericData = new SQLiteLoader();

                DataConnector = GenericData;
            }

            List <IAuroraDataPlugin> Plugins = AuroraModuleLoader.PickupModules <IAuroraDataPlugin>();

            foreach (IAuroraDataPlugin plugin in Plugins)
            {
                try
                {
                    plugin.Initialize(DataConnector.Copy(), source, simBase, ConnectionString);
                }
                catch (Exception ex)
                {
                    MainConsole.Instance.Warn("[DataService]: Exeception occured starting data plugin " + plugin.Name + ", " + ex.ToString());
                }
            }
        }
        public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore registry,
                               string defaultConnectionString)
        {
            m_gd       = GenericData;
            m_registry = registry;

            IConfig config = source.Configs["Currency"];

            if (config == null || source.Configs["Currency"].GetString("Module", "") != "SimpleCurrency")
            {
                return;
            }

            IConfig gridInfo = source.Configs["GridInfoService"];

            if (gridInfo != null)
            {
                InWorldCurrency = gridInfo.GetString("CurrencySymbol", String.Empty) + " ";
                RealCurrency    = gridInfo.GetString("RealCurrencySymbol", String.Empty) + " ";
            }

            if (source.Configs[Name] != null)
            {
                defaultConnectionString = source.Configs[Name].GetString("ConnectionString", defaultConnectionString);
            }

            if (GenericData != null)
            {
                GenericData.ConnectToDatabase(defaultConnectionString, "SimpleCurrency", true);
            }
            Framework.Utilities.DataManager.RegisterPlugin(Name, this);

            m_config = new BaseCurrencyConfig(config);

            Init(m_registry, Name, "", "/currency/", "CurrencyServerURI");

            if (!m_doRemoteCalls)
            {
                MainConsole.Instance.Commands.AddCommand(
                    "money add",
                    "money add",
                    "Adds money to a user's account.",
                    AddMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "money set",
                    "money set",
                    "Sets the amount of money a user has.",
                    SetMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "money get",
                    "money get",
                    "Gets the amount of money a user has.",
                    GetMoney, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "show user transactions",
                    "show user transactions",
                    "Display user transactions for a period.",
                    HandleShowTransactions, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "show user purchases",
                    "show user purchases",
                    "Display user purchases for a period.",
                    HandleShowPurchases, false, true);

                MainConsole.Instance.Commands.AddCommand(
                    "stipend set",
                    "stipend set",
                    "Sets the next date for stipend",
                    HandleStipendSet, false, true);
            }
        }
Esempio n. 49
0
        public void Initialize(IConfigSource config, IRegistryCore registry)
        {
            IConfig m_config = config.Configs["UniverseData"];

            if (m_config != null)
            {
                StorageProvider  = m_config.GetString("StorageProvider", StorageProvider);
                ConnectionString = m_config.GetString("ConnectionString", ConnectionString);
            }

            IGenericData DataConnector = null;

            if (StorageProvider == "MySQL")
            //Allow for fallback when UniverseData isn't set
            {
                MySQLDataLoader GenericData = new MySQLDataLoader();

                DataConnector = GenericData;
            }

            /*else if (StorageProvider == "MSSQL2008")
             * {
             * MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             * DataConnector = GenericData;
             * }
             * else if (StorageProvider == "MSSQL7")
             * {
             * MSSQLDataLoader GenericData = new MSSQLDataLoader();
             *
             * DataConnector = GenericData;
             * }*/
            else if (StorageProvider == "SQLite")
            //Allow for fallback when UniverseData isn't set
            {
                SQLiteLoader GenericData = new SQLiteLoader();

                // set default data directory in case it is needed
                var simBase = registry.RequestModuleInterface <ISimulationBase> ();
                GenericData.DefaultDataPath = simBase.DefaultDataPath;

                DataConnector = GenericData;
            }

            List <IUniverseDataPlugin> Plugins = UniverseModuleLoader.PickupModules <IUniverseDataPlugin>();

            foreach (IUniverseDataPlugin plugin in Plugins)
            {
                try
                {
                    plugin.Initialize(DataConnector == null ? null : DataConnector.Copy(), config, registry,
                                      ConnectionString);
                }
                catch (Exception ex)
                {
                    if (MainConsole.Instance != null)
                    {
                        MainConsole.Instance.Warn("[DataService]: Exception occurred starting data plugin " +
                                                  plugin.Name + ", " + ex);
                    }
                }
            }
        }
Esempio n. 50
0
 public void Initialize(IGenericData GenericData, IConfigSource source, IRegistryCore simBase, string DefaultConnectionString)
 {
     loaded = DateTime.Now;
     MainConsole.Instance.Commands.AddCommand("helphtml", "helphtml", "output help as html document", loadHelp, false, true);
 }
Esempio n. 51
0
 /// <summary>
 ///     Remove generic data for the specified owner by type and key
 /// </summary>
 /// <param name="OwnerID">ID of the entity that owns the generic data</param>
 /// <param name="Type"></param>
 /// <param name="Key"></param>
 /// <param name="GD"></param>
 public static void RemoveGenericByKeyAndType(UUID OwnerID, string Type, string Key, IGenericData GD)
 {
     QueryFilter filter = new QueryFilter();
     filter.andFilters["OwnerID"] = OwnerID;
     filter.andFilters["Type"] = Type;
     filter.andFilters["`Key`"] = Key;
     GD.Delete("generics", filter);
 }
Esempio n. 52
0
        public static List <UUID> GetOwnersByGeneric(string type, string key, OSDMap value, IGenericData genData)
        {
            QueryFilter filter = new QueryFilter();

            filter.andFilters ["Type"]    = type;
            filter.andFilters ["`Key`"]   = key;
            filter.andFilters ["`Value`"] = OSDParser.SerializeJsonString(value);

            return
                (genData.Query(new string [1] {
                "OwnerID"
            }, "generics", filter, null, null, null)
                 .ConvertAll <UUID> (x => new UUID(x)));
        }