コード例 #1
0
        private void Should_be_able_to_add_excluded_file_with_properties_to_project(string projectRelativePath)
        {
            var projectTool = TempCopyAndGetProject(projectRelativePath);

            var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
            var compileFilesBefore             = scanFilesInProjectFolderBefore
                                                 .Where(f => f.IncludeType == "Compile")
                                                 .Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
                                                 .ToArray();

            var newFilePath    = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"SampleClass3NotIncludedInproject.cs");
            var fileProperties = new Dictionary <string, string>()
            {
                { "prop1", "value1" }, { "prop2", "value2" }
            };

            projectTool.AddFileToProject(newFilePath, "Compile", fileProperties);
            projectTool.Save();

            var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
            var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
            var compileFilesAfter             = scanFilesInProjectFolderAfter
                                                .Where(f => f.IncludeType == "Compile")
                                                .Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
                                                .OrderBy(o => o)
                                                .Debug(new ConsoleDebugLogger(true))
                                                .ToArray();

            compileFilesAfter.Should().BeEquivalentTo(
                compileFilesBefore.Union(new string[] { "Compile:SampleClass3NotIncludedInproject.cs:value1:value2" })
                .OrderBy(o => o)
                .Debug(new ConsoleDebugLogger(true))
                .ToArray()
                );
        }
コード例 #2
0
        public void RemoveFilesNotIncludedInProjects(SolutionTool solutionTool)
        {
            var projects = solutionTool.GetProjectsWithParents().ToArray();

            foreach (var project in projects)
            {
                if (solutionTool.CompilableProjects.Contains(project.Type))
                {
                    var projectPath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, project.Path);

                    var projectTool       = new ProjectTool(projectPath, _logger);
                    var fileReferences    = projectTool.ScanFilesInProjectFolder();
                    var filesNotInProject = fileReferences.Where(f => f.OnDisk && !f.InProjectFile).ToArray();
                    var filesNotOnDisk    = fileReferences.Where(f => !f.OnDisk && f.InProjectFile).ToArray();

                    if (filesNotOnDisk.Any() || filesNotInProject.Any())
                    {
                        _logger.LogMessage($"Scanned files in {projectTool.Name}");

                        if (filesNotInProject.Any())
                        {
                            _logger.LogMessage($"\tFiles NOT in {projectTool.Name}");
                            foreach (var fileReference in fileReferences.Where(f => f.OnDisk && !f.InProjectFile))
                            {
                                _logger.LogMessage($"\t\t{fileReference.Name}");

                                System.IO.File.Delete(fileReference.Path);
                            }
                        }
                    }
                }
            }
        }
コード例 #3
0
        private void Should_be_able_to_remove_file_without_properties_from_project(string projectRelativePath)
        {
            var projectTool = TempCopyAndGetProject(projectRelativePath);

            var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
            var compileFilesBefore             = scanFilesInProjectFolderBefore
                                                 .Where(f => f.IncludeType == "Compile")
                                                 .Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
                                                 .ToArray();

            var removeFilePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"SampleClass1IncludedInproject.cs");

            projectTool.RemoveFileFromProject(removeFilePath);
            projectTool.Save();

            var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
            var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
            var compileFilesAfter             = scanFilesInProjectFolderAfter
                                                .Where(f => f.IncludeType == "Compile")
                                                .Select(f => $"{f.IncludeType}:{f.Name}:{f.Properties.Get("prop1")}:{f.Properties.Get("prop2")}")
                                                .OrderBy(o => o)
                                                .ToArray()
                                                .Debug(new ConsoleDebugLogger(true))
            ;

            compileFilesAfter.Should().BeEquivalentTo(
                compileFilesBefore.Except(new string[] { "Compile:SampleClass1IncludedInproject.cs::" })
                .OrderBy(o => o)
                .ToArray()
                .Debug(new ConsoleDebugLogger(true))
                );
        }
コード例 #4
0
        public object Delete(Guid project_id, Guid tool_id, string stage)
        {
            try
            {
                string[] tool_type = _tool.Where(t => t.Id.Equals(tool_id))
                                     .Select(t => t.ToolType).FirstOrDefault().Split(",");
                if (!tool_type.Any(tt => tt.Equals(stage)))
                {
                    throw BadRequest("Unidentified stage!");
                }

                ProjectTool project_tool = _projectTool.GetOne(pt => pt.ProjectId.Equals(project_id) && pt.ToolId.Equals(tool_id));
                if (project_tool == null)
                {
                    throw NotFound();
                }

                if (!string.IsNullOrEmpty(project_tool.Stages))
                {
                    project_tool.Stages = project_tool.Stages.Replace("," + stage, "").Replace(stage + ",", "").Replace(stage, "");
                    if (string.IsNullOrEmpty(project_tool.Stages))
                    {
                        project_tool.Stages = null;
                    }
                }
                SaveChanges();
                return(GetProjectTools(project_id));
            }
            catch (Exception e)
            {
                throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred while delete a project's tool!",
                                                                         e, DateTime.Now, "Server", "Service_ProjectTool_DeleteProjectTool");
            }
        }
コード例 #5
0
        private void Should_be_able_to_add_file_to_project(string projectRelativePath)
        {
            var projectTool = TempCopyAndGetProject(projectRelativePath);

            var scanFilesInProjectFolderBefore = projectTool.ScanFilesInProjectFolder();
            var compileFilesBefore             = scanFilesInProjectFolderBefore
                                                 .Where(f => f.IncludeType == "Compile")
                                                 .Select(f => $"{f.IncludeType}:{f.Name}")
                                                 .ToArray();

            var newFilePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, $"newCompileFile.cs");

            projectTool.AddFileToProject(newFilePath, "Compile");
            projectTool.Save();

            var newProjectTool = new ProjectTool(projectTool.FilePath, new ConsoleDebugLogger(true));
            var scanFilesInProjectFolderAfter = newProjectTool.ScanFilesInProjectFolder();
            var compileFilesAfter             = scanFilesInProjectFolderAfter
                                                .Where(f => f.IncludeType == "Compile")
                                                .Select(f => $"{f.IncludeType}:{f.Name}")
                                                .OrderBy(o => o)
                                                .Debug(new ConsoleDebugLogger(true))
                                                .ToArray();

            compileFilesAfter.Should().BeEquivalentTo(
                // Admittedly this does nothing, as the file actually doesn't exist on disk for CPS projects. But the change to the project should be this (none)
                projectTool.IsCpsDocument ? compileFilesBefore : compileFilesBefore.Union(new string[] { "Compile:newCompileFile.cs" })
                .OrderBy(o => o)
                .Debug(new ConsoleDebugLogger(true))
                .ToArray()
                );
        }
コード例 #6
0
        private ProjectTool GetProjectTool(string projectRelativePath)
        {
            var currentFolder      = System.IO.Path.GetDirectoryName(new Uri(this.GetType().Assembly.CodeBase).LocalPath);
            var csProjAbsolutePath = PathExtensions.GetAbsolutePath(currentFolder, projectRelativePath);

            var projectTool = new ProjectTool(csProjAbsolutePath, new DebugLogger(true));

            return(projectTool);
        }
コード例 #7
0
ファイル: Program.cs プロジェクト: robbratton/AzureDevOpsCLI
        private static Commands SetUpCommands()
        {
            var pat = ToolHelper.GetPersonalAccessToken();

            var client = new Client(pat);

            var projectTool = new ProjectTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject
                );

            var projectId = (Guid)projectTool.GetId(AppSettings.AzureDevOpsProject).Result;

            var buildTool = new BuildDefinitionTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject,
                projectId
                );

            var releaseTool = new ReleaseDefinitionTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject
                );

            var repositoryTool = new RepositoryTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject,
                projectId
                );

            var taskTool = new TaskGroupTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject
                );

            var variableGroupTool = new VariableGroupTool(
                client,
                AppSettings.AzureDevOpsOrganization,
                AppSettings.AzureDevOpsProject
                );

            var commands = new Commands(
                buildTool,
                releaseTool,
                projectTool,
                repositoryTool,
                taskTool,
                variableGroupTool);

            return(commands);
        }
