Update fork

changelog.md

@@ -3,6 +3,10 @@
 ## SmartStore.NET 3.2
 
 ### New Features
+* **EmailReminder**:
+	* Reminders for open shopping carts
+	* Reminders for product reviews
+	* Reminders to visit the shop after a long absence
 * #1144 Enable multi server search index
 * Made Topic ACL enabled
 * Implemented paging & filtering for Topic grid
@@ -15,18 +19,31 @@
 * Added option to display preview pictures in product lists
 * Added option to add multiple file versions to product download section
 * Added options for alternating price display (in badges)
-* Added option to display a captcha on forum pages when creating or replying to a topic.
+* **Forum**:
+	* Added option to display a captcha on forum pages when creating or replying to a topic.
+	* #417 Restrict forum groups to specific customer roles.
+	* Added published property to forum topic and post.
+	* Added voting for forum posts.
+	* Several performance improvements.
 * **MegaSearch**:
 	* Supports searching for forum posts.
 	* #1172 Option to display related search terms on search page.
 * Customer avatar: Letter with colored background if no avatar image was uploaded.
 * Viveum: Supports payment via "Virtual Account Brands" like PayPal.
+* Added options for alternating price display (in badges).
+* #1515 Poll: Add result tab with a list of answers and customers for a poll
 
 ### Improvements
 * (Perf) Significantly increased query performance for products with a lot of category assignments (> 10).
 * Debitoor: Partially update customer instead of full update to avoid all fields being overwritten
 * #1479 Show in messages the delivery time at the time of purchase
 * #1184 Sort Current shopping carts & Current wishlists by ShoppingCartItem.CreatedOn.
+* #1106 BMECat: import & export support for product keywords
+* #1499 Added hint to forms indicating that fields with an asterisk (*)
+* Added filter for newsletter subscriber export by working language
+* Refactored download section  
+* Enhanced EntityPicker to pick from customers, manufacturers & categories
+* #1510 Breadcrumb of an associated product should include the grouped product if it has no assigned categories.
 
 ### Bugfixes
 * In a multi-store environment, multiple topics with the same system name cannot be resolved reliably.
@@ -56,6 +73,11 @@
 * Wrong order of featured products on category page.
 * #1504 Cart item price calculation wrong if attribute combinations with text types are involved.
 * #1485 Dropdown list for product sorting does not work with Internet Explorer 11.
+* #1468 Twitter authentication not working anymore.
+* Newsletter subscription didn't work when customer privacy setting DisplayGdprConsentOnForms was turned off
+* Fixed social media image detection
+* Fixed redirection of bots when several languages were active
+* Region cannot be selected in checkout when entering a billing or shipping address
 
 
 ## SmartStore.NET 3.1.5

src/Libraries/SmartStore.Core/Caching/RequestCache.cs

@@ -8,7 +8,7 @@
 
 namespace SmartStore.Core.Caching
 {
-	public class RequestCache : IRequestCache
+	public class RequestCache : DisposableObject, IRequestCache
 	{
 		const string RegionName = "SmartStoreNET:";
 
@@ -124,5 +124,11 @@ private string BuildKey(string key)
 		{
 			return RegionName + key.EmptyNull();
 		}
+
+		protected override void OnDispose(bool disposing)
+		{
+			if (disposing)
+				Clear();
+		}
 	}
 }

src/Libraries/SmartStore.Core/ComponentModel/FastActivator.cs

@@ -44,6 +44,8 @@ public object Activate(params object[] parameters)
 			return Invoker(parameters);
 		}
 
+		#region Static
+
 		/// <summary>
 		/// Creates a single fast constructor invoker. The result is not cached.
 		/// </summary>
@@ -78,8 +80,6 @@ public static Func<object[], object> MakeFastInvoker(ConstructorInfo constructor
 			return lambda.Compile();
 		}
 
-		#region Static
-
 		/// <summary>
 		/// Creates and caches fast constructor invokers 
 		/// </summary>

src/Libraries/SmartStore.Core/ComponentModel/FastInvoker.cs

