Integrating package manager for package updates.

--HG-- branch : dev rename : src/Orchard.Web/Modules/Orchard.Packaging/Services/NugetLogger.cs => src/Orchard.Web/Modules/Orchard.Packaging/Models/NugetLogger.cs rename : src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageData.cs => src/Orchard.Web/Modules/Orchard.Packaging/Models/PackageData.cs rename : src/Orchard.Web/Modules/Orchard.Packaging/Services/PackagingEntry.cs => src/Orchard.Web/Modules/Orchard.Packaging/Models/PackagingEntry.cs
2025-10-15 11:44:58 +08:00 · 2011-02-18 08:21:19 -08:00
parent 3e17f21eaf
commit 6050e585be
35 changed files with 1149 additions and 25 deletions
--- a/src/Orchard.Tests/Stubs/StubReportsCoordinator.cs
+++ b/src/Orchard.Tests/Stubs/StubReportsCoordinator.cs
@@ -7,8 +7,8 @@ namespace Orchard.Tests.Stubs {
            
        }

-        public void Register(string reportKey, string activityName, string title) {
-            
+        public int Register(string reportKey, string activityName, string title) {
+            return 0;
        }
    }
 }
--- a/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs
+++ b/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs
@@ -56,7 +56,7 @@ namespace Orchard.Modules.Controllers {
            IEnumerable<Module> modules = _extensionManager.AvailableExtensions()
                .Where(x => DefaultExtensionTypes.IsModule(x.ExtensionType))
                .Select(extensionDescriptor => new Module(extensionDescriptor) {
-                                IsRecentlyInstalled = _moduleService.UpdateIsRecentlyInstalled(extensionDescriptor)
+                                IsRecentlyInstalled = _moduleService.IsRecentlyInstalled(extensionDescriptor)
                            });

            return View(new ModulesIndexViewModel { 
@@ -76,7 +76,7 @@ namespace Orchard.Modules.Controllers {
                .Select(f => new ModuleFeature {
                                Descriptor = f,
                                IsEnabled = _shellDescriptor.Features.Any(sf => sf.Name == f.Id),
-                                IsRecentlyInstalled = _moduleService.UpdateIsRecentlyInstalled(f.Extension),
+                                IsRecentlyInstalled = _moduleService.IsRecentlyInstalled(f.Extension),
                                NeedsUpdate = featuresThatNeedUpdate.Contains(f.Id)
                            });

--- a/src/Orchard.Web/Modules/Orchard.Modules/Services/IModuleService.cs
+++ b/src/Orchard.Web/Modules/Orchard.Modules/Services/IModuleService.cs
@@ -7,6 +7,6 @@ namespace Orchard.Modules.Services {
        void EnableFeatures(IEnumerable<string> featureNames, bool force);
        void DisableFeatures(IEnumerable<string> featureNames);
        void DisableFeatures(IEnumerable<string> featureNames, bool force);
-        bool UpdateIsRecentlyInstalled(ExtensionDescriptor module);
+        bool IsRecentlyInstalled(ExtensionDescriptor module);
    }
 }
--- a/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs
+++ b/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs
@@ -95,10 +95,10 @@ namespace Orchard.Modules.Services {
        }

        /// <summary>
-        /// Updates the recently installed flag by using the project's last written time.
+        /// Determines if a module was recently installed by using the project's last written time.
        /// </summary>
        /// <param name="descriptor">The extension descriptor.</param>
-        public bool UpdateIsRecentlyInstalled(ExtensionDescriptor descriptor) {
+        public bool IsRecentlyInstalled(ExtensionDescriptor descriptor) {
            string projectFile = GetManifestPath(descriptor);
            if (!string.IsNullOrEmpty(projectFile)) {
                // If project file was modified less than 24 hours ago, the module was recently deployed
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/AdminMenu.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/AdminMenu.cs
@@ -0,0 +1,48 @@
+using System.Linq;
+using Orchard.Environment.Extensions.Models;
+using Orchard.Localization;
+using Orchard.PackageManager.Services;
+using Orchard.Security;
+using Orchard.UI.Navigation;
+
+namespace Orchard.PackageManager {
+    public class AdminMenu : INavigationProvider {
+        private readonly IBackgroundPackageUpdateStatus _backgroundPackageUpdateStatus;
+
+        public AdminMenu(IBackgroundPackageUpdateStatus backgroundPackageUpdateStatus) {
+            _backgroundPackageUpdateStatus = backgroundPackageUpdateStatus;
+        }
+
+        public Localizer T { get; set; }
+        public string MenuName { get { return "admin"; } }
+
+        public void GetNavigation(NavigationBuilder builder) {
+            int modulesUpdateCount = GetUpdateCount(DefaultExtensionTypes.Module);
+            LocalizedString modulesCaption = (modulesUpdateCount == 0 ? T("Updates") : T("Updates ({0})", modulesUpdateCount));
+
+            int themesUpdateCount = GetUpdateCount(DefaultExtensionTypes.Module);
+            LocalizedString themesCaption = (themesUpdateCount == 0 ? T("Updates") : T("Updates ({0})", themesUpdateCount));
+
+            builder.Add(T("Modules"), "20", menu => menu
+                .Add(modulesCaption, "30.0", item => item.Action("ModulesUpdates", "Admin", new { area = "Orchard.PackageManager" })
+                    .Permission(StandardPermissions.SiteOwner).LocalNav()));
+
+            builder.Add(T("Themes"), "25", menu => menu
+                .Add(themesCaption, "30.0", item => item.Action("ThemesUpdates", "Admin", new { area = "Orchard.PackageManager" })
+                    .Permission(StandardPermissions.SiteOwner).LocalNav()));
+        }
+
+        private int GetUpdateCount(string extensionType) {
+            try {
+                // Admin menu should never block, so simply return the result from the background task
+                return _backgroundPackageUpdateStatus.Value == null ?
+                    0 :
+                    _backgroundPackageUpdateStatus.Value.Entries.Where(updatePackageEntry =>
+                        updatePackageEntry.NewVersionToInstall != null &&
+                        updatePackageEntry.ExtensionsDescriptor.ExtensionType.Equals(extensionType)).Count();
+            } catch {
+                return 0;
+            }
+        }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Controllers/AdminController.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Controllers/AdminController.cs
@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Mvc;
+using Orchard.Environment.Extensions.Models;
+using Orchard.Localization;
+using Orchard.Logging;
+using Orchard.PackageManager.Services;
+using Orchard.PackageManager.ViewModels;
+using Orchard.Packaging.Services;
+using Orchard.Reports;
+using Orchard.Reports.Services;
+using Orchard.Security;
+using Orchard.UI.Notify;
+
+namespace Orchard.PackageManager.Controllers {
+    public class AdminController : Controller {
+        private readonly IPackagingSourceManager _packagingSourceManager;
+        private readonly INotifier _notifier;
+        private readonly IPackageUpdateService _packageUpdateService;
+        private readonly IBackgroundPackageUpdateStatus _backgroundPackageUpdateStatus;
+        private readonly IReportsCoordinator _reportsCoordinator;
+        private readonly IReportsManager _reportsManager;
+
+        public AdminController(IOrchardServices services,
+            IPackagingSourceManager packagingSourceManager,
+            INotifier notifier,
+            IPackageUpdateService packageUpdateService,
+            IBackgroundPackageUpdateStatus backgroundPackageUpdateStatus,
+            IReportsCoordinator reportsCoordinator,
+            IReportsManager reportsManager) {
+
+            _packagingSourceManager = packagingSourceManager;
+            _notifier = notifier;
+            _packageUpdateService = packageUpdateService;
+            _backgroundPackageUpdateStatus = backgroundPackageUpdateStatus;
+            _reportsCoordinator = reportsCoordinator;
+            _reportsManager = reportsManager;
+            Services = services;
+
+            T = NullLocalizer.Instance;
+            Logger = NullLogger.Instance;
+        }
+
+        public IOrchardServices Services { get; private set; }
+        public Localizer T { get; set; }
+        public ILogger Logger { get; set; }
+
+        public ActionResult ThemesUpdates(int? reportId) {
+            return PackageUpdate("ThemesUpdate", DefaultExtensionTypes.Theme, reportId);
+        }
+
+        public ActionResult ModulesUpdates(int? reportId) {
+            return PackageUpdate("ModulesUpdate", DefaultExtensionTypes.Theme, reportId);
+        }
+
+        private ActionResult PackageUpdate(string view, string extensionType, int? reportId) {
+            if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to install packages")))
+                return new HttpUnauthorizedResult();
+
+            if (reportId != null)
+                CreateNotificationsFromReport(reportId.Value);
+
+            if (!_packagingSourceManager.GetSources().Any()) {
+                Services.Notifier.Error(T("No Gallery feed configured"));
+                return View(view, new PackageList { Entries = new List<UpdatePackageEntry>() });
+            }
+
+            // Get status from background task state or directly
+            _backgroundPackageUpdateStatus.Value =
+                _backgroundPackageUpdateStatus.Value ??
+                _packageUpdateService.GetPackagesStatus(_packagingSourceManager.GetSources());
+
+            foreach (var error in _backgroundPackageUpdateStatus.Value.Errors) {
+                for (var scan = error; scan != null; scan = scan.InnerException) {
+                    Services.Notifier.Warning(T("Package retrieve error: {0}", scan.Message));
+                }
+            }
+
+            return View(view, new PackageList {
+                Entries = _backgroundPackageUpdateStatus.Value.Entries
+                .Where(updatePackageEntry => updatePackageEntry.ExtensionsDescriptor.ExtensionType.Equals(extensionType))
+            });
+        }
+
+        public ActionResult RefreshThemes() {
+            _packageUpdateService.TriggerRefresh();
+            _backgroundPackageUpdateStatus.Value = null;
+            return RedirectToAction("ThemesUpdates");
+        }
+
+        public ActionResult RefreshModules() {
+            _packageUpdateService.TriggerRefresh();
+            _backgroundPackageUpdateStatus.Value = null;
+            return RedirectToAction("ModulesUpdates");
+        }
+
+        public ActionResult Install(string packageId, string version, int sourceId, string returnUrl) {
+            if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to install packages")))
+                return new HttpUnauthorizedResult();
+
+            _backgroundPackageUpdateStatus.Value =
+                _backgroundPackageUpdateStatus.Value ??
+                _packageUpdateService.GetPackagesStatus(_packagingSourceManager.GetSources());
+
+            var entry = _backgroundPackageUpdateStatus.Value
+                .Entries
+                .SelectMany(e => e.PackageVersions)
+                .Where(e => e.PackageId == packageId && e.Version == version && e.Source.Id == sourceId)
+                .FirstOrDefault();
+            if (entry == null) {
+                return HttpNotFound();
+            }
+
+            try {
+                _packageUpdateService.Update(entry);
+            }
+            catch (Exception exception) {
+                Logger.Error(exception, "Error installing package {0}, version {1} from source {2}", packageId, version, sourceId);
+                _notifier.Error(T("Error installing package update."));
+                for (Exception scan = exception; scan != null; scan = scan.InnerException) {
+                    _notifier.Error(T("{0}", scan.Message));
+                }
+            }
+
+            int reportId = CreateReport(T("Package Update"), T("Update of package {0} to version {1}", packageId, version));
+
+            return RedirectToAction(returnUrl, new { reportId });
+        }
+
+        public ActionResult Uninstall(string packageId, string returnUrl) {
+            if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not authorized to install packages")))
+                return new HttpUnauthorizedResult();
+
+            try {
+                _packageUpdateService.Uninstall(packageId);
+            }
+            catch (Exception exception) {
+                Logger.Error(exception, "Error un-installing package {0}", packageId);
+                _notifier.Error(T("Error un-installing package."));
+                for (Exception scan = exception; scan != null; scan = scan.InnerException) {
+                    _notifier.Error(T("{0}", scan.Message));
+                }
+            }
+
+            int reportId = CreateReport(T("Package Uninstall"), T("Un-installation of package {0}", packageId));
+
+            return RedirectToAction(returnUrl, new { reportId });
+        }
+
+        private void CreateNotificationsFromReport(int reportId) {
+            // If we have notification in TempData, we don't need to display the
+            // report as notifications (i.e. the AppDomain hasn't been restarted)
+            // Note: This relies on an implementation detail of "Orchard.UI.Notify.NotifyFilter"
+            if (TempData["messages"] != null)
+                return;
+
+            var report = _reportsManager.Get(reportId);
+            if (report == null)
+                return;
+
+            if (report.Entries.Any()) {
+                _notifier.Information(T("Application has been restarted. The following notifications originate from report #{0}:", reportId));
+            }
+            foreach(var entry in report.Entries) {
+                switch(entry.Type) {
+                    case ReportEntryType.Information:
+                        _notifier.Add(NotifyType.Information, T(entry.Message));
+                        break;
+                    case ReportEntryType.Warning:
+                        _notifier.Add(NotifyType.Warning, T(entry.Message));
+                        break;
+                    case ReportEntryType.Error:
+                    default:
+                        _notifier.Add(NotifyType.Error, T(entry.Message));
+                        break;
+                }
+            }
+        }
+
+        private int CreateReport(LocalizedString activityName, LocalizedString title) {
+            // Create a persistent report with all notifications, in case the application needs to be restarted
+            const string reportKey = "PackageManager";
+
+            int reportId = _reportsCoordinator.Register(reportKey, activityName.Text, title.Text);
+
+            foreach(var notifyEntry in _notifier.List()) {
+                switch (notifyEntry.Type) {
+                    case NotifyType.Information:
+                        _reportsCoordinator.Add(reportKey, ReportEntryType.Information, notifyEntry.Message.Text);
+                        break;
+                    case NotifyType.Warning:
+                        _reportsCoordinator.Add(reportKey, ReportEntryType.Warning, notifyEntry.Message.Text);
+                        break;
+                    case NotifyType.Error:
+                    default:
+                        _reportsCoordinator.Add(reportKey, ReportEntryType.Error, notifyEntry.Message.Text);
+                        break;
+                }
+            }
+
+            return reportId;
+        }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Module.txt
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Module.txt
@@ -0,0 +1,13 @@
+Name: Orchard.PackageManager
+AntiForgery: enabled
+Author: The Orchard Team
+Website: http://orchardproject.net
+Version: 1.0.20
+OrchardVersion: 1.0.20
+Description: Description for the module
+Features:
+    Orchard.PackageManager:
+        Name: Package Manager
+        Description: Allow package updates.
+        Category: Packaging
+        Dependencies: Gallery
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Orchard.PackageManager.csproj
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Orchard.PackageManager.csproj
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{E66935C0-830B-466E-A571-4AEED7057CBD}</ProjectGuid>
+    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Orchard.PackageManager</RootNamespace>
+    <AssemblyName>Orchard.PackageManager</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <MvcBuildViews>false</MvcBuildViews>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.ComponentModel.DataAnnotations">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Web.DynamicData" />
+    <Reference Include="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\lib\aspnetmvc\System.Web.Mvc.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Web" />
+    <Reference Include="System.Web.Abstractions" />
+    <Reference Include="System.Web.Routing" />
+    <Reference Include="System.Xml" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Xml.Linq" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Web.config" />
+    <Content Include="Views\Web.config" />
+    <Content Include="Properties\AssemblyInfo.cs" />
+    <Content Include="Module.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Orchard\Orchard.Framework.csproj">
+      <Project>{2D1D92BB-4555-4CBE-8D0E-63563D6CE4C6}</Project>
+      <Name>Orchard.Framework</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Core\Orchard.Core.csproj">
+      <Project>{9916839C-39FC-4CEB-A5AF-89CA7E87119F}</Project>
+      <Name>Orchard.Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Orchard.Packaging\Orchard.Packaging.csproj">
+      <Project>{DFD137A2-DDB5-4D22-BE0D-FA9AD4C8B059}</Project>
+      <Name>Orchard.Packaging</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
+  <ItemGroup>
+    <Compile Include="AdminMenu.cs" />
+    <Compile Include="Controllers\AdminController.cs" />
+    <Compile Include="Services\BackgroundPackageUpdateStatus.cs" />
+    <Compile Include="Services\BackgroundPackageUpdateTask.cs" />
+    <Compile Include="Services\FolderUpdater.cs" />
+    <Compile Include="Services\PackageUpdateManager.cs" />
+    <Compile Include="ViewModels\PackageList.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Views\Admin\ModulesUpdate.cshtml" />
+    <Content Include="Views\Admin\ThemesUpdate.cshtml" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target> -->
+  <Target Name="AfterBuild" DependsOnTargets="AfterBuildCompiler">
+    <PropertyGroup>
+      <AreasManifestDir>$(ProjectDir)\..\Manifests</AreasManifestDir>
+    </PropertyGroup>
+    <!-- If this is an area child project, uncomment the following line:
+    <CreateAreaManifest AreaName="$(AssemblyName)" AreaType="Child" AreaPath="$(ProjectDir)" ManifestPath="$(AreasManifestDir)" ContentFiles="@(Content)" />
+    -->
+    <!-- If this is an area parent project, uncomment the following lines:
+    <CreateAreaManifest AreaName="$(AssemblyName)" AreaType="Parent" AreaPath="$(ProjectDir)" ManifestPath="$(AreasManifestDir)" ContentFiles="@(Content)" />
+    <CopyAreaManifests ManifestPath="$(AreasManifestDir)" CrossCopy="false" RenameViews="true" />
+    -->
+  </Target>
+  <Target Name="AfterBuildCompiler" Condition="'$(MvcBuildViews)'=='true'">
+    <AspNetCompiler VirtualPath="temp" PhysicalPath="$(ProjectDir)\..\$(ProjectName)" />
+  </Target>
+  <ProjectExtensions>
+    <VisualStudio>
+      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
+        <WebProjectProperties>
+          <UseIIS>False</UseIIS>
+          <AutoAssignPort>True</AutoAssignPort>
+          <DevelopmentServerPort>45979</DevelopmentServerPort>
+          <DevelopmentServerVPath>/</DevelopmentServerVPath>
+          <IISUrl>
+          </IISUrl>
+          <NTLMAuthentication>False</NTLMAuthentication>
+          <UseCustomServer>True</UseCustomServer>
+          <CustomServerUrl>http://orchard.codeplex.com</CustomServerUrl>
+          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
+        </WebProjectProperties>
+      </FlavorProperties>
+    </VisualStudio>
+  </ProjectExtensions>
+</Project>
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Properties/AssemblyInfo.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Properties/AssemblyInfo.cs
@@ -0,0 +1,34 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Orchard.PackageManager")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyProduct("Orchard")]
+[assembly: AssemblyCopyright("")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("5c928dc2-aa81-4452-99b4-e4c76600c84b")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Services/BackgroundPackageUpdateStatus.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Services/BackgroundPackageUpdateStatus.cs
@@ -0,0 +1,9 @@
+namespace Orchard.PackageManager.Services {
+    public interface IBackgroundPackageUpdateStatus : ISingletonDependency {
+        PackagesStatusResult Value { get; set; }
+    }
+
+    public class BackgroundPackageUpdateStatus : IBackgroundPackageUpdateStatus {
+        public PackagesStatusResult Value { get; set; }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Services/BackgroundPackageUpdateTask.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Services/BackgroundPackageUpdateTask.cs
@@ -0,0 +1,32 @@
+using Orchard.Packaging.Services;
+using Orchard.Tasks;
+
+namespace Orchard.PackageManager.Services {
+    /// <summary>
+    /// Background task responsible for fetching feeds from the Gallery into the
+    /// BackgroundPackageUpdateStatus singleton dependency.
+    /// The purpose is to make sure we don't block the Admin panel the first time
+    /// it's accessed when the PackageManager feature is enabled. The first time
+    /// the panel is accessed, the list of updates will be empty. It will be non empty
+    /// only if the user asks for an explicit refresh or after the first background
+    /// task sweep.
+    /// </summary>
+    public class BackgroundPackageUpdateTask : IBackgroundTask {
+        private readonly IPackageUpdateService _packageUpdateService;
+        private readonly IPackagingSourceManager _packagingSourceManager;
+        private readonly IBackgroundPackageUpdateStatus _backgroundPackageUpdateStatus;
+
+        public BackgroundPackageUpdateTask(IPackageUpdateService packageUpdateService, 
+            IPackagingSourceManager packagingSourceManager, 
+            IBackgroundPackageUpdateStatus backgroundPackageUpdateStatus) {
+
+            _packageUpdateService = packageUpdateService;
+            _packagingSourceManager = packagingSourceManager;
+            _backgroundPackageUpdateStatus = backgroundPackageUpdateStatus;
+        }
+
+        public void Sweep() {
+            _backgroundPackageUpdateStatus.Value = _packageUpdateService.GetPackagesStatus(_packagingSourceManager.GetSources());
+        }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Services/FolderUpdater.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Services/FolderUpdater.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Orchard.Localization;
+using Orchard.Logging;
+using Orchard.UI.Notify;
+
+namespace Orchard.PackageManager.Services {
+    public interface IFolderUpdater : IDependency {
+        void Backup(DirectoryInfo existingFolder, DirectoryInfo backupfolder);
+        void Update(DirectoryInfo destinationFolder, DirectoryInfo newFolder);
+    }
+
+    public class FolderUpdater : IFolderUpdater {
+        private readonly INotifier _notifier;
+
+        public class FolderContent {
+            public DirectoryInfo Folder { get; set; }
+            public IEnumerable<string> Files { get; set; }
+        }
+
+        public FolderUpdater(INotifier notifier) {
+            _notifier = notifier;
+            T = NullLocalizer.Instance;
+            Logger = NullLogger.Instance;
+        }
+
+        public Localizer T { get; set; }
+        public ILogger Logger { get; set; }
+
+        public void Backup(DirectoryInfo existingFolder, DirectoryInfo backupfolder) {
+            CopyFolder(GetFolderContent(existingFolder), backupfolder);
+        }
+
+        public void Update(DirectoryInfo destinationFolder, DirectoryInfo newFolder) {
+            var destinationContent = GetFolderContent(destinationFolder);
+            var newContent = GetFolderContent(newFolder);
+
+            Update(destinationContent, newContent);
+        }
+
+        private void Update(FolderContent destinationContent, FolderContent newContent) {
+            // Copy files from new folder to existing folder
+            foreach (var file in newContent.Files) {
+                CopyFile(newContent.Folder, file, destinationContent.Folder);
+            }
+
+            // Delete files that are in the existing folder but not in the new folder
+            foreach (var file in destinationContent.Files.Except(newContent.Files, StringComparer.OrdinalIgnoreCase)) {
+                var fileToDelete = new FileInfo(Path.Combine(destinationContent.Folder.FullName, file));
+                try {
+                    fileToDelete.Delete();
+                }
+                catch (Exception exception) {
+                    for (Exception scan = exception; scan != null; scan = scan.InnerException) {
+                        _notifier.Warning(T("Unable to delete file \"{0}\": {1}", fileToDelete.FullName, scan.Message));
+                    }
+                }
+            }
+        }
+
+        private void CopyFolder(FolderContent source, DirectoryInfo dest) {
+            foreach (var file in source.Files) {
+                CopyFile(source.Folder, file, dest);
+            }
+        }
+
+        private void CopyFile(DirectoryInfo sourceFolder, string fileName, DirectoryInfo destinationFolder) {
+            var sourceFile = new FileInfo(Path.Combine(sourceFolder.FullName, fileName));
+            var destFile = new FileInfo(Path.Combine(destinationFolder.FullName, fileName));
+
+            // If destination file exist, overwrite only if changed
+            if (destFile.Exists) {
+                if (sourceFile.Length == destFile.Length) {
+                    var source = File.ReadAllBytes(sourceFile.FullName);
+                    var dest = File.ReadAllBytes(destFile.FullName);
+                    if (source.SequenceEqual(dest)) {
+                        //_notifier.Information(T("Skipping file \"{0}\" because it is the same content as the source file", destFile.FullName));
+                        return;
+                    }
+                }
+            }
+
+            // Create destination directory
+            if (!destFile.Directory.Exists) {
+                destFile.Directory.Create();
+            }
+
+            File.Copy(sourceFile.FullName, destFile.FullName, true);
+        }
+
+        private FolderContent GetFolderContent(DirectoryInfo folder) {
+            var files = new List<string>();
+            GetFolderContent(folder, "", files);
+            return new FolderContent { Folder = folder, Files = files };
+        }
+
+        private void GetFolderContent(DirectoryInfo folder, string prefix, List<string> files) {
+            if (!folder.Exists)
+                return;
+
+            foreach (var file in folder.GetFiles()) {
+                files.Add(Path.Combine(prefix, file.Name));
+            }
+
+            foreach (var child in folder.GetDirectories()) {
+                GetFolderContent(child, Path.Combine(prefix, child.Name), files);
+            }
+        }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Services/PackageUpdateManager.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Services/PackageUpdateManager.cs
@@ -0,0 +1,285 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Orchard.Caching;
+using Orchard.Environment.Extensions;
+using Orchard.Environment.Extensions.Models;
+using Orchard.FileSystems.VirtualPath;
+using Orchard.Localization;
+using Orchard.Logging;
+using Orchard.Packaging.Models;
+using Orchard.Packaging.Services;
+using Orchard.Services;
+using Orchard.UI.Notify;
+
+namespace Orchard.PackageManager.Services {
+    public class PackagesStatusResult {
+        public IEnumerable<UpdatePackageEntry> Entries { get; set; }
+        public IEnumerable<Exception> Errors { get; set; }
+    }
+
+    public class UpdatePackageEntry {
+        public ExtensionDescriptor ExtensionsDescriptor { get; set; }
+        public IList<PackagingEntry> PackageVersions { get; set; }
+
+        /// <summary>
+        /// Return version to install if out-of-date, null otherwise.
+        /// </summary>
+        public PackagingEntry NewVersionToInstall {
+            get {
+                PackagingEntry updateToVersion = null;
+                var latestUpdate = this.PackageVersions.OrderBy(v => new Version(v.Version)).Last();
+                if (new Version(latestUpdate.Version) > new Version(this.ExtensionsDescriptor.Version)) {
+                    updateToVersion = latestUpdate;
+                }
+                return updateToVersion;
+            }
+        }
+    }
+
+    public interface IPackageUpdateService : IDependency {
+        PackagesStatusResult GetPackagesStatus(IEnumerable<PackagingSource> sources);
+        void TriggerRefresh();
+        void Update(PackagingEntry entry);
+        void Uninstall(string packageId);
+    }
+
+    public class PackageUpdateService : IPackageUpdateService {
+        private readonly IPackagingSourceManager _packagingSourceManager;
+        private readonly IExtensionManager _extensionManager;
+        private readonly ICacheManager _cacheManager;
+        private readonly IClock _clock;
+        private readonly ISignals _signals;
+        private readonly INotifier _notifier;
+        private readonly IVirtualPathProvider _virtualPathProvider;
+        private readonly IPackageManager _packageManager;
+        private readonly IFolderUpdater _folderUpdater;
+
+        public PackageUpdateService(IPackagingSourceManager packagingSourceManager,
+            IExtensionManager extensionManager,
+            ICacheManager cacheManager,
+            IClock clock,
+            ISignals signals,
+            INotifier notifier,
+            IVirtualPathProvider virtualPathProvider,
+            IPackageManager packageManager,
+            IFolderUpdater folderUpdater) {
+
+            _packagingSourceManager = packagingSourceManager;
+            _extensionManager = extensionManager;
+            _cacheManager = cacheManager;
+            _clock = clock;
+            _signals = signals;
+            _notifier = notifier;
+            _virtualPathProvider = virtualPathProvider;
+            _packageManager = packageManager;
+            _folderUpdater = folderUpdater;
+            T = NullLocalizer.Instance;
+            Logger = NullLogger.Instance;
+        }
+
+        public Localizer T { get; set; }
+        public ILogger Logger { get; set; }
+
+        public PackagesStatusResult GetPackagesStatus(IEnumerable<PackagingSource> sources) {
+            var result = new PackagesStatusResult {
+                Entries = new List<UpdatePackageEntry>(),
+                Errors = new List<Exception>()
+            };
+
+            foreach (var source in sources) {
+                var sourceResult = GetPackages(source);
+                result.Entries = result.Entries.Concat(sourceResult.Entries);
+                result.Errors = result.Errors.Concat(sourceResult.Errors);
+            }
+
+            return result;
+        }
+
+        public void TriggerRefresh() {
+            _signals.Trigger("PackageUpdateService");
+        }
+
+        private PackagesStatusResult GetPackages(PackagingSource packagingSource) {
+            return _cacheManager.Get(packagingSource.FeedUrl, ctx => {
+                // Refresh every minute or when signal was triggered
+                ctx.Monitor(_clock.When(TimeSpan.FromMinutes(5)));
+                ctx.Monitor(_signals.When("PackageUpdateService"));
+
+                // We cache exception because we are calling on a network feed, and failure may
+                // take quite some time.
+                var result = new PackagesStatusResult {
+                    Entries = new List<UpdatePackageEntry>(),
+                    Errors = new List<Exception>()
+                };
+                try {
+                    result.Entries = GetPackagesWorker(packagingSource);
+                }
+                catch (Exception e) {
+                    result.Errors = new[] { e };
+                }
+                return result;
+            });
+        }
+
+        private IEnumerable<UpdatePackageEntry> GetPackagesWorker(PackagingSource packagingSource) {
+            var list = new Dictionary<string, UpdatePackageEntry>(StringComparer.OrdinalIgnoreCase);
+
+            var extensions = _extensionManager.AvailableExtensions();
+            foreach (var extension in extensions) {
+                var packageId = PackageBuilder.BuildPackageId(extension.Id, extension.ExtensionType);
+
+                GetOrAddEntry(list, packageId).ExtensionsDescriptor = extension;
+            }
+
+            var packages = _packagingSourceManager.GetExtensionList(packagingSource)
+                .ToList()
+                .GroupBy(p => p.PackageId, StringComparer.OrdinalIgnoreCase);
+
+            foreach (var package in packages) {
+                var entry = GetOrAddEntry(list, package.Key);
+                entry.PackageVersions = entry.PackageVersions.Concat(package).ToList();
+            }
+
+            return list.Values.Where(e => e.ExtensionsDescriptor != null && e.PackageVersions.Any());
+        }
+
+        private UpdatePackageEntry GetOrAddEntry(Dictionary<string, UpdatePackageEntry> list, string packageId) {
+            UpdatePackageEntry entry;
+            if (!list.TryGetValue(packageId, out entry)) {
+                entry = new UpdatePackageEntry { PackageVersions = new List<PackagingEntry>() };
+                list.Add(packageId, entry);
+            }
+            return entry;
+        }
+
+        public class UpdateContext {
+            public PackagingEntry PackagingEntry { get; set; }
+            public bool IsTheme {
+                get {
+                    return PackagingEntry.PackageId.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme));
+                }
+            }
+            public string ExtensionFolder {
+                get { return IsTheme ? "Themes" : "Modules"; }
+            }
+            public string ExtensionId {
+                get {
+                    return IsTheme ?
+                        PackagingEntry.PackageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme).Length) :
+                        PackagingEntry.PackageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module).Length);
+                }
+            }
+        }
+
+        public void Update(PackagingEntry entry) {
+            var context = new UpdateContext { PackagingEntry = entry };
+
+            // 1. Backup extension folder
+            try {
+                BackupExtensionFolder(context.ExtensionFolder, context.ExtensionId);
+            }
+            catch (Exception exception) {
+                throw new OrchardException(T("Unable to backup existing local package directory."), exception);
+            }
+
+            // 2. If extension is installed, need to un-install first
+            try {
+                UninstallExtensionIfNeeded(context);
+            }
+            catch (Exception exception) {
+                throw new OrchardException(T("Unable to un-install local package before updating."), exception);
+            }
+
+            // 3. Install package from Gallery to temporary folder
+            DirectoryInfo newPackageFolder;
+            try {
+                newPackageFolder = InstallPackage(context);
+            }
+            catch (Exception exception) {
+                throw new OrchardException(T("Package installation failed."), exception);
+            }
+
+            // 4. Copy new package content to extension folder
+            try {
+                UpdateExtensionFolder(context, newPackageFolder);
+            }
+            catch (Exception exception) {
+                throw new OrchardException(T("Package update failed."), exception);
+            }
+        }
+
+        public void Uninstall(string packageId) {
+            var context = new UpdateContext { PackagingEntry = new PackagingEntry {PackageId = packageId} };
+
+            // Backup extension folder
+            try {
+                BackupExtensionFolder(context.ExtensionFolder, context.ExtensionId);
+            }
+            catch (Exception exception) {
+                throw new OrchardException(T("Unable to backup existing local package directory."), exception);
+            }
+
+            // Uninstall package from local folder
+            _packageManager.Uninstall(packageId, _virtualPathProvider.MapPath("~/"));
+            _notifier.Information(T("Successfully un-installed local package {0}", packageId));
+        }
+
+        private void BackupExtensionFolder(string extensionFolder, string extensionId) {
+            var tempPath = _virtualPathProvider.Combine("~", extensionFolder, "_Backup", extensionId);
+            string localTempPath = null;
+            for (int i = 0; i < 1000; i++) {
+                localTempPath = _virtualPathProvider.MapPath(tempPath) + (i == 0 ? "" : "." + i.ToString());
+                if (!Directory.Exists(localTempPath)) {
+                    Directory.CreateDirectory(localTempPath);
+                    break;
+                }
+                localTempPath = null;
+            }
+
+            if (localTempPath == null) {
+                throw new OrchardException(T("Backup folder {0} has too many backups subfolder (limit is 1,000)", tempPath));
+            }
+
+            var backupFolder = new DirectoryInfo(localTempPath);
+            var source = new DirectoryInfo(_virtualPathProvider.MapPath(_virtualPathProvider.Combine("~", extensionFolder, extensionId)));
+            _folderUpdater.Backup(source, backupFolder);
+            _notifier.Information(T("Successfully backed up local package to local folder \"{0}\"", backupFolder));
+        }
+
+        private void UninstallExtensionIfNeeded(UpdateContext context) {
+            // Nuget requires to un-install the currently installed packages if the new
+            // package is the same version or an older version
+            var extension = _extensionManager
+                .AvailableExtensions()
+                .Where(e => e.Id == context.ExtensionId && new Version(e.Version) >= new Version(context.PackagingEntry.Version))
+                .FirstOrDefault();
+            if (extension == null)
+                return;
+
+            _packageManager.Uninstall(context.PackagingEntry.PackageId, _virtualPathProvider.MapPath("~/"));
+            _notifier.Information(T("Successfully un-installed local package {0}", context.ExtensionId));
+        }
+
+        private DirectoryInfo InstallPackage(UpdateContext context) {
+            var tempPath = _virtualPathProvider.Combine("~", context.ExtensionFolder, "_Updates");
+            var destPath = _virtualPathProvider.Combine(tempPath, context.ExtensionFolder, context.ExtensionId);
+            var localDestPath = (_virtualPathProvider.MapPath(destPath));
+            if (Directory.Exists(localDestPath)) {
+                Directory.Delete(localDestPath, true);
+            }
+            _packageManager.Install(context.PackagingEntry.PackageId, context.PackagingEntry.Version, context.PackagingEntry.Source.FeedUrl, _virtualPathProvider.MapPath(tempPath));
+            return new DirectoryInfo(localDestPath);
+        }
+
+        private void UpdateExtensionFolder(UpdateContext context, DirectoryInfo newPackageFolder) {
+            var extensionPath = _virtualPathProvider.Combine("~", context.ExtensionFolder, context.ExtensionId);
+            var extensionFolder = new DirectoryInfo(_virtualPathProvider.MapPath(extensionPath));
+
+            _folderUpdater.Update(extensionFolder, newPackageFolder);
+
+            _notifier.Information(T("Successfully installed package \"{0}\" to local folder \"{1}\"", context.ExtensionId, extensionFolder));
+        }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/ViewModels/PackageList.cs
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/ViewModels/PackageList.cs
@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+using Orchard.PackageManager.Services;
+
+namespace Orchard.PackageManager.ViewModels {
+    public class PackageList {
+        public IEnumerable<UpdatePackageEntry> Entries { get; set; }
+    }
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Admin/ModulesUpdate.cshtml
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Admin/ModulesUpdate.cshtml
@@ -0,0 +1,76 @@
+@using Orchard.Modules.Extensions
+@using Orchard.Mvc.Html;
+@using Orchard.PackageManager.ViewModels;
+@using Orchard.Packaging.Services;
+@using Orchard.Packaging.Models;
+@using Orchard.Environment.Extensions.Models;
+@using Orchard.Utility.Extensions;
+@model PackageList
+
+@{ Layout.Title = T("Modules").ToString(); }
+
+@functions {
+    public string InstallAction(PackagingEntry package) {
+        return Url.Action("Install", "Admin", new {
+            area = "Orchard.PackageManager",
+            packageId = package.PackageId,
+            version = package.Version,
+            sourceId = package.Source.Id,
+            returnUrl = ViewContext.RequestContext.HttpContext.Request.ToUrlString()
+        });
+    }
+    public string UninstallAction(PackagingEntry package) {
+        return Url.Action("Uninstall", "Admin", new {
+            area = "Orchard.PackageManager",
+            packageId = package.PackageId,
+            returnUrl = ViewContext.RequestContext.HttpContext.Request.ToUrlString()
+        });
+    }
+}
+
+@if (Model.Entries.Count() <= 0) {
+    <p>No package updates available.</p>
+} else {
+    <ul class="contentItems">
+        @foreach (var module in Model.Entries) {
+        <li>
+            <div class="summary">
+                <div class="properties">
+                   <h2>@module.ExtensionsDescriptor.Name - @module.ExtensionsDescriptor.Version
+                   @if (module.NewVersionToInstall != null) {
+                       <span>&nbsp;&#124;&nbsp;
+                         <span style="background-color:#ffa0a0">@Html.Link(T("Install Latest").Text, InstallAction(module.NewVersionToInstall))</span>
+                       </span>
+                   } else {
+                       <span>&nbsp;&#124;&nbsp;
+                         <span style="background-color:#a0ffa0; font-size:small">Up-to-date</span>
+                       </span>
+                   }
+                    <span>&nbsp;&#124;&nbsp;
+                        <span style="font-size:small">@Html.Link(T("Uninstall").Text, UninstallAction(module.PackageVersions.First()))</span>
+                    </span>
+                   </h2>
+                    <ul class="pageStatus" style="color:#666; margin:.6em 0 0 0;">
+                        @foreach (var version in module.PackageVersions.OrderByDescending(e => new Version(e.Version))) {
+                            <li style="float:none">
+                                @T("Gallery Version {0} - Last Updated UTC: {1}", version.Version, version.LastUpdated.ToUniversalTime())
+                                @if (!string.IsNullOrWhiteSpace(version.GalleryDetailsUrl)) {
+                                    <text>&nbsp;(</text><a href="@version.GalleryDetailsUrl" target="_blank">@T("details")</a><text>)</text>
+                                }
+
+                                &nbsp;&#124;&nbsp;
+                                @if (new Version(version.Version) == new Version(module.ExtensionsDescriptor.Version)) {
+                                    @Html.Link(T("Install again").Text, InstallAction(version))
+                                } else if (new Version(version.Version) > new Version(module.ExtensionsDescriptor.Version)) {
+                                    @Html.Link(T("Upgrade").Text, InstallAction(version))
+                                } else {
+                                    @Html.Link(T("Downgrade (not recommended)").Text, InstallAction(version))
+                                }
+                            </li>
+                        }
+                    </ul>
+                </div>
+            </div>
+        </li>}
+    </ul>
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Admin/ThemesUpdate.cshtml
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Admin/ThemesUpdate.cshtml
@@ -0,0 +1,76 @@
+@using Orchard.Modules.Extensions
+@using Orchard.Mvc.Html;
+@using Orchard.PackageManager.ViewModels;
+@using Orchard.Packaging.Services;
+@using Orchard.Packaging.Models;
+@using Orchard.Environment.Extensions.Models;
+@using Orchard.Utility.Extensions;
+@model PackageList
+
+@{ Layout.Title = T("Themes").ToString(); }
+
+@functions {
+    public string InstallAction(PackagingEntry package) {
+        return Url.Action("Install", "Admin", new {
+            area = "Orchard.PackageManager",
+            packageId = package.PackageId,
+            version = package.Version,
+            sourceId = package.Source.Id,
+            returnUrl = ViewContext.RequestContext.HttpContext.Request.ToUrlString()
+        });
+    }
+    public string UninstallAction(PackagingEntry package) {
+        return Url.Action("Uninstall", "Admin", new {
+            area = "Orchard.PackageManager",
+            packageId = package.PackageId,
+            returnUrl = ViewContext.RequestContext.HttpContext.Request.ToUrlString()
+        });
+    }
+}
+
+@if (Model.Entries.Count() <= 0) {
+    <p>No package updates available.</p>
+} else {
+    <ul class="contentItems">
+        @foreach (var module in Model.Entries) {
+        <li>
+            <div class="summary">
+                <div class="properties">
+                   <h2>@module.ExtensionsDescriptor.Name - @module.ExtensionsDescriptor.Version
+                   @if (module.NewVersionToInstall != null) {
+                       <span>&nbsp;&#124;&nbsp;
+                         <span style="background-color:#ffa0a0">@Html.Link(T("Install Latest").Text, InstallAction(module.NewVersionToInstall))</span>
+                       </span>
+                   } else {
+                       <span>&nbsp;&#124;&nbsp;
+                         <span style="background-color:#a0ffa0; font-size:small">Up-to-date</span>
+                       </span>
+                   }
+                    <span>&nbsp;&#124;&nbsp;
+                        <span style="font-size:small">@Html.Link(T("Uninstall").Text, UninstallAction(module.PackageVersions.First()))</span>
+                    </span>
+                   </h2>
+                    <ul class="pageStatus" style="color:#666; margin:.6em 0 0 0;">
+                        @foreach (var version in module.PackageVersions.OrderByDescending(e => new Version(e.Version))) {
+                            <li style="float:none">
+                                @T("Gallery Version {0} - Last Updated UTC: {1}", version.Version, version.LastUpdated.ToUniversalTime())
+                                @if (!string.IsNullOrWhiteSpace(version.GalleryDetailsUrl)) {
+                                    <text>&nbsp;(</text><a href="@version.GalleryDetailsUrl" target="_blank">@T("details")</a><text>)</text>
+                                }
+
+                                &nbsp;&#124;&nbsp;
+                                @if (new Version(version.Version) == new Version(module.ExtensionsDescriptor.Version)) {
+                                    @Html.Link(T("Install again").Text, InstallAction(version))
+                                } else if (new Version(version.Version) > new Version(module.ExtensionsDescriptor.Version)) {
+                                    @Html.Link(T("Upgrade").Text, InstallAction(version))
+                                } else {
+                                    @Html.Link(T("Downgrade (not recommended)").Text, InstallAction(version))
+                                }
+                            </li>
+                        }
+                    </ul>
+                </div>
+            </div>
+        </li>}
+    </ul>
+}
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Web.config
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Views/Web.config
@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<configuration>
+  <appSettings>
+    <add key="webpages:Enabled" value="false" />
+  </appSettings>
+  <system.web>
+    <httpHandlers>
+    </httpHandlers>
+
+    <!--
+        Enabling request validation in view pages would cause validation to occur
+        after the input has already been processed by the controller. By default
+        MVC performs request validation before a controller processes the input.
+        To change this behavior apply the ValidateInputAttribute to a
+        controller or action.
+    -->
+    <pages
+        validateRequest="false"
+        pageParserFilterType="System.Web.Mvc.ViewTypeParserFilter, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"
+        pageBaseType="System.Web.Mvc.ViewPage, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL"
+        userControlBaseType="System.Web.Mvc.ViewUserControl, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <controls>
+        <add assembly="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" namespace="System.Web.Mvc" tagPrefix="mvc" />
+      </controls>
+    </pages>
+  </system.web>
+
+  <system.webServer>
+    <validation validateIntegratedModeConfiguration="false"/>
+    <handlers>
+    </handlers>
+  </system.webServer>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
+        <bindingRedirect oldVersion="2.0.0.0" newVersion="3.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>
--- a/src/Orchard.Web/Modules/Orchard.PackageManager/Web.config
+++ b/src/Orchard.Web/Modules/Orchard.PackageManager/Web.config
@@ -0,0 +1,39 @@
+<?xml version="1.0"?>
+<configuration>
+
+  <configSections>
+    <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
+      <remove name="host" />
+      <remove name="pages" />
+      <section name="host" type="System.Web.WebPages.Razor.Configuration.HostSection, System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
+      <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
+    </sectionGroup>
+  </configSections>
+
+  <system.web.webPages.razor>
+    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
+    <pages pageBaseType="Orchard.Mvc.ViewEngines.Razor.WebViewPage">
+      <namespaces>
+        <add namespace="System.Web.Mvc" />
+        <add namespace="System.Web.Mvc.Ajax" />
+        <add namespace="System.Web.Mvc.Html" />
+        <add namespace="System.Web.Routing" />
+        <add namespace="System.Linq"/>
+        <add namespace="System.Collections.Generic"/>
+        <add namespace="Orchard.Mvc.Html"/>
+      </namespaces>
+    </pages>
+  </system.web.webPages.razor>
+
+  <system.web>
+    <compilation targetFramework="4.0">
+      <assemblies>
+        <add assembly="System.Web.Abstractions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
+        <add assembly="System.Web.Routing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
+        <add assembly="System.Data.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>
+        <add assembly="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
+      </assemblies>
+    </compilation>
+  </system.web>
+
+</configuration>
--- a/src/Orchard.Web/Modules/Orchard.Packaging/AdminMenu.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/AdminMenu.cs
@@ -7,7 +7,6 @@ namespace Orchard.Packaging {
    [OrchardFeature("Gallery")]
    public class AdminMenu : INavigationProvider {
        public Localizer T { get; set; }
-
        public string MenuName { get { return "admin"; } }

        public void GetNavigation(NavigationBuilder builder) {
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Controllers/GalleryController.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Controllers/GalleryController.cs
@@ -10,7 +10,6 @@ using Orchard.Environment.Extensions;
 using Orchard.Environment.Extensions.Models;
 using Orchard.Localization;
 using Orchard.Logging;
-using Orchard.Packaging.GalleryServer;
 using Orchard.Packaging.Models;
 using Orchard.Packaging.Services;
 using Orchard.Packaging.ViewModels;
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/NugetLogger.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/NugetLogger.cs
@@ -3,7 +3,7 @@ using NuGet;
 using Orchard.Localization;
 using Orchard.UI.Notify;

-namespace Orchard.Packaging.Services {
+namespace Orchard.Packaging.Models {
    public class NugetLogger : ILogger {
        private readonly INotifier _notifier;

--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageData.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageData.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace Orchard.Packaging.Services {
+namespace Orchard.Packaging.Models {
    public class PackageData {
        public string ExtensionType { get; set; }
        public string ExtensionName { get; set; }
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackagingEntry.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackagingEntry.cs
@@ -1,7 +1,6 @@
 using System;
-using Orchard.Packaging.Models;

-namespace Orchard.Packaging.Services {
+namespace Orchard.Packaging.Models {
    public class PackagingEntry {
        public PackagingSource Source { get; set; }
        public string Title { get; set; }
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Orchard.Packaging.csproj
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Orchard.Packaging.csproj
@@ -78,12 +78,12 @@
    <Compile Include="Services\IPackageInstaller.cs" />
    <Compile Include="Services\IPackageManager.cs" />
    <Compile Include="Services\IPackagingSourceManager.cs" />
-    <Compile Include="Services\NugetLogger.cs" />
+    <Compile Include="Models\NugetLogger.cs" />
+    <Compile Include="Models\PackageData.cs" />
    <Compile Include="Services\PackageBuilder.cs" />
-    <Compile Include="Services\PackageData.cs" />
    <Compile Include="Services\PackageInstaller.cs" />
    <Compile Include="Services\PackageManager.cs" />
-    <Compile Include="Services\PackagingEntry.cs" />
+    <Compile Include="Models\PackagingEntry.cs" />
    <Compile Include="Services\PackagingSourceManager.cs" />
    <Compile Include="ViewModels\PackagingAddSourceViewModel.cs" />
    <Compile Include="ViewModels\PackagingHarvestViewModel.cs" />
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/IPackageManager.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/IPackageManager.cs
@@ -1,4 +1,5 @@
 using NuGet;
+using Orchard.Packaging.Models;

 namespace Orchard.Packaging.Services {
    public interface IPackageManager : IDependency {
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/IPackagingSourceManager.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/IPackagingSourceManager.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
 using Orchard.Packaging.GalleryServer;
 using Orchard.Packaging.Models;

--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageInstaller.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageInstaller.cs
@@ -5,6 +5,7 @@ using NuGet;
 using Orchard.Environment.Extensions;
 using Orchard.Environment.Extensions.Models;
 using Orchard.Localization;
+using Orchard.Packaging.Models;
 using Orchard.UI.Notify;
 using NuGetPackageManager = NuGet.PackageManager;

--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageManager.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackageManager.cs
@@ -4,6 +4,7 @@ using NuGet;
 using Orchard.Environment.Extensions;
 using Orchard.Environment.Extensions.Models;
 using Orchard.Localization;
+using Orchard.Packaging.Models;

 namespace Orchard.Packaging.Services {
    [OrchardFeature("PackagingServices")]
--- a/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackagingSourceManager.cs
+++ b/src/Orchard.Web/Modules/Orchard.Packaging/Services/PackagingSourceManager.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
 using Orchard.Data;
 using Orchard.Environment.Extensions;
 using Orchard.Localization;
--- a/src/Orchard.Web/Modules/Orchard.Themes/Controllers/AdminController.cs
+++ b/src/Orchard.Web/Modules/Orchard.Themes/Controllers/AdminController.cs
@@ -80,7 +80,7 @@ namespace Orchard.Themes.Controllers {
                    })
                    .Select(extensionDescriptor => new ThemeEntry(extensionDescriptor) {
                        NeedsUpdate = featuresThatNeedUpdate.Contains(extensionDescriptor.Id),
-                        IsRecentlyInstalled = _themeService.UpdateIsRecentlyInstalled(extensionDescriptor),
+                        IsRecentlyInstalled = _themeService.IsRecentlyInstalled(extensionDescriptor),
                        Enabled = _shellDescriptor.Features.Any(sf => sf.Name == extensionDescriptor.Id)
                    })
                    .ToArray();
--- a/src/Orchard.Web/Modules/Orchard.Themes/Services/IThemeService.cs
+++ b/src/Orchard.Web/Modules/Orchard.Themes/Services/IThemeService.cs
@@ -4,6 +4,6 @@ namespace Orchard.Themes.Services {
    public interface IThemeService : IDependency {
        void DisableThemeFeatures(string themeName);
        void EnableThemeFeatures(string themeName);
-        bool UpdateIsRecentlyInstalled(ExtensionDescriptor module);
+        bool IsRecentlyInstalled(ExtensionDescriptor module);
    }
 }
--- a/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeService.cs
+++ b/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeService.cs
@@ -114,10 +114,10 @@ namespace Orchard.Themes.Services {
        }

        /// <summary>
-        /// Updates the recently installed flag by using the project's last written time.
+        /// Determines if a theme was recently installed by using the project's last written time.
        /// </summary>
        /// <param name="descriptor">The extension descriptor.</param>
-        public bool UpdateIsRecentlyInstalled(ExtensionDescriptor descriptor) {
+        public bool IsRecentlyInstalled(ExtensionDescriptor descriptor) {
            string projectFile = GetManifestPath(descriptor);
            if (!string.IsNullOrEmpty(projectFile)) {
                // If project file was modified less than 24 hours ago, the module was recently deployed
--- a/src/Orchard.sln
+++ b/src/Orchard.sln
@@ -108,6 +108,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Orchard.DesignerTools", "Or
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Orchard.MediaPicker", "Orchard.Web\Modules\Orchard.MediaPicker\Orchard.MediaPicker.csproj", "{43D0EC0B-1955-4566-8D31-7B9102DA1703}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Orchard.PackageManager", "Orchard.Web\Modules\Orchard.PackageManager\Orchard.PackageManager.csproj", "{E66935C0-830B-466E-A571-4AEED7057CBD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		CodeCoverage|Any CPU = CodeCoverage|Any CPU
@@ -571,6 +573,16 @@ Global
 		{43D0EC0B-1955-4566-8D31-7B9102DA1703}.FxCop|Any CPU.Build.0 = Release|Any CPU
 		{43D0EC0B-1955-4566-8D31-7B9102DA1703}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{43D0EC0B-1955-4566-8D31-7B9102DA1703}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.CodeCoverage|Any CPU.ActiveCfg = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.CodeCoverage|Any CPU.Build.0 = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Coverage|Any CPU.ActiveCfg = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Coverage|Any CPU.Build.0 = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.FxCop|Any CPU.ActiveCfg = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.FxCop|Any CPU.Build.0 = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E66935C0-830B-466E-A571-4AEED7057CBD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -608,6 +620,7 @@ Global
 		{99002B65-86F7-415E-BF4A-381AA8AB9CCC} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5}
 		{4A4595EF-6C37-4F99-96ED-4AE0B9E438D3} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5}
 		{43D0EC0B-1955-4566-8D31-7B9102DA1703} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5}
+		{E66935C0-830B-466E-A571-4AEED7057CBD} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5}
 		{ABC826D4-2FA1-4F2F-87DE-E6095F653810} = {74E681ED-FECC-4034-B9BD-01B0BB1BDECA}
 		{F112851D-B023-4746-B6B1-8D2E5AD8F7AA} = {74E681ED-FECC-4034-B9BD-01B0BB1BDECA}
 		{6CB3EB30-F725-45C0-9742-42599BA8E8D2} = {74E681ED-FECC-4034-B9BD-01B0BB1BDECA}
--- a/src/Orchard/Reports/Services/IReportsCoordinator.cs
+++ b/src/Orchard/Reports/Services/IReportsCoordinator.cs
@@ -1,6 +1,6 @@
 namespace Orchard.Reports.Services {
    public interface IReportsCoordinator : IDependency {
        void Add(string reportKey, ReportEntryType type, string message);
-        void Register(string reportKey, string activityName, string title);
+        int Register(string reportKey, string activityName, string title);
    }
 }
--- a/src/Orchard/Reports/Services/ReportsCoordinator.cs
+++ b/src/Orchard/Reports/Services/ReportsCoordinator.cs
@@ -27,8 +27,10 @@ namespace Orchard.Reports.Services {
            _reportsManager.Add(_reports[reportKey], type, message);
        }

-        public void Register(string reportKey, string activityName, string title) {
-            _reports.Add(reportKey, _reportsManager.CreateReport(title, activityName));
+        public int Register(string reportKey, string activityName, string title) {
+            int reportId = _reportsManager.CreateReport(title, activityName);
+            _reports.Add(reportKey, reportId);
+            return reportId;
        }
    }
 }