コード例 #8
0
        public void Constructor_Succeeds()
        {
            var result =
                new ProjectTool(
                    _clientMock.Object,
                    TestHelper.RealOrganization,
                    TestHelper.RealProject
                    );

            Assert.That(result, Is.Not.Null);
        }
コード例 #9
0
        public IActionResult AddTool(int toolId, int id)
        {
            var thisProject    = _db.Projects.Include(projects => projects.Updates).Include(projects => projects.ProjectTools).Include(projects => projects.Sprints).FirstOrDefault(projects => projects.ProjectId == id);
            var newTool        = _db.Tools.FirstOrDefault(tools => tools.ToolId == toolId);
            var newProjectTool = new ProjectTool();

            newProjectTool.ProjectId = id;
            newProjectTool.ToolId    = toolId;
            _db.ProjectTools.Add(newProjectTool);
            _db.SaveChanges();
            return(RedirectToAction("Details"));
        }
コード例 #10
0
 public void SetAuth(Guid project_id, Guid tool_id, bool has_auth)
 {
     try
     {
         ProjectTool project_tool = _projectTool.GetOne(pt => pt.ProjectId.Equals(project_id) && pt.ToolId.Equals(tool_id));
         SaveChanges();
     }
     catch (Exception e)
     {
         throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred!",
                                                                  e, DateTime.Now, "Server", "Service-ProjectTool-SetAuth");
     }
 }
コード例 #11
0
        public void ScanAllReferencesInProjectFiles(SolutionTool solutionTool)
        {
            var projects   = solutionTool.GetProjectsWithParents().ToArray();
            var references = new List <ProjectReference>();

            foreach (var project in projects)
            {
                if (solutionTool.CompilableProjects.Contains(project.Type))
                {
                    var projectPath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, project.Path);

                    var projectTool = new ProjectTool(projectPath, _logger);
                    references.AddRange(projectTool.ScanReferences());
                    _logger.LogMessage($"Scanned {projectTool.Name}");
                }
            }

            foreach (var referenceName in references.GroupBy(r => r.Name).OrderBy(r => r.Key))
            {
                var referenceVersions = referenceName.GroupBy(r => $"{r.PackageVersion?.ToString()}-{r.ReferenceType}");
                //var referenceVersions = referenceName.GroupBy(r => $"{r.Version?.ToString()}/{r.PackageVersion?.ToString()}-{r.ReferenceType}");
                if (referenceVersions.Count() > 1)
                {
                    _logger.LogMessage($"\t{referenceName.Key}");

                    foreach (var referenceVersion in referenceVersions)
                    {
                        _logger.LogMessage($"\t\t{referenceVersion.Key}");

                        foreach (var reference in referenceVersion)
                        {
                            _logger.LogMessage(
                                $"\t\t\t{reference.Source} - {reference.Version}/{reference.PackageVersion} {reference.ReferenceType} {reference.PackageName}");
                        }
                    }
                }
                else
                {
                    //_logger.LogMessage($"\t{referenceName.Key} - {referenceVersions.FirstOrDefault().Key} - {referenceName.Count()} references");
                }
            }

            // Check different version of the same reference

            // Check different types of references with the same name
        }
コード例 #12
0
        private ProjectTool TempCopyAndGetProject(string projectRelativePath)
        {
            var currentFolder      = System.IO.Path.GetDirectoryName(new Uri(this.GetType().Assembly.CodeBase).LocalPath);
            var csProjAbsolutePath = PathExtensions.GetAbsolutePath(currentFolder, projectRelativePath);

            var projectFolder       = System.IO.Path.GetDirectoryName(csProjAbsolutePath);
            var projectTempCopyName = $"{System.IO.Path.GetRandomFileName()}.csproj";
            var projectTempCopyPath = PathExtensions.GetAbsolutePath(projectFolder, projectTempCopyName);

            System.IO.File.Copy(csProjAbsolutePath, projectTempCopyPath);

            _temporaryProjectFileCopies.Add(projectTempCopyPath);

            var projectTool = new ProjectTool(projectTempCopyPath, new DebugLogger(true));

            return(projectTool);
        }
コード例 #13
0
        public void CleanUpReferencesInProjectFile(SolutionTool solutionTool)
        {
            var projects = solutionTool.GetProjectsWithParents().ToArray();

            foreach (var project in projects)
            {
                if (solutionTool.CompilableProjects.Contains(project.Type))
                {
                    var projectPath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, project.Path);

                    var projectTool = new ProjectTool(projectPath, _logger);
                    projectTool.CleanUpProject();
                    _logger.LogMessage($"Cleaned {projectTool.Name}");
                    projectTool.Save();
                }
            }
        }