@@ -0,0 +1,228 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Linq.Expressions;
+using System.Collections.Concurrent;
+using SmartStore.Utilities;
+
+namespace SmartStore.ComponentModel
+{
+	public class FastInvoker
+	{
+		private static readonly ConcurrentDictionary<MethodKey, FastInvoker> _invokersCache = new ConcurrentDictionary<MethodKey, FastInvoker>();
+
+		public FastInvoker(MethodInfo methodInfo)
+		{
+			Guard.NotNull(methodInfo, nameof(methodInfo));
+
+			Method = methodInfo;
+			Invoker = MakeFastInvoker(methodInfo);
+			ParameterTypes = methodInfo.GetParameters().Select(p => p.ParameterType).ToArray();
+		}
+
+		/// <summary>
+		/// Gets the backing <see cref="MethodInfo"/>.
+		/// </summary>
+		public MethodInfo Method { get; private set; }
+
+		/// <summary>
+		/// Gets the parameter types from the backing <see cref="MethodInfo"/>
+		/// </summary>
+		public Type[] ParameterTypes { get; private set; }
+
+		/// <summary>
+		/// Gets the method invoker.
+		/// </summary>
+		public Func<object, object[], object> Invoker { get; private set; }
+
+		/// <summary>
+		/// Invokes the method using the specified parameters.
+		/// </summary>
+		/// <returns>The method invocation result.</returns>
+		public object Invoke(object obj, params object[] parameters)
+		{
+			return Invoker(obj, parameters);
+		}
+
+		#region Static
+
+		/// <summary>
+		/// Creates a single fast method invoker. The result is not cached.
+		/// </summary>
+		/// <param name="method">Method to create invoker for.</param>
+		/// <returns>The fast method invoker delegate.</returns>
+		public static Func<object, object[], object> MakeFastInvoker(MethodInfo method)
+		{
+			Guard.NotNull(method, nameof(method));
+
+			var instanceParameterExpression = Expression.Parameter(typeof(object), "instance");
+			var argumentsParameterExpression = Expression.Parameter(typeof(object[]), "args");
+			var index = 0;
+
+			var argumentExtractionExpressions =
+				method
+			   .GetParameters()
+			   .Select(parameter =>
+				  Expression.Convert(
+					 Expression.ArrayAccess(
+						argumentsParameterExpression,
+						Expression.Constant(index++)
+					 ),
+					 parameter.ParameterType
+				  )
+			   ).ToList();
+
+			var callExpression = method.IsStatic
+			   ? Expression.Call(method, argumentExtractionExpressions)
+			   : Expression.Call(
+				  Expression.Convert(
+					 instanceParameterExpression,
+					 method.DeclaringType
+				  ),
+				  method,
+				  argumentExtractionExpressions
+			   );
+
+			var endLabel = Expression.Label(typeof(object));
+
+			var finalExpression = method.ReturnType == typeof(void)
+			   ? (Expression)Expression.Block(
+					callExpression,
+					Expression.Return(endLabel, Expression.Constant(null)),
+					Expression.Label(endLabel, Expression.Constant(null))
+				 )
+			   : Expression.Convert(callExpression, typeof(object));
+
+			var lambdaExpression = Expression.Lambda<Func<object, object[], object>>(
+			   finalExpression,
+			   instanceParameterExpression,
+			   argumentsParameterExpression
+			);
+
+			var lamdba = lambdaExpression.Compile();
+			return lamdba;
+		}
+
+		/// <summary>
+		/// Invokes a method using the specified object and parameter instances.
+		/// </summary>
+		/// <param name="obj">The objectinstance</param>
+		/// <param name="methodName">Method name</param>
+		/// <param name="parameterTypes">Argument types of the matching method overload (in exact order)</param>
+		/// <param name="parameters">Parameter instances to pass to invocation</param>
+		/// <returns>The method invocation result.</returns>
+		public static object Invoke(object obj, string methodName, Type[] parameterTypes, object[] parameters)
+		{
+			Guard.NotNull(obj, nameof(obj));
+
+			FastInvoker invoker;
+
+			if (parameterTypes == null || parameterTypes.Length == 0)
+			{
+				invoker = GetInvoker(obj.GetType(), methodName);
+			}
+			else
+			{
+				invoker = GetInvoker(obj.GetType(), methodName, parameterTypes);
+			}
+
+			//var hasAnyNullParam = parameters.Any(x => x == null);
+			//if (hasAnyNullParam)
+			//{
+			//	throw new ArgumentException("When invoking a method with parameter instances, no instance must be null.", nameof(parameters));
+			//}
+
+			return invoker.Invoke(obj, parameters ?? Array.Empty<object>());
+		}
+
+		/// <summary>
+		/// Creates and caches a fast method invoker.
+		/// </summary>
+		/// <param name="methodInfo">Method info instance to create an invoker for.</param>
+		/// <returns>The fast method invoker.</returns>
+		public static FastInvoker GetInvoker(MethodInfo methodInfo)
+		{
+			Guard.NotNull(methodInfo, nameof(methodInfo));
+
+			return GetInvoker(
+				methodInfo.DeclaringType, 
+				methodInfo.Name,
+				methodInfo.GetParameters().Select(x => x.ParameterType).ToArray());
+		}
+
+		/// <summary>
+		/// Creates and caches a fast method invoker.
+		/// </summary>
+		/// <param name="methodName">Name of method to create an invoker for.</param>
+		/// <param name="argTypes">Argument types of method to create an invoker for.</param>
+		/// <returns>The fast method invoker.</returns>
+		public static FastInvoker GetInvoker<T>(string methodName, params Type[] argTypes)
+		{
+			return GetInvoker(typeof(T), methodName, argTypes);
+		}
+
+		/// <summary>
+		/// Creates and caches a fast method invoker.
+		/// </summary>
+		/// <param name="type">The type to extract fast method invoker for.</param>
+		/// <param name="methodName">Name of method to create an invoker for.</param>
+		/// <param name="argTypes">Argument types of method to create an invoker for.</param>
+		/// <returns>The fast method invoker.</returns>
+		public static FastInvoker GetInvoker(Type type, string methodName, params Type[] argTypes)
+		{
+			Guard.NotNull(type, nameof(type));
+			Guard.NotEmpty(methodName, nameof(methodName));
+
+			var cacheKey = MethodKey.Create(type, methodName, argTypes);
+
+			if (!_invokersCache.TryGetValue(cacheKey, out var invoker))
+			{
+				var method = FindMatchingMethod(type, methodName, argTypes);
+
+				if (method == null)
+				{
+					throw new MethodAccessException("Could not find a matching method '{0}' in type {1}.".FormatInvariant(methodName, type));
+				}
+
+				invoker = new FastInvoker(method);
+				_invokersCache.TryAdd(cacheKey, invoker);
+			}
+
+			return invoker;
+		}
+
+		private static MethodInfo FindMatchingMethod(Type type, string methodName, Type[] argTypes)
+		{
+			var method = argTypes == null || argTypes.Length == 0 
+				? type.GetMethod(methodName)
+				: type.GetMethod(
+					methodName,
+					BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly,
+					null,
+					argTypes ?? new Type[0],
+					null);
+
+			return method;
+		}
+
+		#endregion
+
+		class MethodKey : Tuple<Type, string, int>
+		{
+			public MethodKey(Type type, string methodName, int parametersHash)
+				: base(type, methodName, parametersHash)
+			{
+			}
+			public Type Type { get { return base.Item1; } }
+			public string MethodName { get { return base.Item2; } }
+			public int ParameterHash { get { return base.Item3; } }
+
+			public static MethodKey Create(Type type, string methodName, IEnumerable<Type> parameterTypes)
+			{
+				var hashCombiner = HashCodeCombiner.Start().Add(parameterTypes);
+				return new MethodKey(type, methodName, hashCombiner.CombinedHash);
+			}
+		}
+	}
+}

