Merge

--HG--
branch : dev

src/Orchard.Azure.Tests/Storage/AzureBlobStorageProviderTests.cs

@@ -4,6 +4,7 @@ using NUnit.Framework;
 using Orchard.Azure.Storage;
 using Microsoft.WindowsAzure;
 using System.Linq;
+using Orchard.Environment.Configuration;
 
 namespace Orchard.Azure.Tests.Storage {
     [TestFixture]
@@ -15,7 +16,7 @@ namespace Orchard.Azure.Tests.Storage {
             CloudStorageAccount devAccount;
             CloudStorageAccount.TryParse("UseDevelopmentStorage=true", out devAccount);
 
-            _azureBlobStorageProvider = new AzureBlobStorageProvider("default", devAccount);
+            _azureBlobStorageProvider = new AzureBlobStorageProvider(new ShellSettings { Name = "default" }, devAccount);
         }
 
         [SetUp]

src/Orchard.Azure/AzureFileSystem.cs

@@ -11,19 +11,19 @@ namespace Orchard.Azure {
         public string ContainerName { get; protected set; }
 
         private readonly CloudStorageAccount _storageAccount;
-        private readonly string _shellName;
+        private readonly string _root;
         public CloudBlobClient BlobClient { get; private set; }
         public CloudBlobContainer Container { get; private set; }
 
-        public AzureFileSystem(string containerName, string shellName, bool isPrivate)
+        public AzureFileSystem(string containerName, string root, bool isPrivate)
-            : this(containerName, shellName, isPrivate, CloudStorageAccount.FromConfigurationSetting("DataConnectionString")) {
+            : this(containerName, root, isPrivate, CloudStorageAccount.FromConfigurationSetting("DataConnectionString")) {
         }
 
-        public AzureFileSystem(string containerName, string shellName, bool isPrivate, CloudStorageAccount storageAccount) {
+        public AzureFileSystem(string containerName, string root, bool isPrivate, CloudStorageAccount storageAccount) {
             // Setup the connection to custom storage accountm, e.g. Development Storage
             _storageAccount = storageAccount;
             ContainerName = containerName;
-            _shellName = shellName;
+            _root = String.IsNullOrEmpty(root) || root == "/" ? String.Empty : root + "/";
 
             BlobClient = _storageAccount.CreateCloudBlobClient();
             // Get and create the container if it does not exist
@@ -47,20 +47,20 @@ namespace Orchard.Azure {
 
         public IStorageFile GetFile(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
             Container.EnsureBlobExists(path);
             return new AzureBlobFileStorage(Container.GetBlockBlobReference(path));
         }
 
         public bool FileExists(string path) {
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
             return Container.BlobExists(path);
         }
 
         public IEnumerable<IStorageFile> ListFiles(string path) {
             EnsurePathIsRelative(path);
 
-            string prefix = String.Concat(Container.Name, "/", _shellName, "/", path);
+            string prefix = String.Concat(Container.Name, "/", _root, path);
             if ( !prefix.EndsWith("/") )
                 prefix += "/";
 
@@ -71,7 +71,7 @@ namespace Orchard.Azure {
 
         public IEnumerable<IStorageFolder> ListFolders(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             if ( !Container.DirectoryExists(path) ) {
                 try {
@@ -91,7 +91,7 @@ namespace Orchard.Azure {
 
         public void CreateFolder(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             Container.EnsureDirectoryDoesNotExist(path);
             Container.GetDirectoryReference(path);
@@ -99,7 +99,7 @@ namespace Orchard.Azure {
 
         public void DeleteFolder(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             Container.EnsureDirectoryExists(path);
             foreach ( var blob in Container.GetDirectoryReference(path).ListBlobs() ) {
@@ -107,7 +107,7 @@ namespace Orchard.Azure {
                     ( (CloudBlob)blob ).Delete();
 
                 if ( blob is CloudBlobDirectory )
-                    DeleteFolder(blob.Uri.ToString().Substring(Container.Uri.ToString().Length + 2 + _shellName.Length));
+                    DeleteFolder(blob.Uri.ToString().Substring(Container.Uri.ToString().Length + 1 + _root.Length));
             }
         }
 
@@ -122,7 +122,7 @@ namespace Orchard.Azure {
             if ( !newPath.EndsWith("/") )
                 newPath += "/";
 
-            foreach ( var blob in Container.GetDirectoryReference(_shellName + "/" + path).ListBlobs() ) {
+            foreach ( var blob in Container.GetDirectoryReference(_root + path).ListBlobs() ) {
                 if ( blob is CloudBlob ) {
                     string filename = Path.GetFileName(blob.Uri.ToString());
                     string source = String.Concat(path, filename);
@@ -142,7 +142,7 @@ namespace Orchard.Azure {
 
         public void DeleteFile(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             Container.EnsureBlobExists(path);
             var blob = Container.GetBlockBlobReference(path);
@@ -151,10 +151,10 @@ namespace Orchard.Azure {
 
         public void RenameFile(string path, string newPath) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             EnsurePathIsRelative(newPath);
-            newPath = String.Concat(_shellName, "/", newPath);
+            newPath = String.Concat(_root, newPath);
 
             Container.EnsureBlobExists(path);
             Container.EnsureBlobDoesNotExist(newPath);
@@ -167,7 +167,7 @@ namespace Orchard.Azure {
 
         public IStorageFile CreateFile(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
 
             if ( Container.BlobExists(path) ) {
                 throw new ArgumentException("File " + path + " already exists");
@@ -180,7 +180,7 @@ namespace Orchard.Azure {
 
         public string GetPublicUrl(string path) {
             EnsurePathIsRelative(path);
-            path = String.Concat(_shellName, "/", path);
+            path = String.Concat(_root, path);
             Container.EnsureBlobExists(path);
             return Container.GetBlockBlobReference(path).Uri.ToString();
         }

src/Orchard.Azure/Environment/Configuration/AzureAppDataFolder.cs

@@ -9,8 +9,8 @@ namespace Orchard.Azure.Environment.Configuration {
 
         private readonly AzureFileSystem _fs;
 
-        public AzureAppDataFolder(string shellName) {
+        public AzureAppDataFolder() {
-            _fs = new AzureFileSystem("appdata", shellName, true);
+            _fs = new AzureFileSystem("appdata", null, true);
         }
 
         public void CreateFile(string path, string content) {

src/Orchard.Azure/Orchard.Azure.Web/Config/Host.config

@@ -16,17 +16,11 @@
       <component instance-scope="single-instance"
                  type="Orchard.Azure.Storage.AzureBlobStorageProvider, Orchard.Azure"
                  service="Orchard.Storage.IStorageProvider">
-        <parameters>
-          <parameter name="shellName" value="Default" />
-        </parameters>
       </component>
 
       <component instance-scope="single-instance"
                  type="Orchard.Azure.Environment.Configuration.AzureAppDataFolder, Orchard.Azure"
                  service="Orchard.Environment.Configuration.IAppDataFolder">
-        <parameters>
-          <parameter name="shellName" value="Default" />
-        </parameters>
       </component>
 
       

src/Orchard.Azure/Storage/AzureBlobStorageProvider.cs

@@ -1,15 +1,16 @@
 using Microsoft.WindowsAzure;
+using Orchard.Environment.Configuration;
 using Orchard.Storage;
 
 namespace Orchard.Azure.Storage {
 
     public class AzureBlobStorageProvider : AzureFileSystem, IStorageProvider {
 
-        public AzureBlobStorageProvider(string shellName)
+        public AzureBlobStorageProvider(ShellSettings shellSettings)
-            : this(shellName, CloudStorageAccount.FromConfigurationSetting("DataConnectionString")) {
+            : this(shellSettings, CloudStorageAccount.FromConfigurationSetting("DataConnectionString")) {
         }
 
-        public AzureBlobStorageProvider(string shellName, CloudStorageAccount storageAccount) : base("media", shellName, false, storageAccount) { }
+        public AzureBlobStorageProvider(ShellSettings shellSettings, CloudStorageAccount storageAccount) : base("media", shellSettings.Name, false, storageAccount) { }
     }
 }
 

src/Orchard.Tests/Events/EventTests.cs

@@ -2,6 +2,7 @@
 using Autofac;
 using NUnit.Framework;
 using Orchard.Events;
+using System;
 
 namespace Orchard.Tests.Events {
     [TestFixture]
@@ -9,12 +10,15 @@ namespace Orchard.Tests.Events {
         private IContainer _container;
         private IEventBus _eventBus;
         private StubEventBusHandler _eventBusHandler;
+        private StubEventHandler _eventHandler;
 
         [SetUp]
         public void Init() {
             var builder = new ContainerBuilder();
             _eventBusHandler = new StubEventBusHandler();
+            _eventHandler = new StubEventHandler();
             builder.RegisterInstance(_eventBusHandler).As<IEventBusHandler>();
+            builder.RegisterInstance(_eventHandler).As<IEventHandler>();
             builder.RegisterType<DefaultOrchardEventBus>().As<IEventBus>();
             _container = builder.Build();
             _eventBus = _container.Resolve<IEventBus>();
@@ -38,5 +42,29 @@ namespace Orchard.Tests.Events {
 
             #endregion
         }
+
+        [Test]
+        public void EventsAreCorrectlyDispatchedToEventHandlers() {
+            Assert.That(_eventHandler.Count, Is.EqualTo(0));
+            _eventBus.Notify("ITestEventHandler.Increment", new Dictionary<string, object>());
+            Assert.That(_eventHandler.Count, Is.EqualTo(1));
+        }
+
+        public interface ITestEventHandler : IEventHandler {
+            void Increment();
+        }
+
+        public class StubEventHandler : ITestEventHandler {
+            public int Count { get; set; }
+
+            public void Increment() {
+                Count++;
+            }
+        }
+
+        [Test]
+        public void EventBusThrowsIfMessageNameIsNotCorrectlyFormatted() {
+            Assert.Throws<ArgumentException>(() => _eventBus.Notify("StubEventHandlerIncrement", new Dictionary<string, object>()));
+        }
     }
 }

src/Orchard/Events/DefaultOrchardEventBus.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Orchard.Localization;
 using Orchard.Logging;
 
 namespace Orchard.Events {
@@ -11,9 +12,11 @@ namespace Orchard.Events {
             _handlers = handlers;
             _eventHandlers = eventHandlers;
             Logger = NullLogger.Instance;
+            T = NullLocalizer.Instance;
         }
 
         public ILogger Logger { get; set; }
+        public Localizer T { get; set; }
 
         #region Implementation of IEventBus
 
@@ -22,6 +25,35 @@ namespace Orchard.Events {
         }
 
         public void Notify(string messageName, Dictionary<string, object> eventData) {
+            string[] parameters = messageName.Split('.');
+            if (parameters.Length != 2) {
+                throw new ArgumentException(messageName + T(" is not formatted correctly"));
+            }
+            string interfaceName = parameters[0];
+            string methodName = parameters[1];
+
+            foreach (var eventHandler in _eventHandlers) {
+                TryInvoke(eventHandler, interfaceName, methodName, eventData);
+            }
+        }
+
+        private static void TryInvoke(IEventHandler eventHandler, string interfaceName, string methodName, Dictionary<string, object> arguments) {
+            Type type = eventHandler.GetType();
+            foreach (var interfaceType in type.GetInterfaces()) {
+                if (String.Equals(interfaceType.Name, interfaceName, StringComparison.OrdinalIgnoreCase)) {
+                    TryInvokeMethod(eventHandler, methodName, arguments);
+                    break;
+                }
+            }
+        }
+
+        private static void TryInvokeMethod(IEventHandler eventHandler, string methodName, Dictionary<string, object> arguments) {
+            foreach (var method in eventHandler.GetType().GetMethods()) {
+                if (String.Equals(method.Name, methodName)) {
+                    method.Invoke(eventHandler, new object[] { });
+                    break;
+                }
+            }
         }
 
         #endregion