コード例 #14
0
        public static IEnumerable <FolderProjectItem> GetMatchingTargets(SolutionTool solutionTool, FolderTool folderTool, ILogger logger)
        {
            var matchingTargets      = new List <FolderProjectItem>();
            var projects             = solutionTool.GetProjectsWithParents().ToArray();
            var targetProjects       = folderTool.GetProjects();
            var targetProjectsLookup = targetProjects.ToDictionary(p => p.Name, p => p);

            foreach (var project in projects)
            {
                if (solutionTool.CompilableProjects.Contains(project.Type))
                {
                    var projectPath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, project.Path);

                    var projectTool = new ProjectTool(projectPath, logger);
                    foreach (var reference in projectTool.GetReferences())
                    {
                        if (targetProjectsLookup.ContainsKey(reference.Name))
                        {
                            var matchingProject = targetProjectsLookup[reference.Name];

                            var nugetPackagesConfigPath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, "packages.config");

                            if (System.IO.File.Exists(nugetPackagesConfigPath))
                            {
                                var nugetTool = new NugetTool(nugetPackagesConfigPath);

                                var packages = nugetTool.GetNugetPackages();

                                var referencePackage = packages.FirstOrDefault(pkg => pkg.Name == reference.Name);

                                if (referencePackage != null)
                                {
                                    if (!matchingTargets.Contains(matchingProject))
                                    {
                                        matchingTargets.Add(matchingProject);
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(matchingTargets);
        }
コード例 #15
0
        public void SetAccount(TokenProjectAccountM model)
        {
            try
            {
                ProjectTool project_tool = _projectTool.GetOne(pt => pt.ProjectId.Equals(model.ProjectId) && pt.ToolId.Equals(model.ToolId));
                if (project_tool == null)
                {
                    throw NotFound();
                }

                project_tool.AccountId = model.AccountId;
                SaveChanges();
            }
            catch (Exception e)
            {
                throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred!",
                                                                         e, DateTime.Now, "Server", "Service-ProjectTool-SetAccount");
            }
        }
コード例 #16
0
        private static RepositoryTool SetUpRealTool()
        {
            var pat    = ToolHelper.GetPersonalAccessToken();
            var client = new Client(pat);

            var projectTool = new ProjectTool(
                client,
                TestHelper.RealOrganization,
                TestHelper.RealProject);

            var projectId = Guid.Parse(projectTool.GetId(TestHelper.RealProject).Result.ToString());

            var output = new RepositoryTool(
                client,
                TestHelper.RealOrganization,
                TestHelper.RealProject,
                projectId);

            return(output);
        }
コード例 #17
0
        public object Add(Guid project_id, Guid tool_id, string stage)
        {
            try
            {
                string[] tool_type = _tool.Where(t => t.Id.Equals(tool_id))
                                     .Select(t => t.ToolType).FirstOrDefault().Split(",");
                if (!tool_type.Any(tt => tt.Equals(stage)))
                {
                    throw BadRequest("Unidentified stage!");
                }

                ProjectTool project_tool = _projectTool.GetOne(pt => pt.ProjectId.Equals(project_id) && pt.ToolId.Equals(tool_id));
                if (project_tool == null)
                {
                    project_tool = _projectTool.Add(new ProjectTool
                    {
                        ToolId    = tool_id,
                        ProjectId = project_id,
                        Stages    = stage
                    });
                }
                else
                {
                    if (string.IsNullOrEmpty(project_tool.Stages))
                    {
                        project_tool.Stages = stage;
                    }
                    else if (!project_tool.Stages.Contains(stage))
                    {
                        project_tool.Stages += "," + stage;
                    }
                }
                SaveChanges();
                return(GetProjectTools(project_id));
            }
            catch (Exception e)
            {
                throw e is RequestException ? e : _errorHandler.WriteLog("An error occurred!",
                                                                         e, DateTime.Now, "Server", "Service-ProjectTool-Add");
            }
        }
コード例 #18
0
ファイル: Assembly.cs プロジェクト: markfinal/bam-csharp
        public object Build(
            CSharp.Assembly moduleToBuild,
            out System.Boolean success)
        {
            var assemblyModule = moduleToBuild as Bam.Core.BaseModule;
            var node = assemblyModule.OwningNode;
            var target = node.Target;
            var options = assemblyModule.Options as CSharp.OptionCollection;

            var moduleName = node.ModuleName;

            string platformName;
            switch ((options as CSharp.IOptions).Platform)
            {
                case CSharp.EPlatform.AnyCpu:
                    platformName = "AnyCPU";
                    break;

                case CSharp.EPlatform.X86:
                    platformName = "x86";
                    break;

                case CSharp.EPlatform.X64:
                case CSharp.EPlatform.Itanium:
                    platformName = "x64";
                    break;

                default:
                    throw new Bam.Core.Exception("Unrecognized platform");
            }

            ICSProject projectData = null;
            // TODO: want to remove this
            lock (this.solutionFile.ProjectDictionary)
            {
                if (this.solutionFile.ProjectDictionary.ContainsKey(moduleName))
                {
                    projectData = this.solutionFile.ProjectDictionary[moduleName] as ICSProject;
                }
                else
                {
                    var solutionType = Bam.Core.State.Get("VSSolutionBuilder", "SolutionType") as System.Type;
                    var SolutionInstance = System.Activator.CreateInstance(solutionType);
                    var ProjectExtensionProperty = solutionType.GetProperty("ProjectExtension");
                    var projectExtension = ProjectExtensionProperty.GetGetMethod().Invoke(SolutionInstance, null) as string;

                    var projectDir = node.GetModuleBuildDirectoryLocation().GetSinglePath();
                    var projectPathName = System.IO.Path.Combine(projectDir, moduleName);
                    projectPathName += projectExtension;

                    var projectType = VSSolutionBuilder.GetProjectClassType();
                    projectData = System.Activator.CreateInstance(projectType, new object[] { moduleName, projectPathName, node.Package.Identifier, assemblyModule.ProxyPath }) as ICSProject;

                    this.solutionFile.ProjectDictionary.Add(moduleName, projectData);
                }
            }

            {
                if (!projectData.Platforms.Contains(platformName))
                {
                    projectData.Platforms.Add(platformName);
                }
            }

            // solution folder
            {
                var groups = moduleToBuild.GetType().GetCustomAttributes(typeof(Bam.Core.ModuleGroupAttribute), true);
                if (groups.Length > 0)
                {
                    projectData.GroupName = (groups as Bam.Core.ModuleGroupAttribute[])[0].GroupName;
                }
            }

            if (node.ExternalDependents != null)
            {
                foreach (var dependentNode in node.ExternalDependents)
                {
                    if (dependentNode.ModuleName == moduleName)
                    {
                        continue;
                    }

                    // TODO: want to remove this
                    lock (this.solutionFile.ProjectDictionary)
                    {
                        if (this.solutionFile.ProjectDictionary.ContainsKey(dependentNode.ModuleName))
                        {
                            var dependentProject = this.solutionFile.ProjectDictionary[dependentNode.ModuleName];
                            projectData.DependentProjects.Add(dependentProject);
                        }
                    }
                }
            }

            // references
            // TODO: convert to var
            foreach (Bam.Core.Location location in (options as CSharp.IOptions).References)
            {
                var reference = location.GetSinglePath();
                projectData.References.Add(reference);
            }

            var configurationName = VSSolutionBuilder.GetConfigurationNameFromTarget(target, platformName);

            ProjectConfiguration configuration;
            lock (projectData.Configurations)
            {
                if (!projectData.Configurations.Contains(configurationName))
                {
                    // TODO: fix me?
                    configuration = new ProjectConfiguration(configurationName, projectData);
                    configuration.CharacterSet = EProjectCharacterSet.NotSet;
                    projectData.Configurations.Add((Bam.Core.BaseTarget)target, configuration);
                }
                else
                {
                    configuration = projectData.Configurations[configurationName];
                    projectData.Configurations.AddExistingForTarget((Bam.Core.BaseTarget)target, configuration);
                }
            }

            var fields = moduleToBuild.GetType().GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
            foreach (var field in fields)
            {
                // C# files
                {
                    var sourceFileAttributes = field.GetCustomAttributes(typeof(Bam.Core.SourceFilesAttribute), false);
                    if (null != sourceFileAttributes && sourceFileAttributes.Length > 0)
                    {
                        var sourceField = field.GetValue(moduleToBuild);
                        if (sourceField is Bam.Core.Location)
                        {
                            var file = sourceField as Bam.Core.Location;
                            var absolutePath = file.GetSinglePath();
                            if (!System.IO.File.Exists(absolutePath))
                            {
                                throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
                            }

                            ProjectFile sourceFile;
                            lock (projectData.SourceFiles)
                            {
                                if (!projectData.SourceFiles.Contains(absolutePath))
                                {
                                    sourceFile = new ProjectFile(absolutePath);
                                    sourceFile.FileConfigurations = new ProjectFileConfigurationCollection();
                                    projectData.SourceFiles.Add(sourceFile);
                                }
                                else
                                {
                                    sourceFile = projectData.SourceFiles[absolutePath];
                                }
                            }
                        }
                        else if (sourceField is Bam.Core.FileCollection)
                        {
                            var sourceCollection = sourceField as Bam.Core.FileCollection;
                            // TODO: convert to var
                            foreach (Bam.Core.Location location in sourceCollection)
                            {
                                var absolutePath = location.GetSinglePath();
                                if (!System.IO.File.Exists(absolutePath))
                                {
                                    throw new Bam.Core.Exception("Source file '{0}' does not exist", absolutePath);
                                }

                                ProjectFile sourceFile;
                                lock (projectData.SourceFiles)
                                {
                                    if (!projectData.SourceFiles.Contains(absolutePath))
                                    {
                                        sourceFile = new ProjectFile(absolutePath);
                                        sourceFile.FileConfigurations = new ProjectFileConfigurationCollection();
                                        projectData.SourceFiles.Add(sourceFile);
                                    }
                                    else
                                    {
                                        sourceFile = projectData.SourceFiles[absolutePath];
                                    }
                                }
                            }
                        }
                        else
                        {
                            throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
                        }
                    }
                }

                // WPF application definition .xaml file
                {
                    var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.ApplicationDefinitionAttribute), false);
                    if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
                    {
                        var sourceField = field.GetValue(moduleToBuild);
                        if (sourceField is Bam.Core.Location)
                        {
                            var file = sourceField as Bam.Core.Location;
                            var absolutePath = file.GetSinglePath();
                            if (!System.IO.File.Exists(absolutePath))
                            {
                                throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
                            }

            #if false
                            // TODO: in theory, this file should be generated in VS, but it doesn't seem to
                            string csPath = absolutePath + ".cs";
                            if (!System.IO.File.Exists(csPath))
                            {
                                throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath);
                            }
            #endif

                            projectData.ApplicationDefinition = new ProjectFile(absolutePath);
                        }
                        else if (sourceField is Bam.Core.FileCollection)
                        {
                            var sourceCollection = sourceField as Bam.Core.FileCollection;
                            if (sourceCollection.Count != 1)
                            {
                                throw new Bam.Core.Exception("There can be only one application definition");
                            }

                            // TODO: convert to var
                            foreach (string absolutePath in sourceCollection)
                            {
                                if (!System.IO.File.Exists(absolutePath))
                                {
                                    throw new Bam.Core.Exception("Application definition file '{0}' does not exist", absolutePath);
                                }

            #if false
                                // TODO: in theory, this file should be generated in VS, but it doesn't seem to
                                string csPath = absolutePath + ".cs";
                                if (!System.IO.File.Exists(csPath))
                                {
                                    throw new Bam.Core.Exception("Associated source file '{0}' to application definition file '{1}' does not exist", csPath, absolutePath));
                                }
            #endif

                                projectData.ApplicationDefinition = new ProjectFile(absolutePath);
                            }
                        }
                        else
                        {
                            throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
                        }
                    }
                }

                // WPF page .xaml files
                {
                    var xamlFileAttributes = field.GetCustomAttributes(typeof(CSharp.PagesAttribute), false);
                    if (null != xamlFileAttributes && xamlFileAttributes.Length > 0)
                    {
                        var sourceField = field.GetValue(moduleToBuild);
                        if (sourceField is Bam.Core.Location)
                        {
                            var file = sourceField as Bam.Core.Location;
                            var absolutePath = file.GetSinglePath();
                            if (!System.IO.File.Exists(absolutePath))
                            {
                                throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
                            }

                            lock (projectData.Pages)
                            {
                                if (!projectData.Pages.Contains(absolutePath))
                                {
                                    projectData.Pages.Add(new ProjectFile(absolutePath));
                                }
                            }
                        }
                        else if (sourceField is Bam.Core.FileCollection)
                        {
                            var sourceCollection = sourceField as Bam.Core.FileCollection;
                            // TODO: convert to var
                            foreach (string absolutePath in sourceCollection)
                            {
                                if (!System.IO.File.Exists(absolutePath))
                                {
                                    throw new Bam.Core.Exception("Page file '{0}' does not exist", absolutePath);
                                }

                                var csPath = absolutePath + ".cs";
                                if (!System.IO.File.Exists(csPath))
                                {
                                    throw new Bam.Core.Exception("Associated source file '{0}' to page file '{1}' does not exist", csPath, absolutePath);
                                }

                                lock (projectData.Pages)
                                {
                                    if (!projectData.Pages.Contains(absolutePath))
                                    {
                                        projectData.Pages.Add(new ProjectFile(absolutePath));
                                    }
                                }
                            }
                        }
                        else
                        {
                            throw new Bam.Core.Exception("Field '{0}' of '{1}' should be of type Bam.Core.File or Bam.Core.FileCollection, not '{2}'", field.Name, node.ModuleName, sourceField.GetType().ToString());
                        }
                    }
                }
            }

            configuration.Type = EProjectConfigurationType.Application;

            var toolName = "VCSCompiler";
            var vcsCompiler = configuration.GetTool(toolName);
            if (null == vcsCompiler)
            {
                vcsCompiler = new ProjectTool(toolName);
                configuration.AddToolIfMissing(vcsCompiler);
                configuration.OutputDirectory = moduleToBuild.Locations[CSharp.Assembly.OutputDir];

                if (options is VisualStudioProcessor.IVisualStudioSupport)
                {
                    var visualStudioProjectOption = options as VisualStudioProcessor.IVisualStudioSupport;
                    var settingsDictionary = visualStudioProjectOption.ToVisualStudioProjectAttributes(target);

                    foreach (var setting in settingsDictionary)
                    {
                        vcsCompiler[setting.Key] = setting.Value;
                    }
                }
                else
                {
                    throw new Bam.Core.Exception("Assembly options does not support VisualStudio project translation");
                }
            }

            success = true;
            return projectData;
        }