src/Libraries/SmartStore.Core/ComponentModel/FastProperty.cs

@@ -543,7 +543,7 @@ protected static IDictionary<string, FastProperty> GetVisibleProperties(
 			{
 				return result;
 			}
-
+			
 			// The simple and common case, this is normal POCO object - no need to allocate.
 			var allPropertiesDefinedOnType = true;
 			var allProperties = GetProperties(type, createPropertyHelper, allPropertiesCache);

src/Libraries/SmartStore.Core/Data/IQueryableExtensions.cs

@@ -9,7 +9,6 @@ namespace SmartStore
 {
 	public static class IQueryableExtensions
 	{
-
 		/// <summary>
 		/// Instructs the repository to eager load entities that may be in the type's association path.
 		/// </summary>
@@ -40,6 +39,5 @@ public static IQueryable<T> Expand<T, TProperty>(this IQueryable<T> query, Expre
 
 			return query.Include(path);
 		}
-
 	}
 }

src/Libraries/SmartStore.Core/Domain/Catalog/Product.cs

@@ -22,32 +22,21 @@ public partial class Product : BaseEntity, IAuditable, ISoftDeletable, ILocalize
 	{
 		#region static
 
-		private static readonly HashSet<string> _visibilityAffectingProductProps = new HashSet<string>();
-
-		static Product()
-		{
-			AddPropsToSet(_visibilityAffectingProductProps,
-				x => x.AvailableEndDateTimeUtc,
-				x => x.AvailableStartDateTimeUtc,
-				x => x.Deleted,
-				x => x.LowStockActivityId,
-				x => x.LimitedToStores,
-				x => x.ManageInventoryMethodId,
-				x => x.MinStockQuantity,
-				x => x.Published,
-				x => x.SubjectToAcl,
-				x => x.VisibleIndividually);
-		}
-
-		static void AddPropsToSet(HashSet<string> props, params Expression<Func<Product, object>>[] lambdas)
+		private static readonly HashSet<string> _visibilityAffectingProductProps = new HashSet<string>
 		{
-			foreach (var lambda in lambdas)
-			{
-				props.Add(lambda.ExtractPropertyInfo().Name);
-			}
-		}
-
-		public static HashSet<string> GetVisibilityAffectingPropertyNames()
+			nameof(Product.AvailableEndDateTimeUtc),
+			nameof(Product.AvailableStartDateTimeUtc),
+			nameof(Product.Deleted),
+			nameof(Product.LowStockActivityId),
+			nameof(Product.LimitedToStores),
+			nameof(Product.ManageInventoryMethodId),
+			nameof(Product.MinStockQuantity),
+			nameof(Product.Published),
+			nameof(Product.SubjectToAcl),
+			nameof(Product.VisibleIndividually)
+		};
+
+		public static IReadOnlyCollection<string> GetVisibilityAffectingPropertyNames()
 		{
 			return _visibilityAffectingProductProps;
 		}