private static IEnumerable <HtmlTag> determineSocialIcons(ProjectRoot project, IAssetUrls urls)
{
if (project == null)
{
yield break;
}
if (project.TwitterHandle.IsNotEmpty())
{
yield return(new HtmlTag("a")
.AddClass("ico-twitter")
.Attr("href", "http://twitter.com/" + project.TwitterHandle)
.Append("img", img =>
{
img.Attr("alt", "Twitter")
.Attr("src", urls.UrlForAsset(AssetFolder.images, "twitter-icon.png"));
}));
}
if (project.GitHubPage.IsNotEmpty())
{
yield return(new HtmlTag("a")
.AddClass("ico-github")
.Attr("href", project.GitHubPage)
.Append("img", img =>
{
img.Attr("alt", "Github")
.Attr("src", urls.UrlForAsset(AssetFolder.images, "github-icon.png"));
}));
}
}
public Project(FilePath projectPath, CustomProjectParserResult projectParserResult)
{
ProjectPath = projectPath;
ProjectParserResult = projectParserResult;
ProjectRoot = ProjectPath.GetDirectory();
ProjectName = ProjectRoot.GetDirectoryName();
}
public ProjectBuilder AddProperty(params Property[] properties)
{
if (properties == null || properties.Length == 0)
{
// if call .AddProperty() but not specifying a property just return;
return(this);
}
// If no property group is created then create it automatically.
if (_lastPropertyGroupElement == null)
{
AddPropertyGroup();
}
_lastPropertyElements.Clear();
foreach (var property in properties)
{
ProjectPropertyElement projectProperty = ProjectRoot.CreatePropertyElement(property.Name);
projectProperty.Value = property.Value;
projectProperty.Label = property.Label;
projectProperty.Condition = property.Condition;
_lastPropertyGroupElement.AppendChild(projectProperty);
_lastPropertyElements.Add(projectProperty);
}
return(this);
}
public void SetUp()
{
fubudocs = ObjectMother.TopicGraph.ProjectFor("FubuDocs");
fubudocs.ShouldNotBeNull();
splashTopic = fubudocs.Splash;
}
public ProjectBuilder AddItem(params Item[] items)
{
if (items == null || items.Length == 0)
{
// if call .AddItem() but not specifying an item just return;
return(this);
}
// If no item group is created then create it automatically.
if (_lastItemGroupElement == null)
{
AddItemGroup();
}
_lastItemElements.Clear();
foreach (var item in items)
{
ProjectItemElement projectItem = ProjectRoot.CreateItemElement(item.Name);
projectItem.Include = item.Value;
projectItem.Label = item.Label;
projectItem.Condition = item.Condition;
_lastItemGroupElement.AppendChild(projectItem);
if (item.Metadata != null && item.Metadata.Length > 0)
{
AddMetadataToItem(projectItem, item.Metadata);
}
_lastItemElements.Add(projectItem);
}
return(this);
}
public async Task TestUpdatePost()
{
// Create a post
ProjectRoot post = new ProjectRoot
{
Project = new Project
{
ProjectNumber = "A1",
Description = "First project",
StartDate = "2017-11-01",
EndDate = "2017-11-08",
Status = "COMPLETED"
}
};
// Update the post
FortnoxResponse<ProjectRoot> fr = await config.fortnox_client.Update<ProjectRoot>(post, "projects/A1");
// Log the error
if (fr.model == null)
{
config.logger.LogError(fr.error);
}
// Test evaluation
Assert.AreNotEqual(null, fr.model);
} // End of the TestUpdatePost method
public void write_and_load()
{
var file = "project.json";
new FileSystem().DeleteFile(file);
var project = new ProjectRoot
{
Name = "FubuMVC",
GitHubPage = "https://github.com/DarthFubuMVC/fubumvc",
UserGroupUrl = "https://groups.google.com/forum/?fromgroups#!forum/fubumvc-devel",
BuildServerUrl = "http://build.fubu-project.org/project.html?projectId=project3&tab=projectOverview",
BottleName = "FubuMVC.Docs"
};
project.WriteTo(file);
var project2 = ProjectRoot.LoadFrom(file);
project2.Name.ShouldEqual(project.Name);
project2.GitHubPage.ShouldEqual(project.GitHubPage);
project2.UserGroupUrl.ShouldEqual(project.UserGroupUrl);
project2.BuildServerUrl.ShouldEqual(project.BuildServerUrl);
project2.BottleName.ShouldEqual(project.BottleName);
project2.Filename.ShouldEqual(file);
}
public async Task TestAddPost()
{
// Create a post
ProjectRoot post = new ProjectRoot
{
Project = new Project
{
ProjectNumber = "A1",
Description = "Första projektet",
StartDate = "2017-11-01",
EndDate = "2019-03-31",
Status = "ONGOING"
}
};
// Add the post
FortnoxResponse<ProjectRoot> fr = await config.fortnox_client.Add<ProjectRoot>(post, "projects");
// Log the error
if (fr.model == null)
{
config.logger.LogError(fr.error);
}
// Test evaluation
Assert.AreNotEqual(null, fr.model);
} // End of the TestAddPost method
public void DeserializeProjectTest()
{
string jsonProjectRoot = "";
ProjectRoot projectRoot = JsonToObject.Deserialize <ProjectRoot>(jsonProjectRoot);
Projects.QueryResult project = projectRoot.QueryResult;
Assert.AreEqual("2", project.Results[0]._rallyAPIMajor);
}
public async Task <Projects.QueryResult> GetProjectsAsync(string projectUrl)
{
string jsonProjectRoot = await GetCall(projectUrl);
ProjectRoot projectRoot = JsonToObject.Deserialize <ProjectRoot>(jsonProjectRoot);
return(projectRoot.QueryResult);
}
public ValueTask SaveAsync(CancellationToken token)
{
_logger.LogDebug("Saving changes to project file");
ProjectRoot.Save();
// Reload the workspace since, at this point, the project may be different from what was loaded
return(Context.ReloadWorkspaceAsync(token));
}
public void SetUp()
{
theProject = new ProjectRoot();
a = new Topic(theProject, new StubTopicFile());
b = new Topic(theProject, new StubTopicFile());
c = new Topic(theProject, new StubTopicFile());
d = new Topic(theProject, new StubTopicFile());
e = new Topic(theProject, new StubTopicFile());
}
public void RemoveProjectProperty(string propertyName)
{
var propertiesToDelete = Project.Xml.Properties.Where(x => x.Name.Equals(propertyName, StringComparison.OrdinalIgnoreCase));
foreach (var property in propertiesToDelete)
{
_logger.LogInformation("Removing Project Property: {ProjectProperty} Value : {PropertyValue}", property.Name, property.Value);
ProjectRoot.RemoveProjectProperty(property);
}
}
public void CreateNewProject()
{
if (CurrentProject != null)
{
log.Info("Closing current project");
CloseProject();
}
CurrentProject = new ProjectRoot();
log.Info("New Project created");
}
public void RemoveFrameworkReferences(IEnumerable <Reference> frameworkReferences)
{
foreach (var reference in FrameworkReferences)
{
if (frameworkReferences.Contains(reference))
{
_logger.LogInformation("Removing outdated framework reference: {FrameworkReference}", reference);
ProjectRoot.RemoveFrameworkReference(reference);
}
}
}
/// <summary>
/// Event for Drag Drop of a project node.
/// </summary>
/// <param name="sender">Sending object.</param>
/// <param name="e">Drag event args.</param>
private void ProjectExplorerTreeViewDragDrop(Object sender, DragEventArgs e)
{
// Retrieve the client coordinates of the drop location.
Point targetPoint = this.projectExplorerTreeView.PointToClient(new Point(e.X, e.Y));
// Retrieve the node at the drop location.
TreeNodeAdv targetNodeAdv = this.projectExplorerTreeView.GetNodeAt(targetPoint);
// Retrieve the node that was dragged.
TreeNodeAdv[] draggedNodesAdv = e.Data.GetData(typeof(TreeNodeAdv[])) as TreeNodeAdv[];
if (draggedNodesAdv.Count() <= 0)
{
return;
}
TreeNodeAdv draggedNodeAdv = draggedNodesAdv[0];
if (draggedNodeAdv != null && targetNodeAdv != null && draggedNodeAdv != targetNodeAdv)
{
ProjectRoot projectRoot = this.ProjectExplorerViewModel.ProjectRoot;
ProjectItem draggedItem = this.GetProjectItemFromNode(draggedNodeAdv);
ProjectItem targetItem = this.GetProjectItemFromNode(targetNodeAdv);
projectRoot?.BuildParents();
if (!(draggedItem is FolderItem) || !(draggedItem as FolderItem).HasNode(targetItem))
{
switch (this.projectExplorerTreeView.DropPosition.Position)
{
case NodePosition.Before:
projectRoot.RemoveNode(draggedItem);
targetItem.Parent?.AddSibling(targetItem, draggedItem, after: false);
break;
case NodePosition.Inside:
if (targetItem is FolderItem)
{
projectRoot.RemoveNode(draggedItem);
(targetItem as FolderItem).AddChild(draggedItem);
}
break;
case NodePosition.After:
projectRoot.RemoveNode(draggedItem);
targetItem.Parent?.AddSibling(targetItem, draggedItem, after: true);
break;
}
}
this.UpdateStructure(this.ProjectExplorerViewModel.ProjectRoot);
}
}
public void RemoveReferences(IEnumerable <Reference> references)
{
foreach (var reference in References)
{
if (references.Contains(reference))
{
_logger.LogInformation("Removing outdated assembly reference: {Reference}", reference);
ProjectRoot.RemoveReference(reference);
}
}
}
public void RemovePackages(IEnumerable <NuGetReference> references)
{
foreach (var reference in NuGetReferences.PackageReferences)
{
if (references.Contains(reference))
{
_logger.LogInformation("Removing outdated package reference: {PackageReference}", reference);
ProjectRoot.RemovePackage(reference);
}
}
}
private void AddMetadataToItem(ProjectItemElement item, ItemMetadata[] metadata)
{
foreach (var meta in metadata)
{
ProjectMetadataElement metaDataElement = ProjectRoot.CreateMetadataElement(meta.Name);
metaDataElement.Value = meta.Value;
metaDataElement.Condition = meta.Condition;
metaDataElement.Label = meta.Label;
item.AppendChild(metaDataElement);
}
}
public void AddPackages(IEnumerable <NuGetReference> references)
{
if (references.Any())
{
var packageReferenceItemGroup = ProjectRoot.GetOrCreateItemGroup(MSBuildConstants.PackageReferenceType);
foreach (var reference in references)
{
_logger.LogInformation("Adding package reference: {PackageReference}", reference);
ProjectRoot.AddPackageReference(packageReferenceItemGroup, reference);
}
}
}
public void AddFrameworkReferences(IEnumerable <Reference> frameworkReferences)
{
if (frameworkReferences.Any())
{
var frameworkReferenceItemGroup = ProjectRoot.GetOrCreateItemGroup(MSBuildConstants.FrameworkReferenceType);
foreach (var reference in frameworkReferences)
{
_logger.LogInformation("Adding framework reference: {FrameworkReference}", reference);
ProjectRoot.AddFrameworkReference(frameworkReferenceItemGroup, reference);
}
}
}
public override AkWwiseTreeViewItem GetComponentDataRoot(WwiseObjectType objectType)
{
if (!wwiseObjectFolders.ContainsKey(objectType))
{
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(objectType));
}
var tempProjectRoot = new AkWwiseTreeViewItem(ProjectRoot);
tempProjectRoot.AddWwiseItemChild(wwiseObjectFolders[objectType]);
return(tempProjectRoot);
}
public void read_into_a_project_with_no_whitelist()
{
var directory = ".".ToFullPath().ParentDirectory().ParentDirectory().ParentDirectory().ParentDirectory();
var project = new ProjectRoot();
PublishedNuget.GatherNugetsIntoProject(project, directory);
// There's a second nuspec for testing that throws this off
project.Nugets.Select(x => x.ToString()).ShouldHaveTheSameElementsAs(
"Name: FubuDocs, Description: Frictionless documentation tooling"
);
}
private static void gatherNuspecInformation(string directory)
{
string file = directory.AppendPath(ProjectRoot.File);
var project = ProjectRoot.LoadFrom(file);
var initial = project.Nugets;
PublishedNuget.GatherNugetsIntoProject(project, Environment.CurrentDirectory);
if (initial == null && project.Nugets != null || !Enumerable.SequenceEqual(initial, project.Nugets))
{
project.WriteTo(file);
}
}
protected void InitializeMinimal()
{
ProjectRoot = CreateProjectRootItem();
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.Event));
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.Switch));
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.State));
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.Soundbank));
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.AuxBus));
ProjectRoot.AddWwiseItemChild(BuildObjectTypeTree(WwiseObjectType.AcousticTexture));
TreeUtility.TreeToList(ProjectRoot, Data);
}
private void Signal_ProjectNameEdited(string str)
{
ModProject.Name = str;
ProjectRoot.SetText(0, $"{str} {ModProject.Version}");
for (var child = ProjectRoot.GetChildren(); child != null; child = child.GetNext())
{
if (child.GetText(0).BeginsWith("["))
{
var controller = ContentPackController.GetControllerForMod((string)child.GetMeta(Meta.CorrespondingController));
child.SetText(0, $"[{controller.ModAbbreviation}] {str}");
}
}
}
/// <summary>
/// Recieves an update of the project items in the project explorer upon value changes.
/// </summary>
/// <param name="projectRoot">The project root.</param>
public void Update(ProjectRoot projectRoot)
{
if (projectRoot != null)
{
this.projectExplorerTreeView.BeginUpdate();
foreach (ProjectItem child in projectRoot.Children.ToArray())
{
this.UpdateNodes(child);
}
this.projectExplorerTreeView.EndUpdate();
}
}
public void read_into_a_project_with_a_whitelist()
{
var directory = ".".ToFullPath().ParentDirectory().ParentDirectory().ParentDirectory().ParentDirectory();
var project = new ProjectRoot();
project.NugetWhitelist = "Sample.Docs, Imported.Docs";
PublishedNuget.GatherNugetsIntoProject(project, directory);
project.Nugets.Select(x => x.ToString()).ShouldHaveTheSameElementsAs(
"Name: Imported.Docs, Description: Documentation for Imported.Docs",
"Name: Sample.Docs, Description: Documentation for Sample.Docs"
);
}
public ScriptEngine(string projectFilePath)
{
if (string.IsNullOrEmpty(projectFilePath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(projectFilePath));
}
if (!Path.IsPathRooted(projectFilePath))
{
throw new ArgumentException("Project path must be absolute", nameof(projectFilePath));
}
_projectFilePath = projectFilePath;
ProjectRoot = new ProjectRoot(projectFilePath);
}
internal ScriptContext(string scriptFilePath, string projectFilePath, ProjectRoot projectRoot)
{
if (string.IsNullOrEmpty(scriptFilePath))
{
throw new ArgumentException("Value cannot be null or empty", nameof(scriptFilePath));
}
if (!Path.IsPathRooted(scriptFilePath))
{
throw new ArgumentException("The script file path must be absolute");
}
ScriptFilePath = scriptFilePath;
ProjectFilePath = projectFilePath;
Project = projectRoot;
Output = new OutputFileCollection(scriptFilePath);
}
