/// <summary>
/// returns the projectitems with the given deploymentpath, it creates a mapped folder if need and the needed subfolder
/// </summary>
/// <param name="project"></param>
/// <param name="sPFileType"></param>
/// <param name="p"></param>
/// <returns></returns>
public static ProjectItems GetDeploymentPath(DTE dte, Project project, SPFileType sPFileType, string deploymentPath)
{
//parameters are e.g. SPFileType.TemplateFile + DeploymentPath = "/Layouts/APPNAME"
//we create and return the project items of path /SharePointRoot/Templates/Layouts/AppName
ProjectItems mappedfolder = null;
if (Helpers2.IsSharePointVSTemplate(dte, project))
{
//get the mapped folder an
mappedfolder = Helpers2.GetMappedFolder(dte, project, sPFileType);
}
else
{
//create the needed folder structure for the deploymentpath
mappedfolder = Helpers2.GetMappedFolder(dte, project, sPFileType);
}
if (mappedfolder != null)
{
if (!string.IsNullOrEmpty(deploymentPath))
{
//subfolder within the mappedfolder needed
return Helpers.GetProjectItemsByPath(mappedfolder, deploymentPath);
}
else
{
return mappedfolder;
}
}
return null;
}
private void SetDeploymentPath(DTE dte, Project project, ProjectItem CreatedProjectItem, SPFileType sPFileType, string evaluatedDeploymentPath)
{
//set to content
if ((sPFileType != SPFileType.CustomCode))
{
CreatedProjectItem.Properties.Item("BuildAction").Value = 2;
}
//ok, file is placed, but we need set the deployment path
ISharePointProjectService projectService = Helpers2.GetSharePointProjectService(dte);
ISharePointProject sharePointProject = projectService.Convert <EnvDTE.Project, ISharePointProject>(project);
sharePointProject.Synchronize();
if (CreatedProjectItem.Collection.Parent is ProjectItem)
{
ProjectItem parentItem = CreatedProjectItem.Collection.Parent as ProjectItem;
string name = parentItem.Name;
//is the parent element a feature?
try
{
ISharePointProjectFeature parentIsFeature = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectFeature>(parentItem);
if (parentIsFeature != null)
{
ISharePointProjectItem addedSharePointItem = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectItem>(CreatedProjectItem);
if (addedSharePointItem != null)
{
parentIsFeature.ProjectItems.Add(addedSharePointItem);
}
}
}
catch { }
}
try
{
//sometimes property deploymentpath is readonly
//1. new added items need to be validated before
ISharePointProjectItemFile newaddedSharePointItem = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectItemFile>(CreatedProjectItem);
newaddedSharePointItem.DeploymentType = Helpers2.GetDeploymentTypeFromFileType(this.DeploymentType);
if (!string.IsNullOrEmpty(evaluatedDeploymentPath))
{
newaddedSharePointItem.DeploymentPath = evaluatedDeploymentPath;
}
}
catch { }
}
private void SetDeploymentPath(DTE dte, Project project, ProjectItem CreatedProjectItem, SPFileType sPFileType, string evaluatedDeploymentPath)
{
//set to content
if ((sPFileType != SPFileType.CustomCode))
{
CreatedProjectItem.Properties.Item("BuildAction").Value = 2;
}
//ok, file is placed, but we need set the deployment path
ISharePointProjectService projectService = Helpers2.GetSharePointProjectService(dte);
ISharePointProject sharePointProject = projectService.Convert<Project, ISharePointProject>(project);
sharePointProject.Synchronize();
if (CreatedProjectItem.Collection.Parent is ProjectItem)
{
ProjectItem parentItem = CreatedProjectItem.Collection.Parent as ProjectItem;
string name = parentItem.Name;
//is the parent element a feature?
try
{
ISharePointProjectFeature parentIsFeature = projectService.Convert<ProjectItem, ISharePointProjectFeature>(parentItem);
if (parentIsFeature != null)
{
ISharePointProjectItem addedSharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItem>(CreatedProjectItem);
if (addedSharePointItem != null)
{
parentIsFeature.ProjectItems.Add(addedSharePointItem);
}
}
}
catch { }
}
try
{
//sometimes property deploymentpath is readonly
//1. new added items need to be validated before
ISharePointProjectItemFile newaddedSharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItemFile>(CreatedProjectItem);
newaddedSharePointItem.DeploymentType = Helpers2.GetDeploymentTypeFromFileType(this.DeploymentType);
if (!string.IsNullOrEmpty(evaluatedDeploymentPath))
{
newaddedSharePointItem.DeploymentPath = evaluatedDeploymentPath;
}
}
catch { }
}
private void AddResources(Project _CurrentProject, string folderName, string resourcefilename, string content, SPFileType deploymentFileType, string deploymentPath)
{
//in VSS we would create an empty element "Resources" and would add the resource.resx there with different deploymenttargets
//1. erstelle folder "Resources" und packe Text\Resources\SharePointProjectItem.spdata.t4 rein
//2. packe file da hinein und setze noch schnell den deployment path
//1. erstelle Folder Resources\AppResources
ProjectItems contentTypeFolder = null;
string SPDataTemplate = @"Text\Resources\SharePointProjectItem.spdata.t4";
string evaluatedSPDataTemplate = EvaluateParameterAsString(_CurrentProject.DTE, SPDataTemplate);
string spDataContent = GenerateContent(evaluatedSPDataTemplate, "SharePointProjectItem.spdata");
ProjectItem spDataItem = Helpers2.AddFileToProject(_CurrentProject.DTE, _CurrentProject, folderName, "SharePointProjectItem.spdata", spDataContent, false, false, out contentTypeFolder);
//add the resx file or the content to the folder
ProjectItem resourceFileItem = AddResourcesToFolder(contentTypeFolder.Parent as ProjectItem, resourcefilename, content);
//ensure that the resources element folder is part of package
Helpers2.AddVSElementToVSPackage(_CurrentProject.DTE, _CurrentProject, contentTypeFolder.Parent as ProjectItem);
//set the deployment type to Resource, AppGlobalResource
Helpers2.SetDeploymentType(resourceFileItem, deploymentFileType);
Helpers2.SetDeploymentPath(resourceFileItem, deploymentPath);
}
private void AddResources(Project _CurrentProject, string folderName, string resourcefilename, string content, SPFileType deploymentFileType, string deploymentPath)
{
//in VSS we would create an empty element "Resources" and would add the resource.resx there with different deploymenttargets
//1. erstelle folder "Resources" und packe Text\Resources\SharePointProjectItem.spdata.t4 rein
//2. packe file da hinein und setze noch schnell den deployment path
//1. erstelle Folder Resources\AppResources
ProjectItems contentTypeFolder = null;
string SPDataTemplate = @"Text\Resources\SharePointProjectItem.spdata.t4";
string evaluatedSPDataTemplate = EvaluateParameterAsString(_CurrentProject.DTE, SPDataTemplate);
string spDataContent = GenerateContent(evaluatedSPDataTemplate, "SharePointProjectItem.spdata");
ProjectItem spDataItem = Helpers2.AddFileToProject(_CurrentProject.DTE, _CurrentProject, folderName, "SharePointProjectItem.spdata", spDataContent, false, false, out contentTypeFolder);
//add the resx file or the content to the folder
ProjectItem resourceFileItem = AddResourcesToFolder(contentTypeFolder.Parent as ProjectItem, resourcefilename, content);
//ensure that the resources element folder is part of package
Helpers2.AddVSElementToVSPackage(_CurrentProject.DTE, _CurrentProject, contentTypeFolder.Parent as ProjectItem);
//set the deployment type to Resource, AppGlobalResource
Helpers2.SetDeploymentType(resourceFileItem, deploymentFileType);
Helpers2.SetDeploymentPath(resourceFileItem, deploymentPath);
}
internal static DeploymentType GetDeploymentTypeFromFileType(SPFileType sPFileType)
{
if (sPFileType == SPFileType.RootFile)
{
return DeploymentType.RootFile;
}
else if (sPFileType == SPFileType.TemplateFile)
{
return DeploymentType.TemplateFile;
}
else if (sPFileType == SPFileType.ElementFile)
{
return DeploymentType.ElementFile;
}
else if (sPFileType == SPFileType.ElementManifest)
{
return DeploymentType.ElementManifest;
}
else if (sPFileType == SPFileType.CustomCode)
{
return DeploymentType.NoDeployment;
}
else if (sPFileType == SPFileType.AppGlobalResource)
{
return DeploymentType.AppGlobalResource;
}
else if (sPFileType == SPFileType.ClassResource)
{
return DeploymentType.ClassResource;
}
else if (sPFileType == SPFileType.Resource)
{
return DeploymentType.Resource;
}
return DeploymentType.RootFile;
}
internal static ProjectItem AddTemplateToMappedFolder(DTE dte, Project project, SPFileType sPFileType, string targetFolder, string templateContent, string evaluatedTargetFileName, bool overwrite, bool open)
{
string relativeDestinationPath = GetMappedFolderPath(dte, project, sPFileType, targetFolder);
ProjectItems whereToAdd = Helpers.GetProjectItemsByPath(project, relativeDestinationPath);
return AddFile(dte, whereToAdd, evaluatedTargetFileName, templateContent, overwrite, open);
}
internal static ProjectItem AddTemplateToElementManifest(DTE dte, Project project, ProjectItem parentProjectItem, SPFileType sPFileType, string evaluatedTargetFolder, string templateContent, string evaluatedTargetFileName, bool overwrite, bool open)
{
if (IsSharePointVSTemplate(dte, project))
{
//1. place the file in the folder project item
ProjectItems whereToAdd = parentProjectItem.ProjectItems;
ProjectItem addedFile = AddFile(dte, whereToAdd, evaluatedTargetFileName, templateContent, true, false);
try
{
//2. in VS add a reference in the parent element
ISharePointProjectService projectService = GetSharePointProjectService(dte);
ISharePointProject sharePointProject = projectService.Convert<Project, ISharePointProject>(project);
//1. new added items need to be validated before
sharePointProject.Synchronize();
ISharePointProjectItem parentSharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItem>(parentProjectItem);
ISharePointProjectItemFile addedSharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItemFile>(addedFile);
addedSharePointItem.DeploymentType = GetDeploymentTypeFromFileType(sPFileType);
addedSharePointItem.DeploymentPath = evaluatedTargetFolder;
parentSharePointItem.Files.AddFromFile(addedSharePointItem.FullPath);
}
catch
{
}
return addedFile;
}
else
{
if (sPFileType == SPFileType.ElementFile)
{
//file needs to be palced inside a subfolder of a feature (parameter 'ParentElementFolder')
return AddTemplateToProjectItem(dte, project, parentProjectItem, evaluatedTargetFolder, templateContent, evaluatedTargetFileName, overwrite, open);
}
else
{
return AddTemplateToMappedFolder(dte, project, sPFileType, evaluatedTargetFolder, templateContent, evaluatedTargetFileName, overwrite, open);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dte"></param>
/// <param name="sourceproject"></param>
/// <param name="targetFolder"></param>
/// <param name="deploymentType"></param>
internal static void AddProjectOutputReferenceToFolder(DTE dte, Project sourceproject, ProjectItem targetFolder, SPFileType deploymentType)
{
if (IsSharePointVSTemplate(dte, targetFolder.ContainingProject))
{
ISharePointProjectService projectService = GetSharePointProjectService(dte);
ISharePointProjectItem sharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItem>(targetFolder);
sharePointItem.ProjectOutputReferences.Add(sourceproject.FullName, GetDeploymentTypeFromFileType(deploymentType));
}
else
{
//todo
//1. build dependency to sourceproject
// Make Project1 dependent on Project2.
BuildDependency bd = dte.Solution.SolutionBuild.BuildDependencies.Item(targetFolder.ContainingProject.UniqueName);
bd.AddProject(sourceproject.UniqueName);
}
}
/// <summary>
/// Adds a file to the mapped folder
/// </summary>
/// <param name="dte"></param>
/// <param name="project"></param>
/// <param name="sPFileType"></param>
/// <param name="evaluatedSourceFileName"></param>
/// <param name="evaluatedTargetFileName"></param>
/// <param name="p"></param>
/// <param name="p_2"></param>
internal static ProjectItem AddFileToMappedFolder(DTE dte, Project project, SPFileType sPFileType, string targetFolder, string evaluatedSourceFileName, string evaluatedTargetFileName, bool overwrite, bool open)
{
string completeDestinationPath = GetMappedFolderPath(dte, project, sPFileType, targetFolder);
ProjectItems whereToAdd = Helpers.GetProjectItemsByPath(project, completeDestinationPath);
return Helpers.AddFromTemplate(whereToAdd, evaluatedSourceFileName, evaluatedTargetFileName);
}
internal static void SetDeploymentType(ProjectItem CreatedElementFile, SPFileType sPFileType)
{
try
{
ISharePointProjectService projectService = GetSharePointProjectService(CreatedElementFile.DTE);
ISharePointProject sharePointProject = projectService.Convert<Project, ISharePointProject>(CreatedElementFile.ContainingProject);
sharePointProject.Synchronize();
ISharePointProjectItemFile sharePointItem = projectService.Convert<ProjectItem, ISharePointProjectItemFile>(CreatedElementFile);
sharePointItem.DeploymentType = GetDeploymentTypeFromFileType(sPFileType);
}
catch (Exception)
{
}
}
/// <summary>
/// returns the relative path within the project to the mapped folder
/// </summary>
/// <param name="dte"></param>
/// <param name="project"></param>
/// <param name="sPFileType"></param>
/// <param name="subFolderPath"></param>
/// <returns></returns>
internal static string GetMappedFolderPath(DTE dte, Project project, SPFileType sPFileType, string subFolderPath)
{
ProjectItems mappedFolder = GetMappedFolder(dte, project, sPFileType);
string currentPath = "";
if (mappedFolder.Parent is Project)
{
currentPath = Helpers.GetFullPathOfProjectItem(mappedFolder.Parent as Project);
}
else if (mappedFolder.Parent is ProjectItem)
{
currentPath = Helpers.GetFullPathOfProjectItem(mappedFolder.Parent as ProjectItem);
}
string completeDestinationPath = currentPath + subFolderPath;
string projectPath = Helpers.GetFullPathOfProjectItem(project);
completeDestinationPath = completeDestinationPath.Substring(projectPath.Length); //we need the relative path of the mapped folder
return completeDestinationPath;
}
/// <summary>
/// creates or returns the projectitem which points to the given target sharepoint folder
/// </summary>
/// <param name="dte"></param>
/// <param name="project"></param>
/// <param name="sPFileType"></param>
/// <returns></returns>
internal static ProjectItems GetMappedFolder(DTE dte, Project project, SPFileType sPFileType)
{
if (IsSharePointVSTemplate(dte, project))
{
if (sPFileType == SPFileType.TemplateFile)
{
//find a folder which is mapped to images
return GetOrCreateMappedFolder(project, "TemplateFile", "Template");
}
else if (sPFileType == SPFileType.RootFile)
{
//find a folder which is mapped to images
return GetOrCreateMappedFolder(project, "RootFile", "SharePointRoot");
}
}
if (sPFileType == SPFileType.CustomCode)
{
return Helpers.GetProjectItemsByPath(project, "CustomCode");
}
if (sPFileType == SPFileType.ClassResource)
{
return Helpers.GetProjectItemsByPath(project, @"80\wpresources\" + Helpers.GetOutputNameWithoutExtensions(project));
}
if (sPFileType == SPFileType.AppGlobalResource)
{
return Helpers.GetProjectItemsByPath(project, @"80\resources");
}
if (sPFileType == SPFileType.BINFile)
{
return Helpers.GetProjectItemsByPath(project, @"80\BIN");
}
if (sPFileType == SPFileType.GACFile)
{
return Helpers.GetProjectItemsByPath(project, @"GAC");
}
//if not found return root
return null;
}