コード例 #19
0
ファイル: XmlWriter.cs プロジェクト: knocte/BuildAMation
        public object Build(
            XmlUtilities.XmlModule moduleToBuild,
            out bool success)
        {
            var node = moduleToBuild.OwningNode;
            var targetNode = node.ExternalDependents[0];
            var toProject = targetNode.Data as IProject;

            var configCollection = toProject.Configurations;
            var configurationName = configCollection.GetConfigurationNameForTarget((Bam.Core.BaseTarget)targetNode.Target); // TODO: not accurate
            var configuration = configCollection[configurationName];

            var toolName = "VCPreBuildEventTool";
            var vcPreBuildEventTool = configuration.GetTool(toolName);
            if (null == vcPreBuildEventTool)
            {
                vcPreBuildEventTool = new ProjectTool(toolName);
                configuration.AddToolIfMissing(vcPreBuildEventTool);
            }

            var commandLine = new System.Text.StringBuilder();

            var locationMap = moduleToBuild.Locations;
            var outputDir = locationMap[XmlUtilities.XmlModule.OutputDir];
            var outputDirPath = outputDir.GetSingleRawPath();
            commandLine.AppendFormat("IF NOT EXIST {0} MKDIR {0}{1}", outputDirPath, System.Environment.NewLine);

            var outputFileLoc = locationMap[XmlUtilities.XmlModule.OutputFile];
            var outputFilePath = outputFileLoc.GetSingleRawPath();

            var content = XmlUtilities.XmlDocumentToStringBuilder.Write(moduleToBuild.Document);
            foreach (var line in content.ToString().Split('\n'))
            {
                commandLine.AppendFormat("ECHO {0} >> {1}{2}", line, outputFilePath, System.Environment.NewLine);
            }

            {
                string attributeName = null;
                if (VisualStudioProcessor.EVisualStudioTarget.VCPROJ == toProject.VSTarget)
                {
                    attributeName = "CommandLine";
                }
                else if (VisualStudioProcessor.EVisualStudioTarget.MSBUILD == toProject.VSTarget)
                {
                    attributeName = "Command";
                }

                lock (vcPreBuildEventTool)
                {
                    if (vcPreBuildEventTool.HasAttribute(attributeName))
                    {
                        var currentValue = vcPreBuildEventTool[attributeName];
                        currentValue += commandLine.ToString();
                        vcPreBuildEventTool[attributeName] = currentValue;
                    }
                    else
                    {
                        vcPreBuildEventTool.AddAttribute(attributeName, commandLine.ToString());
                    }
                }
            }

            success = true;
            return null;
        }
