/// <summary>
/// Initializes a new instance of the <see cref="SharePointProjectFeatureListItem" /> class.
/// </summary>
/// <param name="feature">The feature.</param>
/// <exception cref="System.ArgumentNullException">feature</exception>
public SharePointProjectFeatureListItem(ISharePointProjectFeature feature)
{
if (feature == null)
{
throw new ArgumentNullException("feature");
}
Feature = feature;
}
//TODO: is this right? it has the same token twice
/// <summary>
/// Uns the tokenize.
/// </summary>
/// <param name="feature">The feature.</param>
/// <param name="tokenString">The token string.</param>
/// <returns></returns>
public static string UnTokenize(this ISharePointProjectFeature feature, string tokenString)
{
if (feature != null)
{
tokenString = tokenString.Replace("$SharePoint.Project.FileNameWithoutExtension$", Path.GetFileNameWithoutExtension(feature.Project.FullPath));
tokenString = tokenString.Replace("$SharePoint.Feature.FileNameWithoutExtension$", DeploymentUtilities.GetLastFolderName(feature.FullPath));
}
return(tokenString);
}
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 { }
}
/// <summary>
/// Gets the feature.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="itemId">The item id.</param>
/// <returns></returns>
public static ISharePointProjectFeature GetFeature(ISharePointProject project,
string projectPath,
Guid itemId)
{
ISharePointProjectFeature feature = null;
ISharePointProject featureProject = project.ProjectService.Projects[projectPath];
if (featureProject != null)
{
feature = (from ISharePointProjectFeature f
in featureProject.Features
where f.Id == itemId
select f).FirstOrDefault();
}
return(feature);
}
/// <summary>
/// Gets the features from feature refs.
/// </summary>
/// <param name="project">The project.</param>
/// <param name="features">The features.</param>
/// <returns></returns>
public static IEnumerable <ISharePointProjectFeature> GetFeaturesFromFeatureRefs(ISharePointProject project,
IEnumerable <ISharePointProjectMemberReference> features)
{
string currentProjectPath = Path.GetDirectoryName(project.FullPath);
List <ISharePointProjectFeature> featuresFromPackage = new List <ISharePointProjectFeature>(features.Count());
foreach (ISharePointProjectMemberReference featureRef in features)
{
string featureProjectPath = String.IsNullOrEmpty(featureRef.ProjectPath) ? project.FullPath : Path.Combine(currentProjectPath, featureRef.ProjectPath);
featureProjectPath = new DirectoryInfo(featureProjectPath).FullName; // required to get rid of ..\..\ in the project path
ISharePointProjectFeature feature = GetFeature(project, featureProjectPath, featureRef.ItemId);
if (feature != null)
{
featuresFromPackage.Add(feature);
}
}
return(featuresFromPackage);
}
public override void Execute()
{
DTE service = (DTE)this.GetService(typeof(DTE));
try
{
if (projectItem != null)
{
Helpers.LogMessage(service, this, "*********** SharePointService Properties ********************");
try
{
ISharePointProjectService projectService = Helpers2.GetSharePointProjectService(service);
ISharePointProject sharePointProject = projectService.Convert <Project, ISharePointProject>(project);
try
{ //is it a feature
ISharePointProjectFeature sharePointFeature = projectService.Convert <ProjectItem, ISharePointProjectFeature>(projectItem);
}
catch { }
try
{ //is it a feature
ISharePointProjectItem sharePointItem = projectService.Convert <ProjectItem, ISharePointProjectItem>(projectItem);
}
catch { }
try
{ //is it a feature
ISharePointProjectItemFile sharePointItemFile = projectService.Convert <ProjectItem, ISharePointProjectItemFile>(projectItem);
}
catch { }
try
{ //is it a mapped folder
IMappedFolder sharePointMappedFolder = projectService.Convert <ProjectItem, IMappedFolder>(projectItem);
}
catch { }
try
{ //is it a mapped folder
ISharePointProjectPackage sharePointProjectPackage = projectService.Convert <ProjectItem, ISharePointProjectPackage>(projectItem);
}
catch { }
}
catch {}
//codelements
Helpers.LogMessage(service, this, "*********** EnvDTE CodeElements ********************");
foreach (CodeElement codeElement in projectItem.FileCodeModel.CodeElements)
{
try
{
Helpers.LogMessage(service, this, "codeElement.FullName: " + codeElement.FullName);
Helpers.LogMessage(service, this, "codeElement.Type: " + codeElement.GetType().ToString());
Helpers.LogMessage(service, this, "codeElement.Kind: " + codeElement.Kind.ToString());
}
catch {}
}
Helpers.LogMessage(service, this, "*********** EnvDTE Properties ********************");
for (int i = 0; i < projectItem.Properties.Count; i++)
{
try
{
string name = projectItem.Properties.Item(i).Name;
string value = "";
try
{
value = projectItem.Properties.Item(i).Value.ToString();
}
catch (Exception)
{
}
Helpers.LogMessage(service, this, name + "=" + value);
}
catch (Exception)
{
}
}
}
else if (project != null)
{
for (int i = 0; i < project.Properties.Count; i++)
{
try
{
string name = project.Properties.Item(i).Name;
string value = "";
try
{
value = project.Properties.Item(i).Value.ToString();
}
catch (Exception)
{
}
Helpers.LogMessage(service, this, name + "=" + value);
if (project.Properties.Item(i).Collection.Count > 0)
{
}
}
catch (Exception)
{
}
}
}
}
catch (Exception ex)
{
Helpers.LogMessage(service, this, ex.ToString());
}
}
/// <summary>
/// Retrieves all projects in the solution where this feature is packaged.
/// </summary>
/// <param name="feature">The ISharePointProjectFeature being extended.</param>
/// <param name="service">The current sharepoint service.</param>
/// <returns>Returns all projects in the solution where this feature is packaged.</returns>
public static IEnumerable <ISharePointProject> GetProjectsWhereInPackage(this ISharePointProjectFeature feature, ISharePointProjectService service)
{
return(service.Projects.Where(p => p.Package.Features.Contains(feature)));
}
/// <summary>
/// Determines if this Feature is packaged in any project in the solution.
/// </summary>
/// <param name="feature">The ISharePointProjectFeature being extended.</param>
/// <param name="service">The current sharepoint service.</param>
/// <returns>Returns true if this Feature is packaged in any project in the solution.</returns>
public static bool IsPartOfAnyProjectPackage(this ISharePointProjectFeature feature, ISharePointProjectService service)
{
return(service.Projects.Any(p => p.Package.Features.Contains(feature)));
}
/// <summary>
/// Determines if this Feature is packaged in the given project.
/// </summary>
/// <param name="feature">The ISharePointProjectFeature being extended.</param>
/// <param name="project">The current sharepoint project.</param>
/// <returns>Returns true if this Feature is packaged in the given project.</returns>
public static bool IsPartOfProjectPackage(this ISharePointProjectFeature feature, ISharePointProject project)
{
return(project.Package.Features.Contains(feature));
}
/// <summary>
/// Initializes a new instance of the <see cref="SharePointProjectFeatureArtefact"/> class.
/// </summary>
/// <param name="feature">The feature.</param>
public SharePointProjectFeatureArtefact(ISharePointProjectFeature feature)
{
this.feature = feature;
}
public override void Execute()
{
DTE dte = (DTE)this.GetService(typeof(DTE));
Project Project = this.GetTargetProject(dte);
string evaluatedTemplateFileName = EvaluateParameterAsString(dte, TemplateFileName);
string evaluatedParentFeatureName = EvaluateParameterAsString(dte, ParentFeatureName);
string evaluatedAssemblyName = EvaluateParameterAsString(dte, AssemblyName);
string evaluatedNamespace = EvaluateParameterAsString(dte, Namespace);
string xmlContent = GenerateContent(evaluatedTemplateFileName, "ReceiverCode.xml");
try
{
//feature name consists of application name + SPSFConstants.NameSeparator + featurename, but we need to strip off the feature name from that
string appName = Helpers.GetSaveApplicationName(dte);
string featureName = evaluatedParentFeatureName;
if (featureName.StartsWith(appName, StringComparison.InvariantCultureIgnoreCase))
{
featureName = featureName.Substring(appName.Length + 1);
}
string FeatureReceiverClass = featureName + "EventReceiver";
if (Helpers2.IsSharePointVSTemplate(dte, Project))
{
//can we cast the project to ISharePointSolution
ISharePointProjectService projectService = Helpers2.GetSharePointProjectService(Project.DTE);
ISharePointProject sharePointProject = projectService.Convert <EnvDTE.Project, ISharePointProject>(Project);
sharePointProject.Synchronize();
ISharePointProjectFeature parentfeature = null;
foreach (ISharePointProjectFeature feature in sharePointProject.Features)
{
if (feature.Name == evaluatedParentFeatureName)
{
parentfeature = feature;
}
}
if (parentfeature != null)
{
if (string.IsNullOrEmpty(parentfeature.Model.ReceiverClass))
{
if (dte.SuppressUI || (MessageBox.Show("Feature '" + evaluatedParentFeatureName + "' contains no feature receiver. Add feature receiver?", "Add Feature Receiver?", MessageBoxButtons.YesNo) == DialogResult.Yes))
{
ProjectItem projectItem = projectService.Convert <ISharePointProjectFeature, EnvDTE.ProjectItem>(parentfeature);
ProjectItem featureXmlFile = projectService.Convert <ISharePointProjectMember, EnvDTE.ProjectItem>(parentfeature.FeatureFile);
//no feature receiver there, we create one
ProjectItem createdFeatureReceiverItem = CreateNewFeatureReceiver(featureName, projectItem, featureXmlFile);
parentfeature.Model.ReceiverAssembly = evaluatedAssemblyName;
parentfeature.Model.ReceiverClass = evaluatedNamespace + "." + FeatureReceiverClass;
this.MergeNewCodeWithClass(createdFeatureReceiverItem, FeatureReceiverClass, xmlContent);
sharePointProject.Synchronize();
//is test run save file
if (dte.SuppressUI)
{
featureXmlFile.Save();
//createdFeatureReceiverItem.Save();
}
}
else
{
return;
}
}
else
{
//1. we check if there is a filename with .generated in it
//we need the class name of the featurereceiver, but in VS-Feature the name contains a ID
string className = parentfeature.Model.ReceiverClass;
if (className.StartsWith("$SharePoint.Type"))
{
//not supported???
if (parentfeature.EventReceiverFile != null)
{
ProjectItem existingCode = projectService.Convert <ISharePointProjectMember, EnvDTE.ProjectItem>(parentfeature.EventReceiverFile);
this.MergeNewCodeWithClass(existingCode, "", xmlContent);
}
}
else
{
string foundReceiverClassName = parentfeature.Model.ReceiverClass;
string receiverNamespace = foundReceiverClassName.Substring(0, foundReceiverClassName.LastIndexOf(".") - 1);
string receiverClassName = foundReceiverClassName.Substring(foundReceiverClassName.LastIndexOf(".") + 1);
//ok, class name found
//yes, there is a feature receiver, but we need to find the class in the project
//find any .cs item which contains the name of the featureclass and namespace
List <string> patterns = new List <string>();
patterns.Add(receiverNamespace);
patterns.Add(receiverClassName);
patterns.Add(" FeatureActivated("); //to ensure that we get the correct partial class
ProjectItem existingCode = Helpers.FindItem(Project, ".cs", patterns);
if (existingCode != null)
{
this.MergeNewCodeWithClass(existingCode, receiverClassName, xmlContent);
}
}
}
}
}
else
{
//find the feature receiver code
ProjectItem featureXMLFile = Helpers.GetFeatureXML(Project, evaluatedParentFeatureName);
ProjectItem featureFolder = Helpers2.GetFeature(Project.DTE, Project, evaluatedParentFeatureName);
//check if feature already contains feature receiver
if (featureXMLFile != null)
{
string receiverClassName = Helpers.GetFeatureReceiverClass(featureXMLFile);
string receiverNamespace = Helpers.GetFeatureReceiverNamespace(featureXMLFile);
if (receiverClassName == "")
{
if (dte.SuppressUI || (MessageBox.Show("Feature '" + evaluatedParentFeatureName + "' contains no feature receiver. Add feature receiver?", "Add Feature Receiver?", MessageBoxButtons.YesNo) == DialogResult.Yes))
{
//there is no feature receiver, we need to create one :-(
string path = Helpers.GetFullPathOfProjectItem(featureXMLFile);
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("ns", "http://schemas.microsoft.com/sharepoint/");
XmlNode node = doc.SelectSingleNode("/ns:Feature", nsmgr);
if (node != null)
{
ProjectItem createdFeatureReceiverItem = CreateNewFeatureReceiver(featureName, featureFolder, featureXMLFile);
XmlAttribute receiverAssemblyAttrib = doc.CreateAttribute("ReceiverAssembly");
receiverAssemblyAttrib.Value = evaluatedAssemblyName;
node.Attributes.Append(receiverAssemblyAttrib);
XmlAttribute receiverClassAttrib = doc.CreateAttribute("ReceiverClass");
receiverClassAttrib.Value = evaluatedNamespace + "." + FeatureReceiverClass;
node.Attributes.Append(receiverClassAttrib);
Helpers.EnsureCheckout(dte, path);
XmlWriter xw = XmlWriter.Create(path, Helpers.GetXmlWriterSettings(path));
doc.Save(xw);
xw.Flush();
xw.Close();
this.MergeNewCodeWithClass(createdFeatureReceiverItem, FeatureReceiverClass, xmlContent);
}
}
else
{
return;
}
}
else
{
//yes, there is a feature receiver, but we need to find the class in the project
//find any .cs item which contains the name of the featureclass and namespace
List <string> patterns = new List <string>();
patterns.Add(receiverClassName);
patterns.Add(receiverNamespace);
patterns.Add(" FeatureActivated("); //to ensure that we get the correct partial class
ProjectItem existingCode = Helpers.FindItem(Project, ".cs", patterns);
if (existingCode != null)
{
//find the activated Function
string featureFilename = Helpers.GetFullPathOfProjectItem(existingCode);
this.MergeNewCodeWithClass(existingCode, receiverClassName, xmlContent);
}
}
}
if (featureXMLFile != null)
{
CreatedProjectItem = featureXMLFile;
}
else
{
CreatedProjectItem = Helpers.GetFeatureXML(Project, evaluatedParentFeatureName);
}
if (featureFolder != null)
{
CreatedProjectFolder = featureFolder;
}
else
{
CreatedProjectFolder = Helpers2.GetFeature(Project.DTE, Project, evaluatedParentFeatureName);
}
}
}
catch (Exception ex)
{
if (dte.SuppressUI)
{
throw new Exception(ex.ToString());
}
else
{
MessageBox.Show(ex.ToString());
}
}
}
/// <summary>
/// Returns all SharePoint artefacts for a given ProjectItem. Multiple items may be returned, for example, if the
/// selection is a folder. Note that this list is not pruned in the event of multiple selections from the same sub-tree.
/// </summary>
/// <param name="projectService"></param>
/// <param name="item"></param>
/// <returns></returns>
public static List <QuickCopyableSharePointArtefact> ResolveProjectItemToArtefacts(ISharePointProjectService projectService, ProjectItem item)
{
// Ensure we have a SharePoint service.
if (projectService == null)
{
return(null);
}
// Prepare list for return.
List <QuickCopyableSharePointArtefact> artefacts = new List <QuickCopyableSharePointArtefact>();
// See if this item is a SPI file.
try
{
ISharePointProjectItemFile spFile = projectService.Convert <ProjectItem, ISharePointProjectItemFile>(item);
if (spFile != null)
{
if (spFile.DeploymentType != DeploymentType.NoDeployment)
{
artefacts.Add(new SharePointProjectItemFileArtefact(spFile));
return(artefacts);
}
}
}
catch { }
// See if this item is an SPI.
try
{
ISharePointProjectItem spItem = projectService.Convert <ProjectItem, ISharePointProjectItem>(item);
if (spItem != null)
{
artefacts.Add(new SharePointProjectItemArtefact(spItem));
return(artefacts);
}
}
catch { }
// See if this item is a Feature.
try
{
ISharePointProjectFeature spFeature = projectService.Convert <ProjectItem, ISharePointProjectFeature>(item);
if (spFeature != null)
{
artefacts.Add(new SharePointProjectFeatureArtefact(spFeature));
return(artefacts);
}
}
catch { }
// See if we have a Folder, and recursively find SharePoint items.
try
{
if (item.ProjectItems.Count > 0)
{
for (int i = 1; i <= item.ProjectItems.Count; i++)
{
ProjectItem childItem = item.ProjectItems.Item(i);
artefacts.AddRange(ResolveProjectItemToArtefacts(projectService, childItem));
}
}
}
catch { }
// TODO: Also, these items are potential types for conversion.
// ISharePointProjectFeatureResourceFile
// ISharePointProjectPackage
return(artefacts);
}
public override void RunWizardFinished()
{
base.RunWizardFinished();
// required to push changes from DTE.Project to ISharePointProject
ISharePointProject spProject = DTEManager.ActiveSharePointProject;
spProject.Synchronize();
string projectPath = Path.GetDirectoryName(spProject.FullPath);
ISharePointProjectItem webTemplate = DTEManager.FindSPIItemByName(projectItemName, spProject);
ISharePointProjectItem webTemplateStamp = DTEManager.FindSPIItemByName(String.Format("{0}Stamp", projectItemName), spProject);
ISharePointProjectItem publishingPage = DTEManager.FindSPIItemByName(String.Format("{0}PublishingPage", projectItemName), spProject);
ISharePointProjectItem wikiPage = DTEManager.FindSPIItemByName(String.Format("{0}WikiPage", projectItemName), spProject);
ISharePointProjectItem webPartPage = DTEManager.FindSPIItemByName(String.Format("{0}WebPartPage", projectItemName), spProject);
ISharePointProjectFeature webTemplateFeature = spProject.Features[projectItemName];
ISharePointProjectFeature webTemplateStampFeature = spProject.Features[String.Format("{0}Stamp", projectItemName)];
ISharePointProjectFeature webTemplateWelcomePageFeature = spProject.Features[String.Format("{0}WelcomePage", projectItemName)];
// remove automatically added feature associations
foreach (ISharePointProjectFeature feature in spProject.Features)
{
feature.ProjectItems.Remove(webTemplate);
feature.ProjectItems.Remove(webTemplateStamp);
feature.ProjectItems.Remove(publishingPage);
feature.ProjectItems.Remove(wikiPage);
feature.ProjectItems.Remove(webPartPage);
}
// add standard spis to own features
webTemplateFeature.ProjectItems.Add(webTemplate);
webTemplateStampFeature.ProjectItems.Add(webTemplateStamp);
webTemplateWelcomePageFeature.ProjectItems.Add(publishingPage);
webTemplateWelcomePageFeature.ProjectItems.Add(wikiPage);
webTemplateWelcomePageFeature.ProjectItems.Add(webPartPage);
ProjectItem pagesFolder = DTEManager.FindItemByName(DTEManager.ActiveProject.ProjectItems, "Pages", true);
ProjectItem defaultPageProjectItem = null;
switch (welcomePageType)
{
case WelcomePageType.WebPartPage:
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WikiPage", projectItemName), true));
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}PublishingPage", projectItemName), true));
defaultPageProjectItem = DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WebPartPage", projectItemName), true);
break;
case WelcomePageType.WikiPage:
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WebPartPage", projectItemName), true));
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}PublishingPage", projectItemName), true));
defaultPageProjectItem = DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WikiPage", projectItemName), true);
break;
case WelcomePageType.PublishingPage:
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WikiPage", projectItemName), true));
DTEManager.SafeDeleteProjectItem(DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}WebPartPage", projectItemName), true));
defaultPageProjectItem = DTEManager.FindItemByName(pagesFolder.ProjectItems, String.Format("{0}PublishingPage", projectItemName), true);
break;
}
if (defaultPageProjectItem != null)
{
defaultPageProjectItem.Name = String.Format("{0}Default", projectItemName);
}
}
