20160607_-_AdminPrivileges

DataTypes/IApplicationInfo.cs

@@ -8,13 +8,19 @@ public interface IApplicationInfo
 
         IDefinitionInfo DefinitionInfo { get; }
 
+        // TODO: Use guid as folder name
         string FolderName { get; }
 
         Guid Id { get; }
 
+        // TODO: Extend this: Use also "Herausgeber" field to identify installed application
         /// <summary>
         /// A regex that matches the name that is displayed in the installed applications list.
         /// </summary>
         string TechnicalNameMatcher { get; }
+
+        // TODO: Add publish year for better sorting
+
+        // TODO: Add series name (like "Battlefield") for better sorting (by grouping)
     }
 }

Logic/Logic.Implementation/Execution/Link/FileLink.cs

@@ -1,33 +1,39 @@
 using System.IO;
-using XElement.CloudSyncHelper.DataTypes;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     internal class FileLink : LinkBase, ILinkInt
     {
-        public FileLink( IApplicationInfo appInfo, 
-                         IFileLinkInfo fileLinkInfo, 
-                         PathVariablesDTO pathVariablesDTO )
-            : base( appInfo, fileLinkInfo, pathVariablesDTO ) { }
+        public FileLink( LinkParametersDTO parametersDTO, 
+                         DependenciesDTO dependenciesDTO )
+            : base( parametersDTO, dependenciesDTO ) { }
+
 
         protected override FileSystemInfo /*LinkBase.*/FileSystemInfo
         {
             get { return new FileInfo( this.LinkPath ); }
         }
 
+
         public override bool /*LinkBase.*/IsInCloud
         {
             get { return File.Exists( this.TargetPath ); }
         }
 
-        protected override string /*LinkBase.*/MkLinkParams { get { return string.Empty; } }
+
+        protected override MkLink.Type /*LinkBase.*/MkLinkType
+        {
+            get { return MkLink.Type.FILE_LINK; }
+        }
+
 
         protected override void /*LinkBase.*/MoveToCloud_CopyStuff()
         {
             File.Copy( this.LinkPath, this.TargetPath );
         }
 
+
         public override void /*LinkBase.*/Undo()
         {
             if ( File.Exists( this.LinkPath ) )

Logic/Logic.Implementation/Execution/Link/FolderLink.cs

@@ -1,16 +1,15 @@
 using System;
 using System.IO;
-using XElement.CloudSyncHelper.DataTypes;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     internal class FolderLink : LinkBase, ILinkInt
     {
-        public FolderLink( IApplicationInfo appInfo, 
-                           IFolderLinkInfo folderLinkInfo, 
-                           PathVariablesDTO pathVariablesDTO )
-            : base( appInfo, folderLinkInfo, pathVariablesDTO ) { }
+        public FolderLink( LinkParametersDTO parametersDTO, 
+                           DependenciesDTO dependenciesDTO )
+            : base( parametersDTO, dependenciesDTO ) { }
+
 
         private void AbstractSourceDestLinker( Func<string, string[]> sourcePathsGetter, 
                                                string source, 
@@ -27,6 +26,7 @@ private void AbstractSourceDestLinker( Func<string, string[]> sourcePathsGetter,
             }
         }
 
+
         // Copy all levels
         private void CopyFilesRecursively( string source, string destination )
         {
@@ -39,23 +39,31 @@ private void CopyFilesRecursively( string source, string destination )
                                            ( s, d ) => this.CopyFilesRecursively( s, d ) );
         }
 
+
         protected override FileSystemInfo /*LinkBase.*/FileSystemInfo
         {
             get { return new DirectoryInfo( this.LinkPath ); }
         }
 
+
         public override bool /*LinkBase.*/IsInCloud
         {
             get { return Directory.Exists( this.TargetPath ); }
         }
 
-        protected override string /*LinkBase.*/MkLinkParams { get { return "/D"; } }
+
+        protected override MkLink.Type /*LinkBase.*/MkLinkType
+        {
+            get { return MkLink.Type.DIRECTORY_LINK; }
+        }
+
 
         protected override void /*LinkBase.*/MoveToCloud_CopyStuff()
         {
             this.CopyFilesRecursively( this.LinkPath, this.TargetPath );
         }
 
+
         // Copy only one level
         private void ShallowCopyFiles( string source, string destination )
         {
@@ -65,6 +73,7 @@ private void ShallowCopyFiles( string source, string destination )
                                            ( s, d ) => File.Copy( s, d ) );
         }
 
+
         public override void /*LinkBase.*/Undo()
         {
             if ( Directory.Exists( this.LinkPath ) )

Logic/Logic.Implementation/Execution/Link/GameLogic.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using XElement.CloudSyncHelper.DataTypes;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     internal class GameLogic : IApplicationLogic

Logic/Logic.Implementation/Execution/Link/IApplicationLogic.cs

@@ -1,4 +1,4 @@
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
     internal interface IApplicationLogic
     {

Logic/Logic.Implementation/Execution/Link/ILinkInt.cs

@@ -1,6 +1,6 @@
 using XElement.DesignPatterns.BehavioralPatterns.Command;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
     internal interface ILinkInt : IDoUndoCommand, ILink
     {

Logic/Logic.Implementation/Execution/Link/LinkBase.cs

@@ -1,50 +1,46 @@
 using System;
-using System.Diagnostics;
 using System.IO;
 using XElement.CloudSyncHelper.DataTypes;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     internal abstract class LinkBase : ILinkInt
     {
-        public LinkBase( IApplicationInfo appInfo, 
-                         ILinkInfo linkInfo, 
-                         PathVariablesDTO pathVariablesDTO )
+        public LinkBase( LinkParametersDTO parametersDTO, 
+                         DependenciesDTO dependenciesDTO )
         {
-            this._linkInfo = linkInfo;
-            this._pathVariablesDTO = pathVariablesDTO;
+            this._mkLinkExecutorFactory = dependenciesDTO.MkLinkExecutorFactory;
+
+            this._linkInfo = parametersDTO.LinkInfo;
+            this._pathVariablesDTO = parametersDTO.PathVariablesDTO;
             this._symLinkHelper = new SymbolicLinkHelper();
 
-            Initialize( appInfo );
+            Initialize( parametersDTO.ApplicationInfo );
         }
 
+
         private void CreatePathToDestinationTarget()
         {
             Directory.CreateDirectory( this.PathToDestinationTarget );
         }
 
+
         public void /*ILink.*/Do()
         {
             this.CreatePathToDestinationTarget();
             this.Undo();
-            this.ExecuteCmd();
-        }
 
-        private void ExecuteCmd()
-        {
-            var mkLink = this.GetCmdCommand();
-            var process = new Process();
-            process.StartInfo.FileName = "cmd.exe";
-            process.StartInfo.Arguments = "/c " + mkLink;
-            process.StartInfo.CreateNoWindow = true;
-            process.StartInfo.UseShellExecute = false;
-            process.StartInfo.Verb = "runas";
-            process.Start();
-
-            process.WaitForExit();
+            var mkLinkParams = new MkLink.ParametersDTO
+            {
+                Link = this.LinkPath, 
+                Target = this.TargetPath, 
+                Type = this.MkLinkType
+            };
+            this._mkLinkExecutorFactory.Get( mkLinkParams ).Execute();
         }
 
+
         private bool DoesSymbolicLinkPointToExpectedPath
         {
             get
@@ -54,13 +50,9 @@ private bool DoesSymbolicLinkPointToExpectedPath
             }
         }
 
+
         protected abstract FileSystemInfo FileSystemInfo { get; }
 
-        private string GetCmdCommand()
-        {
-            return String.Format( "MKLINK {0} \"{1}\" \"{2}\"", this.MkLinkParams, 
-                this.LinkPath, this.TargetPath );
-        }
 
         private void Initialize( IApplicationInfo programInfo )
         {
@@ -74,8 +66,10 @@ private void Initialize( IApplicationInfo programInfo )
             }
         }
 
+
         public abstract bool /*ILink.*/IsInCloud { get; }
 
+
         public bool /*ILink.*/IsLinked
         {
             get
@@ -85,6 +79,7 @@ public bool /*ILink.*/IsLinked
             }
         }
 
+
         private bool IsSymbolicLink
         {
             get
@@ -94,6 +89,7 @@ private bool IsSymbolicLink
             }
         }
 
+
         public string /*ILink.*/LinkPath
         {
             get
@@ -104,16 +100,20 @@ public string /*ILink.*/LinkPath
             }
         }
 