コード例 #20
0
        public void ReTransmogrifyProjectsToNugetPackages(SolutionTool solutionTool, FolderTool folderTool)
        {
            var projectsToRemove = folderTool.GetProjects();

            var solutionProjectItems     = solutionTool.GetProjectsWithParents().ToArray();
            var solutionProjectsToRemove = solutionProjectItems.Where(p => projectsToRemove.Any(p2 => p2.Name == p.Name)).ToArray();

            var possibleParentsToKill = new List <SolutionProjectItem>();

            foreach (var solutionProjectToRemove in solutionProjectsToRemove)
            {
                if (solutionProjectToRemove.ParentId != Guid.Empty)
                {
                    var parentProject = solutionProjectItems.Single(p => p.Id == solutionProjectToRemove.ParentId);
                    if (!possibleParentsToKill.Contains(parentProject))
                    {
                        possibleParentsToKill.Add(parentProject);
                    }
                }
                _logger.LogInformation($"Remove {solutionProjectToRemove.Name}");
                _logger.LogProgress();
            }

            var dependentProjects = solutionProjectItems.Where(p =>
                                                               solutionProjectsToRemove.All(p2 => p2.Name != p.Name) &&
                                                               (p.Type == SolutionTool.ProjectTypeIdClassLibrary || p.Type == SolutionTool.ProjectTypeIdWebProject));

            foreach (var dependentProject in dependentProjects)
            {
                var projectPath = System.IO.Path.Combine(solutionTool.FolderPath, dependentProject.Path);
                var projectTool = new ProjectTool(projectPath, _logger);

                var projectReferences = projectTool.GetProjectReferences().ToArray();
                var packageReferences = projectTool.GetPackageReferences().ToArray();

                _logger.LogInformation($"References in project {dependentProject.Name}");
                var dependencies = new List <NugetPackage>();

                var projectReferencesToRemove = projectReferences.Where(pr => solutionProjectsToRemove.Any(p => p.Name == pr.Name)).ToArray();
                foreach (var projectReference in projectReferencesToRemove)
                {
                    var projectReferencePath = PathExtensions.GetAbsolutePath(projectTool.FolderPath, projectReference.HintPath);
                    var projectReferenceTool = new ProjectTool(projectReferencePath, _logger);

                    var targetFramework  = projectReferenceTool.GetTargetFramework();
                    var nugetPackageTool = NugetPackageTool.GetNugetPackageTool(solutionTool.FolderPath, projectReference.Name, targetFramework);
                    if (nugetPackageTool != null)
                    {
                        var nuspec = nugetPackageTool.GetNuspec();

                        _logger.LogInformation($"\t{projectReference.Name} - {projectReference.HintPath} - {nuspec.Name} {nuspec.Version}");

                        foreach (var dependency in nuspec.Dependencies)
                        {
                            if (dependencies.All(a => a.Name != dependency.Name) &&
                                packageReferences.All(r => r.Name != dependency.Name) &&
                                solutionProjectsToRemove.All(p => p.Name != dependency.Name))
                            {
                                dependencies.Add(new NugetPackage {
                                    Name = dependency.Name, Version = dependency.Version, TargetFramework = targetFramework
                                });
                                _logger.LogInformation($"\t\tSub Nuget dependency {dependency.Name} {dependency.Version}");
                            }
                        }
                        _logger.LogProgress();

                        if (dependencies.All(a => a.Name != nuspec.Name) &&
                            packageReferences.All(r => r.Name != nuspec.Name))
                        {
                            dependencies.Add(new NugetPackage {
                                Name = nuspec.Name, Version = nuspec.Version.ToString(), TargetFramework = targetFramework
                            });
                        }

                        projectTool.RemoveProjectReference(projectReference);
                        projectTool.AddNugetReference(nuspec.Name, nuspec.Version.ToString(), nugetPackageTool.TargetFrameworkVersion);
                    }
                    else
                    {
                        _logger.LogInformation($"\t{projectReference.Name} - {projectReference.HintPath} - NO NUGET");
                    }
                    _logger.LogProgress();
                }

                foreach (var dependency in dependencies)
                {
                    var nugetPackageTool = new NugetPackageTool(solutionTool.FolderPath, dependency.Name, dependency.Version, dependency.TargetFramework);

                    var libReferences = nugetPackageTool.GetLibPaths();
                    foreach (var libReference in libReferences)
                    {
                        projectTool.AddReference(libReference);
                        _logger.LogProgress();
                    }
                    _logger.LogProgress();
                }

                projectTool.Save();
            }

            foreach (var solutionProjectToRemove in solutionProjectsToRemove)
            {
                solutionTool.RemoveProject(solutionProjectToRemove);
                _logger.LogProgress();
            }
            solutionTool.Save();
        }
コード例 #21
0
        public void TransmogrifyNugetPackagesToProjects(SolutionTool solutionTool, FolderTool folderTool)
        {
            UpdateSolutionWithFolderTargets(solutionTool, folderTool);

            var projects       = solutionTool.GetProjectsWithParents().ToArray();
            var projectsLookup = projects.Where(p => solutionTool.CompilableProjects.Contains(p.Type)).ToDictionary(p => p.Name, p => p);

            foreach (var project in projects)
            {
                if (solutionTool.CompilableProjects.Contains(project.Type))
                {
                    var projectPath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, project.Path);

                    var projectTool = new ProjectTool(projectPath, _logger);

                    if (projectTool.IsCpsDocument)
                    {
                        foreach (var packageReference in projectTool.GetPackageReferences().ToArray())
                        {
                            if (projectsLookup.ContainsKey(packageReference.Name))
                            {
                                var matchingProject = projectsLookup[packageReference.Name];

                                projectTool.RemovePackageReference(packageReference.Name);
                                _logger.LogInformation($"Removed NuGet {packageReference.Name} from {project.Name}");

                                var absolutePath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, matchingProject.Path);
                                var relativePath = PathExtensions.MakeRelativePath(projectTool.FolderPath, absolutePath);
                                projectTool.AddProjectReference(matchingProject.Name, relativePath, matchingProject.Id);
                                _logger.LogInformation($"Added ProjectReference {matchingProject.Name} from {relativePath}");

                                var nugetPackageTool = new NugetPackageTool(solutionTool.FolderPath, packageReference.Name, packageReference.Version, packageReference.TargetFramework);
                                var nuspec           = nugetPackageTool.GetNuspec();

                                foreach (var dependency in nuspec.Dependencies)
                                {
                                    if (projectsLookup.ContainsKey(dependency.Name))
                                    {
                                        matchingProject = projectsLookup[dependency.Name];
                                        absolutePath    = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, matchingProject.Path);
                                        relativePath    = PathExtensions.MakeRelativePath(projectTool.FolderPath, absolutePath);
                                        projectTool.AddProjectReference(matchingProject.Name, relativePath, matchingProject.Id);
                                        _logger.LogInformation($"Added ProjectReference {matchingProject.Name} from {relativePath} for dependency from nuspec");
                                    }
                                    else
                                    {
                                        projectTool.AddNugetReference(dependency.Name, dependency.Version, null);
                                    }
                                    _logger.LogProgress();
                                }
                            }
                            _logger.LogProgress();
                        }
                    }
                    else
                    {
                        foreach (var reference in projectTool.GetReferences().ToArray())
                        {
                            if (projectsLookup.ContainsKey(reference.Name))
                            {
                                var matchingProject = projectsLookup[reference.Name];

                                var packages         = projectTool.GetPackageReferences().ToArray();
                                var referencePackage = packages.FirstOrDefault(pkg => pkg.Name == reference.Name);

                                if (referencePackage != null)
                                {
                                    projectTool.RemovePackageReference(referencePackage.Name);
                                    _logger.LogInformation($"Removed NuGet {referencePackage.Name} from packages.config");

                                    projectTool.RemoveReference(reference.Name);
                                    _logger.LogInformation($"Removed Reference {reference.Name} from {projectTool.FilePath}");

                                    var absolutePath = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, matchingProject.Path);
                                    var relativePath = PathExtensions.MakeRelativePath(projectTool.FolderPath, absolutePath);
                                    projectTool.AddProjectReference(matchingProject.Name, relativePath, matchingProject.Id);
                                    _logger.LogInformation($"Added ProjectReference {matchingProject.Name} from {relativePath}");

                                    var nugetPackageTool =
                                        new NugetPackageTool(solutionTool.FolderPath, referencePackage.Name, referencePackage.Version, referencePackage.TargetFramework);
                                    var nuspec = nugetPackageTool.GetNuspec();

                                    foreach (var dependency in nuspec.Dependencies)
                                    {
                                        if (projectsLookup.ContainsKey(dependency.Name))
                                        {
                                            matchingProject = projectsLookup[dependency.Name];
                                            absolutePath    = PathExtensions.GetAbsolutePath(solutionTool.FolderPath, matchingProject.Path);
                                            relativePath    = PathExtensions.MakeRelativePath(projectTool.FolderPath, absolutePath);
                                            projectTool.AddProjectReference(matchingProject.Name, relativePath, matchingProject.Id);
                                            _logger.LogInformation($"Added ProjectReference {matchingProject.Name} from {relativePath} for dependency from nuspec");
                                        }
                                        else
                                        {
                                            var existingReference = packages.FirstOrDefault(pkg => pkg.Name == dependency.Name);
                                            if (existingReference == null)
                                            {
                                                projectTool.AddNugetReference(dependency.Name, dependency.Version, projectTool.GetTargetFramework());
                                            }
                                        }
                                        _logger.LogProgress();
                                    }
                                }
                            }
                            _logger.LogProgress();
                        }
                    }

                    projectTool.Save();
                }
                _logger.LogProgress();
            }
        }
