public void AdjustGroupScheduleOnGroup() { IProjectManager<Task, object> manager = new ProjectManager<Task, object>(); var group = new Task(); var one = new Task(); manager.Add(group); manager.Add(one); // setup: set initial task parameters manager.SetStart(group, 6); manager.SetDuration(group, 5); manager.SetStart(one, 9); manager.SetEnd(one, 15); Assert.IsTrue(group.Start == 6); Assert.IsTrue(group.End == 11); Assert.IsTrue(one.Start == 9); Assert.IsTrue(one.Duration == 6); // test: make a group and group make have same parameters as one manager.Group(group, one); Assert.IsTrue(group.Start == one.Start); Assert.IsTrue(group.End == one.End); Assert.IsTrue(group.Duration == one.Duration); Assert.IsTrue(group.Complete == one.Complete); }
public void AdjustDependantScheduleOnRelate() { IProjectManager<Task, object> manager = new ProjectManager<Task, object>(); var one = new Task() { Name = "one" }; var two = new Task() { Name = "two" }; manager.Add(one); manager.Add(two); // setup: make 2 independant tasks manager.SetStart(one, 10); manager.SetDuration(one, 6); manager.SetStart(two, 10); manager.SetDuration(two, 10); Assert.IsTrue(one.Start == 10); Assert.IsTrue(one.End == 16); Assert.IsTrue(two.Start == 10); Assert.IsTrue(two.End == 20); // test: relate one and two; one before two manager.Relate(one, two); Assert.IsTrue(one.Start == 10); Assert.IsTrue(one.End == 16); Assert.IsTrue(two.Start == 17); Assert.IsTrue(two.End == 27); }
public ConnectionContext(Socket acceptedSocket, string hostName, ProtocolManager protocolManager, DesignTimeWorkspace workspaceContext, IDictionary<int, ProjectManager> projects) { _hostName = hostName; _projects = projects; _queue = new ProcessingQueue(new NetworkStream(acceptedSocket)); _queue.OnReceive += message => { if (protocolManager.IsProtocolNegotiation(message)) { message.Sender = this; protocolManager.Negotiate(message); } else { message.Sender = this; ProjectManager projectManager; if (!_projects.TryGetValue(message.ContextId, out projectManager)) { projectManager = new ProjectManager(message.ContextId, workspaceContext, protocolManager); _projects[message.ContextId] = projectManager; } projectManager.OnReceive(message); } }; }
public void GetRemotePackagesTest() { // Arrange var siteRoot = "x:\\"; var localRepository = new MockPackageRepository(); var sourceRepository = new MockServiceBasePackageRepository(); var projectSystem = new WebProjectSystem(siteRoot); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(sourceRepository, pathResolver, projectSystem, localRepository); var net40 = new FrameworkName(".NETFramework", new Version("4.0.0.0")); var net45 = new FrameworkName(".NETFramework", new Version("4.5.0.0")); IPackage packageA = PackageFactory.Create("A", new Version("1.0"), null, new FrameworkName[]{ net40 }); IPackage packageB = PackageFactory.Create("B", new Version("1.0"), null, new FrameworkName[]{ net45 }); IPackage packageC = PackageFactory.Create("C", new Version("1.0")); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); // NOTE THAT target framework used by WebProjectManager would be .NETFramework, Version=4.0.0.0 var webProjectManager = new WebProjectManager(projectManager, siteRoot); // Act var packages = webProjectManager.GetRemotePackages(null, false).ToList(); // Assert Assert.Equal(2, packages.Count); Assert.Equal(packageA, packages[0]); Assert.Equal(packageC, packages[1]); }
public void AddPackageReferenceAddingPackageWithDuplicateReferenceOverwritesReference() { // Arrange var projectSystem = new MockProjectSystem(); var localRepository = new MockPackageRepository(); var mockRepository = new MockPackageRepository(); var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository); var packageA = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "reference.dll" }); var packageB = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "reference.dll" }); mockRepository.AddPackage(packageA); mockRepository.AddPackage(packageB); // Act projectManager.AddPackageReference("A"); projectManager.AddPackageReference("B"); // Assert Assert.AreEqual(0, projectSystem.Paths.Count); Assert.AreEqual(1, projectSystem.References.Count); Assert.IsTrue(projectSystem.References.ContainsKey(@"reference.dll")); Assert.IsTrue(projectSystem.References.ContainsValue(@"B.1.0\reference.dll")); Assert.IsTrue(localRepository.Exists("A")); Assert.IsTrue(localRepository.Exists("B")); }
public void AddPackageReferenceLoadPackagesProjectNameConfigIfPresent() { // Arrange var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem( new FrameworkName(".NETFramework, Version=4.5")); projectSystem.ProjectName = "CoolProject"; projectSystem.AddFile("packages.CoolProject.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""luan"" version=""3.0"" /> </packages>"); var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository()); IPackage packageA = PackageUtility.CreatePackage( "A", "1.0", assemblyReferences: new[] { "lib\\a.dll"}); sourceRepository.AddPackage(packageA); // Act projectManager.AddPackageReference("A"); // Assert Assert.True(projectManager.LocalRepository.Exists("A")); Assert.True(projectManager.Project.FileExists("packages.CoolProject.config")); Assert.False(projectManager.Project.FileExists("packages.config")); }
public ItemList(ProjectManager project, Project buildProject) { this.project = project; this.buildProject = buildProject; new ItemNode(this, VSConstants.VSITEMID_ROOT); }
public void InstallPackageSetOperationToInstall3() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); // Act packageManager.InstallPackage( projectManager, package2, new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), }, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.Equal("Install", sourceRepository.LastOperation); Assert.Equal("bar", sourceRepository.LastMainPackageId); Assert.Equal("2.0", sourceRepository.LastMainPackageVersion); }
public void InstallPackageWithOperationsExecuteAllOperations() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" }); localRepository.AddPackage(package3); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), new PackageOperation(package3, PackageAction.Uninstall) }; // Act packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); Assert.IsTrue(packageManager.LocalRepository.Exists(package2)); Assert.IsTrue(!packageManager.LocalRepository.Exists(package3)); Assert.IsTrue(projectManager.LocalRepository.Exists(package)); Assert.IsTrue(projectManager.LocalRepository.Exists(package2)); }
public void AdjustGroupDuringJoin() { IProjectManager<Task, object> manager = new ProjectManager<Task, object>(); var group = new Task(); var split = new Task(); var part1 = new Task(); var part2 = new Task(); var part3 = new Task(); manager.Add(split); manager.Add(group); // setup: create a split under a group manager.Group(group, split); manager.Split(split, part1, part2, 1); manager.Split(part2, part3, 1); Assert.IsTrue(group.Duration == 5); Assert.IsTrue(group.Duration == split.Duration); Assert.IsTrue(group.End == part3.End); // test: join and make sure group duration is shortened manager.Join(part1, part3); Assert.IsTrue(!manager.IsPart(part3)); Assert.IsTrue(group.Duration == 4); Assert.IsTrue(group.Duration == split.Duration); Assert.IsTrue(group.End == part2.End); }
public void UninstallPackageDoesNotRemoveDependenciesIfFlagIsFalse() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; localRepository.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(new FrameworkName(".NETCore, Version=4.5")); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B"); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, new FrameworkName(".NETCore, Version=4.5"), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(packageA); localRepository.Object.AddPackage(packageB); packageUninstaller.UninstallPackage(project, "A", removeDependencies: false); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(packageA)); Assert.True(localRepository.Object.Contains(packageB)); }
private IEnumerable<ITaskItem> ResolvePackage(ITaskItem package) { string id = package.ItemSpec; string version = package.GetMetadata("Version"); Log.LogMessage(MessageImportance.Normal, "Resolving Package Reference {0} {1}...", id, version); // Initial version just searches a machine-level repository var localFs = new PhysicalFileSystem(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Lib")); var defaultResolver = new DefaultPackagePathResolver(localFs); var machineRepo = new LocalPackageRepository(defaultResolver, localFs); var buildRepo = new BuildPackageRepository(); var remoteRepo = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2")); var project = new BuildProjectSystem(ProjectDirectory, new FrameworkName(TargetFramework), CurrentReferences); var manager = new PackageManager(remoteRepo, defaultResolver, localFs, machineRepo); var projectManager = new ProjectManager(remoteRepo, defaultResolver, project, buildRepo); // Install the package var ver = new SemanticVersion(version); manager.PackageInstalling += manager_PackageInstalling; manager.InstallPackage(id, ver); projectManager.AddPackageReference(id, ver); return project.OutputReferences.Select(item => { var name = AssemblyName.GetAssemblyName(item); return new TaskItem(name.FullName, new Dictionary<string, string>() { {"HintPath", item }, {"Private", "true"} }); }); }
public Form1() { InitializeComponent(); // create a project manager var manager = new ProjectManager(); // create built-in task or use your own derived task var task = new Braincase.GanttChart.Task() { Name = "Hello "}; var task1 = new Braincase.GanttChart.Task() { Name = " World" }; var task2 = new Braincase.GanttChart.Task() { Name = "Helly" }; var task3 = new Braincase.GanttChart.Task() { Name = "Hel7875" }; var task5 = new Braincase.GanttChart.Task() { Name = "gmmail" }; // add the task to the manager manager.Add(task2); manager.Add(task); manager.Add(task1); manager.Add(task3); manager.Split(task2,task1,2); //manager.SetDuration(task, 3); // create a chart control var chart = new Chart(); // initialise the chart with the manager chart.Init(manager); // add chart to the form controls collection. this.Controls.Add(chart); // throughout your own code, call chart.Invalidate() // where you expect updates to the drawn chart, // to tell the chart to Paint() itself. }
public void InstallMetadataPackageWithReadMeInstallsIntoProjectAndPackageManager() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var mockPackageA = Mock.Get(packageA); mockPackageA.Setup(m => m.GetFiles()).Returns(PackageUtility.CreateFiles(new[] { "readme.txt" })); var packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "hello.txt" }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); // Act packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(packageA)); Assert.True(projectManager.LocalRepository.Exists(packageA)); Assert.True(packageManager.LocalRepository.Exists(packageB)); Assert.True(projectManager.LocalRepository.Exists(packageB)); }
public void AddPackageReferenceWhenNewVersionOfPackageAlreadyReferencedThrows() { // Arrange var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository()); IPackage packageA10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }, content: new[] { "foo" }); IPackage packageA20 = PackageUtility.CreatePackage("A", "2.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }, content: new[] { "foo" }); IPackage packageB10 = PackageUtility.CreatePackage("B", "1.0", content: new[] { "foo" }); projectManager.LocalRepository.AddPackage(packageA20); projectManager.LocalRepository.AddPackage(packageB10); sourceRepository.AddPackage(packageA20); sourceRepository.AddPackage(packageB10); sourceRepository.AddPackage(packageA10); sourceRepository.AddPackage(packageA20); sourceRepository.AddPackage(packageB10); // Act & Assert ExceptionAssert.Throws<InvalidOperationException>(() => projectManager.AddPackageReference("A", SemanticVersion.Parse("1.0")), @"Already referencing a newer version of 'A'."); }
public void ReinstallPackagesRestoresPackageWithTheSameVersion() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, new MockPackageRepository()); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.2", new[] { "content.txt" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageA); // Act packageManager.ReinstallPackage(projectManager, "A", updateDependencies: true, allowPrereleaseVersions: true, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); }
public void InstallPackageRunsInitAndInstallScripts() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock<IPackageRepositoryFactory>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Init, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Install, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); }
public void XdtTransformOnXmlNodeWithAttributes() { // Arrange var mockProjectSystem = new MockProjectSystem(); var mockRepository = new MockPackageRepository(); mockProjectSystem.AddFile("test.xml", @"<a attrib=""b""/>".AsStream()); var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository()); var package = new Mock<IPackage>(); package.Setup(m => m.Id).Returns("A"); package.Setup(m => m.Version).Returns(new SemanticVersion("1.0")); package.Setup(m => m.Listed).Returns(true); var file = new Mock<IPackageFile>(); file.Setup(m => m.Path).Returns(@"content\test.xml.install.xdt"); file.Setup(m => m.EffectivePath).Returns("test.xml.install.xdt"); file.Setup(m => m.GetStream()).Returns(() => @"<a xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""><test xdt:Transform=""InsertIfMissing""/></a>".AsStream()); package.Setup(m => m.GetFiles()).Returns(new[] { file.Object }); mockRepository.AddPackage(package.Object); // Act projectManager.AddPackageReference("A"); // Assert Assert.True(mockProjectSystem.FileExists("test.xml")); var actual = mockProjectSystem.OpenFile("test.xml").ReadToEnd(); Assert.Equal("<a attrib=\"b\">\t<test/></a>", actual); }
public void AddPackageReferenceAppliesPackageReferencesCorrectly2() { // Arrange var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5")); var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository()); IPackage packageA = PackageUtility.CreatePackage( "A", "1.0", assemblyReferences: new[] { "lib\\net35\\a.dll", "lib\\net35\\b.dll" }); sourceRepository.AddPackage(packageA); Mock<IPackage> mockPackageA = Mock.Get<IPackage>(packageA); mockPackageA.Setup(m => m.PackageAssemblyReferences).Returns( new PackageReferenceSet[] { new PackageReferenceSet(VersionUtility.ParseFrameworkName("net40"), new [] { "a.dll" }), new PackageReferenceSet(VersionUtility.ParseFrameworkName("net45"), new [] { "b.dll" }) } ); // Act projectManager.AddPackageReference("A"); // Assert Assert.True(projectManager.LocalRepository.Exists("A")); Assert.False(projectSystem.ReferenceExists("a.dll")); Assert.True(projectSystem.ReferenceExists("b.dll")); }
public void AdjustGroupDurationOnUngroup() { IProjectManager<Task, object> manager = new ProjectManager<Task, object>(); var split = new Task(); var part1 = new Task(); var part2 = new Task(); var group = new Task(); var task = new Task(); manager.Add(group); manager.Add(split); manager.Add(task); // setup: create a group and split under it manager.Split(split, part1, part2, 1); manager.Group(group, part1); // intentionall group using part manager.Group(group, task); manager.SetDuration(part1, 30); manager.SetDuration(part2, 15); manager.SetDuration(task, 20); manager.SetStart(task, 50); Assert.IsTrue(group.Duration == 70); // test: ungroup part should ungroup split task manager.Ungroup(group, part1); Assert.IsTrue(group.Duration == 20); }
public static void Write(ProjectManager projects, string path, IdTable ids) { foreach ( var p in projects ) { if ( p == Project.Empty ) continue; var f = new XmlWriter(path + p.Name + ".xml"); f.Begin(p, ids); f.Begin("Assignments"); var faclist = new FlatAssignmentCollection[p.Assignments.Count]; lock ( p.Assignments ) p.Assignments.CopyTo(faclist, 0); foreach ( var fac in faclist ) { f.Begin(fac, ids); var falist = new FlatAssignment[fac.Count]; lock ( fac ) fac.CopyTo(falist, 0); foreach ( var fa in falist ) f.Write(fa, ids); f.End(fac); } f.End("Assignments"); f.Begin("Costs"); var costlist = new Cost[p.Costs.Count]; lock ( p.Costs ) p.Costs.CopyTo(costlist, 0); foreach ( var c in costlist ) { f.Begin(c, ids); f.Begin("Options"); var optionslist = new CostOptions[c.Options.Count]; lock ( c.Options ) c.Options.CopyTo(optionslist, 0); foreach ( var o in optionslist ) f.Write(o, ids); f.End("Options"); f.End(c); } f.End("Costs"); f.End(p); f.Close(); } }
public void UninstallPackageExecutesUninstallScript() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; localRepository.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var package = PackageUtility.CreatePackage("A"); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", package, project, NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(package); packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(package)); }
public void ReThrowWithMeaningfulErrorMessageWhenXdtFileHasSyntaxError() { // Arrange var mockProjectSystem = new MockProjectSystem(); var mockRepository = new MockPackageRepository(); mockProjectSystem.AddFile("web.config", @"<configuration> <system.web> <compilation debug=""true"" /> </system.web> </configuration> ".AsStream()); var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository()); var package = new Mock<IPackage>(); package.Setup(m => m.Id).Returns("A"); package.Setup(m => m.Version).Returns(new SemanticVersion("1.0")); package.Setup(m => m.Listed).Returns(true); var file = new Mock<IPackageFile>(); file.Setup(m => m.Path).Returns(@"content\web.config.install.xdt"); file.Setup(m => m.EffectivePath).Returns("web.config.install.xdt"); file.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xd:Locator=""Condition('@debug=true')"" debug=""false"" xdt:Transform=""Replace"" /> </system.web> </configuration>".AsStream()); var file2 = new Mock<IPackageFile>(); file2.Setup(m => m.Path).Returns(@"content\web.config.uninstall.xdt"); file2.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt"); file2.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xdt:Locator=""Match(debug)"" debug=""false"" xdt:Transform=""Remove"" /> </system.web> </configuration>".AsStream()); package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, file2.Object }); mockRepository.AddPackage(package.Object); // Act ExceptionAssert.Throws<InvalidDataException>( () => projectManager.AddPackageReference("A"), @"An error occurred while applying transformation to 'web.config' in project 'x:\MockFileSystem': 'xd' is an undeclared prefix. Line 3, position 22."); // Assert Assert.False(mockProjectSystem.FileExists("web.config.install.xdt")); Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt")); Assert.True(mockProjectSystem.FileExists("web.config")); Assert.Equal( @"<configuration> <system.web> <compilation debug=""true"" /> </system.web> </configuration> ", mockProjectSystem.OpenFile("web.config").ReadToEnd()); }
public ExampleSimple() { InitializeComponent(); _mProject = new ProjectManager(); _mProject.Add(new Task() { Name = "New Task" }); _mChart.Init(_mProject); }
public void AddPackageWithXdtTransformFile() { // Arrange var mockProjectSystem = new MockProjectSystem(); var mockRepository = new MockPackageRepository(); mockProjectSystem.AddFile("web.config", @"<configuration> <system.web> <compilation debug=""true"" /> </system.web> </configuration> ".AsStream()); var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository()); var package = new Mock<IPackage>(); package.Setup(m => m.Id).Returns("A"); package.Setup(m => m.Version).Returns(new SemanticVersion("1.0")); package.Setup(m => m.Listed).Returns(true); var file = new Mock<IPackageFile>(); file.Setup(m => m.Path).Returns(@"content\web.config.install.xdt"); file.Setup(m => m.EffectivePath).Returns("web.config.install.xdt"); file.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xdt:Locator=""Condition('@debug=true')"" debug=""false"" xdt:Transform=""Replace"" /> </system.web> </configuration>".AsStream()); var file2 = new Mock<IPackageFile>(); file2.Setup(m => m.Path).Returns(@"content\web.config.uninstall.xdt"); file2.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt"); file2.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xdt:Locator=""Match(debug)"" debug=""false"" xdt:Transform=""Remove"" /> </system.web> </configuration>".AsStream()); package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, file2.Object }); mockRepository.AddPackage(package.Object); // Act projectManager.AddPackageReference("A"); // Assert Assert.False(mockProjectSystem.FileExists("web.config.install.xdt")); Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt")); Assert.True(mockProjectSystem.FileExists("web.config")); Assert.Equal( @"<configuration> <system.web> <compilation debug=""false""/> </system.web> </configuration> ", mockProjectSystem.OpenFile("web.config").ReadToEnd()); }
public ClientManager(string pTestDb) : base(pTestDb) { _doam = new EconomicActivityManager(pTestDb); _locations = new LocationsManager(pTestDb); _projectManager = new ProjectManager(pTestDb); _savingManager = new SavingManager(pTestDb); _userManager = new UserManager(pTestDb); }
public static void AddPackage(this DotNetProject project, IPackage package, IPackageRepository repository) { var packageManager = new PackageManager(repository, project.BaseDirectory); packageManager.InstallPackage(package, false); var projectSystem = new ProjectSystemWrapper(project); var projectManager = new ProjectManager(repository, packageManager.PathResolver, projectSystem, packageManager.LocalRepository); projectManager.AddPackageReference(package.Id); project.NeedsReload = true; }
private void AddProject(object sender, RoutedEventArgs e) { string projectTitle = PromptDialog.Prompt("Project name", "Create new project"); if (!string.IsNullOrWhiteSpace(projectTitle)) { ProjectManager projManager = new ProjectManager(); ProjectProxy proxyProject = ProxyConverter.ProjectModelToProxy(projManager.Create(projectTitle)); this.UIProjectProxyList.Add(proxyProject); } }
//, Func<ProjectExplorerViewModel> projectExplorerViewModelBuilder, Func<EventAggregatorDebugViewModel> eventsDebugBuilder,) public MenuViewModel(IEventAggregator eventAggregator, Func<TeapotViewModel> teapotBuilder, IScriptRunner script, ProjectManager manager) { _eventAggregator = eventAggregator; Items = new BindableCollection<MenuItemViewModel> { new MenuItemViewModel { Header = "_FILE", Items = new BindableCollection<MenuItemViewModel> { new MenuItemViewModel { Header = "_Open", Items = new BindableCollection<MenuItemViewModel> { new MenuItemViewModel { Header = "_Project", Action = () => _eventAggregator.Publish(new OpenProjectDialog()) }, new MenuItemViewModel { Header = "Teapot", Action = () => _eventAggregator.Publish(new AddTabViewCommand {Model = teapotBuilder()}) }, } }, new MenuItemViewModel { Header = "Close", Action = () => _eventAggregator.Publish(new DebugCommand("close")) } } }, new MenuItemViewModel { Header = "_EDIT" }, new MenuItemViewModel { Header = "_VIEW" }, new MenuItemViewModel { Header = "_BUILD", Items = new BindableCollection<MenuItemViewModel> { new MenuItemViewModel { Header = "_Build Project", Action = () => script.Execute(manager.Project) }, new MenuItemViewModel { Header = "Teapot", Action = () => _eventAggregator.Publish(new AddTabViewCommand {Model = teapotBuilder()}) }, } }, new MenuItemViewModel { Header = "_WINDOW" }, new MenuItemViewModel { Header = "_HELP" } }; }
public ClientManager(User pUser, bool pInitializeProject, bool pInitializeSavings) : base(pUser) { _doam = new EconomicActivityManager(pUser); _locations = new LocationsManager(pUser); if (pInitializeProject) _projectManager = new ProjectManager(pUser, true); if (pInitializeSavings) _savingManager = new SavingManager(pUser); _userManager = new UserManager(pUser); }
private void CreateDataGridHistory() { DocsPaWR.DettItemsConservazione[] dettItemsCons = null; if (Session["TypeObject"].Equals("D")) { dettItemsCons = DocumentManager.getStoriaConsDoc(DocumentManager.getSelectedRecord().systemId); } else if (Session["TypeObject"].Equals("F")) { dettItemsCons = ProjectManager.getStoriaConsFasc(ProjectManager.getProjectInSession().systemID); } if (dettItemsCons != null && dettItemsCons.Length > 0) { string language = UIManager.UserManager.GetUserLanguage(); var filtered_data = (from f in dettItemsCons select new { ID_Istanza = GetID(f.IdConservazione), Descrizione = GetDescrizione(f.Descrizione), Data_Conservazione = GetRegistro(f.Data_riversamento), Utente = GetUtente(f.UserId), Collocazione = GetCollocazione(f.CollocazioneFisica), Tipo_Conservazione = GetConservazione(f.tipo_cons), Num_Doc_In_Fasc = GetNumDoc(f.num_docInFasc), IdSel = f.id_profile_trasm, Tooltip0 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell0", language), Tooltip1 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell1", language), Tooltip2 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell2", language), Tooltip3 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell3", language), Tooltip4 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell4", language), Tooltip5 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell5", language), Tooltip6 = Utils.Languages.GetLabelFromCode("HistoryPreservedTooltipCell6", language) }).ToArray(); this.GridViewHistory.DataSource = filtered_data; this.GridViewHistory.DataBind(); this.GridViewHistory.HeaderRow.Cells[0].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid0", language); this.GridViewHistory.HeaderRow.Cells[1].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid1", language); this.GridViewHistory.HeaderRow.Cells[2].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid2", language); this.GridViewHistory.HeaderRow.Cells[3].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid3", language); this.GridViewHistory.HeaderRow.Cells[4].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid4", language); this.GridViewHistory.HeaderRow.Cells[5].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid5", language); this.GridViewHistory.HeaderRow.Cells[7].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid7", language); if (Session["TypeObject"].Equals("D")) { this.GridViewHistory.Columns[6].Visible = false; } else { this.GridViewHistory.Columns[6].Visible = true; this.GridViewHistory.HeaderRow.Cells[6].Text = Utils.Languages.GetLabelFromCode("HistoryPreservedHeaderGrid6", language); } this.GridViewHistory.Visible = true; } else { this.HistroyPreservedPnlNotFound.Visible = true; } }
/// <summary> /// Reads the mail. /// </summary> public MailboxReaderResult ReadMail() { var result = new MailboxReaderResult(); IList <Project> projects = new List <Project>(); LogInfo("MailboxReader: Begin read mail."); try { using (var pop3Client = new POP3_Client()) { // configure the logger pop3Client.Logger = new Logger(); pop3Client.Logger.WriteLog += LogPop3Client; // connect to the server pop3Client.Connect(Config.Server, Config.Port, Config.UseSsl); // authenticate pop3Client.Login(Config.Username, Config.Password); // process the messages on the server foreach (POP3_ClientMessage message in pop3Client.Messages) { var mailHeader = Mail_Message.ParseFromByte(message.HeaderToByte()); if (mailHeader != null) { var messageFrom = string.Empty; if (mailHeader.From.Count > 0) { messageFrom = string.Join("; ", mailHeader.From.ToList().Select(p => p.Address).ToArray()).Trim(); } var recipients = mailHeader.To.Mailboxes.Select(mailbox => mailbox.Address).ToList(); if (mailHeader.Cc != null) { recipients.AddRange(mailHeader.Cc.Mailboxes.Select(mailbox => mailbox.Address)); } if (mailHeader.Bcc != null) { recipients.AddRange(mailHeader.Bcc.Mailboxes.Select(mailbox => mailbox.Address)); } // loop through the mailboxes foreach (var address in recipients) { var pmbox = ProjectMailboxManager.GetByMailbox(address); // cannot find the mailbox skip the rest if (pmbox == null) { LogWarning(string.Format("MailboxReader: could not find project mailbox: {0} skipping.", address)); continue; } var project = projects.FirstOrDefault(p => p.Id == pmbox.ProjectId); if (project == null) { project = ProjectManager.GetById(pmbox.ProjectId); // project is disabled skip if (project.Disabled) { LogWarning(string.Format("MailboxReader: Project {0} - {1} is flagged as disabled skipping.", project.Id, project.Code)); continue; } projects.Add(project); } var entry = new MailboxEntry { Title = mailHeader.Subject.Trim(), From = messageFrom, ProjectMailbox = pmbox, Date = mailHeader.Date, Project = project, Content = "Email Body could not be parsed." }; var mailbody = Mail_Message.ParseFromByte(message.MessageToByte()); if (string.IsNullOrEmpty(mailbody.BodyHtmlText)) // no html must be text { entry.Content = mailbody.BodyText.Replace("\n\r", "<br/>").Replace("\r\n", "<br/>").Replace("\r", ""); } else { //TODO: Enhancements could include regular expressions / string matching or not matching // for particular strings values in the subject or body. // strip the <body> out of the message (using code from below) var bodyExtractor = new Regex("<body.*?>(?<content>.*)</body>", RegexOptions.IgnoreCase | RegexOptions.Singleline); var match = bodyExtractor.Match(mailbody.BodyHtmlText); var emailContent = match.Success && match.Groups["content"] != null ? match.Groups["content"].Value : mailbody.BodyHtmlText; entry.Content = emailContent.Replace("<", "<").Replace(">", ">"); entry.IsHtml = true; } if (Config.ProcessAttachments && project.AllowAttachments) { foreach (var attachment in mailbody.GetAttachments(Config.ProcessInlineAttachedPictures).Where(p => p.ContentType != null)) { entry.MailAttachments.Add(attachment); } } //save this message SaveMailboxEntry(entry); // add the entry if the save did not throw any exceptions result.MailboxEntries.Add(entry); LogInfo(string.Format( "MailboxReader: Message #{0} processing finished, found [{1}] attachments, total saved [{2}].", message.SequenceNumber, entry.MailAttachments.Count, entry.AttachmentsSavedCount)); // delete the message?. if (!Config.DeleteAllMessages) { continue; } try { message.MarkForDeletion(); } catch (Exception) { } } } else { LogWarning(string.Format("pop3Client: Message #{0} header could not be parsed.", message.SequenceNumber)); } } } } catch (Exception ex) { LogException(ex); result.LastException = ex; result.Status = ResultStatuses.FailedWithException; } LogInfo("MailboxReader: End read mail."); return(result); }
/// <summary> /// Событие аварийного завершения работы программы. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void MainForm_FormClosing(object sender, FormClosingEventArgs e) { _project.SelectedNoteIndex = NoteListBox.SelectedIndex; ProjectManager.SaveToFile(_project, ProjectManager.DefaultPath); }
public static ArrayList ChangeStateGetMissingRoles(string idProject, string idStato) { try { return(new ArrayList(docsPaWS.ChangeStateGetMissingRoles(idProject, idStato, UserManager.GetInfoUser(), ProjectManager.getInfoFascicoloDaFascicolo(UIManager.ProjectManager.getProjectInSession())))); } catch (Exception ex) { UIManager.AdministrationManager.DiagnosticError(ex); return(null); } }
private void OpenMenuItemClick(object sender, RoutedEventArgs e) { ProjectManager projectManager = new ProjectManager(new FileStorageManger()); //Project = projectManager.Load(@"C:\Users\sesa151027\Desktop\cards.json"); }
/// <summary> /// Initializes a new instance of the <see cref="ContactsController" /> class. /// </summary> /// <param name="projectManager">The project manager that the <see cref="ContactsController" /> operates against.</param> public ContactsController(ProjectManager projectManager) { _projectManager = projectManager; }
/// <summary> /// Initializes a new instance of the <see cref="PortalsController" /> class. /// </summary> /// <param name="userManager">The user manager that the <see cref="PortalsController" /> operates against.</param> /// <param name="projectManager">The project manager that the <see cref="PortalsController" /> operates against.</param> /// <param name="portalManager">The project manager that the <see cref="PortalsController" /> operates against.</param> public PortalsController(UserManager userManager, ProjectManager projectManager, PortalManager portalManager) { _userManager = userManager; _projectManager = projectManager; _portalManager = portalManager; }
protected void Page_Load(object sender, EventArgs e) { try { string qs = Request.QueryString.ToString(); string f = Request.Form.ToString(); if (Request.Form != null && Request.Form.Count > 0) { string folderId = Request.Form["id"].Replace("node_", "").Replace("root_", ""); DocsPaWR.Folder folder = new DocsPaWR.Folder(); if (!string.IsNullOrEmpty(folderId) && folderId.IndexOf("doc") < 0) { folder = ProjectManager.getFolder(this, folderId); folder = ProjectManager.getFolder(this, folder); } switch (Request.Form["operation"]) { case "create_node": // id=node_12595771 // position=1 // title=gggg // type=default Session["dataentry_node_folder"] = folder; this.html_data.Text = "<" + "script type=\"text/javascript\">ajaxModalPopupCreateNode();<" + "/script>"; break; case "rename_node": // operation=rename_node // title=ffffff // id=rootnode_12595773 Session["dataentry_node_folder"] = folder; this.html_data.Text = "<" + "script type=\"text/javascript\">ajaxModalPopupModifyNode();<" + "/script>"; break; case "move_node": // id=node_34342324 // parent=node_35366466 string parentId = Request.Form["parent"].Replace("node_", "").Replace("root_", ""); this.MoveFolder(folder, parentId); break; case "remove_node": // id=node_12595771 Session["remove_node_folder"] = folder; this.html_data.Text = "<" + "script type=\"text/javascript\">ajaxConfirmModal('ConfirmProjectDeleteSubset', 'HiddenRemoveNode', '');<" + "/script>"; break; case "drag_documents": folderId = Request.Form["ref"].Replace("node_", "").Replace("root_", ""); folder = new DocsPaWR.Folder(); if (!string.IsNullOrEmpty(folderId) && folderId.IndexOf("doc") < 0) { folder = ProjectManager.getFolder(this, folderId); folder = ProjectManager.getFolder(this, folder); } string docsId = Request.Form["ids"]; this.MoveDocuments(docsId, this.Project.folderSelezionato, folder); break; } } else { //Se ACL rimossa, allora visualizzo un messaggio di warning all'utente per poi reindirizzarlo alla HOME. Fascicolo Prj = this.Project; if ((Prj.systemID != null && !string.IsNullOrEmpty(Prj.systemID)) && ProjectManager.CheckRevocationAcl(Prj)) { this.html_data.Text = "<" + "script type=\"text/javascript\">function RedirectHome(){$(location).attr('href','" + this.ResolveUrl("~/Index.aspx") + "');} if (parent.fra_main) {parent.fra_main.ajaxDialogModal('RevocationAcl', 'warning', '','',null,null,'RedirectHome()')} else {parent.parent.ajaxDialogModal('RevocationAcl', 'warning', '','',null,null,'RedirectHome()');}<" + "/script>\n"; return; } if (Request.QueryString["id"] == "0") { Fascicolo Fasc = this.Project; DocsPaWR.Folder folder = ProjectManager.getFolder(this, Fasc); this.caricaFoldersFascicolo(folder); } else if (Request.QueryString["q"] != null && Request.QueryString["q"].Length > 0) { string descrizione = Request.QueryString["q"].Trim(); Fascicolo fascSelezionato = this.Project; string idFascicolo = fascSelezionato.systemID; if (descrizione != string.Empty) { Folder[] risultatiFolder = ProjectManager.getFolderByDescrizione(this, idFascicolo, descrizione); if (risultatiFolder != null) { for (int i = 0; i < risultatiFolder.Length; i++) { if (this.html_data.Text.Length > 0) { this.html_data.Text += ", "; } this.html_data.Text += " { \"id\": \"node_"+ ((Folder)risultatiFolder[i]).systemID + "\" , \"isResult\": \"true\" }"; } this.html_data.Text = "[\n" + html_data.Text + "]\n"; } } } } } catch (System.Exception ex) { UIManager.AdministrationManager.DiagnosticError(ex); return; } }
public ReferencedFileSave AddSingleFileTo(string fileName, string rfsName, string extraCommandLineArguments, BuildToolAssociation buildToolAssociation, bool isBuiltFile, string options, IElement sourceElement, string directoryOfTreeNode) { // Is the file relative to the project? // If not, don't allow the addition. string projectRoot = ProjectManager.ProjectRootDirectory; ReferencedFileSave toReturn = null; //string directoryOfTreeNode = EditorLogic.CurrentTreeNode.GetRelativePath(); string targetDirectory = FlatRedBall.Glue.Plugins.ExportedImplementations.CommandInterfaces.ElementCommands.GetFullPathContentDirectory(sourceElement, directoryOfTreeNode); string targetFile = fileName; string errorMessage = null; bool failed = false; if (isBuiltFile) { targetFile = targetDirectory + rfsName + "." + buildToolAssociation.DestinationFileType; } string targetFileWithOriginalExtension = FileManager.RemoveExtension(targetFile) + "." + FileManager.GetExtension(fileName); bool copied = false; if (!FileManager.IsRelativeTo(fileName, projectRoot) && isBuiltFile) { copied = PluginManager.TryCopyFile(fileName, targetFileWithOriginalExtension); if (!copied) { MessageBox.Show("Could not add the file\n" + fileName + "\n\nBecause it is not relative to\n" + projectRoot + "\n\nPlease move this file to a folder inside your project and try again"); failed = true; } else { // the file was copied - from now on just use the copied file name: fileName = targetFileWithOriginalExtension; } } if (!failed) { if (isBuiltFile) { errorMessage = buildToolAssociation.PerformBuildOn(fileName, targetFile, extraCommandLineArguments, PluginManager.ReceiveOutput, PluginManager.ReceiveError); } string creationReport; if (String.IsNullOrWhiteSpace(errorMessage)) { string directoryToUse = null; if (!isBuiltFile) { directoryToUse = directoryOfTreeNode; } toReturn = ElementCommands.CreateReferencedFileSaveForExistingFile( sourceElement, directoryToUse, targetFile, PromptHandleEnum.Prompt, AvailableAssetTypes.Self.GetAssetTypeFromExtension(FileManager.GetExtension(targetFile)), out creationReport, out errorMessage); // If toReturn was null, that means the object wasn't created // The user could have said No/Cancel to some option if (toReturn != null) { TaskManager.Self.OnUiThread(() => { ElementViewWindow.UpdateChangedElements(); }); if (sourceElement == null) { GlueCommands.Self.RefreshCommands.RefreshGlobalContent(); } if (!string.IsNullOrEmpty(errorMessage)) { // this is handled below //MessageBox.Show(errorMessage); } else if (string.IsNullOrEmpty(toReturn.Name)) { MessageBox.Show("There was an error creating the named object for\n" + fileName); } else { if (isBuiltFile) { toReturn.SourceFile = ProjectManager.MakeRelativeContent(fileName); toReturn.AdditionalArguments = extraCommandLineArguments; toReturn.BuildTool = buildToolAssociation.ToString(); // If a background sync is happening, this can lock the thread, so we want to // make sure this doesn't happen at the same time as a background sync: TaskManager.Self.AddAsyncTask(() => { UpdateReactor.UpdateFile(ProjectManager.MakeAbsolute(toReturn.Name)); }, "Updating file " + toReturn.Name); string directoryOfFile = FileManager.GetDirectory(ProjectManager.MakeAbsolute(fileName)); RightClickHelper.SetExternallyBuiltFileIfHigherThanCurrent(directoryOfFile, false); } PluginManager.ReactToNewFile(toReturn); GluxCommands.Self.SaveGlux(); } } } } if (!string.IsNullOrWhiteSpace(errorMessage)) { PluginManager.ReceiveError(errorMessage); // I think we should show an error message. I had a user // try to add a file and no popup appeared telling them that // the entity was named that. MessageBox.Show(errorMessage); } if (toReturn != null) { ApplyOptions(toReturn, options); } return(toReturn); }
/// <summary> /// Builds the Q# syntax tree from the given files. /// The files are given as a list of filenames, as per the format expected by /// the <see cref="Microsoft.Quantum.QsCompiler.CompilationBuilder.ProjectManager.LoadSourceFiles(IEnumerable{string}, Action{VisualStudio.LanguageServer.Protocol.Diagnostic}, Action{Exception})" /> /// method. /// </summary> private static QsCompiler.SyntaxTree.QsNamespace[] BuildQsSyntaxTree(string[] files, QsReferences references, QSharpLogger logger) { var sources = ProjectManager.LoadSourceFiles(files, d => logger?.Log(d), ex => logger?.Log(ex)); return(BuildQsSyntaxTree(sources, references, logger)); }
private static void ModifyPlugins(string value, bool doAdd, bool userAction = false) { ProjectManager.AdvLog("Modifying plugins: " + value + ", " + doAdd + ", " + userAction); // If this is an add action this must be done before any scripting defines are changed if (doAdd && (EditorApplication.isCompiling || EditorApplication.isUpdating)) { DisplayProgressBar(doAdd, false, value); } // Move plugins not in use outside of the assets folder // (I was just going to change their import platform settings but it was a pain to manage them for different platforms // so just keeping defaults and moving out of the assets folder will be fine + cleaner project with less projects active) List <string> activePlatformPluginFiles = GetPluginFiles(value, EditorUserBuildSettings.selectedBuildTargetGroup, true); List <string> otherPlatformPluginFiles = GetPluginFiles(value, EditorUserBuildSettings.selectedBuildTargetGroup, false); string projectPath = Application.dataPath.Replace("/Assets", ""); // Absolute path to the project with Assets folder removed e.g C:/Projects/My Game string disabledPluginsPath = projectPath + "/Disabled Plugins"; // C:/Projects/My Game/Disabled Plugins // Make sure the Disabled Plugins folder exists if (!Directory.Exists(disabledPluginsPath)) { Directory.CreateDirectory(disabledPluginsPath); } if (Directory.Exists(disabledPluginsPath)) { // Move plugins files for other platforms out of the project if (otherPlatformPluginFiles.Count > 0) { ProjectManager.AdvLog("There are " + otherPlatformPluginFiles.Count + " other plugin files to move out of the project!"); foreach (string file in otherPlatformPluginFiles) { ProjectManager.AdvLog("Moving " + file + " out of project!"); string insideProjectPath = "Assets/" + file; string outsideProjectPath = file; // Run GetAttributes within a try catch or if the file doesn't exist it'll throw an error (and we're calling this in the first place to see if the file exists ;_;) try { // Are we moving a directory or just a file? bool isDir = File.GetAttributes(projectPath + "/" + insideProjectPath) == FileAttributes.Directory; // Before we bother calculating any moving or folder creation check if the files we want to move out of the project are actually in the project already if (!isDir) { if (File.Exists(projectPath + "/" + insideProjectPath)) { // Get each folder as an array from the new file path so we can create all the nessesary folders string[] splitOutsidePath = outsideProjectPath.Split("/" [0]); // ["Plugins", "Android", "Example.aar"] string curPath = ""; // Minus 1 from the total iteration because the last value will be the actual file for (int i = 0; i < splitOutsidePath.Length - 1; i++) { curPath += "/" + splitOutsidePath [i]; if (!Directory.Exists(disabledPluginsPath + curPath)) { Directory.CreateDirectory(disabledPluginsPath + curPath); } } // All the folders should now be created and the files can be moved MoveFile(projectPath + "/" + insideProjectPath, disabledPluginsPath + "/" + outsideProjectPath); MoveFile(projectPath + "/" + insideProjectPath + ".meta", disabledPluginsPath + "/" + outsideProjectPath + ".meta"); } else { ProjectManager.AdvLog("File to be taken out of project not found at: " + projectPath + "/" + insideProjectPath); } } else { if (Directory.Exists(projectPath + "/" + insideProjectPath)) { // Get each folder as an array from the new file path so we can create all the nessesary folders string[] splitOutsidePath = outsideProjectPath.Split("/" [0]); // ["Plugins", "Android", "Example"] string curPath = ""; // Minus 1 from the total iteration because the last value will be the actual folder we're moving for (int i = 0; i < splitOutsidePath.Length - 1; i++) { curPath += "/" + splitOutsidePath [i]; if (!Directory.Exists(disabledPluginsPath + curPath)) { Directory.CreateDirectory(disabledPluginsPath + curPath); } } // All the folders should now be created and we can move the wanted directories into them MoveFile(projectPath + "/" + insideProjectPath, disabledPluginsPath + "/" + outsideProjectPath); MoveFile(projectPath + "/" + insideProjectPath + ".meta", disabledPluginsPath + "/" + outsideProjectPath + ".meta"); } else { ProjectManager.AdvLog("Directory to be moved out of project not found at: " + projectPath + "/" + insideProjectPath); } } } catch (System.Exception error) { ProjectManager.AdvLog("File or folder not found! " + error.Message); } } } // Move the plugin files for the active platform ProjectManager.AdvLog("The activePlatformPluginFiles has " + activePlatformPluginFiles.Count + " files to move"); if (activePlatformPluginFiles.Count > 0) { foreach (string file in activePlatformPluginFiles) { ProjectManager.AdvLog("Yay lets move " + file); // These variables are only relative to the assets folder (commented values are flipped if doAdd is false) string oldFullFilePath = (doAdd ? "Disabled Plugins/" : "Assets/") + file; // (if doAdd) Disabled Plugins/Plugins/Android/Example.aar string newFullFilePath = (doAdd ? "Assets/" : "Disabled Plugins/") + file; // (if doAdd) Assets/Plugins/Android/Example.aar // Run GetAttributes within a try catch or if the file doesn't exist it'll throw an error (and we're calling this in the first place to see if the file exists ;_;) try { // Are we moving to a directory or just a file? bool isDir = File.GetAttributes(projectPath + "/" + oldFullFilePath) == FileAttributes.Directory; // Before we bother calculating any moving or folder creation make sure the file we're wanting to move exist if (!isDir) { if (File.Exists(projectPath + "/" + oldFullFilePath)) { if (!doAdd) { newFullFilePath = newFullFilePath.Replace("Disabled Plugins/", ""); // Plugins/Android/Example.aar // Get each folder as an array from the new file path so we can create all the nessesary folders string[] splitNewPaths = newFullFilePath.Split("/" [0]); // ["Plugins", "Android", "Example.aar"] string curPath = ""; // Minus 1 from the total iteration because the last value will be the actual file for (int i = 0; i < splitNewPaths.Length - 1; i++) { curPath += "/" + splitNewPaths [i]; if (!Directory.Exists(disabledPluginsPath + curPath)) { Directory.CreateDirectory(disabledPluginsPath + curPath); } } // All the folders should now be created and the files can be moved MoveFile(projectPath + "/" + oldFullFilePath, disabledPluginsPath + "/" + newFullFilePath); MoveFile(projectPath + "/" + oldFullFilePath + ".meta", disabledPluginsPath + "/" + newFullFilePath + ".meta"); } else { MoveFile(projectPath + "/" + oldFullFilePath, projectPath + "/" + newFullFilePath); MoveFile(projectPath + "/" + oldFullFilePath + ".meta", projectPath + "/" + newFullFilePath + ".meta"); } } else { ProjectManager.AdvLog("File to be moved doesn't exist! (" + oldFullFilePath + ")"); } } else { if (Directory.Exists(projectPath + "/" + oldFullFilePath)) { if (!doAdd) { newFullFilePath = newFullFilePath.Replace("Disabled Plugins/", ""); // Plugins/Android/Example // Get each folder as an array from the new file path so we can create all the nessesary folders string[] splitNewPaths = newFullFilePath.Split("/" [0]); // ["Plugins", "Android", "Example"] string curPath = ""; // Minus 1 from the total iteration because the last value will be the actual folder for (int i = 0; i < splitNewPaths.Length - 1; i++) { curPath += "/" + splitNewPaths[i]; if (!Directory.Exists(disabledPluginsPath + curPath)) { Directory.CreateDirectory(disabledPluginsPath + curPath); } } // All the folders should now be created and the folder can be moved MoveFile(projectPath + "/" + oldFullFilePath, disabledPluginsPath + "/" + newFullFilePath); MoveFile(projectPath + "/" + oldFullFilePath + ".meta", disabledPluginsPath + "/" + newFullFilePath + ".meta"); } else { MoveFile(projectPath + "/" + oldFullFilePath, projectPath + "/" + newFullFilePath); MoveFile(projectPath + "/" + oldFullFilePath + ".meta", projectPath + "/" + newFullFilePath + ".meta"); } } else { ProjectManager.AdvLog("File to be moved doesn't exist! (" + oldFullFilePath + ")"); } } } catch (System.Exception error) { ProjectManager.AdvLog("File or folder not found! " + error.Message); } } } else { ProjectManager.AdvLog("This platform does not have any plugin files for " + value + "!"); } } else { ProjectManager.AdvLog("Failed to create Disabled Plugins folder or it was deleted whilst moving files!"); } // If this was a request to remove a plugin we now need to force re-add any files which still active plugins shared! if (!doAdd) { string[] ScriptingDefineSymbolNames = System.Enum.GetNames(typeof(ScriptingDefineSymbols)); for (int i = 0; i < ScriptingDefineSymbolNames.Length; i++) { ScriptingDefineSymbols curScriptingDefineSymbol = (ScriptingDefineSymbols)i; if (IsScriptingDefineSymbolActive(curScriptingDefineSymbol)) { ModifyScriptingDefineSymbol(curScriptingDefineSymbol, true, userAction, true); } } } // Force reload assets otherwise it'll wait for the user to click the Unity window again AssetDatabase.Refresh(ImportAssetOptions.Default); }
public void SaveGlux() { ProjectManager.SaveGlux(); }
public void RemoveReferencedFile(ReferencedFileSave referencedFileToRemove, List <string> additionalFilesToRemove, bool regenerateCode) { // There are some things that need to happen: // 1. Remove the ReferencedFileSave from the Glue project (GLUX) // 2. Remove the GUI item // 3. Remove the item from the Visual Studio project. #region Remove the file from the current Screen or Entity if there is a current Screen or Entity IElement container = referencedFileToRemove.GetContainer(); if (container != null) { // The referenced file better be a globally referenced file if (!container.ReferencedFiles.Contains(referencedFileToRemove)) { throw new ArgumentException(); } else { container.ReferencedFiles.Remove(referencedFileToRemove); } // Ask about any NamedObjects that reference this file. for (int i = container.NamedObjects.Count - 1; i > -1; i--) { var nos = container.NamedObjects[i]; if (nos.SourceType == SourceType.File && nos.SourceFile == referencedFileToRemove.Name) { MainGlueWindow.Self.Invoke(() => { // Ask the user what to do here - remove it? Keep it and not compile? MultiButtonMessageBox mbmb = new MultiButtonMessageBox(); mbmb.MessageText = "The object\n" + nos.ToString() + "\nreferences the file\n" + referencedFileToRemove.Name + "\nWhat would you like to do?"; mbmb.AddButton("Remove this object", DialogResult.Yes); mbmb.AddButton("Keep it (object will not be valid until changed)", DialogResult.No); var result = mbmb.ShowDialog(); if (result == DialogResult.Yes) { container.NamedObjects.RemoveAt(i); } }); } nos.ResetVariablesReferencing(referencedFileToRemove); } MainGlueWindow.Self.Invoke(() => { if (EditorLogic.CurrentScreenTreeNode != null) { EditorLogic.CurrentScreenTreeNode.UpdateReferencedTreeNodes(); } else if (EditorLogic.CurrentEntityTreeNode != null) { EditorLogic.CurrentEntityTreeNode.UpdateReferencedTreeNodes(false); } if (regenerateCode) { ElementViewWindow.GenerateSelectedElementCode(); } }); } #endregion #region else, the file is likely part of the GlobalContentFile else { ProjectManager.GlueProjectSave.GlobalFiles.Remove(referencedFileToRemove); ProjectManager.GlueProjectSave.GlobalContentHasChanged = true; // Much faster to just remove the tree node. This was done // to reuse code and make things reactive, but this has gotten // slow on bigger projects. //ElementViewWindow.UpdateGlobalContentTreeNodes(false); // don't save here because projects will get saved below Action refreshUiAction = () => { TreeNode treeNode = GlueState.Self.Find.ReferencedFileSaveTreeNode(referencedFileToRemove); if (treeNode.Tag != referencedFileToRemove) { throw new Exception("Error removing the tree node - the selected tree node doesn't reference the file being removed"); } treeNode.Parent.Nodes.Remove(treeNode); }; MainGlueWindow.Self.Invoke((MethodInvoker) delegate { refreshUiAction(); } ); ContentLoadWriter.UpdateLoadGlobalContentCode(); List <IElement> elements = ObjectFinder.Self.GetAllElementsReferencingFile(referencedFileToRemove.Name); foreach (IElement element in elements) { if (regenerateCode) { CodeWriter.GenerateCode(element); } } } #endregion // November 10, 2015 // I feel like this may // have been old code before // we had full dependency tracking // in Glue. This file should only be // removed from the project if nothing // else references it, including no entities. // This code does just entities/screens/global // content, but doesn't check the full dependency // tree. I think we can just remove it and depend on // the code below. // Actually, removing this seems to cause problems - files // that should be removed aren't. So instead we'll chnage the // call to use the dependency tree: // replace: List <string> referencedFiles = GlueCommands.Self.FileCommands.GetAllReferencedFileNames().Select(item => item.ToLowerInvariant()).ToList(); string absoluteToLower = GlueCommands.Self.GetAbsoluteFileName(referencedFileToRemove).ToLowerInvariant(); string relativeToProject = FileManager.MakeRelative(absoluteToLower, GlueState.Self.ContentDirectory); bool isReferencedByOtherContent = referencedFiles.Contains(relativeToProject); if (isReferencedByOtherContent == false) { additionalFilesToRemove.Add(referencedFileToRemove.GetRelativePath()); string itemName = referencedFileToRemove.GetRelativePath(); string absoluteName = ProjectManager.MakeAbsolute(referencedFileToRemove.Name, true); // I don't know why we were removing the file from the ProjectBase - it should // be from the Content project //ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase, itemName); ProjectManager.RemoveItemFromProject(ProjectManager.ProjectBase.ContentProject, itemName, performSave: false); foreach (ProjectBase syncedProject in ProjectManager.SyncedProjects) { ProjectManager.RemoveItemFromProject(syncedProject.ContentProject, absoluteName); } } if (ProjectManager.IsContent(referencedFileToRemove.Name)) { UnreferencedFilesManager.Self.RefreshUnreferencedFiles(false); foreach (var file in UnreferencedFilesManager.LastAddedUnreferencedFiles) { additionalFilesToRemove.Add(file.FilePath); } } ReactToRemovalIfCsv(referencedFileToRemove, additionalFilesToRemove); GluxCommands.Self.SaveGlux(); }
public ProjectNodeSource(string name, IDocumentManager documentManager, ProjectManager projectManager, DefaultState defaultState) : base(name) { this.projectManager = projectManager; this.documentManager = documentManager; this.documentManager.DocumentRenamed += documentManager_DocumentRenamed; game = Core.Prometheus.Instance.GetGameDefinitionByGameID(projectManager.GameID); // Combined tag source - Project References and TemplateTags that exist in the project. projectReferences = new ProjectReferencesLibrary( "projectrefs", projectManager.Project, projectManager.Project.Templates); projectReferences.FileAdded += FileAdded; projectReferences.FileRemoved += FileRemoved; projectFolder = projectManager.ProjectFolder; projectFolder.FileAdded += FileAdded; projectFolder.FileRemoved += FileRemoved; projectFolder.FolderAdded += FolderAdded; projectFolder.FolderRemoved += FolderRemoved; projectManager.Project.Templates.FileAdded += Templates_FileAdded; projectManager.Project.Templates.FileRemoved += Templates_FileRemoved; AddNodeType(CreateNodeType <RootNodeType>(defaultState)); UnreferencedState unreferenced = new UnreferencedState(this, "unreferenced", Resources.document_plain16, Resources.document_plain16, Color.Gray, Color.White); MissingReferencedState missing = new MissingReferencedState(this, "missing_reference", Resources.document_error16, Resources.document_error16, Color.Red, Color.White); NodeType folder = CreateNodeType <FolderNodeType>(Resources.folder16, Resources.folder_closed16); AddNodeType(folder); folder.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(folder_NodeRenamed); NodeType tagNode = CreateNodeType <TagNode>(Resources.document16); tagNode.AddNodeState(new ValidReferencedState(this, "valid_reference", Resources.document16, Resources.document16, Color.Black, Color.White)); tagNode.AddNodeState(new DocumentOpenState(documentManager, game.GameID, TagLocation.Project, Resources.document_view16, Resources.document_view16, Color.Blue, Color.White)); tagNode.AddNodeState(unreferenced); tagNode.AddNodeState(missing); AddNodeType(tagNode); tagNode.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(tagNode_NodeRenamed); ObjectTag objectFile = CreateNodeType <ObjectTag>(Resources.data16); objectFile.AddNodeState(new DocumentOpenState(documentManager, game.GameID, TagLocation.Project, Resources.data_view16, Resources.data_view16, Color.Blue, Color.White)); objectFile.AddNodeState(new ValidReferencedState(this, "valid_reference", Resources.data16, Resources.data16, Color.Black, Color.White)); objectFile.AddNodeState(unreferenced); objectFile.AddNodeState(missing); AddNodeType(objectFile); objectFile.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(tagNode_NodeRenamed); NodeType modelFile = CreateNodeType <ModelTag>(Resources.cube_molecule16); modelFile.AddNodeState(new DocumentOpenState(documentManager, game.GameID, TagLocation.Project, Resources.cube_molecule_view16, Resources.cube_molecule_view16, Color.Blue, Color.White)); modelFile.AddNodeState(new ValidReferencedState(this, "valid_reference", Resources.cube_molecule16, Resources.cube_molecule16, Color.Black, Color.White)); modelFile.AddNodeState(unreferenced); modelFile.AddNodeState(missing); AddNodeType(modelFile); modelFile.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(tagNode_NodeRenamed); NodeType sbspFile = CreateNodeType <SbspTag>(Resources.environment16); sbspFile.AddNodeState(new DocumentOpenState(documentManager, game.GameID, TagLocation.Project, Resources.environment_view16, Resources.environment_view16, Color.Blue, Color.White)); sbspFile.AddNodeState(new ValidReferencedState(this, "valid_reference", Resources.environment16, Resources.environment16, Color.Black, Color.White)); sbspFile.AddNodeState(unreferenced); sbspFile.AddNodeState(missing); AddNodeType(sbspFile); sbspFile.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(tagNode_NodeRenamed); NodeType scenarioFile = CreateNodeType <ScenarioTag>(Resources.earth16); scenarioFile.AddNodeState(new DocumentOpenState(documentManager, game.GameID, TagLocation.Project, Resources.earth_view16, Resources.earth_view16, Color.Blue, Color.White)); scenarioFile.AddNodeState(new ValidReferencedState(this, "valid_reference", Resources.earth16, Resources.earth16, Color.Black, Color.White)); scenarioFile.AddNodeState(unreferenced); scenarioFile.AddNodeState(missing); AddNodeType(scenarioFile); scenarioFile.NodeRenamed += new System.EventHandler <NodeRenamedEventArgs>(tagNode_NodeRenamed); NodeType propertiesNode = CreateNodeType <PropertiesRootNodeType>(Resources.preferences16); AddNodeType(propertiesNode); NodeType essentialTagsNode = CreateNodeType <EssentialTagsRoot>(Resources.components16); AddNodeType(essentialTagsNode); NodeType projectTemplateTagNode = CreateNodeType <ProjectTemplateTagNodeType>(Resources.application16); AddNodeType(projectTemplateTagNode); NodeType globalTemplateTagNode = CreateNodeType <GlobalTemplateTagNodeType>(Resources.joystick16); AddNodeType(globalTemplateTagNode); NodeType recycleBinNode = CreateNodeType <RecycleBinRootNodeType>(Resources.garbage_empty16); recycleBinNode.AddNodeState(new RecycleBinContainsFilesState(projectManager.Project.RecycleBin, "recyclebin_not_empty", Resources.garbage_full16, Resources.garbage_full16, Color.Black, Color.White)); //TODO: Need to create a state for when the recycle bin is completely full (though, I'm not sure how this //would work, because you can't say that it's "full" because you don't know how big the file is that they //are going to try to add - it may fit or it may not, and the recycle bin is very unlikely to contain //the exact number of bytes that it can hold before it is considered "full".) AddNodeType(recycleBinNode); }
public override bool Conflict(string rPath, ProjectManager project) { return(true); }
/// <summary> /// Builds the user interface for selecting query fields. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param> protected void Page_Load(object sender, EventArgs e) { Message1.Visible = false; _queryId = Request.Get("id", Globals.NEW_ID); ProjectId = Request.Get("pid", Globals.NEW_ID); // If no project id or query id then redirect away if (ProjectId == 0) { ErrorRedirector.TransferToSomethingMissingPage(Page); } if (!Page.User.Identity.IsAuthenticated || (_queryId != 0 && !UserManager.HasPermission(ProjectId, Common.Permission.EditQuery.ToString()))) { Response.Redirect("~/Errors/AccessDenied"); } if (!Page.User.Identity.IsAuthenticated || !UserManager.HasPermission(ProjectId, Common.Permission.AddQuery.ToString())) { SaveQueryForm.Visible = false; pnlSaveQuery.Visible = false; } DisplayClauses(); if (!Page.IsPostBack) { lblProjectName.Text = ProjectManager.GetById(ProjectId).Name; Results.Visible = false; if (_queryId != 0) { //edit query. plhClauses.Controls.Clear(); var query = QueryManager.GetById(_queryId); txtQueryName.Text = query.Name; chkGlobalQuery.Checked = query.IsPublic; //ClauseCount = 0; foreach (var qc in query.Clauses) { ClauseCount++; AddClause(true, qc); } } else { ClauseCount = 3; DisplayClauses(); } BindQueryFieldTypes(); } // The ExpandIssuePaths method is called to handle // the SiteMapResolve event. SiteMap.SiteMapResolve += ExpandIssuePaths; }
public override bool CanExecute(PackageItem item) { // Only enable command on a Package in the Online provider if it is not installed yet return(!ProjectManager.IsInstalled(item.PackageIdentity)); }
public MyTask(ProjectManager manager) : base() { Manager = manager; }
public IActionResult DeleteManager(ProjectManager manager) { userManagerRepository.DeleteProjectManager(manager); return(View()); }
public void InitializeGanttHost() { _Chart = new Braincase.GanttChart.Chart(); this._Chart.Dock = System.Windows.Forms.DockStyle.Fill; this._Chart.Font = new System.Drawing.Font("Microsoft JhengHei UI", 8F); this._Chart.Location = new System.Drawing.Point(0, 0); this._Chart.Margin = new System.Windows.Forms.Padding(0); this._Chart.Name = "_Chart"; this._Chart.Size = new System.Drawing.Size(671, 496); this._Chart.TabIndex = 0; this._Chart.TimeResolution = Braincase.GanttChart.TimeResolution.Day; Project1 = new ProjectManager() { Start = new DateTime(2018, 11, 1) }; var task1 = new MyTask(Project1) { Name = "Project 1" }; var task2 = new MyTask(Project1) { Name = "Task 1" }; var task3 = new MyTask(Project1) { Name = "Task 2" }; var task4 = new MyTask(Project1) { Name = "Task 3" }; var task5 = new MyTask(Project1) { Name = "Task 4" }; var task6 = new MyTask(Project1) { Name = "Task 5" }; var task7 = new MyTask(Project1) { Name = "Task 6" }; Project1.Add(task1); Project1.Add(task2); Project1.Add(task3); Project1.Add(task4); Project1.Add(task5); Project1.Add(task6); Project1.Add(task7); Project1.SetDuration(task1, TimeSpan.FromDays(3)); Project1.SetDuration(task2, TimeSpan.FromDays(5)); Project1.SetDuration(task3, TimeSpan.FromDays(7)); Project1.SetDuration(task4, TimeSpan.FromDays(4)); Project1.SetDuration(task5, TimeSpan.FromDays(3)); Project1.SetDuration(task6, TimeSpan.FromDays(5)); Project1.Group(task1, task2); Project1.Group(task1, task3); Project1.Group(task1, task4); Project1.Group(task1, task5); Project1.Group(task1, task6); Project1.Group(task1, task7); Project1.Relate(task2, task3); Project1.Relate(task2, task4); Project1.Relate(task4, task5); Project1.Relate(task4, task6); Project1.Relate(task6, task7); Project1.Relate(task5, task7); var span = DateTime.Today - Project1.Start; Project1.Now = span; Projects.Add(Project1); Project1 = new ProjectManager() { Start = new DateTime(2018, 11, 16) }; task1 = new MyTask(Project1) { Name = "Project 2" }; task2 = new MyTask(Project1) { Name = "Task 1" }; task3 = new MyTask(Project1) { Name = "Task 2" }; task4 = new MyTask(Project1) { Name = "Task 3" }; task5 = new MyTask(Project1) { Name = "Task 4" }; task6 = new MyTask(Project1) { Name = "Task 5" }; task7 = new MyTask(Project1) { Name = "Task 6" }; Project1.Add(task1); Project1.Add(task2); Project1.Add(task3); Project1.Add(task4); Project1.Add(task5); Project1.Add(task6); Project1.Add(task7); Project1.SetDuration(task7, TimeSpan.FromDays(4)); Project1.SetDuration(task2, TimeSpan.FromDays(5)); Project1.SetDuration(task3, TimeSpan.FromDays(12)); Project1.SetDuration(task4, TimeSpan.FromDays(6)); Project1.SetDuration(task5, TimeSpan.FromDays(3)); Project1.SetDuration(task6, TimeSpan.FromDays(8)); Project1.Group(task1, task2); Project1.Group(task1, task3); Project1.Group(task1, task4); Project1.Group(task1, task5); Project1.Group(task1, task6); Project1.Group(task1, task7); Project1.Relate(task2, task3); Project1.Relate(task2, task4); Project1.Relate(task2, task5); Project1.Relate(task4, task6); Project1.Relate(task3, task7); Project1.Relate(task5, task7); span = DateTime.Today - Project1.Start; Project1.Now = span; Projects.Add(Project1); Project1 = new ProjectManager() { Start = new DateTime(2018, 10, 26) }; task1 = new MyTask(Project1) { Name = "Project 3" }; task2 = new MyTask(Project1) { Name = "Task 1" }; task3 = new MyTask(Project1) { Name = "Task 2" }; task4 = new MyTask(Project1) { Name = "Task 3" }; task5 = new MyTask(Project1) { Name = "Task 4" }; task6 = new MyTask(Project1) { Name = "Task 5" }; task7 = new MyTask(Project1) { Name = "Task 6" }; var task8 = new MyTask(Project1) { Name = "Task 7" }; Project1.Add(task1); Project1.Add(task2); Project1.Add(task3); Project1.Add(task4); Project1.Add(task5); Project1.Add(task6); Project1.Add(task7); Project1.Add(task8); Project1.SetDuration(task2, TimeSpan.FromDays(5)); Project1.SetDuration(task3, TimeSpan.FromDays(12)); Project1.SetDuration(task4, TimeSpan.FromDays(6)); Project1.SetDuration(task5, TimeSpan.FromDays(3)); Project1.SetDuration(task6, TimeSpan.FromDays(8)); Project1.SetDuration(task7, TimeSpan.FromDays(12)); Project1.SetDuration(task8, TimeSpan.FromDays(18)); Project1.Group(task1, task2); Project1.Group(task1, task3); Project1.Group(task1, task4); Project1.Group(task1, task5); Project1.Group(task1, task6); Project1.Group(task1, task7); Project1.Relate(task2, task4); Project1.Relate(task2, task6); Project1.Relate(task2, task5); Project1.Relate(task4, task6); Project1.Relate(task3, task7); Project1.Relate(task5, task8); span = DateTime.Today - Project1.Start; Project1.Now = span; Projects.Add(Project1); //_Chart.Init(Project1); //_Chart.CreateTaskDelegate = delegate () { return new MyTask(Project1); }; this.GanttHost.Child = _Chart; TimeViewComboBox.ItemsSource = typeof(TimeResolution).GetEnumNames(); TimeViewComboBox.SelectedIndex = 1; foreach (var p in Projects.ToList()) { ProjectNames.Add(p.Tasks.FirstOrDefault()); } ProjectsComboBox.ItemsSource = ProjectNames.ToList(); }
public static void CreateTransmissionsMissingRoles(string[] roleReasonsList, string idStato) { try { docsPaWS.ChangeStateTransmissionsMissingRoles(roleReasonsList, UserManager.GetInfoUser(), ProjectManager.getInfoFascicoloDaFascicolo(UIManager.ProjectManager.getProjectInSession()), idStato); } catch (Exception ex) { UIManager.AdministrationManager.DiagnosticError(ex); } }
static void Main(string[] args) { // 表示一个具体的项目名字叫:项目A WebProject wpA = new WebProject() { ProjectName = "项目A" }; // 表示一个具体的项目名字叫:项目B WebProject wpB = new WebProject() { ProjectName = "项目B" }; // 开发者 Developer developer = new Developer() { DeveloperName = "张三" }; // 开发者所需要接收的命令 ICommand codeCmd = new CodingCommand() { project = wpA, dp = developer }; ICommand UpdateCmd = new UpdateRoutineCommand() { project = wpB, dp = developer }; //项目经理 ProjectManager pm = new ProjectManager(); //设置命令 pm.SetCommand(codeCmd); pm.SetCommand(UpdateCmd); //发起命令让开发者去完成 pm.ExcuteCommand(); Console.WriteLine("========== 可取消 =========="); // 开发者 DeveloperCancelAble developer2 = new DeveloperCancelAble() { DeveloperName = "李四" }; //开发者所需要接收的命令 ICommandCancelAble codeCmd2 = new CodingCommandCancelAble() { project = wpA, dp = developer2 }; ICommandCancelAble UpdateCmd2 = new UpdateRoutineCommandCancelAble() { project = wpB, dp = developer2 }; //项目经理 ProjectManagerCancelAble pm2 = new ProjectManagerCancelAble(); //设置命令 pm2.SetCommand(codeCmd2); pm2.SetCommand(UpdateCmd2); //发起命令让开发者去完成 pm2.ExcuteCommand(); //撤销UpdateCmd命令 pm2.CancelExectueCommand(UpdateCmd2); Console.ReadLine(); }
/// <summary> /// Saves the mailbox entry. /// </summary> /// <param name="entry">The entry.</param> void SaveMailboxEntry(MailboxEntry entry) { try { //load template var body = string.Format("<div >Sent by:{1} on: {2}<br/>{0}</div>", entry.Content.Trim(), entry.From, entry.Date); if (Config.BodyTemplate.Trim().Length > 0) { var data = new Dictionary <string, object> { { "MailboxEntry", entry } }; body = NotificationManager.GenerateNotificationContent(Config.BodyTemplate, data); } var projectId = entry.ProjectMailbox.ProjectId; var mailIssue = IssueManager.GetDefaultIssueByProjectId( projectId, entry.Title.Trim(), body.Trim(), entry.ProjectMailbox.AssignToUserName, Config.ReportingUserName); if (!IssueManager.SaveOrUpdate(mailIssue)) { return; } entry.IssueId = mailIssue.Id; entry.WasProcessed = true; var project = ProjectManager.GetById(projectId); var projectFolderPath = Path.Combine(Config.UploadsFolderPath, project.UploadPath); var doc = new HtmlDocument(); doc.LoadHtml(mailIssue.Description); // load the issue body to we can process it for inline images (if exist) //If there is an attached file present then add it to the database //and copy it to the directory specified in the web.config file foreach (MIME_Entity mimeEntity in entry.MailAttachments) { string fileName; var isInline = false; var contentType = mimeEntity.ContentType.Type.ToLower(); var attachment = new IssueAttachment { Id = 0, Description = "File attached by mailbox reader", DateCreated = DateTime.Now, ContentType = mimeEntity.ContentType.TypeWithSubtype, CreatorDisplayName = Config.ReportingUserName, CreatorUserName = Config.ReportingUserName, IssueId = mailIssue.Id, ProjectFolderPath = projectFolderPath }; switch (contentType) { case "application": attachment.Attachment = ((MIME_b_SinglepartBase)mimeEntity.Body).Data; break; case "attachment": case "image": case "video": case "audio": attachment.Attachment = ((MIME_b_SinglepartBase)mimeEntity.Body).Data; break; case "message": // we need to pull the actual email message out of the entity, and strip the "content type" out so that // email programs will read the file properly var messageBody = mimeEntity.ToString().Replace(mimeEntity.Header.ToString(), ""); if (messageBody.StartsWith("\r\n")) { messageBody = messageBody.Substring(2); } attachment.Attachment = Encoding.UTF8.GetBytes(messageBody); break; default: LogWarning(string.Format("MailboxReader: Attachment type could not be processed {0}", mimeEntity.ContentType.Type)); break; } if (contentType.Equals("attachment")) // this is an attached email { fileName = mimeEntity.ContentDisposition.Param_FileName; } else if (contentType.Equals("message")) // message has no filename so we create one { fileName = string.Format("Attached_Message_{0}.eml", entry.AttachmentsSavedCount); } else { isInline = true; fileName = string.IsNullOrWhiteSpace(mimeEntity.ContentType.Param_Name) ? string.Format("untitled.{0}", mimeEntity.ContentType.SubType) : mimeEntity.ContentType.Param_Name; } attachment.FileName = fileName; var saveFile = IsAllowedFileExtension(fileName); var fileSaved = false; // can we save the file? if (saveFile) { fileSaved = IssueAttachmentManager.SaveOrUpdate(attachment); if (fileSaved) { entry.AttachmentsSavedCount++; } else { LogWarning("MailboxReader: Attachment could not be saved, please see previous logs"); } } if (!entry.IsHtml || !isInline) { continue; } if (string.IsNullOrWhiteSpace(mimeEntity.ContentID)) { continue; } var contentId = mimeEntity.ContentID.Replace("<", "").Replace(">", "").Replace("[", "").Replace("]", ""); // this is pretty greedy but since people might be sending screenshots I doubt they will send in dozens of images // embedded in the email. one would hope foreach (var node in doc.DocumentNode.SelectNodes(XpathElementCaseInsensitive("img")).ToList()) { var attr = node.Attributes.FirstOrDefault(p => p.Name.ToLowerInvariant() == "src");// get the src attribute if (attr == null) { continue; // image has no src attribute } if (!attr.Value.Contains(contentId)) { continue; // is the attribute value the content id? } // swap out the content of the parent node html will our link to the image var anchor = string.Format("<span class='inline-mail-attachment'>Inline Attachment: <a href='DownloadAttachment.axd?id={0}' target='_blank'>{1}</a></span>", attachment.Id, fileName); // for each image in the body if the file was saved swap out the inline link for a link to the saved attachment // otherwise blank out the content link so we don't get a missing image link node.ParentNode.InnerHtml = fileSaved ? anchor : ""; } mailIssue.Description = doc.DocumentNode.InnerHtml; mailIssue.LastUpdateUserName = mailIssue.OwnerUserName; mailIssue.LastUpdate = DateTime.Now; IssueManager.SaveOrUpdate(mailIssue); } } catch (Exception ex) { LogException(ex); throw; } }
public SuccessController() { _projectUnitOfWork = UnitOfWork <ProjectManager>(); _readerUnitOfWork = UnitOfWork <ReaderManager>(); _resourceUnitOfWork = UnitOfWork <ResourceManager>(); }
/// <summary> /// Binds a data source to the invoked server control and all its child controls. /// </summary> public new void DataBind() { //Private issue check DataSource = IssueManager.StripPrivateIssuesForRequestor(DataSource, Security.GetUserName()).ToList(); if (DataSource.Count > 0) { gvIssues.Visible = true; pager.Visible = true; ScrollPanel.Visible = true; OptionsContainerPanel.Visible = true; var pId = Request.QueryString.Get("pid", -1); //get custom fields for project if (pId > Globals.NEW_ID) { var customFields = CustomFieldManager.GetByProjectId(pId); var nrColumns = FIXED_COLUMNS; //checks if its initial load to add custom controls and checkboxes if (gvIssues.Columns.Count <= nrColumns + 1) { var firstIssue = DataSource[0]; //if there is custom fields add them if (firstIssue.IssueCustomFields.Count > 0) { foreach (var value in firstIssue.IssueCustomFields) { //increments nr of columns nrColumns++; //create checkbox item var lstValue = new ListItem(value.FieldName, nrColumns.ToString()); //find custom controls that has been checked and check them var selected = Array.IndexOf(_arrIssueColumns, nrColumns.ToString()) >= 0; if (selected) { lstValue.Selected = true; } //add item to checkbox list lstIssueColumns.Items.Add(lstValue); //create column for custom control var tf = new TemplateField { HeaderText = value.FieldName, SortExpression = value.DatabaseFieldName.Replace(" ", "[]") }; tf.HeaderStyle.Wrap = false; gvIssues.Columns.Add(tf); } } } } DisplayColumns(); SelectColumnsPanel.Visible = true; lblResults.Visible = false; if (ShowProjectColumn) { gvIssues.Columns[0].Visible = false; LeftButtonContainerPanel.Visible = false; } else { gvIssues.Columns[4].Visible = false; lstIssueColumns.Items.Remove(lstIssueColumns.Items.FindByValue("4")); var projectId = _dataSource[0].ProjectId; //hide votes column if issue voting is disabled if (!ProjectManager.GetById(projectId).AllowIssueVoting) { gvIssues.Columns[4].Visible = false; lstIssueColumns.Items.Remove(lstIssueColumns.Items.FindByValue("4")); } if (Page.User.Identity.IsAuthenticated && UserManager.HasPermission(projectId, Common.Permission.EditIssue.ToString())) { LeftButtonContainerPanel.Visible = true; // performance enhancement // WRH 2012-04-06 // only load these if the user has permission to do so var categories = new CategoryTree(); dropCategory.DataSource = categories.GetCategoryTreeByProjectId(projectId); dropCategory.DataBind(); dropMilestone.DataSource = MilestoneManager.GetByProjectId(projectId); dropMilestone.DataBind(); dropAffectedMilestone.DataSource = dropMilestone.DataSource; dropAffectedMilestone.DataBind(); dropOwner.DataSource = UserManager.GetUsersByProjectId(projectId); dropOwner.DataBind(); dropPriority.DataSource = PriorityManager.GetByProjectId(projectId); dropPriority.DataBind(); dropStatus.DataSource = StatusManager.GetByProjectId(projectId); dropStatus.DataBind(); dropType.DataSource = IssueTypeManager.GetByProjectId(projectId); dropType.DataBind(); dropAssigned.DataSource = UserManager.GetUsersByProjectId(projectId); dropAssigned.DataBind(); dropResolution.DataSource = ResolutionManager.GetByProjectId(projectId); dropResolution.DataBind(); chkDueDateReset.Checked = false; } else { //hide selection column for unauthenticated users gvIssues.Columns[0].Visible = false; LeftButtonContainerPanel.Visible = false; } } foreach (var item in _arrIssueColumns.Select(colIndex => lstIssueColumns.Items.FindByValue(colIndex)).Where(item => item != null)) { item.Selected = true; } gvIssues.DataSource = DataSource; gvIssues.DataBind(); } else { ScrollPanel.Visible = false; OptionsContainerPanel.Visible = false; lblResults.Visible = true; gvIssues.Visible = false; pager.Visible = false; } }
public static void GenerateEventGeneratedFile(IElement element) { //string fileName = EventManager.GetEventFileNameForElement(element); //string fullCustomFileName = ProjectManager.ProjectBase.Directory + fileName; ////////////////// Early Out ////////////////////// ///////////////// End Early Out//////////////////// string projectDirectory = ProjectManager.ProjectBase.Directory; string fullGeneratedFileName = projectDirectory + EventManager.GetGeneratedEventFileNameForElement(element); ////////////////EARLY OUT/////////////// if (element.Events.Count == 0) { // The file may exist. If it does, we want to make sure it's empty: if (File.Exists(fullGeneratedFileName)) { FileWatchManager.IgnoreNextChangeOnFile(fullGeneratedFileName); FileManager.SaveText("", fullGeneratedFileName); } return; } ///////////////END EARLY OUT/////////// if (!File.Exists(fullGeneratedFileName)) { CodeWriter.AddEventGeneratedCodeFileForElement(element); } else { // Make sure the file is part of the project ProjectManager.UpdateFileMembershipInProject(ProjectManager.ProjectBase, fullGeneratedFileName, false, false); } ICodeBlock codeBlock = GenerateEventGeneratedCodeFile(element); // Let's try this a few times: int numberOfFailures = 0; bool succeeded = false; FileWatchManager.IgnoreNextChangeOnFile(fullGeneratedFileName); while (numberOfFailures < 3) { try { FileManager.SaveText(codeBlock.ToString(), fullGeneratedFileName); succeeded = true; break; } catch { numberOfFailures++; System.Threading.Thread.Sleep(30); } } if (!succeeded) { GlueGui.ShowMessageBox("Could not save " + fullGeneratedFileName); } }
/// <summary> /// Initializes a new instance of the <see cref="ScheduleActionJob" /> class. /// </summary> /// <param name="projectManager">The project manager.</param> /// <param name="workflowInvoker">The workflow invoker.</param> public ScheduleActionJob(ProjectManager projectManager, WorkflowInvoker workflowInvoker) { _projectManager = projectManager; _workflowInvoker = workflowInvoker; }
public void ReactToCustomVariableChangedValue(string changedMember, CustomVariable customVariable, object oldValue) { #region Name if (changedMember == "Name") { ReactToChangedCustomVariableName((string)oldValue, customVariable); } #endregion #region SetByDerived if (changedMember == "SetByDerived") { bool didErrorOccur = false; if (customVariable.SetByDerived && customVariable.IsShared) { MessageBox.Show("Variables that are IsShared cannot be SetByDerived"); didErrorOccur = true; } if (didErrorOccur) { customVariable.SetByDerived = (bool)oldValue; } else { ProjectManager.UpdateAllDerivedElementFromBaseValues(false, true); } } #endregion #region IsShared else if (changedMember == "IsShared") { HandleIsSharedVariableSet(customVariable, oldValue); } #endregion #region SouceObjectProperty else if (changedMember == "SourceObjectProperty") { // See if there is already a NOS that uses this SourceObject/SourceObjectProperty combo IElement currentElement = EditorLogic.CurrentElement; CustomVariable currentVariable = customVariable; if (!string.IsNullOrEmpty(currentVariable.SourceObject) && !string.IsNullOrEmpty(currentVariable.SourceObjectProperty)) { foreach (CustomVariable variableInLoop in currentElement.CustomVariables) { if (variableInLoop != currentVariable && !string.IsNullOrEmpty(variableInLoop.SourceObject) && currentVariable.SourceObject == variableInLoop.SourceObject && !string.IsNullOrEmpty(variableInLoop.SourceObjectProperty) && currentVariable.SourceObjectProperty == variableInLoop.SourceObjectProperty) { MessageBox.Show("There is already a variable that is modifying " + currentVariable.SourceObjectProperty + " on " + currentVariable.SourceObject); currentVariable.SourceObjectProperty = (string)oldValue; } } } } #endregion #region DefaultValue else if (changedMember == "DefaultValue") { customVariable.FixEnumerationTypes(); var currentElement = GlueState.Self.CurrentElement; if (!string.IsNullOrEmpty(customVariable.SourceObject)) { // See if the source NamedObjectSave has // this variable exposed, and if so, set that // variable too so the two mirror each other... // or make it null if this is a recasted variable. NamedObjectSave nos = currentElement.GetNamedObjectRecursively(customVariable.SourceObject); if (nos != null) { CustomVariableInNamedObject cvino = nos.GetCustomVariable(customVariable.SourceObjectProperty); // If the cvino is null, that means that the NOS doesn't have this exposed, so we don't // need to do anything. if (cvino != null) { if (string.IsNullOrEmpty(customVariable.OverridingPropertyType)) { cvino.Value = customVariable.DefaultValue; } else { cvino.Value = null; } } } } Plugins.PluginManager.ReactToElementVariableChange(currentElement, customVariable); } #endregion #region HasAccompanyingVelocityProperty else if (changedMember == "HasAccompanyingVelocityProperty") { ReactToChangedHasAccompanyingVelocityProperty(customVariable); } #endregion #region OverridingPropertyType else if (changedMember == "OverridingPropertyType") { if (customVariable.OverridingPropertyType != null) { customVariable.SetDefaultValueAccordingToType(customVariable.OverridingPropertyType); } GlueCommands.Self.RefreshCommands.RefreshPropertyGrid(); } #endregion #region Type else if (changedMember == "Type") { customVariable.SetDefaultValueAccordingToType(customVariable.Type); } #endregion }
public static void RenameElement(this IElement elementToRename, string value) { bool isValid = true; string whyItIsntValid; if (elementToRename is ScreenSave) { isValid = NameVerifier.IsScreenNameValid(value, elementToRename as ScreenSave, out whyItIsntValid); } else { isValid = NameVerifier.IsEntityNameValid(value, elementToRename as EntitySave, out whyItIsntValid); } if (!isValid) { MessageBox.Show(whyItIsntValid); } else { string oldName = elementToRename.Name; string newName = oldName.Substring(0, oldName.Length - elementToRename.ClassName.Length) + value; DialogResult result = ChangeClassNamesInCodeAndFileName(elementToRename, value, oldName, newName); if (result == DialogResult.Yes) { // Set the name first because that's going // to be used by code that follows to modify // inheritance. elementToRename.Name = newName; if (elementToRename is EntitySave) { // Change any Entities that depend on this for (int i = 0; i < ProjectManager.GlueProjectSave.Entities.Count; i++) { EntitySave entitySave = ProjectManager.GlueProjectSave.Entities[i]; if (entitySave.BaseEntity == oldName) { entitySave.BaseEntity = newName; } } // Change any NamedObjects that use this as their type (whether in Entity, or as a generic class) List <NamedObjectSave> namedObjects = ObjectFinder.Self.GetAllNamedObjectsThatUseEntity(oldName); foreach (NamedObjectSave nos in namedObjects) { if (nos.SourceType == SourceType.Entity && nos.SourceClassType == oldName) { nos.SourceClassType = newName; nos.UpdateCustomProperties(); } else if (nos.SourceType == SourceType.FlatRedBallType && nos.SourceClassGenericType == oldName) { nos.SourceClassGenericType = newName; } } } else { // Change any Screens that depend on this for (int i = 0; i < ProjectManager.GlueProjectSave.Screens.Count; i++) { ScreenSave screenSave = ProjectManager.GlueProjectSave.Screens[i]; if (screenSave.BaseScreen == oldName) { screenSave.BaseScreen = newName; } } if (ProjectManager.StartUpScreen == oldName) { ProjectManager.StartUpScreen = newName; } // Don't do anything with NamedObjects and Screens since they can't (currently) be named objects } ProjectManager.SaveProjects(); GluxCommands.Self.SaveGlux(); TreeNode treeNode = GlueState.Self.Find.ElementTreeNode(elementToRename); if (treeNode is ScreenTreeNode) { ((ScreenTreeNode)treeNode).UpdateReferencedTreeNodes(); } else if (treeNode is EntityTreeNode) { ((EntityTreeNode)treeNode).UpdateReferencedTreeNodes(); } if (elementToRename is EntitySave) { ProjectManager.SortAndUpdateUI(elementToRename as EntitySave); } else if (elementToRename is ScreenSave) { ProjectManager.SortAndUpdateUI(elementToRename as ScreenSave); } } } }
public ProjectServices(string testDB) { _ProjectManager = new ProjectManager(testDB); }