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);
}