コード例 #22
0
ファイル: EditorDockFactory.cs プロジェクト: bamfbamf/Core2D
        /// <inheritdoc/>
        public override IDock CreateLayout()
        {
            // Documents

            var pageDocument = new PageDocument
            {
                Id    = nameof(PageDocument),
                Title = "Page"
            };

            // Tools

            var projectTool = new ProjectTool
            {
                Id    = nameof(ProjectTool),
                Title = "Project"
            };

            var optionsTool = new OptionsTool
            {
                Id    = nameof(OptionsTool),
                Title = "Options"
            };

            var imagesTool = new ImagesTool
            {
                Id    = nameof(ImagesTool),
                Title = "Images"
            };

            var groupsTool = new GroupsTool
            {
                Id    = nameof(GroupsTool),
                Title = "Groups"
            };

            var databasesTool = new DatabasesTool
            {
                Id    = nameof(DatabasesTool),
                Title = "Databases"
            };

            var scriptTool = new ScriptTool
            {
                Id    = nameof(ScriptTool),
                Title = "Script"
            };

            var browserTool = new BrowserTool
            {
                Id    = nameof(BrowserTool),
                Title = "Browser"
            };

            var stylesTool = new StylesTool
            {
                Id    = nameof(StylesTool),
                Title = "Styles"
            };

            var templatesTool = new TemplatesTool
            {
                Id    = nameof(TemplatesTool),
                Title = "Templates"
            };

            var containerTool = new ContainerTool
            {
                Id    = nameof(ContainerTool),
                Title = "Container"
            };

            var zoomTool = new ZoomTool
            {
                Id    = nameof(ZoomTool),
                Title = "Zoom"
            };

            var shapeTool = new ShapeTool
            {
                Id    = nameof(ShapeTool),
                Title = "Shape"
            };

            var toolsTool = new ToolsTool
            {
                Id    = nameof(ToolsTool),
                Title = "Tools"
            };

            var dataTool = new DataTool
            {
                Id    = nameof(DataTool),
                Title = "Data"
            };

            var styleTool = new StyleTool
            {
                Id    = nameof(StyleTool),
                Title = "Style"
            };

            var templateTool = new TemplateTool
            {
                Id    = nameof(TemplateTool),
                Title = "Template"
            };

            // Panes

            var leftPane = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Title       = "EditorLeft",
                Orientation = Orientation.Vertical,
                Proportion  = 0.17,
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Title       = "EditorLeftTop",
                        Proportion  = double.NaN,
                        CurrentView = projectTool,
                        Views       = new ObservableCollection <IView>
                        {
                            projectTool,
                            optionsTool,
                            imagesTool
                        }
                    },
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Title = "LeftTopSplitter"
                    },
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Title       = "EditorLeftBottom",
                        Proportion  = double.NaN,
                        CurrentView = groupsTool,
                        Views       = new ObservableCollection <IView>
                        {
                            groupsTool,
                            databasesTool,
                            scriptTool,
                            browserTool
                        }
                    }
                }
            };

            var rightPane = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Title       = "EditorRight",
                Orientation = Orientation.Vertical,
                Proportion  = 0.17,
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Title       = "EditorRightTop",
                        Proportion  = double.NaN,
                        CurrentView = stylesTool,
                        Views       = new ObservableCollection <IView>
                        {
                            stylesTool,
                            templatesTool,
                            containerTool,
                            zoomTool
                        }
                    },
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Title = "RightTopSplitter"
                    },
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Title       = "EditorRightBottom",
                        Proportion  = double.NaN,
                        CurrentView = shapeTool,
                        Views       = new ObservableCollection <IView>
                        {
                            shapeTool,
                            toolsTool,
                            dataTool,
                            styleTool,
                            templateTool
                        }
                    }
                }
            };

            var documentsPane = new DocumentDock
            {
                Id          = nameof(IDocumentDock),
                Title       = "DocumentsPane",
                Proportion  = double.NaN,
                CurrentView = pageDocument,
                Views       = new ObservableCollection <IView>
                {
                    pageDocument
                }
            };

            // Editor

            var editorLayout = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Title       = "EditorLayout",
                Orientation = Orientation.Horizontal,
                Proportion  = double.NaN,
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    leftPane,
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Title = "LeftSplitter"
                    },
                    documentsPane,
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Title = "RightSplitter"
                    },
                    rightPane
                }
            };

            // Views

            var editorView = new EditorView
            {
                Id          = nameof(EditorView),
                Title       = "Editor",
                CurrentView = editorLayout,
                Views       = new ObservableCollection <IView>
                {
                    editorLayout
                }
            };

            var aboutView = new AboutView
            {
                Id    = nameof(AboutView),
                Title = "About"
            };

            var browserView = new BrowserView
            {
                Id    = nameof(BrowserView),
                Title = "Browser"
            };

            var scriptView = new ScriptView
            {
                Id    = nameof(ScriptView),
                Title = "Script"
            };

            var documentView = new DocumentView
            {
                Id    = nameof(DocumentView),
                Title = "Document"
            };

            var dashboardView = new DashboardView
            {
                Id    = nameof(DashboardView),
                Title = "Dashboard"
            };

            // Root

            var layout = new RootDock
            {
                Id          = nameof(IRootDock),
                Title       = "Root",
                CurrentView = dashboardView,
                DefaultView = dashboardView,
                Views       = new ObservableCollection <IView>
                {
                    dashboardView,
                    editorView,
                    aboutView,
                    browserView,
                    scriptView,
                    documentView
                }
            };

            return(layout);
        }