-        protected abstract string MkLinkParams { get; }
+
+        protected abstract MkLink.Type MkLinkType { get; }
+
 
         public void /*ILink.*/MoveToCloud()
         {
             Directory.CreateDirectory( this.PathToCloudUserFolder );
             this.MoveToCloud_CopyStuff();
         }
 
+
         protected abstract void MoveToCloud_CopyStuff();
 
+
         private string PathToDestinationTarget
         {
             get
@@ -123,6 +123,7 @@ private string PathToDestinationTarget
             }
         }
 
+
         private string PathToCloudUserFolder
         {
             get
@@ -135,6 +136,7 @@ private string PathToCloudUserFolder
             }
         }
 
+
         public string /*ILink.*/TargetPath
         {
             get
@@ -144,9 +146,12 @@ public string /*ILink.*/TargetPath
             }
         }
 
+
         public abstract void /*ILink.*/Undo(); // TODO: Delete folders if they are empty
 
+
         private ILinkInfo _linkInfo;
+        private MkLink.IFactory _mkLinkExecutorFactory;
         private PathVariablesDTO _pathVariablesDTO;
         private IApplicationLogic _programLogic;
         private SymbolicLinkHelper _symLinkHelper;

Logic/Logic.Implementation/Execution/Link/LinkFactory.cs

