/// <summary>
/// Imports the type of the content.
/// </summary>
/// <param name="contentTypeInfo">The content type info.</param>
public static void ImportContentType(ContentTypeInfo contentTypeInfo)
{
if (contentTypeInfo != null)
{
//Create the encoding definition
XDeclaration declaration = new XDeclaration("1.0", Encoding.UTF8.WebName, null);
XNamespace sharepointToolsNamespace = @"http://schemas.microsoft.com/VisualStudio/2010/SharePointTools/SharePointProjectItemModel";
XNamespace sharepointNamespace = @"http://schemas.microsoft.com/sharepoint/";
XElement elementsFileContents = XElement.Parse(BuildElements(contentTypeInfo, declaration, sharepointNamespace));
EnvDTE.Project activeProject = DTEManager.ActiveProject;
if (activeProject != null)
{
ISharePointProjectService projectService = DTEManager.ProjectService;
ISharePointProject activeSharePointProject = DTEManager.ActiveSharePointProject;
if (activeSharePointProject != null)
{
ISharePointProjectItem contentTypeProjectItem = activeSharePointProject.ProjectItems.Add(contentTypeInfo.Name, "Microsoft.VisualStudio.SharePoint.ContentType");
System.IO.File.WriteAllText(Path.Combine(contentTypeProjectItem.FullPath, "Elements.xml"), elementsFileContents.ToString().Replace("xmlns=\"\"", String.Empty));
ISharePointProjectItemFile elementsXml = contentTypeProjectItem.Files.AddFromFile("Elements.xml");
elementsXml.DeploymentType = DeploymentType.ElementManifest;
elementsXml.DeploymentPath = String.Format(@"{0}\", contentTypeInfo.Name);
contentTypeProjectItem.DefaultFile = elementsXml;
}
}
}
}
private void ProjectItemNameChanged(object sender, NameChangedEventArgs e)
{
ISharePointProjectItem projectItem = (ISharePointProjectItem)sender;
string message = String.Format("The name of the {0} item changed to: {1}",
e.OldName, projectItem.Name);
projectService.Logger.WriteLine(message, LogCategory.Message);
}
//</Snippet3>
void MenuItemExtension_Click(object sender, MenuItemEventArgs e)
{
ISharePointProjectItem projectItem = (ISharePointProjectItem)e.Owner;
projectItem.Project.ProjectService.Logger.WriteLine(
String.Format("This message was written from a shortcut menu for {0}.", projectItem.Name),
LogCategory.Status);
}
void projectItemType_ProjectItemAdded(object sender, SharePointProjectItemEventArgs e)
{
ISharePointProjectItem projectItem = (ISharePointProjectItem)sender;
string message = String.Format("An Event Handler project item named {0} was added to the {1} project.",
projectItem.Name, projectItem.Project.Name);
projectItem.Project.ProjectService.Logger.WriteLine(message, LogCategory.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref="SPMetalDefinitionProperties"/> class.
/// </summary>
/// <param name="definition">The definition.</param>
/// <param name="owner">The owner.</param>
/// <param name="properties">The CKSProperties.</param>
public SPMetalDefinitionProperties(SPMetalDefinitionTypeProvider definition,
ISharePointProjectItem owner,
IDictionary <string, string> properties)
{
_owner = owner;
_properties = properties;
_definition = definition;
}
private void MenuItemClick(object sender, MenuItemEventArgs e)
{
ISharePointProjectItem projectItem = (ISharePointProjectItem)e.Owner;
string message = String.Format("You clicked the menu on the {0} item. " +
"You could perform some related task here, such as displaying a designer " +
"for the custom action.", projectItem.Name);
System.Windows.Forms.MessageBox.Show(message, "Contoso Custom Action");
}
/// <summary>
/// Handles the Click event of the removeFromAllReferencesMenuItem control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.VisualStudio.SharePoint.MenuItemEventArgs"/> instance containing the event data.</param>
void removeFromAllReferencesMenuItem_Click(object sender,
MenuItemEventArgs e)
{
if (MessageBox.Show("Are you sure you want to remove this project item from all Features and Packages?", "Remove from all Features and Packages", MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.OK)
{
ISharePointProjectItem spi = e.Owner as ISharePointProjectItem;
if (spi != null)
{
ISharePointProjectLogger logger = spi.Project.ProjectService.Logger;
logger.ClearErrorList();
logger.ActivateOutputWindow();
logger.WriteLine(String.Format("Removing SharePoint Project Item '{0}' from Packages and Features...", spi.Name), LogCategory.Status);
var projects = spi.Project.ProjectService.Projects;
foreach (var project in projects)
{
ISharePointProjectItem spiInPackage = null;
foreach (ISharePointProjectItem s in project.Package.ProjectItems)
{
if (s.Id == spi.Id)
{
spiInPackage = s;
break;
}
}
if (spiInPackage != null)
{
project.Package.ProjectItems.Remove(spiInPackage);
logger.WriteLine(String.Format("SharePoint Project Item '{0}' removed from Package '{1}'", spi.Name, project.Package.Model.Name), LogCategory.Message, project.Package.PackageFile.FullPath, 1, 1);
}
foreach (var feature in project.Features)
{
ISharePointProjectItem spiInFeature = null;
foreach (var s in feature.ProjectItems)
{
if (s.Id == spi.Id)
{
spiInFeature = s;
break;
}
}
if (spiInFeature != null)
{
feature.ProjectItems.Remove(spiInFeature);
logger.WriteLine(String.Format("SharePoint Project Item '{0}' removed from Feature '{1}'", spi.Name, feature.Model.Title), LogCategory.Message, feature.FeatureFile.FullPath, 1, 1);
}
}
}
}
}
}
/// <summary>
/// Forces the regenerate the SPMetal designer file.
/// </summary>
/// <param name="owner">The owner.</param>
/// <param name="properties">The properties for the SPMetal definition.</param>
internal void ForceRegenerate(ISharePointProjectItem owner, SPMetalDefinitionProperties properties)
{
owner.Annotations.Remove <SPMetalDefinitionProperties>();
owner.Annotations.Add <SPMetalDefinitionProperties>(properties);
ProjectItem dteItem = owner.Project.ProjectService.Convert <ISharePointProjectItemFile, ProjectItem>(owner.DefaultFile);
VSProjectItem vp = (VSProjectItem)dteItem.Object;
vp.RunCustomTool();
}
/// <summary>
/// Initializes a new instance of the <see cref="FeaturesViewerForm"/> class.
/// </summary>
/// <param name="spi">The spi.</param>
public FeaturesViewerForm(ISharePointProjectItem spi)
{
if (spi == null)
{
throw new ArgumentNullException("spi");
}
InitializeComponent();
LoadProjects(spi.Project);
LoadFeatures(spi);
FilterFeaturesList();
}
/// <summary>
/// Imports the field.
/// </summary>
/// <param name="fieldNode">The field node.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public static void ImportField(IExplorerNode fieldNode)
{
if (fieldNode == null)
{
throw new ArgumentNullException("fieldNode");
}
Microsoft.VisualStudio.SharePoint.Explorer.Extensions.IFieldNodeInfo nodeInfo = fieldNode.Annotations.GetValue <Microsoft.VisualStudio.SharePoint.Explorer.Extensions.IFieldNodeInfo>();
if (nodeInfo != null)
{
FieldNodeInfo fieldNodeInfo = new FieldNodeInfo
{
ContentTypeName = nodeInfo.ContentTypeName,
Id = nodeInfo.Id,
IsHidden = nodeInfo.IsHidden,
ListId = nodeInfo.ListId,
Title = nodeInfo.Title
};
Dictionary <string, string> fieldProperties = null;
if (String.IsNullOrEmpty(fieldNodeInfo.ContentTypeName) && fieldNodeInfo.ListId == Guid.Empty)
{
fieldProperties = fieldNode.Context.SharePointConnection.ExecuteCommand <FieldNodeInfo, Dictionary <string, string> >(SiteColumnsSharePointCommandIds.GetProperties, fieldNodeInfo);
}
else
{
fieldProperties = fieldNode.Context.SharePointConnection.ExecuteCommand <FieldNodeInfo, Dictionary <string, string> >(FieldSharePointCommandIds.GetProperties, fieldNodeInfo);
}
if (fieldProperties != null)
{
XNamespace xn = XNamespace.Get("http://schemas.microsoft.com/sharepoint/");
XElement xElements = new XElement(xn + "Elements",
XElement.Parse(fieldProperties["SchemaXml"]));
EnvDTE.Project activeProject = DTEManager.ActiveProject;
if (activeProject != null)
{
ISharePointProjectService projectService = fieldNode.ServiceProvider.GetService(typeof(ISharePointProjectService)) as ISharePointProjectService;
ISharePointProject activeSharePointProject = projectService.Projects[activeProject.FullName];
if (activeSharePointProject != null)
{
ISharePointProjectItem fieldProjectItem = activeSharePointProject.ProjectItems.Add(fieldProperties["InternalName"], "Microsoft.VisualStudio.SharePoint.Field");
System.IO.File.WriteAllText(Path.Combine(fieldProjectItem.FullPath, "Elements.xml"), xElements.ToString().Replace("xmlns=\"\"", String.Empty));
ISharePointProjectItemFile elementsXml = fieldProjectItem.Files.AddFromFile("Elements.xml");
elementsXml.DeploymentType = DeploymentType.ElementManifest;
elementsXml.DeploymentPath = String.Format(@"{0}\", fieldProperties["InternalName"]);
fieldProjectItem.DefaultFile = elementsXml;
}
}
}
}
}
public void ValidateProjectItem(
IFeatureValidationContext context,
ISharePointProjectItem projectItem)
{
if (projectItem.Name == "")
{
context.RuleViolations.Add(
"CustomFeatureValidationRule001",
ValidationRuleViolationSeverity.Warning,
"SharePoint project items must have a name.");
}
}
/// <summary>
/// Determines if this SPI is included inside a feature that is packaged in any project in the solution.
/// </summary>
/// <param name="item">The ISharePointProjectItem being extended.</param>
/// <param name="service">The sharepoint project service.</param>
/// <returns>Returns true if this SPI is included inside a feature that is packaged in any project in the solution.</returns>
public static bool IsPartOfAnyPackagedProjectFeature(this ISharePointProjectItem item, ISharePointProjectService service)
{
foreach (ISharePointProject project in service.Projects)
{
if (item.IsPartOfPackagedProjectFeature(project))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Gets all features in the given project whether packaged or not that contain this SPI.
/// </summary>
/// <param name="item">The ISharePointProjectItem being extended.</param>
/// <param name="project">The current project.</param>
/// <returns>Returns all features in the given project.</returns>
public static List <ISharePointProjectFeature> ParentFeaturesInProject(this ISharePointProjectItem item, ISharePointProject project)
{
List <ISharePointProjectFeature> features = new List <ISharePointProjectFeature>();
features.AddRange(
from feature
in project.Features
where feature.ProjectItems.Contains(item)
select feature
);
return(features);
}
void ImportListInstanceExplorerExtension_Click(object sender, MenuItemEventArgs e)
{
IExplorerNode listNode = e.Owner as IExplorerNode;
if (listNode != null)
{
try {
IListNodeInfo listInfo = listNode.Annotations.GetValue <IListNodeInfo>();
string listInstanceContents = listNode.Context.SharePointConnection.ExecuteCommand <Guid, string>(CommandIds.GetListInstanceXmlCommandId, listInfo.Id);
XNamespace xn = "http://schemas.microsoft.com/sharepoint/";
string moduleContents = new XElement(xn + "Elements",
XElement.Parse(listInstanceContents)).ToString().Replace(" xmlns=\"\"", String.Empty);
EnvDTE.Project activeProject = Utils.GetActiveProject();
if (activeProject != null)
{
ISharePointProjectService projectService = listNode.ServiceProvider.GetService(typeof(ISharePointProjectService)) as ISharePointProjectService;
ISharePointProject activeSharePointProject = projectService.Projects[activeProject.FullName];
if (activeSharePointProject != null)
{
string spiName = listInfo.Title;
ISharePointProjectItem listInstanceProjectItem = null;
bool itemCreated = false;
int counter = 0;
do
{
try {
listInstanceProjectItem = activeSharePointProject.ProjectItems.Add(spiName, "Microsoft.VisualStudio.SharePoint.ListInstance");
itemCreated = true;
}
catch (ArgumentException) {
spiName = String.Format("{0}{1}", listInfo.Title, ++counter);
}
}while (!itemCreated);
string elementsXmlFullPath = Path.Combine(listInstanceProjectItem.FullPath, "Elements.xml");
System.IO.File.WriteAllText(elementsXmlFullPath, moduleContents);
ISharePointProjectItemFile elementsXml = listInstanceProjectItem.Files.AddFromFile("Elements.xml");
elementsXml.DeploymentType = DeploymentType.ElementManifest;
elementsXml.DeploymentPath = String.Format(@"{0}\", spiName);
listInstanceProjectItem.DefaultFile = elementsXml;
Utils.OpenFile(Path.Combine(elementsXmlFullPath));
}
}
}
catch (Exception ex) {
listNode.Context.ShowMessageBox(String.Format("The following exception occured while exporting List Instance: {0}", ex.Message), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Handles the Click event of the findAllReferencesMenuItem control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.VisualStudio.SharePoint.MenuItemEventArgs"/> instance containing the event data.</param>
void findAllReferencesMenuItem_Click(object sender,
MenuItemEventArgs e)
{
ISharePointProjectItem spi = e.Owner as ISharePointProjectItem;
if (spi != null)
{
ISharePointProjectLogger logger = spi.Project.ProjectService.Logger;
logger.ClearErrorList();
logger.ActivateOutputWindow();
logger.WriteLine(String.Format("Searching for references to SharePoint Project Item '{0}'...", spi.Name), LogCategory.Status);
bool referencesFound = false;
foreach (var project in spi.Project.ProjectService.Projects)
{
if (SupportsDeploymentScope(spi.ProjectItemType.SupportedDeploymentScopes, SupportedDeploymentScopes.Package))
{
if ((from ISharePointProjectItem s
in project.Package.ProjectItems
where s.Id == spi.Id
select s).Any())
{
referencesFound = true;
spi.Project.ProjectService.Logger.WriteLine(String.Format("Found reference to SharePoint Project Item '{0}' in Package '{1}' ({2})", spi.Name, project.Package.Model.Name, project.Name), LogCategory.Message, project.Package.PackageFile.FullPath, 1, 1);
}
}
if (CanBeDeployedUsingFeature(spi.ProjectItemType.SupportedDeploymentScopes))
{
var spiInFeatures = from ISharePointProjectFeature f
in project.Features
where (from ISharePointProjectItem s
in f.ProjectItems
where s.Id == spi.Id
select s).Any()
select f;
foreach (var feature in spiInFeatures)
{
referencesFound = true;
spi.Project.ProjectService.Logger.WriteLine(String.Format("Found reference to SharePoint Project Item '{0}' in Feature '{1}' ({2})", spi.Name, feature.Model.Title, feature.Project.Name), LogCategory.Message, feature.FeatureFile.FullPath, 1, 1);
}
}
}
if (!referencesFound)
{
logger.WriteLine(String.Format("No references to SharePoint Project Item '{0}' found", spi.Name), LogCategory.Status);
}
}
}
/// <summary>
/// Retrieves all projects in the solution where this SPI is packaged.
/// </summary>
/// <param name="item">The ISharePointProjectItem being extended.</param>
/// <param name="service">The sharepoint project service.</param>
/// <returns>Returns all projects in the solution where this SPI is packaged.</returns>
public static IEnumerable <ISharePointProject> GetProjectsWhereInPackage(this ISharePointProjectItem item, ISharePointProjectService service)
{
List <ISharePointProject> pkgProjects = new List <ISharePointProject>();
foreach (ISharePointProject project in service.Projects)
{
if (item.IsPartOfProjectPackage(project))
{
pkgProjects.Add(project);
}
}
return(pkgProjects);
}
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>
/// Loads the features.
/// </summary>
/// <param name="spi">The spi.</param>
private void LoadFeatures(ISharePointProjectItem spi)
{
allFeatures = new List <ISharePointProjectFeature>();
foreach (var p in spi.Project.ProjectService.Projects)
{
foreach (var f in p.Features)
{
if (f.Model != null &&
FeatureSupportsSpiScope(f.Model.Scope, spi.ProjectItemType.SupportedDeploymentScopes))
{
allFeatures.Add(f);
}
}
}
}
/// <summary>
/// Handles the Click event of the addToSpecificFeature control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.VisualStudio.SharePoint.MenuItemEventArgs"/> instance containing the event data.</param>
void addToSpecificFeature_Click(object sender, MenuItemEventArgs e)
{
ISharePointProjectItem spi = e.Owner as ISharePointProjectItem;
if (spi != null)
{
using (FeaturesViewerForm form = new FeaturesViewerForm(spi))
{
if (form.ShowDialog() == DialogResult.OK && form.SelectedFeature != null)
{
form.SelectedFeature.ProjectItems.Add(spi);
ISharePointProjectLogger logger = spi.Project.ProjectService.Logger;
logger.ClearErrorList();
logger.ActivateOutputWindow();
logger.WriteLine(String.Format("SharePoint Project Item '{0}' successfully added to Feature '{1}'", spi.Name, form.SelectedFeature.Model.Title), LogCategory.Message, form.SelectedFeature.FullPath, 1, 1);
}
}
}
}
// Gets the ISharePointProjectItemFile object for the BDC model file.
private ISharePointProjectItemFile GetModelFile(ISharePointProjectItem projectItem)
{
string modelFileName;
if (projectItem.FeatureProperties.TryGetValue(ModelFileNameString, out modelFileName))
{
modelFileName = Path.GetFileName(modelFileName);
return((from file in projectItem.Files
where string.Compare(file.Name, modelFileName, StringComparison.OrdinalIgnoreCase) == 0
select file).FirstOrDefault());
}
else
{
// if we can't find the ModelFileName through the FeatureProperties,
// get the first file that has a '.bdcm' extension
return((from file in projectItem.Files
where file.Name.EndsWith(EXTENSION_BDCM, StringComparison.OrdinalIgnoreCase)
select file).FirstOrDefault());
}
}
/// <summary>
/// Handles the ProjectItemInitialized event of the spiType control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="SharePointProjectItemEventArgs" /> instance containing the event data.</param>
private void spiType_ProjectItemInitialized(object sender, SharePointProjectItemEventArgs e)
{
if (recentlyAddedItem == e.ProjectItem.Id)
{
recentlyAddedItem = Guid.Empty;
ISharePointProjectItem spi = e.ProjectItem;
IEnumerable <ISharePointProjectFeature> source = from ISharePointProjectFeature feature
in spi.Project.Features
where feature.ProjectItems.Contains(spi)
select feature;
if ((source != null) && (source.Count() > 0))
{
foreach (ISharePointProjectFeature feature in source)
{
feature.ProjectItems.Remove(spi);
}
}
}
}
// Generates an external data list for each Entity in the BDC model. This event handler is called
// when the developer clicks the shortcut menu item that the extension adds to the BDC project item.
private void GenerateExternalDataLists_Execute(object sender, MenuItemEventArgs e)
{
ISharePointProjectItem projectItem = (ISharePointProjectItem)e.Owner;
ISharePointProjectItemFile bdcmFile = GetModelFile(projectItem);
XDocument doc = XDocument.Load(bdcmFile.FullPath);
List <XElement> skippedEntities = new List <XElement>();
// Try to generate an external data list for each entity defined in the BDC model file.
foreach (XElement entity in doc.Root.Elements(BdcNamespace + "LobSystems").Elements(
BdcNamespace + "LobSystem").Elements(BdcNamespace + "Entities").Elements(BdcNamespace + "Entity"))
{
if (!GenerateExternalDataList(projectItem, entity))
{
skippedEntities.Add(entity);
}
}
// Report skipped entities.
if (skippedEntities.Count != 0)
{
StringBuilder entityNameList = null;
skippedEntities.ForEach(delegate(XElement entity)
{
if (entityNameList == null)
{
entityNameList = new StringBuilder();
}
else
{
entityNameList.AppendLine(",");
}
entityNameList.Append(entity.Attribute("Name").Value);
});
string message = string.Format("The following Entities were skipped because either a LobSystemInstance, " +
"SpecificFinder, or Finder was not found for them. \r\n{0}", entityNameList);
projectItem.Project.ProjectService.Logger.WriteLine(message, LogCategory.Warning);
}
}
// Tries to generate an external data list for the specified BDC model project item and entity.
private bool GenerateExternalDataList(ISharePointProjectItem projectItem, XElement entity)
{
string lobSystemInstanceName = GetLobSystemInstanceName(entity);
string specificFinderName = GetSpecificFinderName(entity);
string finderName = GetFinderName(entity);
string entityName = entity.Attribute("Name").Value;
if (string.IsNullOrEmpty(lobSystemInstanceName) || string.IsNullOrEmpty(specificFinderName) ||
string.IsNullOrEmpty(finderName))
{
return(false);
}
string newExternalDataListName = entityName + "DataList";
ISharePointProjectItem existingProjectItem = (from ISharePointProjectItem existingItem in projectItem.Project.ProjectItems
where existingItem.Name == newExternalDataListName
select existingItem).FirstOrDefault();
// Add a new list instance and populate it with data from the BDC model.
if (existingProjectItem == null)
{
ISharePointProjectItem newExternalDataList = projectItem.Project.ProjectItems.Add(newExternalDataListName,
"Microsoft.VisualStudio.SharePoint.ListInstance");
string newExternalDataListString = externalDataListContent;
newExternalDataListString = newExternalDataListString.Replace("$EntityName$", entityName);
newExternalDataListString = newExternalDataListString.Replace("$LobSystemInstance$", lobSystemInstanceName);
newExternalDataListString = newExternalDataListString.Replace("$EntityNamespace$", entity.Attribute("Namespace").Value);
newExternalDataListString = newExternalDataListString.Replace("$SpecificFinder$", specificFinderName);
newExternalDataListString = newExternalDataListString.Replace("$Finder$", finderName);
string elementsXmlPath = Path.Combine(newExternalDataList.FullPath, "Elements.xml");
File.WriteAllText(elementsXmlPath, newExternalDataListString);
ISharePointProjectItemFile elementsFile = newExternalDataList.Files.AddFromFile(elementsXmlPath);
elementsFile.DeploymentType = DeploymentType.ElementManifest;
}
return(true);
}
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());
}
}
internal SiteColumnProperties(ISharePointProjectItem projectItem)
{
this.projectItem = projectItem;
}
internal CustomActionProperties(ISharePointProjectItem projectItem)
{
this.projectItem = projectItem;
}
/// <summary>
/// Create a new instance of the SharePointProjectItemArtefact object.
/// </summary>
/// <param name="item"></param>
public SharePointProjectItemArtefact(ISharePointProjectItem item)
{
this.item = item;
}
internal CustomActionProperties(ISharePointProjectItem projectItem)
{
this.projectItem = projectItem;
}
/// <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);
}
/// <summary>
/// Initializes a new instance of the <see cref="FullTrustProxyProperties"/> class.
/// </summary>
/// <param name="proxy">The proxy.</param>
/// <param name="projectItem">The project item.</param>
public FullTrustProxyProperties(FullTrustProxyTypeProvider proxy, ISharePointProjectItem projectItem)
{
Proxy = proxy;
ProjectItem = projectItem;
}
/// <summary>
/// returns the relative path of the item in the final sharepoint folder
/// </summary>
/// <param name="dte"></param>
/// <param name="selectedItem"></param>
/// <returns></returns>
public static string GetDeploymentPathOfItem(DTE dte, ProjectItem selectedItem)
{
//1. trying to use VS 2010
try
{
ISharePointProjectService projectService = Helpers2.GetSharePointProjectService(dte);
try
{
ISharePointProjectItemFile selectedSharePointItem = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectItemFile>(selectedItem);
string path = selectedSharePointItem.DeploymentRoot + selectedSharePointItem.DeploymentPath + selectedSharePointItem.Name; //= {SharePointRoot}\\Template\\
if (path.StartsWith("{SharePointRoot}"))
{
path = path.Replace("{SharePointRoot}", "");
}
if (path.Contains("{FeatureName}"))
{
//ok, element is part of a feature, need to find the feature where the element is located
string parentFeatureName = "";
ISharePointProjectItem sharePointItem = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectItem>(selectedItem);
if (sharePointItem == null)
{
if (selectedItem.Collection.Parent is ProjectItem)
{
sharePointItem = projectService.Convert <EnvDTE.ProjectItem, ISharePointProjectItem>(selectedItem.Collection.Parent as ProjectItem);
}
}
foreach (ISharePointProject project in projectService.Projects)
{
foreach (ISharePointProjectFeature feature in project.Features)
{
if (feature.ProjectItems.Contains(sharePointItem))
{
parentFeatureName = feature.Name;
}
}
}
path = path.Replace("{FeatureName}", parentFeatureName);
}
return(path);
}
catch { }
}
catch { }
//ok, we have HIVE format!
//structure could be 12, 14, oder SharePointRoot
string projectfolder = Path.GetDirectoryName(Helpers.GetFullPathOfProjectItem(selectedItem.ContainingProject));
string itemFullPath = Helpers.GetFullPathOfProjectItem(selectedItem);
string itemRelativePath = itemFullPath.Substring(projectfolder.Length + 1);
if (itemRelativePath.StartsWith("12"))
{
return(itemRelativePath.Substring(2));
}
else if (itemRelativePath.StartsWith("14"))
{
return(itemRelativePath.Substring(2));
}
else if (itemRelativePath.StartsWith("15"))
{
return(itemRelativePath.Substring(2));
}
else if (itemRelativePath.StartsWith("SharePointRoot", StringComparison.InvariantCultureIgnoreCase))
{
return(itemRelativePath.Substring(14));
}
return("");
}