public static void RemovePackageFiles(this IPackage package)
{
//For Content Files remove the files off disk
foreach (var file in package.GetContentFiles())
{
//Remove File from disk
//Remove File that its package from disk
var fileLocation = file.EffectivePath;
//Map Path from location
var mappedFileLocation = HostingEnvironment.MapPath("~/" + fileLocation);
//Ensure file exists on disk
if (File.Exists(mappedFileLocation))
{
//It exists - so let's delete it
File.Delete(mappedFileLocation);
}
}
//Remove the directories
foreach (var dir in package.GetContentFiles())
{
//Remove File that its package from disk
var fileLocation = dir.EffectivePath;
//Map Path from location
var mappedFileLocation = HostingEnvironment.MapPath("~/" + fileLocation);
//Get the directory to delete
var directoryPath = Path.GetDirectoryName(mappedFileLocation);
//Check direcotry exists
if (Directory.Exists(directoryPath))
{
//Delete the directory
Directory.Delete(directoryPath);
}
}
//For Lib files (aka /bin)
foreach (var file in package.GetLibFiles())
{
//Remove File from to /bin folder
//Copy File from package to /bin folder
var fileLocation = file.EffectivePath;
//Map Path from location
var mappedFileLocation = HostingEnvironment.MapPath("~/bin/" + fileLocation);
//Remove DLL from bin
File.Delete(mappedFileLocation);
}
}
public IEnumerable <string> GetContentFiles()
{
foreach (var file in _package.GetContentFiles())
{
yield return(file.Path);
}
}
public void InstallPackage(IPackage package)
{
var directoryToExpandTo = Path.Combine(_localRepository.Source, package.Id);
foreach (var file in package.GetContentFiles())
{
string pathWithoutContextPrefix = file.Path.Substring("content/".Length);
var fullPath = Path.Combine(directoryToExpandTo, pathWithoutContextPrefix);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = File.OpenWrite(fullPath),
readStream = file.GetStream())
{
readStream.CopyTo(writeStream);
}
}
// If there is no xdt file, generate a default one
string xdtPath = Path.Combine(directoryToExpandTo, "applicationHost.xdt");
if (!File.Exists(xdtPath))
{
var xdtTemplate = new XdtTemplate { Path = package.Id };
File.WriteAllText(xdtPath, xdtTemplate.TransformText().Trim());
}
var packageFile = Path.Combine(
directoryToExpandTo,
String.Format("{0}.{1}.nupkg", package.Id, package.Version));
using (Stream readStream = package.GetStream(),
writeStream = File.OpenWrite(packageFile))
{
readStream.CopyTo(writeStream);
}
}
public static bool IsCompatible(this Project project, IPackage package)
{
if (package == null)
{
return(true);
}
// if there is any file under content/lib which has no target framework, we consider the package
// compatible with any project, because that file will be the fallback if no supported frameworks matches the project's.
// REVIEW: what about install.ps1 and uninstall.ps1?
bool hasFileWithNullTargetFramework = package.GetContentFiles()
.Concat(package.GetLibFiles())
.Any(file => file.TargetFramework == null);
if (hasFileWithNullTargetFramework)
{
return(true);
}
FrameworkName frameworkName = project.GetTargetFrameworkName();
// if the target framework cannot be determined the frameworkName becomes null (for example, for WiX projects).
// indicate it as compatible, because we cannot determine that ourselves. Offer the capability to the end-user.
if (frameworkName == null)
{
return(true);
}
return(VersionUtility.IsCompatible(frameworkName, package.GetSupportedFrameworks()));
}
public static void CopyPackageFiles(this IPackage package)
{
//For Content Files Copy the files to the correct places
foreach (var file in package.GetContentFiles())
{
//Copy File from package to correct location on disk
var fileLocation = file.EffectivePath;
//Map Path from location
var mappedFileLocation = HostingEnvironment.MapPath("~/" + fileLocation);
//Ensure directory exists
if (!Directory.Exists(Path.GetDirectoryName(mappedFileLocation)))
{
//Directory does NOT exist
//Create it
Directory.CreateDirectory(Path.GetDirectoryName(mappedFileLocation));
}
//Get File Contents
var fileContents = file.GetStream();
//Save file to disk
//http://stackoverflow.com/questions/411592/how-do-i-save-a-stream-to-a-file
using (var fileStream = File.Create(mappedFileLocation))
{
fileContents.CopyTo(fileStream);
}
}
//For Lib files (aka /bin)
foreach (var file in package.GetLibFiles())
{
//Copy File from package to /bin folder
var fileLocation = file.EffectivePath;
//Map Path from location
var mappedFileLocation = HostingEnvironment.MapPath("~/bin/" + fileLocation);
//Ensure directory exists (I hope so as it's the /bin folder)
if (!Directory.Exists(Path.GetDirectoryName(mappedFileLocation)))
{
//Directory does NOT exist
//Create it
Directory.CreateDirectory(Path.GetDirectoryName(mappedFileLocation));
}
//Get File Contents
var fileContents = file.GetStream();
//Save file to disk
//http://stackoverflow.com/questions/411592/how-do-i-save-a-stream-to-a-file
using (var fileStream = File.Create(mappedFileLocation))
{
fileContents.CopyTo(fileStream);
}
}
}
private IPackage InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
GenerateApplicationHostXdt(installationDirectory, '/' + package.Id, isPreInstalled: false);
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Id));
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = GetNuGetPackageFile(package.Id, package.Version.ToString());
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return(_localRepository.FindPackage(package.Id));
}
private void RemovePackageReferenceFromProject(IPackage package)
{
string packageFullName = package.GetFullName();
Logger.Log(MessageLevel.Info, NuGetResources.Log_BeginRemovePackageReference, packageFullName, Project.ProjectName);
PackageOperationEventArgs args = CreateOperation(package);
OnPackageReferenceRemoving(args);
if (args.Cancel)
{
return;
}
// Get other packages
IEnumerable <IPackage> otherPackages = from p in LocalRepository.GetPackages()
where p.Id != package.Id
select p;
// Get other references
var otherAssemblyReferences = from p in otherPackages
let assemblyReferences = GetCompatibleItemsForPackage(p.Id, p.AssemblyReferences)
from assemblyReference in assemblyReferences ?? Enumerable.Empty <IPackageAssemblyReference>() // This can happen if package installed left the project in a bad state
select assemblyReference;
// Get content files from other packages
// Exclude transform files since they are treated specially
var otherContentFiles = from p in otherPackages
from file in GetCompatibleItemsForPackage(p.Id, p.GetContentFiles())
where !_fileTransformers.ContainsKey(Path.GetExtension(file.Path))
select file;
// Get the files and references for this package, that aren't in use by any other packages so we don't have to do reference counting
var assemblyReferencesToDelete = GetCompatibleItemsForPackage(package.Id, package.AssemblyReferences)
.Except(otherAssemblyReferences, PackageFileComparer.Default);
var contentFilesToDelete = GetCompatibleItemsForPackage(package.Id, package.GetContentFiles())
.Except(otherContentFiles, PackageFileComparer.Default);
// Delete the content files
Project.DeleteFiles(contentFilesToDelete, otherPackages, _fileTransformers);
// Remove references
foreach (IPackageAssemblyReference assemblyReference in assemblyReferencesToDelete)
{
Project.RemoveReference(assemblyReference.Name);
}
// Remove package to the repository
LocalRepository.RemovePackage(package);
Logger.Log(MessageLevel.Info, NuGetResources.Log_SuccessfullyRemovedPackageReference, packageFullName, Project.ProjectName);
OnPackageReferenceRemoved(args);
}
/// <summary>
/// Returns true if a package has no content that applies to a project.
/// </summary>
public static bool HasProjectContent(this IPackage package)
{
// Note that while checking for both AssemblyReferences and LibFiles seems redundant,
// there are tests that directly inject items into the AssemblyReferences collection
// without having those files represented in the Lib folder. We keep the redundant
// check to play it on the safe side.
return package.FrameworkAssemblies.Any() ||
package.AssemblyReferences.Any() ||
package.GetContentFiles().Any() ||
package.GetLibFiles().Any() ||
package.GetBuildFiles().Any();
}
/// <summary>
/// This method will be called first when a package is installed. We're using
/// this method to perform some pre processing of XDT files in the
/// </summary>
/// <param name="package"></param>
protected override void ExtractPackageFilesToProject(IPackage package)
{
List <IPackageFile> contentFiles = package.GetContentFiles().ToList();
Dictionary <string, string> transformedFiles = new Dictionary <string, string>();
string packageRestorePath = Path.Combine(Project.Root, "App_Data", "PackageRestore");
// go through each *.rock.xdt file and apply the transform first,
foreach (var xdtFile in contentFiles.Where(f => f.Path.EndsWith(TRANSFORM_FILE_PREFIX, StringComparison.OrdinalIgnoreCase)))
{
using (Stream stream = xdtFile.GetStream())
{
var fileName = xdtFile.EffectivePath;
// write the transform file out to the PackageRestore/xdt folder
var transformFilefullPath = Path.Combine(packageRestorePath, "xdt", fileName);
Directory.CreateDirectory(Path.GetDirectoryName(transformFilefullPath));
using (var fileStream = File.Create(transformFilefullPath))
{
stream.CopyTo(fileStream);
}
var sourceFile = fileName.Remove(fileName.Length - TRANSFORM_FILE_PREFIX.Length);
var sourceFileFullPath = Path.Combine(Project.Root, sourceFile);
var tempPathOfTransformedFile = Path.Combine(packageRestorePath, "xdt", sourceFile);
// now transform the Rock file using the xdt file, but write it to the PackageRestore\xdt folder and we'll
// move it into place after the update is finished.
// If the transform fails, then we have to quit and inform the user.
if (!ProcessXmlDocumentTransformation(transformFilefullPath, sourceFileFullPath, tempPathOfTransformedFile))
{
throw new System.Xml.XmlException(sourceFile);
}
transformedFiles.Add(tempPathOfTransformedFile, sourceFile);
}
}
// now let the package installation proceed as normal
base.ExtractPackageFilesToProject(package);
// lastly, move the transformed xml files into place
MoveTransformedFiles(transformedFiles);
try
{
Directory.Delete(packageRestorePath, recursive: true);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, System.Web.HttpContext.Current);
ExceptionLogService.LogException(new Exception(string.Format("Unable to delete package restore folder ({0}) after a successful update.", packageRestorePath)), System.Web.HttpContext.Current);
}
}
/// <summary>
/// This method will be called first when a package is installed. We're using
/// this method to perform some pre processing of XDT files in the
/// </summary>
/// <param name="package"></param>
protected override void ExtractPackageFilesToProject( IPackage package )
{
List<IPackageFile> contentFiles = package.GetContentFiles().ToList();
Dictionary<string, string> transformedFiles = new Dictionary<string, string>();
string packageRestorePath = Path.Combine( Project.Root, "App_Data", "PackageRestore" );
// go through each *.rock.xdt file and apply the transform first,
foreach ( var xdtFile in contentFiles.Where( f => f.Path.EndsWith( TRANSFORM_FILE_PREFIX, StringComparison.OrdinalIgnoreCase ) ) )
{
using ( Stream stream = xdtFile.GetStream() )
{
var fileName = xdtFile.EffectivePath;
// write the transform file out to the PackageRestore/xdt folder
var transformFilefullPath = Path.Combine( packageRestorePath, "xdt", fileName );
Directory.CreateDirectory( Path.GetDirectoryName( transformFilefullPath ) );
using ( var fileStream = File.Create( transformFilefullPath ) )
{
stream.CopyTo( fileStream );
}
var sourceFile = fileName.Remove( fileName.Length - TRANSFORM_FILE_PREFIX.Length );
var sourceFileFullPath = Path.Combine( Project.Root, sourceFile );
var tempPathOfTransformedFile = Path.Combine( packageRestorePath, "xdt", sourceFile );
// now transform the Rock file using the xdt file, but write it to the PackageRestore\xdt folder and we'll
// move it into place after the update is finished.
// If the transform fails, then we have to quit and inform the user.
if ( !ProcessXmlDocumentTransformation( transformFilefullPath, sourceFileFullPath, tempPathOfTransformedFile ) )
{
throw new System.Xml.XmlException( sourceFile );
}
transformedFiles.Add( tempPathOfTransformedFile, sourceFile );
}
}
// now let the package installation proceed as normal
base.ExtractPackageFilesToProject( package );
// lastly, move the transformed xml files into place
MoveTransformedFiles( transformedFiles );
try
{
Directory.Delete( packageRestorePath, recursive: true );
}
catch ( Exception ex )
{
ExceptionLogService.LogException( ex, System.Web.HttpContext.Current );
ExceptionLogService.LogException( new Exception( string.Format( "Unable to delete package restore folder ({0}) after a successful update.", packageRestorePath ) ), System.Web.HttpContext.Current );
}
}
public IPackage InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
string xdtPath = Path.Combine(installationDirectory, "applicationHost.xdt");
if (!FileSystemHelpers.FileExists(xdtPath))
{
string xdtContent = CreateDefaultXdtFile(package.Id);
OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = Path.Combine(installationDirectory,
String.Format("{0}.{1}.nupkg", package.Id, package.Version));
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
return(null);
}
return(_localRepository.FindPackage(package.Id));
}
private static List <ManifestFile> CreateManifestCotentsFiles(IPackage package, string destination)
{
List <ManifestFile> manifestFiles = new List <ManifestFile>();
ExtractContent(package, destination);
foreach (IPackageFile packageFile in package.GetContentFiles())
{
ManifestFile file = new ManifestFile();
file.Source = Path.Combine(destination, package.Id, packageFile.Path);
file.Target = packageFile.Path;
manifestFiles.Add(file);
}
return(manifestFiles);
}
protected virtual void ExtractPackageFilesToProject(IPackage package)
{
// BUG 491: Installing a package with incompatible binaries still does a partial install.
// Resolve assembly references first so that if this fails we never do anything to the project
IEnumerable <IPackageAssemblyReference> assemblyReferences = Project.GetCompatibleItems(package.AssemblyReferences, NuGetResources.AssemblyReferences);
IEnumerable <FrameworkAssemblyReference> frameworkReferences = Project.GetCompatibleItems(package.FrameworkAssemblies, NuGetResources.FrameworkAssemblies);
try {
// Add content files
Project.AddFiles(package.GetContentFiles(), _fileTransformers);
// Add the references to the reference path
foreach (IPackageAssemblyReference assemblyReference in assemblyReferences)
{
// Get the physical path of the assembly reference
string referencePath = Path.Combine(PathResolver.GetInstallPath(package), assemblyReference.Path);
string relativeReferencePath = PathUtility.GetRelativePath(Project.Root, referencePath);
if (Project.ReferenceExists(assemblyReference.Name))
{
Project.RemoveReference(assemblyReference.Name);
}
using (Stream stream = assemblyReference.GetStream()) {
Project.AddReference(relativeReferencePath, stream);
}
}
// Add GAC/Framework references
foreach (FrameworkAssemblyReference frameworkReference in frameworkReferences)
{
if (!Project.ReferenceExists(frameworkReference.AssemblyName))
{
Project.AddFrameworkReference(frameworkReference.AssemblyName);
}
}
}
finally {
// Add package to local repository in the finally so that the user can uninstall it
// if any exception occurs. This is easier than rolling back since the user can just
// manually uninstall things that may have failed.
// If this fails then the user is out of luck.
LocalRepository.AddPackage(package);
}
}
private void InstallIntoWorkspace(ApplicationWorkspace workspace, IPackage package)
{
var projectDirectory = workspace.GetProjectDirectory(_settings);
if (!Directory.Exists(projectDirectory))
{
Directory.CreateDirectory(projectDirectory);
}
foreach (var libFile in FilterCompatibles(package.AssemblyReferences))
{
using (var file = new FileStream(Path.Combine(projectDirectory, libFile.Name), FileMode.Create, FileAccess.ReadWrite))
{
libFile.GetStream().CopyTo(file);
}
}
if (package.Id == _settings.PackageId) // only install content from base package
{
foreach (var contentFile in FilterCompatibles(package.GetContentFiles()))
{
var targetPath = Path.Combine(projectDirectory, contentFile.EffectivePath);
if (File.Exists(targetPath))
{
if (_settings.PreservedFiles.Contains(contentFile.EffectivePath))
{
continue;
}
}
var targetDirectory = Path.GetDirectoryName(targetPath);
if (!Directory.Exists(targetDirectory))
{
Directory.CreateDirectory(targetDirectory);
}
using (var file = new FileStream(targetPath, FileMode.Create, FileAccess.ReadWrite))
{
contentFile.GetStream().CopyTo(file);
}
}
}
}
/// <summary>
/// Create and save new NuGet package.
/// </summary>
/// <param name="packageInfo">The package information.</param>
/// <param name="project">The project.</param>
/// <param name="source">The source.</param>
/// <param name="destination">The destination.</param>
/// <param name="preRelease">if set to <c>true</c> [pre release].</param>
/// <returns></returns>
private static bool CreateNuGet(
NuGetPackageInfo packageInfo,
ProjectInfo project,
string source,
string destination,
bool preRelease,
OperationContext context)
{
IPackage package = packageInfo.NuGetPackage;
PackageBuilder builder = new PackageBuilder();
var manifestFiles = CreateManifestFiles(source, package.GetLibFiles());
builder.PopulateFiles(source, manifestFiles);
if (package.GetContentFiles().Any())
{
var manifestContentFiles = CreateManifestCotentsFiles(
package,
destination);
builder.PopulateFiles("", manifestContentFiles);
}
var manifestMetadata = CreateManifestMetadata(package, project, source, destination, preRelease, context);
if (manifestMetadata == null)
{
return(false);
}
builder.Populate(manifestMetadata);
var packageName = $"{package.Id}.{manifestMetadata.Version}.nupkg";
packageInfo.NewPackageName = packageName;
string packageFile = Path.Combine(destination, packageName);
using (FileStream stream = File.Open(packageFile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None))
{
builder.Save(stream);
}
return(true);
}
public void InstallPackage(IPackage package)
{
var directoryToExpandTo = Path.Combine(_localRepository.Source, package.Id);
foreach (var file in package.GetContentFiles())
{
string pathWithoutContextPrefix = file.Path.Substring("content/".Length);
var fullPath = Path.Combine(directoryToExpandTo, pathWithoutContextPrefix);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = File.OpenWrite(fullPath),
readStream = file.GetStream())
{
readStream.CopyTo(writeStream);
}
}
// If there is no xdt file, generate a default one
string xdtPath = Path.Combine(directoryToExpandTo, "applicationHost.xdt");
if (!File.Exists(xdtPath))
{
var xdtTemplate = new XdtTemplate {
Path = package.Id
};
File.WriteAllText(xdtPath, xdtTemplate.TransformText().Trim());
}
var packageFile = Path.Combine(
directoryToExpandTo,
String.Format("{0}.{1}.nupkg", package.Id, package.Version));
using (Stream readStream = package.GetStream(),
writeStream = File.OpenWrite(packageFile))
{
readStream.CopyTo(writeStream);
}
}
public static void UninstallFromPackageXml(this IPackage package)
{
//Check to swee if we have a package.xml file in the root of the Contents folder
var checkForPackageXML = package.GetContentFiles().SingleOrDefault(x => x.EffectivePath.EndsWith("\\package.xml"));
//Check to see if we found the file
if (checkForPackageXML != null)
{
//Found the package.xml file - let's use it
//Actual path to xml file
var mappedFileLocation = HostingEnvironment.MapPath("~/" + checkForPackageXML.EffectivePath);
//Load the package.xml file into XDocument so we can use it with packaging service
var packageXML = new XmlDocument();
packageXML.Load(mappedFileLocation);
//XElement - DataTypeDefinitions
//Xml as XElement which is used with the new PackagingService
var rootElement = packageXML.DocumentElement.GetXElement();
//Run Uninstall Package Actions
foreach (XmlNode n in packageXML.DocumentElement.SelectNodes("Actions/Action"))
{
if (n.Attributes["runat"] != null && n.Attributes["runat"].Value == "install")
{
try
{
umbraco.cms.businesslogic.packager.PackageAction.UndoPackageAction(package.Id, n.Attributes["alias"].Value, n);
}
catch
{
}
}
}
}
}
public void InstallPackage(IPackage package)
{
var directoryToExpandTo = Path.Combine(_localRepository.Source, package.Id);
foreach (var file in package.GetContentFiles())
{
string pathWithoutContextPrefix = file.Path.Substring("content/".Length);
var fullPath = Path.Combine(directoryToExpandTo, pathWithoutContextPrefix);
Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = File.OpenWrite(fullPath),
readStream = file.GetStream())
{
readStream.CopyTo(writeStream);
}
}
var packageFile = Path.Combine(directoryToExpandTo, package.GetFullName() + ".nupkg");
using (Stream readStream = package.GetStream(),
writeStream = File.OpenWrite(packageFile))
{
readStream.CopyTo(writeStream);
}
}
public void InstallPackages(DirectoryPath absolutePackagesPath, IFileSystem fileSystem, bool updatePackages)
{
PackageManager packageManager = new PackageManager(_packageRepository, absolutePackagesPath.FullPath);
// Install the packages
foreach (Package package in _packages)
{
IPackage installedPackage = package.InstallPackage(packageManager, updatePackages);
if (installedPackage != null)
{
// Add the content path(s) to the input paths if there are content files
// We need to use the directory name from an actual file to make sure we get the casing right
foreach (string contentSegment in installedPackage.GetContentFiles()
.Select(x => new DirectoryPath(x.Path).Segments[0])
.Distinct())
{
string installPath = packageManager.PathResolver.GetInstallPath(installedPackage);
fileSystem.InputPaths.Insert(0, new DirectoryPath(installPath).Combine(contentSegment));
}
}
}
}
public static string InstallExecutablePackage(IPackage package, IFileSystem fileSystem)
{
var targetId = Path.GetFileName(fileSystem.Root);
var targetEntryPoint = targetId + Constants.BonsaiExtension;
var targetEntryPointLayout = targetEntryPoint + Constants.LayoutExtension;
var packageEntryPoint = package.Id + Constants.BonsaiExtension;
var packageEntryPointLayout = packageEntryPoint + Constants.LayoutExtension;
foreach (var file in package.GetContentFiles())
{
var effectivePath = file.EffectivePath;
if (effectivePath == packageEntryPoint)
{
effectivePath = targetEntryPoint;
}
else if (effectivePath == packageEntryPointLayout)
{
effectivePath = targetEntryPointLayout;
}
using (var stream = file.GetStream())
{
fileSystem.AddFile(effectivePath, stream);
}
}
var manifest = Manifest.Create(package);
var metadata = Manifest.Create(manifest.Metadata);
var metadataPath = targetId + global::NuGet.Constants.ManifestExtension;
using (var stream = fileSystem.CreateFile(metadataPath))
{
metadata.Save(stream);
}
return(fileSystem.GetFullPath(targetEntryPoint));
}
private IPackage InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
GenerateApplicationHostXdt(installationDirectory, '/' + package.Id, isPreInstalled: false);
OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Id));
var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
string installScript = Path.Combine(installationDirectory, _installScriptName);
if (FileSystemHelpers.FileExists(installScript))
{
OperationManager.Attempt(() =>
{
Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
installationDirectory,
_settings.GetCommandIdleTimeout(), NullLogger.Instance);
exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
});
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = GetNuGetPackageFile(package.Id, package.Version.ToString());
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
throw;
}
return _localRepository.FindPackage(package.Id);
}
protected virtual void ExtractPackageFilesToProject(IPackage package)
{
// BUG 491: Installing a package with incompatible binaries still does a partial install.
// Resolve assembly references and content files first so that if this fails we never do anything to the project
List <IPackageAssemblyReference> assemblyReferences = Project.GetCompatibleItemsCore(package.AssemblyReferences).ToList();
List <FrameworkAssemblyReference> frameworkReferences = Project.GetCompatibleItemsCore(package.FrameworkAssemblies).ToList();
List <IPackageFile> contentFiles = Project.GetCompatibleItemsCore(package.GetContentFiles()).ToList();
List <IPackageFile> buildFiles = Project.GetCompatibleItemsCore(package.GetBuildFiles()).ToList();
// If the package doesn't have any compatible assembly references or content files,
// throw, unless it's a meta package.
if (assemblyReferences.Count == 0 && frameworkReferences.Count == 0 && contentFiles.Count == 0 && buildFiles.Count == 0 &&
(package.FrameworkAssemblies.Any() || package.AssemblyReferences.Any() || package.GetContentFiles().Any() || package.GetBuildFiles().Any()))
{
// for portable framework, we want to show the friendly short form (e.g. portable-win8+net45+wp8) instead of ".NETPortable, Profile=Profile104".
FrameworkName targetFramework = Project.TargetFramework;
string targetFrameworkString = targetFramework.IsPortableFramework()
? VersionUtility.GetShortFrameworkName(targetFramework)
: targetFramework != null?targetFramework.ToString() : null;
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnableToFindCompatibleItems, package.GetFullName(), targetFrameworkString));
}
// IMPORTANT: this filtering has to be done AFTER the 'if' statement above,
// so that we don't throw the exception in case the <References> filters out all assemblies.
FilterAssemblyReferences(assemblyReferences, package.PackageAssemblyReferences);
try
{
// Log target framework info for debugging
LogTargetFrameworkInfo(package, assemblyReferences, contentFiles, buildFiles);
// Add content files
Project.AddFiles(contentFiles, _fileTransformers);
// Add the references to the reference path
foreach (IPackageAssemblyReference assemblyReference in assemblyReferences)
{
if (assemblyReference.IsEmptyFolder())
{
continue;
}
// Get the physical path of the assembly reference
string referencePath = Path.Combine(PathResolver.GetInstallPath(package), assemblyReference.Path);
string relativeReferencePath = PathUtility.GetRelativePath(Project.Root, referencePath);
if (Project.ReferenceExists(assemblyReference.Name))
{
Project.RemoveReference(assemblyReference.Name);
}
Project.AddReference(relativeReferencePath);
}
// Add GAC/Framework references
foreach (FrameworkAssemblyReference frameworkReference in frameworkReferences)
{
if (!Project.ReferenceExists(frameworkReference.AssemblyName))
{
Project.AddFrameworkReference(frameworkReference.AssemblyName);
}
}
foreach (var importFile in buildFiles)
{
string fullImportFilePath = Path.Combine(PathResolver.GetInstallPath(package), importFile.Path);
Project.AddImport(
fullImportFilePath,
importFile.Path.EndsWith(".props", StringComparison.OrdinalIgnoreCase) ? ProjectImportLocation.Top : ProjectImportLocation.Bottom);
}
}
finally
{
if (_packageReferenceRepository != null)
{
// save the used project's framework if the repository supports it.
_packageReferenceRepository.AddPackage(package.Id, package.Version, package.DevelopmentDependency, Project.TargetFramework);
}
else
{
// Add package to local repository in the finally so that the user can uninstall it
// if any exception occurs. This is easier than rolling back since the user can just
// manually uninstall things that may have failed.
// If this fails then the user is out of luck.
LocalRepository.AddPackage(package);
}
}
}
private void RemovePackageReferenceFromProject(IPackage package)
{
if (IsNuGetAwareProject())
{
RemovePackageReferenceFromNuGetAwareProject(package);
return;
}
string packageFullName = package.GetFullName();
Logger.Log(MessageLevel.Info, NuGetResources.Log_BeginRemovePackageReference, packageFullName, Project.ProjectName);
PackageOperationEventArgs args = CreateOperation(package);
OnPackageReferenceRemoving(args);
if (args.Cancel)
{
return;
}
// Get other packages
IEnumerable <IPackage> otherPackages = from p in LocalRepository.GetPackages()
where p.Id != package.Id
select p;
// Get other references
var otherAssemblyReferences = from p in otherPackages
let assemblyReferences = GetFilteredAssembliesToDelete(p)
from assemblyReference in assemblyReferences ?? Enumerable.Empty <IPackageAssemblyReference>() // This can happen if package installed left the project in a bad state
select assemblyReference;
// Get content files from other packages
// Exclude transform files since they are treated specially
var otherContentFiles = from p in otherPackages
from file in GetCompatibleInstalledItemsForPackage(p.Id, p.GetContentFiles(), NetPortableProfileTable.Default)
where !IsTransformFile(file.Path)
select file;
// Get the files and references for this package, that aren't in use by any other packages so we don't have to do reference counting
var assemblyReferencesToDelete = GetFilteredAssembliesToDelete(package)
.Except(otherAssemblyReferences, PackageFileComparer.Default);
var contentFilesToDelete = GetCompatibleInstalledItemsForPackage(package.Id, package.GetContentFiles(), NetPortableProfileTable.Default)
.Except(otherContentFiles, PackageFileComparer.Default);
var buildFilesToDelete = GetCompatibleInstalledItemsForPackage(package.Id, package.GetBuildFiles(), NetPortableProfileTable.Default);
// Delete the content files
Project.DeleteFiles(contentFilesToDelete, otherPackages, _fileTransformers);
// Remove references
foreach (IPackageAssemblyReference assemblyReference in assemblyReferencesToDelete)
{
Project.RemoveReference(assemblyReference.Name);
}
// remove the <Import> statement from projects for the .targets and .props files
foreach (var importFile in buildFilesToDelete)
{
string fullImportFilePath = Path.Combine(PathResolver.GetInstallPath(package), importFile.Path);
Project.RemoveImport(fullImportFilePath);
}
// Remove package to the repository
LocalRepository.RemovePackage(package);
Logger.Log(MessageLevel.Info, NuGetResources.Log_SuccessfullyRemovedPackageReference, packageFullName, Project.ProjectName);
OnPackageReferenceRemoved(args);
}
public static bool HasFileWithNullTargetFramework(this IPackage package)
{
return package.GetContentFiles()
.Concat(package.GetLibFiles())
.Any(file => file.TargetFramework == null);
}
protected virtual void ExtractPackageFilesToProject(IPackage package)
{
List <IPackageAssemblyReference> assemblyReferences = this.Project.GetCompatibleItemsCore <IPackageAssemblyReference>(package.AssemblyReferences).ToList <IPackageAssemblyReference>();
List <FrameworkAssemblyReference> list2 = this.Project.GetCompatibleItemsCore <FrameworkAssemblyReference>(package.FrameworkAssemblies).ToList <FrameworkAssemblyReference>();
List <IPackageFile> contentFiles = this.Project.GetCompatibleItemsCore <IPackageFile>(package.GetContentFiles()).ToList <IPackageFile>();
List <IPackageFile> buildFiles = this.Project.GetCompatibleItemsCore <IPackageFile>(package.GetBuildFiles()).ToList <IPackageFile>();
if ((assemblyReferences.Count == 0) && ((list2.Count == 0) && ((contentFiles.Count == 0) && ((buildFiles.Count == 0) && (package.FrameworkAssemblies.Any <FrameworkAssemblyReference>() || (package.AssemblyReferences.Any <IPackageAssemblyReference>() || (package.GetContentFiles().Any <IPackageFile>() || package.GetBuildFiles().Any <IPackageFile>())))))))
{
FrameworkName targetFramework = this.Project.TargetFramework;
string str = targetFramework.IsPortableFramework() ? VersionUtility.GetShortFrameworkName(targetFramework) : targetFramework?.ToString();
object[] args = new object[] { package.GetFullName(), str };
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, NuGetResources.UnableToFindCompatibleItems, args));
}
this.FilterAssemblyReferences(assemblyReferences, package.PackageAssemblyReferences);
try
{
this.LogTargetFrameworkInfo(package, assemblyReferences, contentFiles, buildFiles);
this.Project.AddFiles(contentFiles, this._fileTransformers);
foreach (IPackageAssemblyReference reference in assemblyReferences)
{
if (!reference.IsEmptyFolder())
{
string str2 = Path.Combine(this.PathResolver.GetInstallPath(package), reference.Path);
string relativePath = PathUtility.GetRelativePath(this.Project.Root, str2);
if (this.Project.ReferenceExists(reference.Name))
{
this.Project.RemoveReference(reference.Name);
}
this.Project.AddReference(relativePath);
}
}
foreach (FrameworkAssemblyReference reference2 in list2)
{
if (!this.Project.ReferenceExists(reference2.AssemblyName))
{
this.Project.AddFrameworkReference(reference2.AssemblyName);
}
}
foreach (IPackageFile file in buildFiles)
{
string targetFullPath = Path.Combine(this.PathResolver.GetInstallPath(package), file.Path);
this.Project.AddImport(targetFullPath, file.Path.EndsWith(".props", StringComparison.OrdinalIgnoreCase) ? ProjectImportLocation.Top : ProjectImportLocation.Bottom);
}
}
finally
{
if (this._packageReferenceRepository != null)
{
this._packageReferenceRepository.AddPackage(package.Id, package.Version, package.DevelopmentDependency, this.Project.TargetFramework);
}
else
{
this.LocalRepository.AddPackage(package);
}
}
}
protected virtual void ExtractPackageFilesToProject(IPackage package)
{
// BUG 491: Installing a package with incompatible binaries still does a partial install.
// Resolve assembly references and content files first so that if this fails we never do anything to the project
IList <IPackageAssemblyReference> assemblyReferences = Project.GetCompatibleItemsCore(package.AssemblyReferences).ToList();
IList <FrameworkAssemblyReference> frameworkReferences = Project.GetCompatibleItemsCore(package.FrameworkAssemblies).ToList();
IList <IPackageFile> contentFiles = Project.GetCompatibleItemsCore(package.GetContentFiles()).ToList();
// If the package doesn't have any compatible assembly references or content files,
// throw, unless it's a meta package.
if (assemblyReferences.Count == 0 && frameworkReferences.Count == 0 && contentFiles.Count == 0 &&
(package.FrameworkAssemblies.Any() || package.AssemblyReferences.Any() || package.GetContentFiles().Any()))
{
// for portable framework, we want to show the friendly short form (e.g. portable-win8+net45+wp8) instead of ".NETPortable, Profile=Profile104".
string targetFrameworkString = VersionUtility.IsPortableFramework(Project.TargetFramework)
? VersionUtility.GetShortFrameworkName(Project.TargetFramework)
: Project.TargetFramework.ToString();
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.UnableToFindCompatibleItems, package.GetFullName(), targetFrameworkString));
}
try
{
// Add content files
Project.AddFiles(contentFiles, _fileTransformers);
// Add the references to the reference path
foreach (IPackageAssemblyReference assemblyReference in assemblyReferences)
{
if (assemblyReference.IsEmptyFolder())
{
continue;
}
// Get the physical path of the assembly reference
string referencePath = Path.Combine(PathResolver.GetInstallPath(package), assemblyReference.Path);
string relativeReferencePath = PathUtility.GetRelativePath(Project.Root, referencePath);
if (Project.ReferenceExists(assemblyReference.Name))
{
Project.RemoveReference(assemblyReference.Name);
}
// The current implementation of all ProjectSystem does not use the Stream parameter at all.
// We can't change the API now, so just pass in a null stream.
Project.AddReference(relativeReferencePath, Stream.Null);
}
// Add GAC/Framework references
foreach (FrameworkAssemblyReference frameworkReference in frameworkReferences)
{
if (!Project.ReferenceExists(frameworkReference.AssemblyName))
{
Project.AddFrameworkReference(frameworkReference.AssemblyName);
}
}
}
finally
{
if (_packageReferenceRepository != null)
{
// save the used project's framework if the repository supports it.
_packageReferenceRepository.AddPackage(package.Id, package.Version, Project.TargetFramework);
}
else
{
// Add package to local repository in the finally so that the user can uninstall it
// if any exception occurs. This is easier than rolling back since the user can just
// manually uninstall things that may have failed.
// If this fails then the user is out of luck.
LocalRepository.AddPackage(package);
}
}
}
public static bool HasFileWithNullTargetFramework(this IPackage package) => Enumerable.Any <IPackageFile>(package.GetContentFiles().Concat <IPackageFile>(package.GetLibFiles()), file => file.TargetFramework == null);
private IEnumerable <IPackageFile> GetTransformFiles(IPackage package)
{
return(package.GetContentFiles().Where(IsTransformFile));
}
private static IEnumerable<Tuple<IPackageFile, string>> GetFiles(IPackage package)
{
if (package.GetLibFiles().IsEmpty() && package.GetContentFiles().IsEmpty()) {
foreach (var packageFile in package.GetFiles()) {
yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path);
}
} else {
// TODO: net40 is hard-coded. Some day more frameworks should be supported
foreach (var packageFile in package.GetLibFiles()) {
yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path.Substring(@"lib\net40\".Length));
}
foreach (var packageFile in package.GetContentFiles()) {
yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path.Substring(@"content\".Length));
}
}
}
public static bool HasProjectContent(this IPackage package) => (package.FrameworkAssemblies.Any <FrameworkAssemblyReference>() || (package.AssemblyReferences.Any <IPackageAssemblyReference>() || (package.GetContentFiles().Any <IPackageFile>() || (package.GetLibFiles().Any <IPackageFile>() || package.GetBuildFiles().Any <IPackageFile>()))));
/// <summary>
/// Returns true if a package has no content that applies to a project.
/// </summary>
public static bool HasProjectContent(this IPackage package)
{
return(package.FrameworkAssemblies.Any() ||
package.AssemblyReferences.Any() ||
package.GetContentFiles().Any());
}
public bool InstallExtension(IPackage package, string installationDirectory)
{
try
{
if (FileSystemHelpers.DirectoryExists(installationDirectory))
{
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
}
foreach (IPackageFile file in package.GetContentFiles())
{
// It is necessary to place applicationHost.xdt under site extension root.
string contentFilePath = file.Path.Substring("content/".Length);
string fullPath = Path.Combine(installationDirectory, contentFilePath);
FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
// If there is no xdt file, generate default.
string xdtPath = Path.Combine(installationDirectory, "applicationHost.xdt");
if (!FileSystemHelpers.FileExists(xdtPath))
{
string xdtContent = CreateDefaultXdtFile(package.Id);
OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
}
// Copy nupkg file for package list/lookup
FileSystemHelpers.CreateDirectory(installationDirectory);
string packageFilePath = Path.Combine(installationDirectory,
String.Format("{0}.{1}.nupkg", package.Id, package.Version));
using (
Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
{
OperationManager.Attempt(() => readStream.CopyTo(writeStream));
}
}
catch (Exception ex)
{
ITracer tracer = _traceFactory.GetTracer();
tracer.TraceError(ex);
FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
return false;
}
return true;
}
private void ShowMessageAndReadme(IPackage package, string message)
{
var files = package.GetContentFiles();
string filePath = null;
if (files != null)
{
var readme = files.FirstOrDefault(
(file) => file.Path.Equals("ReadMe.txt", StringComparison.OrdinalIgnoreCase));
if (readme == null)
{
readme = files.FirstOrDefault(
(file) => file.Path.IndexOf("ReadMe.txt", StringComparison.OrdinalIgnoreCase) >= 0);
}
string text = null;
if (readme != null)
{
try
{
using (var stream = readme.GetStream())
{
using (var reader = new StreamReader(stream))
{
text = reader.ReadToEnd();
}
}
if (!string.IsNullOrWhiteSpace(text))
{
var tempFilePath = Path.GetTempFileName();
lock (_lock)
{
if (!_cleanupAdded)
{
var dispatcher = TryGetDispatcher();
if (dispatcher != null)
{
dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)AddExitCleanUp);
}
}
}
File.WriteAllText(tempFilePath, text);
filePath = tempFilePath;
lock (_lock)
{
_tempFilesToDelete.Add(filePath);
}
}
}
catch (Exception ex)
{
Debug.Fail(ex.ToString());
}
}
}
if (filePath != null)
{
_webMatrixHost.ShowNotification(message, Resources.ClickForReadme, () => ShowReadMe(filePath, true));
}
else
{
_webMatrixHost.ShowNotification(message);
}
}
private void ShowMessageAndReadme(IPackage package, string message)
{
var files = package.GetContentFiles();
string filePath = null;
if (files != null)
{
var readme = files.FirstOrDefault(
(file) => file.Path.Equals("ReadMe.txt", StringComparison.OrdinalIgnoreCase));
if (readme == null)
{
readme = files.FirstOrDefault(
(file) => file.Path.IndexOf("ReadMe.txt", StringComparison.OrdinalIgnoreCase) >= 0);
}
string text = null;
if (readme != null)
{
try
{
using (var stream = readme.GetStream())
{
using (var reader = new StreamReader(stream))
{
text = reader.ReadToEnd();
}
}
if (!string.IsNullOrWhiteSpace(text))
{
var tempFilePath = Path.GetTempFileName();
lock (_lock)
{
if (!_cleanupAdded)
{
var dispatcher = TryGetDispatcher();
if (dispatcher != null)
{
dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)AddExitCleanUp);
}
}
}
File.WriteAllText(tempFilePath, text);
filePath = tempFilePath;
lock (_lock)
{
_tempFilesToDelete.Add(filePath);
}
}
}
catch (Exception ex)
{
Debug.Fail(ex.ToString());
}
}
}
if (filePath != null)
{
_webMatrixHost.ShowNotification(message, Resources.ClickForReadme, () => ShowReadMe(filePath, true));
}
else
{
_webMatrixHost.ShowNotification(message);
}
}
private IEnumerable<IPackageFile> GetTransformFiles(IPackage package)
{
return package.GetContentFiles().Where(IsTransformFile);
}
public static void InstallFromPackageXml(this IPackage package)
{
//Check to swee if we have a package.xml file in the root of the Contents folder
var checkForPackageXML = package.GetContentFiles().SingleOrDefault(x => x.EffectivePath.EndsWith("\\package.xml"));
//Check to see if we found the file
if (checkForPackageXML != null)
{
//Found the package.xml file - let's use it
//Actual path to xml file
var mappedFileLocation = HostingEnvironment.MapPath("~/" + checkForPackageXML.EffectivePath);
//Load the package.xml file into XDocument so we can use it with packaging service
var packageXML = new XmlDocument();
packageXML.Load(mappedFileLocation);
//Umbraco admin user
var currentUser = User.GetCurrent();
//Code Below heavily lifted from umbraco.core
//https://github.com/umbraco/Umbraco-CMS/blob/d5d4dc95619dd510a4fa9713c593d2a918bcb43b/src/umbraco.cms/businesslogic/Packager/Installer.cs
//XElement - DataTypeDefinitions
//Xml as XElement which is used with the new PackagingService
var rootElement = packageXML.DocumentElement.GetXElement();
var packagingService = ApplicationContext.Current.Services.PackagingService;
//Data Types
var dataTypeElement = rootElement.Descendants("DataTypes").FirstOrDefault();
if (dataTypeElement != null)
{
var dataTypeDefinitions = packagingService.ImportDataTypeDefinitions(dataTypeElement);
}
//Languages
var languageItemsElement = rootElement.Descendants("Languages").FirstOrDefault();
if (languageItemsElement != null)
{
var insertedLanguages = packagingService.ImportLanguages(languageItemsElement);
}
//Dictionary Items
var dictionaryItemsElement = rootElement.Descendants("DictionaryItems").FirstOrDefault();
if (dictionaryItemsElement != null)
{
var insertedDictionaryItems = packagingService.ImportDictionaryItems(dictionaryItemsElement);
}
//Macros
foreach (XmlNode n in packageXML.DocumentElement.SelectNodes("//macro"))
{
//WB: Hopefully this gets a nice packagingService too...
Macro m = Macro.Import(n);
}
//Templates
var templateElement = rootElement.Descendants("Templates").FirstOrDefault();
if (templateElement != null)
{
var templates = packagingService.ImportTemplates(templateElement);
}
//DocumentTypes
//Check whether the root element is a doc type rather then a complete package
var docTypeElement = rootElement.Name.LocalName.Equals("DocumentType") ||
rootElement.Name.LocalName.Equals("DocumentTypes")
? rootElement
: rootElement.Descendants("DocumentTypes").FirstOrDefault();
if (docTypeElement != null)
{
var contentTypes = packagingService.ImportContentTypes(docTypeElement);
}
//Stylesheets
foreach (XmlNode n in packageXML.DocumentElement.SelectNodes("Stylesheets/Stylesheet"))
{
//WB: Hopefully this gets a nice packagingService too...
StyleSheet s = StyleSheet.Import(n, currentUser);
}
//Documents
var documentElement = rootElement.Descendants("DocumentSet").FirstOrDefault();
if (documentElement != null)
{
var content = packagingService.ImportContent(documentElement, -1);
}
//Package Actions
foreach (XmlNode n in packageXML.DocumentElement.SelectNodes("Actions/Action"))
{
if (n.Attributes["runat"] != null && n.Attributes["runat"].Value == "install")
{
try
{
umbraco.cms.businesslogic.packager.PackageAction.RunPackageAction(package.Id, n.Attributes["alias"].Value, n);
}
catch
{
}
}
}
}
}