@@ -1,12 +1,15 @@
 using XElement.CloudSyncHelper.DataTypes;
-using XElement.CloudSyncHelper.Logic.Execution;
 
-namespace XElement.CloudSyncHelper.Logic
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     public class LinkFactory : ILinkFactory
     {
-        public LinkFactory() { }
+        public LinkFactory( MkLink.IFactory mkLinkExecutorFactory )
+        {
+            this._mkLinkExecutorFactory = mkLinkExecutorFactory;
+        }
+
 
         public ILink Get( IApplicationInfo appInfo, 
                           ILinkInfo linkInfo, 
@@ -20,25 +23,29 @@ public ILink Get( IApplicationInfo appInfo,
             };
             return this.Get( linkParamsDTO );
         }
+
         public ILink Get( LinkParametersDTO linkParametersDTO )
         {
             ILink link = null;
 
+            var dependenciesDTO = new Link.DependenciesDTO
+            {
+                MkLinkExecutorFactory = this._mkLinkExecutorFactory
+            };
             if ( linkParametersDTO.LinkInfo is IFolderLinkInfo )
             {
-                link = new FolderLink( linkParametersDTO.ApplicationInfo,
-                                       linkParametersDTO.LinkInfo as IFolderLinkInfo,
-                                       linkParametersDTO.PathVariablesDTO );
+                link = new FolderLink( linkParametersDTO, dependenciesDTO );
             }
             else
             {
-                link = new FileLink( linkParametersDTO.ApplicationInfo, 
-                                       linkParametersDTO.LinkInfo as IFileLinkInfo, 
-                                       linkParametersDTO.PathVariablesDTO );
+                link = new FileLink( linkParametersDTO, dependenciesDTO );
             }
 
             return link;
         }
+
+
+        protected MkLink.IFactory _mkLinkExecutorFactory;
     }
 #endregion
 }

Logic/Logic.Implementation/Execution/Link/ToolLogic.cs

@@ -1,7 +1,7 @@
 using System.IO;
 using XElement.CloudSyncHelper.DataTypes;
 
-namespace XElement.CloudSyncHelper.Logic.Execution
+namespace XElement.CloudSyncHelper.Logic.Execution.Link
 {
 #region not unit-tested
     internal class ToolLogic : IApplicationLogic