コード例 #23
0
        /// <inheritdoc/>
        public override IDock CreateLayout()
        {
            // Documents

            var pageDocument = new PageDocument
            {
                Id     = nameof(PageDocument),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Page"
            };

            // Left / Top

            var projectView = new ProjectTool
            {
                Id     = nameof(ProjectTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Project"
            };

            var optionsView = new OptionsTool
            {
                Id     = nameof(OptionsTool),
                Width  = 200,
                Height = 200,
                Title  = "Options"
            };

            var imagesView = new ImagesTool
            {
                Id     = nameof(ImagesTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Images"
            };

            // Left / Bottom

            var groupsView = new GroupsTool
            {
                Id     = nameof(GroupsTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Groups"
            };

            var databasesView = new DatabasesTool
            {
                Id     = nameof(DatabasesTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Databases"
            };

            // Right / Top

            var stylesView = new StylesTool
            {
                Id     = nameof(StylesTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Styles"
            };

            var templatesView = new TemplatesTool
            {
                Id     = nameof(TemplatesTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Templates"
            };

            var containerView = new ContainerTool
            {
                Id     = nameof(ContainerTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Container"
            };

            var zoomView = new ZoomTool
            {
                Id     = nameof(ZoomTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Zoom"
            };

            // Right / Bottom

            var toolsView = new ToolsTool
            {
                Id     = nameof(ToolsTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Tools"
            };

            var shapeView = new ShapeTool
            {
                Id     = nameof(ShapeTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Shape"
            };

            var dataView = new DataTool
            {
                Id     = nameof(DataTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Data"
            };

            var styleView = new StyleTool
            {
                Id     = nameof(StyleTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Style"
            };

            var templateView = new TemplateTool
            {
                Id     = nameof(TemplateTool),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Template"
            };

            // Left Pane

            var leftPane = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Dock        = "Left",
                Width       = 200,
                Height      = double.NaN,
                Title       = "EditorLeft",
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Dock        = "Top",
                        Width       = double.NaN,
                        Height      = 340,
                        Title       = "EditorLeftTop",
                        CurrentView = projectView,
                        Views       = new ObservableCollection <IView>
                        {
                            projectView,
                            optionsView,
                            imagesView
                        }
                    },
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Dock  = "Top",
                        Title = "LeftTopSplitter"
                    },
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Dock        = "Bottom",
                        Width       = double.NaN,
                        Height      = double.NaN,
                        Title       = "EditorLeftBottom",
                        CurrentView = groupsView,
                        Views       = new ObservableCollection <IView>
                        {
                            groupsView,
                            databasesView
                        }
                    }
                }
            };

            // Right Pane

            var rightPane = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Dock        = "Right",
                Width       = 240,
                Height      = double.NaN,
                Title       = "EditorRight",
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Dock        = "Top",
                        Width       = double.NaN,
                        Height      = 340,
                        Title       = "EditorRightTop",
                        CurrentView = stylesView,
                        Views       = new ObservableCollection <IView>
                        {
                            stylesView,
                            templatesView,
                            containerView,
                            zoomView
                        }
                    },
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Dock  = "Top",
                        Title = "RightTopSplitter"
                    },
                    new ToolDock
                    {
                        Id          = nameof(IToolDock),
                        Dock        = "Bottom",
                        Width       = double.NaN,
                        Height      = double.NaN,
                        Title       = "EditorRightBottom",
                        CurrentView = toolsView,
                        Views       = new ObservableCollection <IView>
                        {
                            toolsView,
                            shapeView,
                            dataView,
                            styleView,
                            templateView
                        }
                    }
                }
            };

            // Documents

            var documentsPane = new DocumentDock
            {
                Id          = nameof(IDocumentDock),
                Dock        = "",
                Width       = double.NaN,
                Height      = double.NaN,
                Title       = "DocumentsPane",
                CurrentView = pageDocument,
                Views       = new ObservableCollection <IView>
                {
                    pageDocument
                }
            };

            // Main

            var editorLayout = new LayoutDock
            {
                Id          = nameof(ILayoutDock),
                Dock        = "",
                Width       = double.NaN,
                Height      = double.NaN,
                Title       = "EditorLayout",
                CurrentView = null,
                Views       = new ObservableCollection <IView>
                {
                    leftPane,
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Dock  = "Left",
                        Title = "LeftSplitter"
                    },
                    rightPane,
                    new SplitterDock()
                    {
                        Id    = nameof(ISplitterDock),
                        Dock  = "Right",
                        Title = "RightSplitter"
                    },
                    documentsPane
                }
            };

            var editorView = new EditorView
            {
                Id          = nameof(EditorView),
                Width       = double.NaN,
                Height      = double.NaN,
                Title       = "Editor",
                CurrentView = editorLayout,
                Views       = new ObservableCollection <IView>
                {
                    editorLayout
                }
            };

            // About

            var aboutView = new AboutView
            {
                Id     = nameof(AboutView),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "About"
            };

            // Browser

            var browserView = new BrowserView
            {
                Id     = nameof(BrowserView),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Browser"
            };

            // Document

            var documentView = new DocumentView
            {
                Id     = nameof(DocumentView),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Document"
            };

            // Dashboard

            var dashboardView = new DashboardView
            {
                Id     = nameof(DashboardView),
                Width  = double.NaN,
                Height = double.NaN,
                Title  = "Dashboard"
            };

            // Main

            var layout = new RootDock
            {
                Id          = nameof(IRootDock),
                Width       = double.NaN,
                Height      = double.NaN,
                Title       = "Root",
                CurrentView = dashboardView,
                DefaultView = dashboardView,
                Views       = new ObservableCollection <IView>
                {
                    dashboardView,
                    editorView,
                    aboutView,
                    browserView,
                    documentView
                }
            };

            return(layout);
        }
コード例 #24
0
        /// <inheritdoc/>
        public override DM.IDock CreateLayout()
        {
            // Documents

            var pageDocument = new PageDocument
            {
                Id    = nameof(PageDocument),
                Title = "Page"
            };

            // Tools

            var projectTool = new ProjectTool
            {
                Id    = nameof(ProjectTool),
                Title = "Project"
            };

            var optionsTool = new OptionsTool
            {
                Id    = nameof(OptionsTool),
                Title = "Options"
            };

            var imagesTool = new ImagesTool
            {
                Id    = nameof(ImagesTool),
                Title = "Images"
            };

            var groupsTool = new GroupsTool
            {
                Id    = nameof(GroupsTool),
                Title = "Groups"
            };

            var databasesTool = new DatabasesTool
            {
                Id    = nameof(DatabasesTool),
                Title = "Databases"
            };

            var scriptTool = new ScriptTool
            {
                Id    = nameof(ScriptTool),
                Title = "Script"
            };

            var exportTool = new ExportTool
            {
                Id    = nameof(ExportTool),
                Title = "Export"
            };

            var browserTool = new BrowserTool
            {
                Id    = nameof(BrowserTool),
                Title = "Browser"
            };

            var documentTool = new DocumentTool
            {
                Id    = nameof(DocumentTool),
                Title = "Document"
            };

            var stylesTool = new StylesTool
            {
                Id    = nameof(StylesTool),
                Title = "Styles"
            };

            var templatesTool = new TemplatesTool
            {
                Id    = nameof(TemplatesTool),
                Title = "Templates"
            };

            var scriptsTool = new ScriptsTool
            {
                Id    = nameof(ScriptsTool),
                Title = "Scripts"
            };

            var containerTool = new ContainerTool
            {
                Id    = nameof(ContainerTool),
                Title = "Container"
            };

            var zoomTool = new ZoomTool
            {
                Id    = nameof(ZoomTool),
                Title = "Zoom"
            };

            var rendererTool = new RendererTool
            {
                Id    = nameof(RendererTool),
                Title = "Renderer"
            };

            var shapeTool = new ShapeTool
            {
                Id    = nameof(ShapeTool),
                Title = "Shape"
            };

            var toolsTool = new ToolsTool
            {
                Id    = nameof(ToolsTool),
                Title = "Tools"
            };

            var recordTool = new RecordTool
            {
                Id    = nameof(RecordTool),
                Title = "Record"
            };

            var propertiesTool = new PropertiesTool
            {
                Id    = nameof(PropertiesTool),
                Title = "Properties"
            };

            var styleTool = new StyleTool
            {
                Id    = nameof(StyleTool),
                Title = "Style"
            };

            var templateTool = new TemplateTool
            {
                Id    = nameof(TemplateTool),
                Title = "Template"
            };

            // Panes

            var leftPane = new DMC.ProportionalDock
            {
                Id               = nameof(DMC.IProportionalDock),
                Title            = "EditorLeft",
                Orientation      = DM.Orientation.Vertical,
                Proportion       = 0.17,
                ActiveDockable   = null,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    new DMC.ToolDock
                {
                    Id               = nameof(DMC.IToolDock),
                    Title            = "EditorLeftTop",
                    Proportion       = double.NaN,
                    ActiveDockable   = projectTool,
                    VisibleDockables = CreateList <DM.IDockable>
                                       (
                        projectTool,
                        optionsTool,
                        rendererTool,
                        imagesTool
                                       )
                },
                    new DMC.SplitterDock()
                {
                    Id    = nameof(DMC.ISplitterDock),
                    Title = "LeftTopSplitter"
                },
                    new DMC.ToolDock
                {
                    Id               = nameof(DMC.IToolDock),
                    Title            = "EditorLeftBottom",
                    Proportion       = double.NaN,
                    ActiveDockable   = groupsTool,
                    VisibleDockables = CreateList <DM.IDockable>
                                       (
                        groupsTool,
                        databasesTool,
                        toolsTool,
                        scriptsTool
                                       )
                }
                                   )
            };

            var rightPane = new DMC.ProportionalDock
            {
                Id               = nameof(DMC.IProportionalDock),
                Title            = "EditorRight",
                Orientation      = DM.Orientation.Vertical,
                Proportion       = 0.20,
                ActiveDockable   = null,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    new DMC.ToolDock
                {
                    Id               = nameof(DMC.IToolDock),
                    Title            = "EditorRightTop",
                    Proportion       = double.NaN,
                    ActiveDockable   = stylesTool,
                    VisibleDockables = CreateList <DM.IDockable>
                                       (
                        stylesTool,
                        containerTool,
                        templatesTool,
                        templateTool
                                       )
                },
                    new DMC.SplitterDock()
                {
                    Id    = nameof(DMC.ISplitterDock),
                    Title = "RightTopSplitter"
                },
                    new DMC.ToolDock
                {
                    Id               = nameof(DMC.IToolDock),
                    Title            = "EditorRightBottom",
                    Proportion       = double.NaN,
                    ActiveDockable   = shapeTool,
                    VisibleDockables = CreateList <DM.IDockable>
                                       (
                        shapeTool,
                        propertiesTool,
                        recordTool,
                        styleTool,
                        zoomTool
                                       )
                }
                                   )
            };

            var documentsPane = new DMC.DocumentDock
            {
                Id               = nameof(DMC.IDocumentDock),
                Title            = "DocumentsPane",
                IsCollapsable    = false,
                Proportion       = double.NaN,
                ActiveDockable   = pageDocument,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    pageDocument,
                    documentTool,
                    scriptTool,
                    exportTool,
                    browserTool
                                   )
            };

            // Editor

            var editorLayout = new DMC.ProportionalDock
            {
                Id               = nameof(DMC.IProportionalDock),
                Title            = "EditorLayout",
                Orientation      = DM.Orientation.Horizontal,
                Proportion       = double.NaN,
                ActiveDockable   = null,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    leftPane,
                    new DMC.SplitterDock()
                {
                    Id    = nameof(DMC.ISplitterDock),
                    Title = "LeftSplitter"
                },
                    documentsPane,
                    new DMC.SplitterDock()
                {
                    Id    = nameof(DMC.ISplitterDock),
                    Title = "RightSplitter"
                },
                    rightPane
                                   )
            };

            // Views

            var dashboardView = new DashboardView
            {
                Id    = nameof(DashboardView),
                Title = "Dashboard"
            };

            var editorView = new EditorView
            {
                Id               = nameof(EditorView),
                Title            = "Editor",
                ActiveDockable   = editorLayout,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    editorLayout
                                   )
            };

            // Root

            var root = new DMC.RootDock
            {
                Id               = nameof(DMC.IRootDock),
                Title            = "Root",
                IsCollapsable    = false,
                ActiveDockable   = dashboardView,
                DefaultDockable  = dashboardView,
                VisibleDockables = CreateList <DM.IDockable>
                                   (
                    dashboardView,
                    editorView
                                   )
            };

            root.Top              = CreatePinDock();
            root.Top.Alignment    = DM.Alignment.Top;
            root.Bottom           = CreatePinDock();
            root.Bottom.Alignment = DM.Alignment.Bottom;
            root.Left             = CreatePinDock();
            root.Left.Alignment   = DM.Alignment.Left;
            root.Right            = CreatePinDock();
            root.Right.Alignment  = DM.Alignment.Right;

            return(root);
        }
