Beispiel #1
0
        /// <summary>
        /// Opens the learning module (or schedules it for opening).
        /// </summary>
        /// <param name="configFilePath">The config file path.</param>
        /// <param name="LmId">The lm id.</param>
        /// <param name="LmName">Name of the lm.</param>
        /// <param name="UserId">The user id.</param>
        /// <param name="UserName">Name of the user.</param>
        /// <param name="UserPassword">The user password (needed for FormsAuthentication, else empty).</param>
        /// <remarks>Documented by Dev02, 2009-06-26</remarks>
        /// <exception cref="MLHasOpenFormsException">Occurs when settings or the learning module could not be changed because MemoryLifter has other forms/windows open.</exception>
        /// <exception cref="ConfigFileParseException">Occurs when the supplied config file could not be parsed properly or does not contain a valid connection.</exception>
        /// <exception cref="MLCouldNotBeStartedException">Occurs when MemoryLifter did not start or did not react to connection attempts.</exception>
        public void OpenLearningModule(string configFilePath, int LmId, string LmName, int UserId, string UserName, string UserPassword)
        {
            ConnectionStringHandler csHandler = new ConnectionStringHandler(configFilePath);
            if (csHandler.ConnectionStrings.Count < 1)
                throw new ConfigFileParseException();

            Debug.WriteLine(string.Format("Config file parsed ({0}), building connection...", configFilePath));

            IConnectionString connectionString = csHandler.ConnectionStrings[0];

            ConnectionStringStruct css = new ConnectionStringStruct();
            css.LmId = LmId;
            css.Typ = connectionString.ConnectionType;
            css.ConnectionString = connectionString.ConnectionString;
            if (connectionString is UncConnectionStringBuilder)
            {
                css.ConnectionString = Path.Combine(css.ConnectionString, LmName + Helper.EmbeddedDbExtension);
                css.Typ = DatabaseType.MsSqlCe;
            }

            if (connectionString is ISyncableConnectionString)
            {
                ISyncableConnectionString syncConnectionString = (ISyncableConnectionString)connectionString;
                css.LearningModuleFolder = syncConnectionString.MediaURI;
                css.ExtensionURI = syncConnectionString.ExtensionURI;
                css.SyncType = syncConnectionString.SyncType;
            }

            LearningModulesIndexEntry entry = new LearningModulesIndexEntry(css);
            entry.User = new DummyUser(UserId, UserName);
            ((DummyUser)entry.User).Password = UserPassword;
            entry.UserName = UserName;
            entry.UserId = UserId;
            entry.Connection = connectionString;
            entry.DisplayName = LmName;
            entry.SyncedPath = LmName + Helper.SyncedEmbeddedDbExtension;

            Debug.WriteLine("Opening learning module...");

            try
            {
                loader.LoadDictionary(entry);
            }
            catch (MLifter.Classes.FormsOpenException)
            {
                throw new MLHasOpenFormsException();
            }
        }
        public void CSHConstructorTestNull()
        {
            string generalPath = null;
            string userPath = null;

            ConnectionStringHandler target = new ConnectionStringHandler(generalPath, userPath);
            Assert.IsTrue(target.ConnectionStrings.FindAll(c => !(c is UncConnectionStringBuilder) || !(c as UncConnectionStringBuilder).IsOnStick).Count == 0, "CSHConstructorTest - There should be 0 connection strings!");
        }
        public void UncStickCSBReadWriteTest()
        {
            List<DriveInfo> drives = Methods.GetMLifterSticks();
            if (drives.Count < 1)
                Assert.Inconclusive("No Stick plugged in! To test the stick functionality please plug in a stick!");

            string LMPath = Path.Combine(drives[0].RootDirectory.ToString(), "LearningModules");
            UncConnectionStringBuilder stick = new UncConnectionStringBuilder(Path.Combine(drives[0].RootDirectory.ToString(), "LearningModules"), false, true);
            ConnectionStringHandler.CreateUncConnection("StickTest", LMPath, drives[0].RootDirectory.ToString(), "defaultConnection.mlcfg", false, true);

            // test that the file was generated with the proper placeholder
            StreamReader sreader = new StreamReader(drives[0].RootDirectory.ToString() + "defaultConnection.mlcfg");
            Assert.AreNotEqual(-1, sreader.ReadToEnd().IndexOf("MEMSTICK:\\"), "MEMSTICK identifier not found");
            sreader.Close();

            // test that reading the file translates to the proper drive letter
            ConnectionStringHandler handler = new ConnectionStringHandler(drives[0].RootDirectory.ToString(), string.Empty);
            IConnectionString connection = handler.ConnectionStrings.Find(c => c.Name == "StickTest");
            Assert.IsNotNull(connection, "MEMSTICK config file not generated");
            Assert.AreEqual<string>(drives[0].RootDirectory.ToString() + "defaultConnection.mlcfg", connection.ConfigFileName);

            File.Delete(Path.Combine(drives[0].RootDirectory.ToString(), "defaultConnection.mlcfg"));
        }