コード例 #25
0
        Build(
            XmlUtilities.TextFileModule moduleToBuild,
            out bool success)
        {
            var node       = moduleToBuild.OwningNode;
            var targetNode = node.ExternalDependents[0];
            var toProject  = targetNode.Data as IProject;

            var configCollection  = toProject.Configurations;
            var configurationName = configCollection.GetConfigurationNameForTarget((Bam.Core.BaseTarget)targetNode.Target); // TODO: not accurate
            var configuration     = configCollection[configurationName];

            var toolName            = "VCPreBuildEventTool";
            var vcPreBuildEventTool = configuration.GetTool(toolName);

            if (null == vcPreBuildEventTool)
            {
                vcPreBuildEventTool = new ProjectTool(toolName);
                configuration.AddToolIfMissing(vcPreBuildEventTool);
            }

            var commandLine = new System.Text.StringBuilder();

            var locationMap   = moduleToBuild.Locations;
            var outputDir     = locationMap[XmlUtilities.TextFileModule.OutputDir];
            var outputDirPath = outputDir.GetSingleRawPath();

            commandLine.AppendFormat("IF NOT EXIST {0} MKDIR {0}{1}", outputDirPath, System.Environment.NewLine);

            var outputFileLoc  = locationMap[XmlUtilities.TextFileModule.OutputFile];
            var outputFilePath = outputFileLoc.GetSingleRawPath();

            foreach (var line in moduleToBuild.Content.ToString().Split('\n'))
            {
                commandLine.AppendFormat("ECHO {0} >> {1}{2}", line, outputFilePath, System.Environment.NewLine);
            }

            {
                string attributeName = null;
                if (VisualStudioProcessor.EVisualStudioTarget.VCPROJ == toProject.VSTarget)
                {
                    attributeName = "CommandLine";
                }
                else if (VisualStudioProcessor.EVisualStudioTarget.MSBUILD == toProject.VSTarget)
                {
                    attributeName = "Command";
                }

                lock (vcPreBuildEventTool)
                {
                    if (vcPreBuildEventTool.HasAttribute(attributeName))
                    {
                        var currentValue = vcPreBuildEventTool[attributeName];
                        currentValue += commandLine.ToString();
                        vcPreBuildEventTool[attributeName] = currentValue;
                    }
                    else
                    {
                        vcPreBuildEventTool.AddAttribute(attributeName, commandLine.ToString());
                    }
                }
            }

            success = true;
            return(null);
        }
コード例 #26
0
 public void SetUp()
 {
     _clientMock = TestHelper.SetUpMockClient();
     _fakeTool   = new ProjectTool(_clientMock.Object, TestHelper.RealOrganization, TestHelper.RealProject);
 }