Beispiel #4
0
		/// <summary>
		/// GUI logic for Drag and Drop
		/// </summary>
		/// <param name="file">The file.</param>
		/// <remarks>Documented by Dev08, 2009-03-02</remarks>
		public void DoDragAndDrop(string file)
		{
			bool draggedLearningModuleIsOpen = false;
			string appConfigFile = Setup.GlobalConfigPath;
			string usrConfigFile = Setup.UserConfigPath;
			ConnectionStringHandler handler = new ConnectionStringHandler(appConfigFile, usrConfigFile);
			IConnectionString defaultConString = handler.ConnectionStrings.Find(c => c.IsDefault || c.ConnectionType == DatabaseType.Unc);
			TaskDialogResult result;

			//No default connection available
			if (defaultConString == null)
			{
				TaskDialog.MessageBox(Resources.DRAG_NO_DEFAULT_CONNECTION_AVAILABLE_TITLE, Resources.DRAG_NO_DEFAULT_CONNECTION_AVAILABLE_MAININTRODUCTION,
					Resources.DRAG_NO_DEFAULT_CONNECTION_AVAILABLE_CONTENT, TaskDialogButtons.OK, TaskDialogIcons.Error);
				return;
			}
			//User draged a LM from a available UNC connection to the ML
			else if (ConnectionStringHandler.IsFileInUncConnection(file, appConfigFile, usrConfigFile))   //(Path.GetDirectoryName(file) == defaultConString.ConnectionString)
			{
				OpenLearningModule(file);
				return;
			}
			//File already exists
			else if (File.Exists(Path.Combine(defaultConString.ConnectionString, Path.GetFileName(file))))
			{
				//User draged the LM which is currently opened into MemoryLifter. (only possible while user is learning)
				//[Check if the future place of the LM is currently opened (e.g. the older LM is open)]
				if (LearnLogic != null && LearnLogic.CurrentLearningModule != null &&
					LearnLogic.CurrentLearningModule.ConnectionString.ConnectionString == Path.Combine(defaultConString.ConnectionString, Path.GetFileName(file)))
					draggedLearningModuleIsOpen = true;

				TaskDialogResult resultFileExists = ShowFileExistsDragAndDropDialog();

				switch (resultFileExists.CommandButtonsIndex)
				{
					// Replace
					case 0:
						if (draggedLearningModuleIsOpen)
						{
							if (!LearnLogic.CloseLearningModule())
								return;
						}
						try
						{
							ConnectionStringHandler.PutLearningModuleToDefaultUNC(file, defaultConString.ConnectionString, false, true);
						}
						catch (Exception exc)
						{
							TaskDialog.MessageBox(Resources.DRAG_COPY_ERROR_TITLE, Resources.DRAG_COPY_ERROR_MAININTRODUCTION,
								exc.Message, exc.ToString(), string.Empty, string.Empty, TaskDialogButtons.OK, TaskDialogIcons.Error, TaskDialogIcons.Error);
						}

						OpenLearningModule(Path.Combine(defaultConString.ConnectionString, Path.GetFileName(file)));
						break;

					//Just learn
					case 1:
						OpenLearningModule(file);
						break;

					//Cancel
					case 2:
					default:
						break;
				}

				return;
			}
			else if (Path.GetExtension(file) == Helper.DzpExtension)
				result = new TaskDialogResult() { CommandButtonsIndex = 2, VerificationChecked = false };
			else
				result = ShowDefaultDragAndDropDialog();

			//User draged the LM which is currently opened into MemoryLifter. (only possible while user is learning)
			//[Check if currently ]
			if (LearnLogic != null && LearnLogic.CurrentLearningModule != null &&
				LearnLogic.CurrentLearningModule.ConnectionString.ConnectionString == file)
				draggedLearningModuleIsOpen = true;

			switch (result.CommandButtonsIndex)
			{
				//Copy
				case 0:
					try
					{
						ConnectionStringHandler.PutLearningModuleToDefaultUNC(file, defaultConString.ConnectionString, false);
					}
					catch (Exception exc)
					{
						TaskDialog.MessageBox(Resources.DRAG_COPY_ERROR_TITLE, Resources.DRAG_COPY_ERROR_MAININTRODUCTION,
							exc.Message, exc.ToString(), string.Empty, string.Empty, TaskDialogButtons.OK, TaskDialogIcons.Error, TaskDialogIcons.Error);
					}
					OpenLearningModule(Path.Combine(defaultConString.ConnectionString, Path.GetFileName(file)));
					break;

				//Move
				case 1:
					if (draggedLearningModuleIsOpen)
					{
						if (!LearnLogic.CloseLearningModule())
							return;
					}
					try
					{
						ConnectionStringHandler.PutLearningModuleToDefaultUNC(file, defaultConString.ConnectionString, true);
					}
					catch (Exception exc)
					{
						TaskDialog.MessageBox(Resources.DRAG_COPY_ERROR_TITLE, Resources.DRAG_COPY_ERROR_MAININTRODUCTION,
							exc.Message, exc.ToString(), string.Empty, string.Empty, TaskDialogButtons.OK, TaskDialogIcons.Error, TaskDialogIcons.Error);
					}
					OpenLearningModule(Path.Combine(defaultConString.ConnectionString, Path.GetFileName(file)));
					break;

				//Just open
				case 2:
					OpenLearningModule(file);
					break;

				//Cancel
				case 3:
				default:
					break;
			}
		}
        public void CSHConstructorTest()
        {
            Dictionary<string, string> referenceValues1, referenceValues2, referenceValues3, referenceValues4, referenceValues5, referenceValues6;

            string generalPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
            string userPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            Directory.CreateDirectory(generalPath);
            Directory.CreateDirectory(userPath);

            ConnectionStringHandler.CreateUncConnection(PrepareUncConnectionStringBuilder(out referenceValues1), generalPath, "unc1.mlcfg");
            ConnectionStringHandler.CreateUncConnection(PrepareUncConnectionStringBuilder(out referenceValues2), generalPath, "unc2.mlcfg");
            ConnectionStringHandler.CreatePostgreSqlConnection(PreparePostgreSqlConnectionStringBuilder(out referenceValues3), generalPath, "pg1.mlcfg");

            ConnectionStringHandler.CreateUncConnection(PrepareUncConnectionStringBuilder(out referenceValues4), userPath, "unc1.mlcfg");
            ConnectionStringHandler.CreatePostgreSqlConnection(PreparePostgreSqlConnectionStringBuilder(out referenceValues5), userPath, "pg1.mlcfg");
            ConnectionStringHandler.CreatePostgreSqlConnection(PreparePostgreSqlConnectionStringBuilder(out referenceValues6), userPath, "pg2.mlcfg");
            ConnectionStringHandler target = new ConnectionStringHandler(generalPath, userPath);
            Assert.IsTrue(target.ConnectionStrings.FindAll(c => !(c is UncConnectionStringBuilder) || !(c as UncConnectionStringBuilder).IsOnStick).Count == 2, "CSHConstructorTest - There should be 6 connection strings!");
            foreach (IConnectionString csb in target.ConnectionStrings.FindAll(c => !(c is UncConnectionStringBuilder) || !(c as UncConnectionStringBuilder).IsOnStick))
            {
                if (csb.ConnectionType == MLifter.DAL.DatabaseType.PostgreSQL)
                {
                    Assert.AreEqual<MLifter.DAL.DatabaseType>(MLifter.DAL.DatabaseType.PostgreSQL, csb.ConnectionType, "CSHPostgreSqlConnectionStringBuilderTest - ConnectionType is not correct!");
                    Assert.AreEqual<string>(referenceValues3["Name"], csb.Name, "CSHPostgreSqlConnectionStringBuilderTest - Name is not correct!");
                }
                else
                {
                    Assert.AreEqual<MLifter.DAL.DatabaseType>(MLifter.DAL.DatabaseType.Unc, csb.ConnectionType, "CSHUncConnectionStringBuilderTest - ConnectionType is not correct!");
                    Assert.AreEqual<string>(referenceValues1["Name"], csb.Name, "CSHUncConnectionStringBuilderTest - Name is not correct!");
                    Assert.AreEqual<string>(referenceValues1["ConnectionString"], csb.ConnectionString, "CSHUncConnectionStringBuilderTest - ConnectionString is not correct!");
                }
            }

            Directory.Delete(generalPath, true);
            Directory.Delete(userPath, true);
        }
        /// <summary>
        /// Saves the given connection string to the configPath. If the conString.Name doesn't exists, a new connection will be created.
        /// If the conString.Name exists it will be updated.
        /// </summary>
        /// <param name="configPath">The config path (e.g. %ProgramFiles%\MemoryLifter\Config).</param>
        /// <param name="conString">The ConnectionString. ATTENTION: conString.ConfigFileName must be a valid FileName!!!</param>
        /// <param name="identifier">The identifier.</param>
        /// <exception cref="T:System.IO.IOException" />
        /// <remarks>Documented by Dev08, 2009-04-01</remarks>
        public static void SaveConnectionString(string configPath, IConnectionString conString, ConnectionStringIdentifier identifier)
        {
            //todo: get all connections from the configPath
            //todo: search for the connectionString based on the identifier
            //todo: update/create the new connection

            //1. Get all connections
            ConnectionStringHandler handler = new ConnectionStringHandler(configPath, string.Empty, false);

            //2. Check if the given connection is already available (search based on identifier)
            bool connectionStringLocated = false;
            foreach (IConnectionString cs in handler.ConnectionStrings)
            {
                if (identifier == ConnectionStringIdentifier.IdentifyByConnectionStringAndType)
                {
                    if (cs.ConnectionString == conString.ConnectionString && cs.ConnectionType == conString.ConnectionType)
                    {
                        conString.ConfigFileName = cs.ConfigFileName;
                        connectionStringLocated = true;
                        break;
                    }
                }
                else
                {
                    if (cs.Name == conString.Name)
                    {
                        conString.ConfigFileName = cs.ConfigFileName;
                        connectionStringLocated = true;
                        break;
                    }
                }
            }

            //3.1 Update connectionstring
            if (!Directory.Exists(Path.GetDirectoryName(conString.ConfigFileName)))
                throw new IOException("The given connectionString does not have a valid value in ConfigFileName property.");

            if (connectionStringLocated)
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(File.OpenWrite(conString.ConfigFileName));

                foreach (XmlNode item in doc.GetElementsByTagName("Connections"))
                {
                    foreach (XmlNode subItem in item.ChildNodes)
                    {

                    }
                }
            }
            else    //3.2 Create new connection; Should not happen, because the startupWiz always creates a connection
            {
                List<IConnectionString> list = new List<IConnectionString>();
                list.Add(conString);
                CreateConnections(list, conString.ConfigFileName);
            }
        }
        /// <summary>
        /// Checks if the given filename is in one of the available UNC connections
        /// </summary>
        /// <param name="filename">The filename.</param>
        /// <returns>
        /// 	<c>true</c> if [is file in unc connection] [the specified filename]; otherwise, <c>false</c>.
        /// </returns>
        /// <remarks>Documented by Dev08, 2009-03-03</remarks>
        public static bool IsFileInUncConnection(string filename, string generalPath, string userPath)
        {
            ConnectionStringHandler handler = new ConnectionStringHandler(generalPath, userPath);
            foreach (IConnectionString conString in handler.ConnectionStrings)
            {
                if (conString.ConnectionType != DatabaseType.Unc)
                    continue;

                if (Path.GetDirectoryName(filename).StartsWith(conString.ConnectionString))
                    return true;
            }
            return false;
        }
        /// <summary>
        /// Imports the mlcfg-file.
        /// </summary>
        /// <param name="filepath">The filepath.</param>
        /// <param name="generalPath">The general path.</param>
        /// <param name="userPath">The user path.</param>
        /// <returns>The number of successfully imported/updated connections</returns>
        /// <remarks>Documented by Dev08, 2009-03-02</remarks>
        public static int ImportConfigFile(string filepath, string generalPath, string userPath)
        {
            ConnectionStringHandler currentHandler = new ConnectionStringHandler(generalPath, userPath);
            List<IConnectionString> fromNewFileConnectionStrings;
            List<IConnectionString> importConnectionList = new List<IConnectionString>();
            List<ModuleFeedConnection> feedsInFile;
            List<ModuleFeedConnection> importFeeds = new List<ModuleFeedConnection>();

            try
            {
                fromNewFileConnectionStrings = GetConnectionStringsFromFile(filepath);
                feedsInFile = GetFeedsFromFile(filepath);
            }
            catch
            {
                throw new InvalidConfigFileException();
            }

            if (fromNewFileConnectionStrings.Count + feedsInFile.Count == 0)
                return 0;

            //Compare and write new connections to importConnectionList
            foreach (IConnectionString newConString in fromNewFileConnectionStrings)
            {
                bool isEqual = false;
                foreach (IConnectionString oldConString in currentHandler.ConnectionStrings)
                    isEqual = newConString.ConnectionString == oldConString.ConnectionString &&	newConString.ConnectionType == oldConString.ConnectionType;

                if (!isEqual)
                    importConnectionList.Add(newConString);
            }

            //compare and write new feeds to importFeeds
            foreach (ModuleFeedConnection feed in feedsInFile)
            {
                bool isEqual = false;
                foreach (ModuleFeedConnection oldFeed in currentHandler.Feeds)
                    isEqual = oldFeed.ModulesUri == feed.ModulesUri && oldFeed.CategoriesUri == feed.CategoriesUri;

                if (!isEqual)
                    importFeeds.Add(feed);
            }

            if (importConnectionList.Count + importFeeds.Count == 0)
                return 0;

            //Search for a config file with the same filename...
            int loopKillCounter = 1;
            string newConfigFile = Path.Combine(userPath, Path.GetFileName(filepath));
            while (File.Exists(newConfigFile) && loopKillCounter <= 10000)
            {
                newConfigFile = Path.Combine(Path.GetDirectoryName(newConfigFile),
                                             Path.GetFileNameWithoutExtension(newConfigFile) + "_" + loopKillCounter.ToString() + Path.GetExtension(newConfigFile));
                ++loopKillCounter;
            }

            return CreateConnections(importConnectionList, newConfigFile, importFeeds);
        }
 /// <summary>
 /// Gets the default connection string. If there are more than one default conStrings (which isn't allowed), this methods returns the first
 /// located default connection. If there is no default connection string, it returns null.
 /// </summary>
 /// <param name="configPath">The config path (e.g. %ProgramFiles%\MemoryLifter\Config).</param>
 /// <returns>The default connection string if there is one, otherwise null</returns>
 /// <remarks>Documented by Dev08, 2009-04-01</remarks>
 public static IConnectionString GetDefaultConnectionString(string configPath)
 {
     ConnectionStringHandler csh = new ConnectionStringHandler(configPath, string.Empty, false);
     foreach (IConnectionString conString in csh.ConnectionStrings)
     {
         if (conString.IsDefault)
             return conString;
     }
     return null;
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="LearningModulesIndex"/> class.
        /// </summary>
        /// <param name="generalPath">The general path.</param>
        /// <param name="userPath">The path to the user configurations.</param>
        /// <param name="getLoginDelegate">The get login delegate.</param>
        /// <param name="dataAccessErrorDelegate">The data access error delegate.</param>
        /// <remarks>Documented by Dev05, 2008-12-03</remarks>
        public LearningModulesIndex(string generalPath, string userPath, GetLoginInformation getLoginDelegate, DataAccessErrorDelegate dataAccessErrorDelegate, string syncedModulesPath)
            : this()
        {
            SyncedModulesPath = syncedModulesPath;

            getLogin = getLoginDelegate;
            dataAccessError = dataAccessErrorDelegate;

            updateTimer.Interval = 1000;
            updateTimer.Tick += new EventHandler(updateTimer_Tick);

            if (userPath != null && userPath != string.Empty)
            {
                cacheFile = System.IO.Path.Combine(userPath, Properties.Settings.Default.LMIndexCacheFilename);
                try
                {
                    if (System.IO.File.Exists(cacheFile))
                        RestoreIndexCache(cacheFile);
                }
                catch (Exception e)
                {
                    Trace.WriteLine("Index entry cache restore failed: " + e.ToString());
                }
            }

            ConnectionsHandler = new ConnectionStringHandler(generalPath, userPath);

            ConnectionUsers.Clear();
            foreach (IConnectionString con in ConnectionsHandler.ConnectionStrings)
            {
                ListViewGroup group = new ListViewGroup(con.Name);
                group.Tag = con;
                Groups.Add(group);
            }
        }