From 6e4c04b32983f7ee7a0efdbf13463dfaa17966f2 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sun, 14 Jul 2019 13:54:08 +0430
Subject: [PATCH 01/46] add RegExpConstructor

---
 Signum.React/Scripts/Globals.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Signum.React/Scripts/Globals.ts b/Signum.React/Scripts/Globals.ts
index 9f77f2c589..90be4c4dc1 100644
--- a/Signum.React/Scripts/Globals.ts
+++ b/Signum.React/Scripts/Globals.ts
@@ -3,6 +3,10 @@ declare global {
   function require<T>(path: string): T;
   function require<T>(paths: string[], callback: (...modules: any[]) => void): void;
 
+  interface RegExpConstructor {
+    escape(s: string): string;
+  }
+
   interface Promise<T> {
     done(this: Promise<T>): void;
   }

From 293efbb89418ce68b33e22b617a596476a67412a Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sat, 10 Aug 2019 13:28:37 +0200
Subject: [PATCH 02/46] fixes in Local DateTime

---
 Signum.Engine/Connection/FieldReader.cs       | 1219 +++++++++--------
 Signum.React/Scripts/Lines/ValueLine.tsx      |    2 +-
 Signum.React/Scripts/Reflection.ts            |    2 +-
 .../SearchControl/SystemTimeEditor.tsx        |    2 +-
 4 files changed, 613 insertions(+), 612 deletions(-)

diff --git a/Signum.Engine/Connection/FieldReader.cs b/Signum.Engine/Connection/FieldReader.cs
index 16e10a199f..09c985d68d 100644
--- a/Signum.Engine/Connection/FieldReader.cs
+++ b/Signum.Engine/Connection/FieldReader.cs
@@ -1,582 +1,583 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Signum.Utilities.Reflection;
-using System.Linq.Expressions;
-using System.Reflection;
-using Signum.Utilities;
-using Signum.Engine.Maps;
-using Signum.Entities;
-using System.Data.SqlTypes;
-using System.Data.Common;
-//using Microsoft.SqlServer.Types;
-using Signum.Utilities.ExpressionTrees;
-using System.Data.SqlClient;
-using Microsoft.SqlServer.Server;
-using System.IO;
-
-namespace Signum.Engine
-{
-    public class FieldReader
-    {
-        DbDataReader reader;
-        TypeCode[] typeCodes;
-
-        private const TypeCode tcGuid = (TypeCode)20;
-        private const TypeCode tcTimeSpan = (TypeCode)21;
-        private const TypeCode tcDateTimeOffset = (TypeCode)22;
-
-        public int LastOrdinal;
-
-        TypeCode GetTypeCode(int ordinal)
-        {
-            Type type = reader.GetFieldType(ordinal);
-            TypeCode tc = Type.GetTypeCode(type);
-            if (tc == TypeCode.Object)
-            {
-                if (type == typeof(Guid))
-                    tc = tcGuid;
-
-                if (type == typeof(TimeSpan))
-                    tc = tcTimeSpan;
-
-                if (type == typeof(DateTimeOffset))
-                    tc = tcDateTimeOffset;
-            }
-            return tc;
-        }
-
-        public FieldReader(DbDataReader reader)
-        {
-            this.reader = reader;
-
-            this.typeCodes = new TypeCode[reader.FieldCount];
-            for (int i = 0; i < typeCodes.Length; i++)
-                typeCodes[i] = GetTypeCode(i);
-        }
-
-        public bool IsNull(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            return reader.IsDBNull(ordinal);
-        }
-
-        public string? GetString(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return reader.GetByte(ordinal).ToString();
-                case TypeCode.Int16:
-                    return reader.GetInt16(ordinal).ToString();
-                case TypeCode.Int32:
-                    return reader.GetInt32(ordinal).ToString();
-                case TypeCode.Int64:
-                    return reader.GetInt64(ordinal).ToString();
-                case TypeCode.Double:
-                    return reader.GetDouble(ordinal).ToString();
-                case TypeCode.Single:
-                    return reader.GetFloat(ordinal).ToString();
-                case TypeCode.Decimal:
-                    return reader.GetDecimal(ordinal).ToString();
-                case TypeCode.DateTime:
-                    return reader.GetDateTime(ordinal).ToString();
-                case tcGuid:
-                    return reader.GetGuid(ordinal).ToString();
-                case TypeCode.String:
-                    return reader.GetString(ordinal);
-                default:
-                    return reader.GetValue(ordinal).ToString();
-            }
-        }
-
-        public byte[]? GetByteArray(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-
-            return (byte[])reader.GetValue(ordinal);
-        }
-
-        public bool GetBoolean(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Boolean:
-                    return reader.GetBoolean(ordinal);
-                case TypeCode.Byte:
-                    return reader.GetByte(ordinal) != 0;
-                case TypeCode.Int16:
-                    return reader.GetInt16(ordinal) != 0;
-                case TypeCode.Int32:
-                    return reader.GetInt32(ordinal) != 0;
-                case TypeCode.Int64:
-                    return reader.GetInt64(ordinal) != 0;
-                case TypeCode.String:
-                    return bool.Parse(reader.GetString(ordinal));
-                default:
-                    return ReflectionTools.ChangeType<bool>(reader.GetValue(ordinal));
-            }
-        }
-
-        public bool? GetNullableBoolean(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetBoolean(ordinal);
-        }
-
-
-        public Byte GetByte(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Byte)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Byte)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Byte)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Byte)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Byte)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Byte)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Byte>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Byte? GetNullableByte(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetByte(ordinal);
-        }
-
-
-        public Char GetChar(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Char)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Char)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Char)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Char)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Char)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Char)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Char)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Char>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Char? GetNullableChar(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetChar(ordinal);
-        }
-
-
-        public Single GetFloat(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Single)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Single)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Single)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Single)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Single)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Single)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Single>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Single? GetNullableFloat(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetFloat(ordinal);
-        }
-
-
-        public Double GetDouble(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Double)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Double)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Double)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Double)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Double)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Double)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Double>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Double? GetNullableDouble(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetDouble(ordinal);
-        }
-
-
-        public Decimal GetDecimal(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Decimal)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Decimal)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Decimal)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Decimal)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Decimal)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Decimal)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Decimal>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Decimal? GetNullableDecimal(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetDecimal(ordinal);
-        }
-
-
-        public Int16 GetInt16(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Int16)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Int16)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Int16)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Int16)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Int16)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Int16)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Int16>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Int16? GetNullableInt16(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetInt16(ordinal);
-        }
-
-
-        public Int32 GetInt32(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Int32)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Int32)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Int32)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Int32)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Int32)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Int32)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Int32>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Int32? GetNullableInt32(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetInt32(ordinal);
-        }
-
-
-        public Int64 GetInt64(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.Byte:
-                    return (Int64)reader.GetByte(ordinal);
-                case TypeCode.Int16:
-                    return (Int64)reader.GetInt16(ordinal);
-                case TypeCode.Int32:
-                    return (Int64)reader.GetInt32(ordinal);
-                case TypeCode.Int64:
-                    return (Int64)reader.GetInt64(ordinal);
-                case TypeCode.Double:
-                    return (Int64)reader.GetDouble(ordinal);
-                case TypeCode.Single:
-                    return (Int64)reader.GetFloat(ordinal);
-                case TypeCode.Decimal:
-                    return (Int64)reader.GetDecimal(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Int64>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Int64? GetNullableInt64(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetInt64(ordinal);
-        }
-
-
-        public DateTime GetDateTime(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            DateTime dt;
-            switch (typeCodes[ordinal])
-            {
-                case TypeCode.DateTime:
-                    dt = reader.GetDateTime(ordinal);
-                    break;
-                default:
-                    dt = ReflectionTools.ChangeType<DateTime>(reader.GetValue(ordinal));
-                    break;
-            }
-
-            if (Schema.Current.TimeZoneMode == TimeZoneMode.Utc)
-                return new DateTime(dt.Ticks, DateTimeKind.Utc);
-            return dt;
-        }
-
-        public DateTime? GetNullableDateTime(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetDateTime(ordinal);
-        }
-
-
-        public DateTimeOffset GetDateTimeOffset(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case tcDateTimeOffset:
-                    return ((SqlDataReader)reader).GetDateTimeOffset(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<DateTimeOffset>(reader.GetValue(ordinal));
-            }
-        }
-
-        public DateTimeOffset? GetNullableDateTimeOffset(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetDateTimeOffset(ordinal);
-        }
-
-
-        public TimeSpan GetTimeSpan(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case tcTimeSpan:
-                    return ((SqlDataReader)reader).GetTimeSpan(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<TimeSpan>(reader.GetValue(ordinal));
-            }
-        }
-
-        public TimeSpan? GetNullableTimeSpan(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetTimeSpan(ordinal);
-        }
-
-
-        public Guid GetGuid(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            switch (typeCodes[ordinal])
-            {
-                case tcGuid:
-                    return reader.GetGuid(ordinal);
-                default:
-                    return ReflectionTools.ChangeType<Guid>(reader.GetValue(ordinal));
-            }
-        }
-
-        public Guid? GetNullableGuid(int ordinal)
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return null;
-            }
-            return GetGuid(ordinal);
-        }
-      
-        static MethodInfo miGetUdt = ReflectionTools.GetMethodInfo((FieldReader r) => r.GetUdt<IBinarySerialize>(0)).GetGenericMethodDefinition(); 
-
-        public T GetUdt<T>(int ordinal)
-            where T : IBinarySerialize
-        {
-            LastOrdinal = ordinal;
-            if (reader.IsDBNull(ordinal))
-            {
-                return (T)(object)null!;
-            }
-
-            var udt = Activator.CreateInstance<T>();
-            udt.Read(new BinaryReader(reader.GetStream(ordinal)));
-            return udt;
-        }
-
-        static Dictionary<Type, MethodInfo> methods =
-            typeof(FieldReader).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
-            .Where(m => m.Name != "GetExpression" && m.Name != "IsNull")
-            .ToDictionary(a => a.ReturnType);
-
-
-        public static Expression GetExpression(Expression reader, int ordinal, Type type)
-        {
-            MethodInfo? mi = methods.TryGetC(type);
-            if (mi != null)
-                return Expression.Call(reader, mi, Expression.Constant(ordinal));
-
-            if (typeof(IBinarySerialize).IsAssignableFrom(type.UnNullify()))
-            {
-                if (type.IsNullable())
-                    return Expression.Call(reader, miGetUdt.MakeGenericMethod(type.UnNullify()), Expression.Constant(ordinal)).Nullify();
-                else
-                    return Expression.Call(reader, miGetUdt.MakeGenericMethod(type.UnNullify()), Expression.Constant(ordinal));
-            }
-
-            throw new InvalidOperationException("Type {0} not supported".FormatWith(type));
-        }
-
-        static MethodInfo miIsNull = ReflectionTools.GetMethodInfo((FieldReader r) => r.IsNull(0));
-
-        public static Expression GetIsNull(Expression reader, int ordinal)
-        {
-            return Expression.Call(reader, miIsNull, Expression.Constant(ordinal));
-        }
-
-        internal FieldReaderException CreateFieldReaderException(Exception ex)
-        {
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Signum.Utilities.Reflection;
+using System.Linq.Expressions;
+using System.Reflection;
+using Signum.Utilities;
+using Signum.Engine.Maps;
+using Signum.Entities;
+using System.Data.SqlTypes;
+using System.Data.Common;
+//using Microsoft.SqlServer.Types;
+using Signum.Utilities.ExpressionTrees;
+using System.Data.SqlClient;
+using Microsoft.SqlServer.Server;
+using System.IO;
+
+namespace Signum.Engine
+{
+    public class FieldReader
+    {
+        DbDataReader reader;
+        TypeCode[] typeCodes;
+
+        private const TypeCode tcGuid = (TypeCode)20;
+        private const TypeCode tcTimeSpan = (TypeCode)21;
+        private const TypeCode tcDateTimeOffset = (TypeCode)22;
+
+        public int LastOrdinal;
+
+        TypeCode GetTypeCode(int ordinal)
+        {
+            Type type = reader.GetFieldType(ordinal);
+            TypeCode tc = Type.GetTypeCode(type);
+            if (tc == TypeCode.Object)
+            {
+                if (type == typeof(Guid))
+                    tc = tcGuid;
+
+                if (type == typeof(TimeSpan))
+                    tc = tcTimeSpan;
+
+                if (type == typeof(DateTimeOffset))
+                    tc = tcDateTimeOffset;
+            }
+            return tc;
+        }
+
+        public FieldReader(DbDataReader reader)
+        {
+            this.reader = reader;
+
+            this.typeCodes = new TypeCode[reader.FieldCount];
+            for (int i = 0; i < typeCodes.Length; i++)
+                typeCodes[i] = GetTypeCode(i);
+        }
+
+        public bool IsNull(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            return reader.IsDBNull(ordinal);
+        }
+
+        public string? GetString(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return reader.GetByte(ordinal).ToString();
+                case TypeCode.Int16:
+                    return reader.GetInt16(ordinal).ToString();
+                case TypeCode.Int32:
+                    return reader.GetInt32(ordinal).ToString();
+                case TypeCode.Int64:
+                    return reader.GetInt64(ordinal).ToString();
+                case TypeCode.Double:
+                    return reader.GetDouble(ordinal).ToString();
+                case TypeCode.Single:
+                    return reader.GetFloat(ordinal).ToString();
+                case TypeCode.Decimal:
+                    return reader.GetDecimal(ordinal).ToString();
+                case TypeCode.DateTime:
+                    return reader.GetDateTime(ordinal).ToString();
+                case tcGuid:
+                    return reader.GetGuid(ordinal).ToString();
+                case TypeCode.String:
+                    return reader.GetString(ordinal);
+                default:
+                    return reader.GetValue(ordinal).ToString();
+            }
+        }
+
+        public byte[]? GetByteArray(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+
+            return (byte[])reader.GetValue(ordinal);
+        }
+
+        public bool GetBoolean(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Boolean:
+                    return reader.GetBoolean(ordinal);
+                case TypeCode.Byte:
+                    return reader.GetByte(ordinal) != 0;
+                case TypeCode.Int16:
+                    return reader.GetInt16(ordinal) != 0;
+                case TypeCode.Int32:
+                    return reader.GetInt32(ordinal) != 0;
+                case TypeCode.Int64:
+                    return reader.GetInt64(ordinal) != 0;
+                case TypeCode.String:
+                    return bool.Parse(reader.GetString(ordinal));
+                default:
+                    return ReflectionTools.ChangeType<bool>(reader.GetValue(ordinal));
+            }
+        }
+
+        public bool? GetNullableBoolean(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetBoolean(ordinal);
+        }
+
+
+        public Byte GetByte(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Byte)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Byte)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Byte)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Byte)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Byte)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Byte)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Byte>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Byte? GetNullableByte(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetByte(ordinal);
+        }
+
+
+        public Char GetChar(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Char)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Char)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Char)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Char)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Char)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Char)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Char)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Char>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Char? GetNullableChar(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetChar(ordinal);
+        }
+
+
+        public Single GetFloat(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Single)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Single)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Single)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Single)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Single)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Single)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Single>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Single? GetNullableFloat(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetFloat(ordinal);
+        }
+
+
+        public Double GetDouble(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Double)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Double)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Double)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Double)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Double)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Double)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Double>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Double? GetNullableDouble(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetDouble(ordinal);
+        }
+
+
+        public Decimal GetDecimal(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Decimal)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Decimal)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Decimal)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Decimal)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Decimal)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Decimal)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Decimal>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Decimal? GetNullableDecimal(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetDecimal(ordinal);
+        }
+
+
+        public Int16 GetInt16(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Int16)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Int16)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Int16)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Int16)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Int16)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Int16)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Int16>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Int16? GetNullableInt16(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetInt16(ordinal);
+        }
+
+
+        public Int32 GetInt32(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Int32)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Int32)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Int32)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Int32)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Int32)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Int32)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Int32>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Int32? GetNullableInt32(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetInt32(ordinal);
+        }
+
+
+        public Int64 GetInt64(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.Byte:
+                    return (Int64)reader.GetByte(ordinal);
+                case TypeCode.Int16:
+                    return (Int64)reader.GetInt16(ordinal);
+                case TypeCode.Int32:
+                    return (Int64)reader.GetInt32(ordinal);
+                case TypeCode.Int64:
+                    return (Int64)reader.GetInt64(ordinal);
+                case TypeCode.Double:
+                    return (Int64)reader.GetDouble(ordinal);
+                case TypeCode.Single:
+                    return (Int64)reader.GetFloat(ordinal);
+                case TypeCode.Decimal:
+                    return (Int64)reader.GetDecimal(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Int64>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Int64? GetNullableInt64(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetInt64(ordinal);
+        }
+
+
+        public DateTime GetDateTime(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            DateTime dt;
+            switch (typeCodes[ordinal])
+            {
+                case TypeCode.DateTime:
+                    dt = reader.GetDateTime(ordinal);
+                    break;
+                default:
+                    dt = ReflectionTools.ChangeType<DateTime>(reader.GetValue(ordinal));
+                    break;
+            }
+
+            if (Schema.Current.TimeZoneMode == TimeZoneMode.Utc)
+                return new DateTime(dt.Ticks, DateTimeKind.Utc);
+
+            return new DateTime(dt.Ticks, DateTimeKind.Local);
+        }
+
+        public DateTime? GetNullableDateTime(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetDateTime(ordinal);
+        }
+
+
+        public DateTimeOffset GetDateTimeOffset(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case tcDateTimeOffset:
+                    return ((SqlDataReader)reader).GetDateTimeOffset(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<DateTimeOffset>(reader.GetValue(ordinal));
+            }
+        }
+
+        public DateTimeOffset? GetNullableDateTimeOffset(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetDateTimeOffset(ordinal);
+        }
+
+
+        public TimeSpan GetTimeSpan(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case tcTimeSpan:
+                    return ((SqlDataReader)reader).GetTimeSpan(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<TimeSpan>(reader.GetValue(ordinal));
+            }
+        }
+
+        public TimeSpan? GetNullableTimeSpan(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetTimeSpan(ordinal);
+        }
+
+
+        public Guid GetGuid(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            switch (typeCodes[ordinal])
+            {
+                case tcGuid:
+                    return reader.GetGuid(ordinal);
+                default:
+                    return ReflectionTools.ChangeType<Guid>(reader.GetValue(ordinal));
+            }
+        }
+
+        public Guid? GetNullableGuid(int ordinal)
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return null;
+            }
+            return GetGuid(ordinal);
+        }
+      
+        static MethodInfo miGetUdt = ReflectionTools.GetMethodInfo((FieldReader r) => r.GetUdt<IBinarySerialize>(0)).GetGenericMethodDefinition(); 
+
+        public T GetUdt<T>(int ordinal)
+            where T : IBinarySerialize
+        {
+            LastOrdinal = ordinal;
+            if (reader.IsDBNull(ordinal))
+            {
+                return (T)(object)null!;
+            }
+
+            var udt = Activator.CreateInstance<T>();
+            udt.Read(new BinaryReader(reader.GetStream(ordinal)));
+            return udt;
+        }
+
+        static Dictionary<Type, MethodInfo> methods =
+            typeof(FieldReader).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
+            .Where(m => m.Name != "GetExpression" && m.Name != "IsNull")
+            .ToDictionary(a => a.ReturnType);
+
+
+        public static Expression GetExpression(Expression reader, int ordinal, Type type)
+        {
+            MethodInfo? mi = methods.TryGetC(type);
+            if (mi != null)
+                return Expression.Call(reader, mi, Expression.Constant(ordinal));
+
+            if (typeof(IBinarySerialize).IsAssignableFrom(type.UnNullify()))
+            {
+                if (type.IsNullable())
+                    return Expression.Call(reader, miGetUdt.MakeGenericMethod(type.UnNullify()), Expression.Constant(ordinal)).Nullify();
+                else
+                    return Expression.Call(reader, miGetUdt.MakeGenericMethod(type.UnNullify()), Expression.Constant(ordinal));
+            }
+
+            throw new InvalidOperationException("Type {0} not supported".FormatWith(type));
+        }
+
+        static MethodInfo miIsNull = ReflectionTools.GetMethodInfo((FieldReader r) => r.IsNull(0));
+
+        public static Expression GetIsNull(Expression reader, int ordinal)
+        {
+            return Expression.Call(reader, miIsNull, Expression.Constant(ordinal));
+        }
+
+        internal FieldReaderException CreateFieldReaderException(Exception ex)
+        {
             return new FieldReaderException(ex, 
                 ordinal:  LastOrdinal,
-                columnName: reader.GetName(LastOrdinal),
-                columnType: reader.GetFieldType(LastOrdinal)
-            );
-        }
-    }
-
-    [Serializable]
-    public class FieldReaderException : SqlTypeException
-    {
+                columnName: reader.GetName(LastOrdinal),
+                columnType: reader.GetFieldType(LastOrdinal)
+            );
+        }
+    }
+
+    [Serializable]
+    public class FieldReaderException : SqlTypeException
+    {
         public FieldReaderException(Exception inner, int ordinal, string columnName, Type columnType) : base(null, inner)
         {
             this.Ordinal = ordinal;
@@ -586,35 +587,35 @@ public FieldReaderException(Exception inner, int ordinal, string columnName, Typ
 #pragma warning disable CS8618 // Non-nullable field is uninitialized.
         protected FieldReaderException(
 #pragma warning restore CS8618 // Non-nullable field is uninitialized.
-          System.Runtime.Serialization.SerializationInfo info,
-          System.Runtime.Serialization.StreamingContext context)
-            : base(info, context) { }
-
-        public override string Message
-        {
-            get
-            {
-                string text = "{0}\r\nOrdinal: {1}\r\nColumnName: {2}\r\nRow: {3}".FormatWith(
-                    InnerException.Message, Ordinal, ColumnName, Row);
-
-                if (Projector != null)
-                {
-                    text += "\r\nCalling: row.Reader.Get{0}({1})".FormatWith(ColumnType.Name, Ordinal);
-                    text += "\r\nProjector:\r\n{0}".FormatWith(Projector.ToString().Indent(4));
-                }
-
-                if(Command != null)
-                    text += "\r\nCommand:\r\n{0}".FormatWith(Command.PlainSql().Indent(4));
-
-                 return text;
-            }
-        }
-
-        public int Ordinal { get; internal set; }
-        public string ColumnName { get; internal set; }
-        public Type ColumnType { get; internal set; }
-        public int Row { get; internal set; }
-        public SqlPreCommand? Command { get; internal set; }
-        public LambdaExpression? Projector { get; internal set; }
-    }
-}
+          System.Runtime.Serialization.SerializationInfo info,
+          System.Runtime.Serialization.StreamingContext context)
+            : base(info, context) { }
+
+        public override string Message
+        {
+            get
+            {
+                string text = "{0}\r\nOrdinal: {1}\r\nColumnName: {2}\r\nRow: {3}".FormatWith(
+                    InnerException.Message, Ordinal, ColumnName, Row);
+
+                if (Projector != null)
+                {
+                    text += "\r\nCalling: row.Reader.Get{0}({1})".FormatWith(ColumnType.Name, Ordinal);
+                    text += "\r\nProjector:\r\n{0}".FormatWith(Projector.ToString().Indent(4));
+                }
+
+                if(Command != null)
+                    text += "\r\nCommand:\r\n{0}".FormatWith(Command.PlainSql().Indent(4));
+
+                 return text;
+            }
+        }
+
+        public int Ordinal { get; internal set; }
+        public string ColumnName { get; internal set; }
+        public Type ColumnType { get; internal set; }
+        public int Row { get; internal set; }
+        public SqlPreCommand? Command { get; internal set; }
+        public LambdaExpression? Projector { get; internal set; }
+    }
+}
diff --git a/Signum.React/Scripts/Lines/ValueLine.tsx b/Signum.React/Scripts/Lines/ValueLine.tsx
index d8732e372e..a6e088e5b3 100644
--- a/Signum.React/Scripts/Lines/ValueLine.tsx
+++ b/Signum.React/Scripts/Lines/ValueLine.tsx
@@ -548,7 +548,7 @@ ValueLine.renderers["DateTime" as ValueLineType] = (vl) => {
 
   const momentFormat = toMomentFormat(s.formatText);
 
-  const m = s.ctx.value ? moment(s.ctx.value, moment.ISO_8601) : undefined;
+  const m = s.ctx.value ? moment(s.ctx.value) : undefined;
   const showTime = momentFormat != "L" && momentFormat != "LL";
 
   if (s.ctx.readOnly)
diff --git a/Signum.React/Scripts/Reflection.ts b/Signum.React/Scripts/Reflection.ts
index f14df6642b..8519e50644 100644
--- a/Signum.React/Scripts/Reflection.ts
+++ b/Signum.React/Scripts/Reflection.ts
@@ -172,7 +172,7 @@ export function dateToString(val: any, format?: string) {
   if (val == null)
     return "";
 
-  var m = moment(val, moment.ISO_8601);
+  var m = moment(val);
   return m.format(toMomentFormat(format));
 }
 
diff --git a/Signum.React/Scripts/SearchControl/SystemTimeEditor.tsx b/Signum.React/Scripts/SearchControl/SystemTimeEditor.tsx
index 70f776430e..6336ab43b4 100644
--- a/Signum.React/Scripts/SearchControl/SystemTimeEditor.tsx
+++ b/Signum.React/Scripts/SearchControl/SystemTimeEditor.tsx
@@ -140,7 +140,7 @@ export default class SystemTimeEditor extends React.Component<SystemTimeEditorPr
       systemTime[field] = m.isValid() ? m.format() : undefined;
     };
 
-    var m = moment(systemTime[field], moment.ISO_8601)
+    var m = moment(systemTime[field])
     var momentFormat = "YYYY-MM-DDTHH:mm:ss";
     return (
       <div className="rw-widget-sm ml-1" style={{ width: "230px" }}>

From a934de655846c89f852abfb6dd9106f4bcd43ebe Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sat, 17 Aug 2019 09:53:34 +0430
Subject: [PATCH 03/46] add createOnFind

---
 Signum.React/Scripts/Lines/EntityBase.tsx     | 5 +++--
 Signum.React/Scripts/Lines/EntityListBase.tsx | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/Signum.React/Scripts/Lines/EntityBase.tsx b/Signum.React/Scripts/Lines/EntityBase.tsx
index fbf365a887..0559096f0c 100644
--- a/Signum.React/Scripts/Lines/EntityBase.tsx
+++ b/Signum.React/Scripts/Lines/EntityBase.tsx
@@ -19,6 +19,7 @@ export interface EntityBaseProps extends LineBaseProps {
   viewOnCreate?: boolean;
   navigate?: boolean;
   create?: boolean;
+  createOnFind?: boolean;
   find?: boolean;
   remove?: boolean | ((item: any /*T*/) => boolean);
 
@@ -272,12 +273,12 @@ export abstract class EntityBase<T extends EntityBaseProps, S extends EntityBase
   defaultFind(): Promise<ModifiableEntity | Lite<Entity> | undefined> {
 
     if (this.state.findOptions) {
-      return Finder.find(this.state.findOptions);
+      return Finder.find(this.state.findOptions, { searchControlProps: { create: this.props.createOnFind } });
     }
 
     return this.chooseType(ti => Finder.isFindable(ti, false))
       .then<ModifiableEntity | Lite<Entity> | undefined>(qn =>
-        qn == undefined ? undefined : Finder.find({ queryName: qn } as FindOptions));
+        qn == undefined ? undefined : Finder.find({ queryName: qn } as FindOptions, { searchControlProps: { create: this.props.createOnFind } }));
   }
 
   handleFindClick = (event: React.SyntheticEvent<any>) => {
diff --git a/Signum.React/Scripts/Lines/EntityListBase.tsx b/Signum.React/Scripts/Lines/EntityListBase.tsx
index 37260b840b..07c6d946aa 100644
--- a/Signum.React/Scripts/Lines/EntityListBase.tsx
+++ b/Signum.React/Scripts/Lines/EntityListBase.tsx
@@ -127,11 +127,12 @@ export abstract class EntityListBase<T extends EntityListBaseProps, S extends En
   defaultFindMany(): Promise<(ModifiableEntity | Lite<Entity>)[] | undefined> {
 
     if (this.state.findOptions) {
-      return Finder.findMany(this.state.findOptions);
+      return Finder.findMany(this.state.findOptions, { searchControlProps: { create: this.props.createOnFind } });
     }
 
     return this.chooseType(ti => Finder.isFindable(ti, false))
-      .then<(ModifiableEntity | Lite<Entity>)[] | undefined>(qn => qn == undefined ? undefined : Finder.findMany({ queryName: qn } as FindOptions));
+      .then<(ModifiableEntity | Lite<Entity>)[] | undefined>(qn => qn == undefined ? undefined :
+        Finder.findMany({ queryName: qn } as FindOptions, { searchControlProps: { create: this.props.createOnFind } }));
   }
 
   addElement(entityOrLite: Lite<Entity> | ModifiableEntity) {

From 44188236a23724733cb461979511178ff5a741d5 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 19 Aug 2019 09:51:00 +0200
Subject: [PATCH 04/46] add IDiacriticsRemover

---
 Signum.Utilities/Extensions/StringExtensions.cs     |  5 +++++
 Signum.Utilities/NaturalLanguage/German.cs          | 13 +++++++++++++
 .../NaturalLanguage/NaturalLanguageTools.cs         | 10 ++++++++++
 3 files changed, 28 insertions(+)

diff --git a/Signum.Utilities/Extensions/StringExtensions.cs b/Signum.Utilities/Extensions/StringExtensions.cs
index 8667b80b11..9e20698664 100644
--- a/Signum.Utilities/Extensions/StringExtensions.cs
+++ b/Signum.Utilities/Extensions/StringExtensions.cs
@@ -743,6 +743,11 @@ public static string RemoveDiacritics(this string s)
             if (string.IsNullOrEmpty(s))
                 return s;
 
+            var dr  = NaturalLanguageTools.DiacriticsRemover.TryGetC(CultureInfo.CurrentCulture.TwoLetterISOLanguageName);
+
+            if (dr != null)
+                s = dr.RemoveDiacritics(s);
+
             string normalizedString = s.Normalize(NormalizationForm.FormD);
             StringBuilder stringBuilder = new StringBuilder();
 
diff --git a/Signum.Utilities/NaturalLanguage/German.cs b/Signum.Utilities/NaturalLanguage/German.cs
index c67ea0eecd..a4eda2a31d 100644
--- a/Signum.Utilities/NaturalLanguage/German.cs
+++ b/Signum.Utilities/NaturalLanguage/German.cs
@@ -302,4 +302,17 @@ private static string GetUpToHundred(int number)
 
     }
 
+    public class GermanDiacriticsRemover : IDiacriticsRemover
+    {
+        public string RemoveDiacritics(string str)
+        {
+            return str
+                .Replace("ü", "ue")
+                .Replace("ä", "ae")
+                .Replace("ö", "oe")
+                .Replace("Ü", "Ue")
+                .Replace("Ä", "Ae")
+                .Replace("Ö", "Oe");
+        }
+    }
 }
diff --git a/Signum.Utilities/NaturalLanguage/NaturalLanguageTools.cs b/Signum.Utilities/NaturalLanguage/NaturalLanguageTools.cs
index 22f8d96bf3..cbaf3dcec8 100644
--- a/Signum.Utilities/NaturalLanguage/NaturalLanguageTools.cs
+++ b/Signum.Utilities/NaturalLanguage/NaturalLanguageTools.cs
@@ -29,6 +29,11 @@ public static class NaturalLanguageTools
             {"de", new GermanNumberWriter()},
         };
 
+        public static Dictionary<string, IDiacriticsRemover> DiacriticsRemover = new Dictionary<string, IDiacriticsRemover>
+        {
+            {"de", new GermanDiacriticsRemover()},
+        };
+
         public static char? GetGender(string name, CultureInfo? culture = null)
         {
             var defCulture = culture ?? CultureInfo.CurrentUICulture;
@@ -287,6 +292,11 @@ public interface INumberWriter
         string ToNumber(decimal number, NumberWriterSettings settings);
     }
 
+    public interface IDiacriticsRemover
+    {
+        string RemoveDiacritics(string str);
+    }
+
 #pragma warning disable CS8618 // Non-nullable field is uninitialized.
     public class NumberWriterSettings
     {

From c54c76bcf9b8a079e1a40919cc45c400655dcaaf Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 20 Aug 2019 16:15:50 +0200
Subject: [PATCH 05/46] add help text to ValueLine inlineCheckbox

---
 Signum.React/Scripts/Lines/ValueLine.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Signum.React/Scripts/Lines/ValueLine.tsx b/Signum.React/Scripts/Lines/ValueLine.tsx
index 9f99277e86..a79270eca1 100644
--- a/Signum.React/Scripts/Lines/ValueLine.tsx
+++ b/Signum.React/Scripts/Lines/ValueLine.tsx
@@ -193,6 +193,7 @@ ValueLine.renderers["Checkbox" as ValueLineType] = (vl) => {
       <label className={vl.state.ctx.error} style={{ display: s.inlineCheckbox == "block" ? "block" : undefined }} {...vl.baseHtmlAttributes()} {...s.formGroupHtmlAttributes}>
         <input type="checkbox" {...vl.state.valueHtmlAttributes} checked={s.ctx.value || false} onChange={handleCheckboxOnChange} disabled={s.ctx.readOnly} />
         {" " + s.labelText}
+        {s.helpText && <small className="form-text text-muted">{s.helpText}</small>}
       </label>
     );
   }

From 33611910207091ac2d919b799d00a7f9f84af267 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 20 Aug 2019 16:16:12 +0200
Subject: [PATCH 06/46] add empty collection  to IsSetOnlyWhen

---
 Signum.Entities/ValidationAttributes.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Signum.Entities/ValidationAttributes.cs b/Signum.Entities/ValidationAttributes.cs
index 86eb5e2550..bbca206698 100644
--- a/Signum.Entities/ValidationAttributes.cs
+++ b/Signum.Entities/ValidationAttributes.cs
@@ -92,7 +92,9 @@ public static class NotNullValidatorExtensions
     {
         public static string? IsSetOnlyWhen(this (PropertyInfo pi, object? nullableValue) tuple, bool shouldBeSet)
         {
-            var isNull = tuple.nullableValue == null || tuple.nullableValue is string s && string.IsNullOrEmpty(s);
+            var isNull = tuple.nullableValue == null || 
+                tuple.nullableValue is string s && string.IsNullOrEmpty(s) || 
+                tuple.nullableValue is ICollection col && col.Count == 0;
 
             if (isNull && shouldBeSet)
                 return ValidationMessage._0IsNotSet.NiceToString(tuple.pi.NiceName());

From 0eb34e9b5166ed365ed3a717b089e6cabc6a44c8 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Wed, 21 Aug 2019 12:09:34 +0200
Subject: [PATCH 07/46] add Navigator.isReadonly(ignoreTypeIsReadonly) to avoid
 need for showOnReadOnly on System entities

---
 Signum.React/Scripts/Navigator.tsx                       | 5 ++---
 Signum.React/Scripts/Operations/ContextualOperations.tsx | 4 ++--
 Signum.React/Scripts/Operations/EntityOperations.tsx     | 2 +-
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/Signum.React/Scripts/Navigator.tsx b/Signum.React/Scripts/Navigator.tsx
index 7c0112cd02..0d5c9aad25 100644
--- a/Signum.React/Scripts/Navigator.tsx
+++ b/Signum.React/Scripts/Navigator.tsx
@@ -345,18 +345,17 @@ function typeIsCreable(typeName: string): EntityWhen {
 
 export const isReadonlyEvent: Array<(typeName: string, entity?: EntityPack<ModifiableEntity>) => boolean> = [];
 
-export function isReadOnly(typeOrEntity: PseudoType | EntityPack<ModifiableEntity>) {
+export function isReadOnly(typeOrEntity: PseudoType | EntityPack<ModifiableEntity>, ignoreTypeIsReadonly: boolean = false) {
 
   const entityPack = isEntityPack(typeOrEntity) ? typeOrEntity : undefined;
 
   const typeName = isEntityPack(typeOrEntity) ? typeOrEntity.entity.Type : getTypeName(typeOrEntity as PseudoType);
 
-  const baseIsReadOnly = typeIsReadOnly(typeName);
+  const baseIsReadOnly = ignoreTypeIsReadonly ? false : typeIsReadOnly(typeName);
 
   return baseIsReadOnly || isReadonlyEvent.some(f => f(typeName, entityPack));
 }
 
-
 function typeIsReadOnly(typeName: string): boolean {
 
   const es = entitySettings[typeName];
diff --git a/Signum.React/Scripts/Operations/ContextualOperations.tsx b/Signum.React/Scripts/Operations/ContextualOperations.tsx
index d47b4d9abe..7403c7837b 100644
--- a/Signum.React/Scripts/Operations/ContextualOperations.tsx
+++ b/Signum.React/Scripts/Operations/ContextualOperations.tsx
@@ -114,7 +114,7 @@ export function getEntityOperationsContextualItems(ctx: ContextualItemsContext<E
       contextPromise = Navigator.API.fetchEntityPack(ctx.lites[0]).then(ep => {
         contexts.forEach(coc => {
           coc.canExecute = ep.canExecute[coc.operationInfo.key];
-          coc.isReadonly = Navigator.isReadOnly(ep);
+          coc.isReadonly = Navigator.isReadOnly(ep, true);
         });
         return contexts;
       });
@@ -130,7 +130,7 @@ export function getEntityOperationsContextualItems(ctx: ContextualItemsContext<E
     }
   } else {
 
-    if (Navigator.isReadOnly(ti)) {
+    if (Navigator.isReadOnly(ti, true)) {
       contexts.forEach(a => a.isReadonly = true);
     }
 
diff --git a/Signum.React/Scripts/Operations/EntityOperations.tsx b/Signum.React/Scripts/Operations/EntityOperations.tsx
index d6ff541be0..10b60fa238 100644
--- a/Signum.React/Scripts/Operations/EntityOperations.tsx
+++ b/Signum.React/Scripts/Operations/EntityOperations.tsx
@@ -53,7 +53,7 @@ export function getEntityOperationButtons(ctx: ButtonsContext): Array<ButtonBarE
       if (eos && eos.hideOnCanExecute && eoc.canExecute)
         return false;
 
-      if (Navigator.isReadOnly(ctx.pack) && !(eos && eos.showOnReadOnly))
+      if (Navigator.isReadOnly(ctx.pack, true) && !(eos && eos.showOnReadOnly))
         return false;
 
       return true;

From a87ed3276ecc0adcfe6196f96b00116ad348bf13 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Wed, 21 Aug 2019 12:09:48 +0200
Subject: [PATCH 08/46] fix getMember

---
 Signum.React/Scripts/Reflection.ts | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Reflection.ts b/Signum.React/Scripts/Reflection.ts
index f14df6642b..dbf54ded2c 100644
--- a/Signum.React/Scripts/Reflection.ts
+++ b/Signum.React/Scripts/Reflection.ts
@@ -1189,6 +1189,9 @@ let missingSymbols: ISymbol[] = [];
 
 function getMember(key: string): MemberInfo | undefined {
 
+  if (!key.contains("."))
+    return undefined;
+
   const type = _types[key.before(".").toLowerCase()];
 
   if (!type)
@@ -1201,9 +1204,14 @@ function getMember(key: string): MemberInfo | undefined {
 
 export function symbolNiceName(symbol: Entity & ISymbol | Lite<Entity & ISymbol>) {
   if ((symbol as Entity).Type != null) //Don't use isEntity to avoid cycle
-    return getMember((symbol as Entity & ISymbol).key)!.niceName;
-  else
-    return getMember(symbol.toStr!)!.niceName;
+  {
+    var m = getMember((symbol as Entity & ISymbol).key);
+    return m && m.niceName || symbol.toStr;
+  }
+  else {
+    var m = getMember(symbol.toStr!);
+    return m && m.niceName || symbol.toStr;
+  }
 }
 
 export function getSymbol<T extends Entity & ISymbol>(type: Type<T>, key: string) { //Unsafe Type!

From 66e45eb6124debaefa9db3db5ec61baf45daf631 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Wed, 21 Aug 2019 16:08:07 +0200
Subject: [PATCH 09/46] make symbolNiceName return string

---
 Signum.React/Scripts/Reflection.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Reflection.ts b/Signum.React/Scripts/Reflection.ts
index 77365a57f1..ce860ee718 100644
--- a/Signum.React/Scripts/Reflection.ts
+++ b/Signum.React/Scripts/Reflection.ts
@@ -1202,15 +1202,15 @@ function getMember(key: string): MemberInfo | undefined {
   return member;
 }
 
-export function symbolNiceName(symbol: Entity & ISymbol | Lite<Entity & ISymbol>) {
+export function symbolNiceName(symbol: Entity & ISymbol | Lite<Entity & ISymbol>) : string {
   if ((symbol as Entity).Type != null) //Don't use isEntity to avoid cycle
   {
     var m = getMember((symbol as Entity & ISymbol).key);
-    return m && m.niceName || symbol.toStr;
+    return m && m.niceName || symbol.toStr!;
   }
   else {
     var m = getMember(symbol.toStr!);
-    return m && m.niceName || symbol.toStr;
+    return m && m.niceName || symbol.toStr!;
   }
 }
 

From ca11d439a03b160726122cb4e85444c5efdbdc3b Mon Sep 17 00:00:00 2001
From: "Hinrichs, Jonas" <jonas.hinrichs@bechtle.com>
Date: Wed, 21 Aug 2019 16:12:51 +0200
Subject: [PATCH 10/46] readonly shortend

---
 Signum.React/Scripts/Lines/FormControlReadonly.tsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Lines/FormControlReadonly.tsx b/Signum.React/Scripts/Lines/FormControlReadonly.tsx
index d3bd52632b..fef8ada37a 100644
--- a/Signum.React/Scripts/Lines/FormControlReadonly.tsx
+++ b/Signum.React/Scripts/Lines/FormControlReadonly.tsx
@@ -22,11 +22,11 @@ export class FormControlReadonly extends React.Component<FormControlReadonlyProp
     if (onlyText) { //Text is scrollable in inputs
       if (ctx.readonlyAsPlainText) {
         return (
-          <input {...attrs} className={classes(ctx.formControlPlainTextClass, attrs && attrs.className, this.props.className)} tabIndex={-1} value={onlyText} ref={innerRef}/>
+          <input {...attrs} readOnly className={classes(ctx.formControlPlainTextClass, attrs && attrs.className, this.props.className)} tabIndex={-1} value={onlyText} ref={innerRef} />
         );
       } else {
         return (
-          <input {...attrs} {...{ readOnly: true }} className={classes(ctx.formControlClass, attrs && attrs.className, this.props.className)} tabIndex={-1} value={onlyText} ref={innerRef} />
+          <input {...attrs} readOnly className={classes(ctx.formControlClass, attrs && attrs.className, this.props.className)} tabIndex={-1} value={onlyText} ref={innerRef} />
         );
       }
     }
@@ -39,7 +39,7 @@ export class FormControlReadonly extends React.Component<FormControlReadonlyProp
         );
       } else {
         return (
-          <div {...attrs} {...{ readOnly: true }} className={classes(ctx.formControlClass, attrs && attrs.className, this.props.className)} ref={innerRef}>
+          <div {...attrs} className={classes(ctx.formControlClass, attrs && attrs.className, this.props.className)} ref={innerRef}>
             {this.props.children || <span>&nbsp;</span>}
           </div>
         );

From 6dc2af99f8525b785269a6c638962205df0145cc Mon Sep 17 00:00:00 2001
From: "Hinrichs, Jonas" <jonas.hinrichs@bechtle.com>
Date: Thu, 22 Aug 2019 16:32:42 +0200
Subject: [PATCH 11/46] updateData rename to setData

---
 Signum.React/Scripts/Hooks.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Hooks.ts b/Signum.React/Scripts/Hooks.ts
index a683625e85..de7df6fd73 100644
--- a/Signum.React/Scripts/Hooks.ts
+++ b/Signum.React/Scripts/Hooks.ts
@@ -17,16 +17,16 @@ interface APIHookOptions{
 
 export function useAPI<T>(defaultValue: T, key: ReadonlyArray<any> | undefined, makeCall: (signal: AbortSignal) => Promise<T>, options?: APIHookOptions): T {
 
-  const [data, updateData] = React.useState<T>(defaultValue)
+  const [data, setData] = React.useState<T>(defaultValue);
 
   React.useEffect(() => {
     var abortController = new AbortController();
 
     if (options == null || !options.avoidReset)
-      updateData(defaultValue);
+      setData(defaultValue);
 
     makeCall(abortController.signal)
-      .then(result => !abortController.signal.aborted && updateData(result))
+      .then(result => !abortController.signal.aborted && setData(result))
       .done();
 
     return () => {

From 28323c1909ca5ddb6627ae25d76361963776995f Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Thu, 22 Aug 2019 17:16:33 +0200
Subject: [PATCH 12/46] fix GetParentEntity constraint to IModifiableEntity

---
 Signum.Entities/ModifiableEntity.cs                  | 8 ++++----
 Signum.React/Scripts/SearchControl/SearchControl.tsx | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Signum.Entities/ModifiableEntity.cs b/Signum.Entities/ModifiableEntity.cs
index e0cd051027..d1df1603ec 100644
--- a/Signum.Entities/ModifiableEntity.cs
+++ b/Signum.Entities/ModifiableEntity.cs
@@ -217,18 +217,18 @@ protected virtual void ChildPropertyChanged(object sender, PropertyChangedEventA
         ModifiableEntity? parentEntity;
 
         public T? TryGetParentEntity<T>()
-            where T: ModifiableEntity
+            where T: class, IModifiableEntity 
         {
-            return parentEntity as T;
+            return ((IModifiableEntity?)parentEntity) as T;
         }
 
         public T GetParentEntity<T>()
-            where T : ModifiableEntity
+            where T : IModifiableEntity
         {
             if (parentEntity == null)
                 throw new InvalidOperationException("parentEntity is null");
 
-            return (T)parentEntity;
+            return (T)(IModifiableEntity)parentEntity;
         }
 
         private void SetParentEntity(ModifiableEntity? p)
diff --git a/Signum.React/Scripts/SearchControl/SearchControl.tsx b/Signum.React/Scripts/SearchControl/SearchControl.tsx
index 9151b5d043..1055f84920 100644
--- a/Signum.React/Scripts/SearchControl/SearchControl.tsx
+++ b/Signum.React/Scripts/SearchControl/SearchControl.tsx
@@ -51,7 +51,7 @@ export interface SearchControlProps extends React.Props<SearchControl> {
   simpleFilterBuilder?: (sfbc: Finder.SimpleFilterBuilderContext) => React.ReactElement<any> | undefined;
   onNavigated?: (lite: Lite<Entity>) => void;
   onDoubleClick?: (e: React.MouseEvent<any>, row: ResultRow) => void;
-  onSelectionChanged?: (entity: ResultRow[]) => void;
+  onSelectionChanged?: (rows: ResultRow[]) => void;
   onFiltersChanged?: (filters: FilterOptionParsed[]) => void;
   onHeighChanged?: () => void;
   onSearch?: (fo: FindOptionsParsed, dataChange: boolean) => void;

From d4260d1afb3346cdc727b9a4d3edaf56fb270b35 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sun, 25 Aug 2019 10:13:52 +0430
Subject: [PATCH 13/46] show StackTrace link by ExceptionEntity type rules

---
 Signum.React/Scripts/Modals/ErrorModal.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Modals/ErrorModal.tsx b/Signum.React/Scripts/Modals/ErrorModal.tsx
index 5e9829de5c..e3cfbea5c9 100644
--- a/Signum.React/Scripts/Modals/ErrorModal.tsx
+++ b/Signum.React/Scripts/Modals/ErrorModal.tsx
@@ -63,7 +63,7 @@ export default class ErrorModal extends React.Component<ErrorModalProps, { showD
               this.renderMessage(e)}
 
           {
-            se && se.httpError.stackTrace &&
+            se && se.httpError.stackTrace && Navigator.isViewable(ExceptionEntity) &&
             <div>
               <a href="#" onClick={this.handleShowStackTrace}>StackTrace</a>
               {this.state.showDetails && <pre>{se.httpError.stackTrace}</pre>}

From e6d2caded70de5796ff27fd37a935ce4c71f0c8a Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Mon, 26 Aug 2019 09:43:14 +0430
Subject: [PATCH 14/46] fix getDefaultFilter

---
 Signum.React/Scripts/Finder.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Signum.React/Scripts/Finder.tsx b/Signum.React/Scripts/Finder.tsx
index f9e63781cf..958927e4c8 100644
--- a/Signum.React/Scripts/Finder.tsx
+++ b/Signum.React/Scripts/Finder.tsx
@@ -500,14 +500,14 @@ export function getDefaultOrder(qd: QueryDescription, qs: QuerySettings | undefi
   } as OrderOption;
 }
 
-export function getDefaultFilter(qd: QueryDescription, qs: QuerySettings | undefined): FilterOption[] | undefined {
+export function getDefaultFilter(qd: QueryDescription | undefined, qs: QuerySettings | undefined): FilterOption[] | undefined {
   if (qs && qs.simpleFilterBuilder)
     return undefined;
 
   if (qs && qs.defaultFilters)
     return qs.defaultFilters;
 
-  if (qd.columns["Entity"]) {
+  if (qd == null || qd.columns["Entity"]) {
     return [
       {
         groupOperation: "Or",

From 761dc0b797820ace47cbc9d62eb3873787632cbd Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Mon, 26 Aug 2019 09:43:30 +0430
Subject: [PATCH 15/46] add As.ReplaceExpression

---
 .../ExpressionExpanderAttributes.cs           | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/Signum.Utilities/ExpressionExpanderAttributes.cs b/Signum.Utilities/ExpressionExpanderAttributes.cs
index 8d0d56757d..0a325cbf12 100644
--- a/Signum.Utilities/ExpressionExpanderAttributes.cs
+++ b/Signum.Utilities/ExpressionExpanderAttributes.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -104,5 +105,32 @@ public static T Expression<T>(Expression<Func<T>> body)
         {
             throw new InvalidOperationException("This method is not meant to be called. Missing reference to Signum.MSBuildTask in this assembly?");
         }
+
+
+        public static void ReplaceExpressionUntyped(MemberInfo methodOrProperty, LambdaExpression newExpression)
+        {
+            var attr = methodOrProperty.GetCustomAttribute<ExpressionFieldAttribute>();
+
+            if (attr == null)
+                throw new InvalidOperationException($"The member {methodOrProperty.Name} has not {nameof(ExpressionFieldAttribute)}");
+
+            var fi = methodOrProperty.DeclaringType.GetField(attr.Name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+
+            fi.SetValue(null, newExpression);
+        }
+
+        public static void ReplaceExpression<T, R>(Expression<Func<T, R>> methodOrProperty, Expression<Func<T, R>> newExpression)
+        {
+            var body = methodOrProperty.Body;
+
+            if (body is UnaryExpression u && u.NodeType == ExpressionType.Convert)
+                body = u.Operand;
+
+            var member = body is MemberExpression m ? m.Expression.Type.GetProperty(((PropertyInfo)m.Member).Name) ?? m.Member:
+                body is MethodCallExpression mc ? mc.Object?.Type.GetMethod(mc.Method.Name, mc.Method.GetParameters().Select(p=> p.ParameterType).ToArray()) ?? mc.Method :
+                throw new InvalidOperationException($"Unexpected expression of type {body.NodeType}");
+
+            ReplaceExpressionUntyped(member, newExpression);
+        }
     }
 }

From feef5e492810ec0f6326388323677db039bd92b6 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 26 Aug 2019 18:19:19 +0200
Subject: [PATCH 16/46] change EntitySettings ViewModule<T> (looks like TS can
 understand it now)

---
 Signum.React/Scripts/Navigator.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Navigator.tsx b/Signum.React/Scripts/Navigator.tsx
index 0d5c9aad25..592dba263a 100644
--- a/Signum.React/Scripts/Navigator.tsx
+++ b/Signum.React/Scripts/Navigator.tsx
@@ -824,7 +824,7 @@ export class EntitySettings<T extends ModifiableEntity> {
     this.viewOverrides.push({ override, viewName });
   }
 
-  constructor(type: Type<T> | string, getViewModule?: (entity: T) => Promise<ViewModule<any>>, options?: EntitySettingsOptions<T>) {
+  constructor(type: Type<T> | string, getViewModule?: (entity: T) => Promise<ViewModule<T>>, options?: EntitySettingsOptions<T>) {
 
     this.typeName = (type as Type<T>).typeName || type as string;
     this.getViewPromise = getViewModule && (entity => new ViewPromise(getViewModule(entity)));

From 73adce4be4c8568854773109af75cc88a8056305 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 26 Aug 2019 18:19:37 +0200
Subject: [PATCH 17/46] add FunctionalAdapter.isInstanceOf

---
 Signum.React/Scripts/Frames/FrameModal.tsx | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Signum.React/Scripts/Frames/FrameModal.tsx b/Signum.React/Scripts/Frames/FrameModal.tsx
index ac19ce3877..1f4a31232f 100644
--- a/Signum.React/Scripts/Frames/FrameModal.tsx
+++ b/Signum.React/Scripts/Frames/FrameModal.tsx
@@ -392,4 +392,17 @@ export class FunctionalAdapter extends React.Component {
       return <FunctionalAdapter ref={ref}>{element}</FunctionalAdapter>
     }
   }
+
+  static isInstanceOf(component: React.Component | null | undefined, type: React.ComponentType) {
+
+    if (component instanceof type)
+      return true;
+
+    if (component instanceof FunctionalAdapter) {
+      var only = React.Children.only(component.props.children);
+      return React.isValidElement(only) && only.type == type;
+    }
+
+    return false
+  }
 }

From e2b49a46b9ee3c710c7f9606a28fbed0ff304871 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Thu, 29 Aug 2019 15:18:53 +0200
Subject: [PATCH 18/46] add useTitle

---
 Signum.React/Scripts/Hooks.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Signum.React/Scripts/Hooks.ts b/Signum.React/Scripts/Hooks.ts
index de7df6fd73..89a9de48da 100644
--- a/Signum.React/Scripts/Hooks.ts
+++ b/Signum.React/Scripts/Hooks.ts
@@ -15,6 +15,13 @@ interface APIHookOptions{
   avoidReset?: boolean;
 }
 
+export function useTitle(title: string, deps?: readonly any[]) {
+  React.useEffect(() => {
+    Navigator.setTitle(title);
+    return () => Navigator.setTitle();
+  }, deps);
+}
+
 export function useAPI<T>(defaultValue: T, key: ReadonlyArray<any> | undefined, makeCall: (signal: AbortSignal) => Promise<T>, options?: APIHookOptions): T {
 
   const [data, setData] = React.useState<T>(defaultValue);

From af77ddfe53750e65e5709e7dcb9f05b2a0989e76 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 2 Sep 2019 15:44:56 +0200
Subject: [PATCH 19/46] translation to german

---
 .../Translations/Signum.Entities.de.xml       | 70 ++++++++++++++++---
 1 file changed, 61 insertions(+), 9 deletions(-)

diff --git a/Signum.Entities/Translations/Signum.Entities.de.xml b/Signum.Entities/Translations/Signum.Entities.de.xml
index f6288a15b7..e3fc483d10 100644
--- a/Signum.Entities/Translations/Signum.Entities.de.xml
+++ b/Signum.Entities/Translations/Signum.Entities.de.xml
@@ -14,7 +14,12 @@
   <Type Name="CalendarMessage">
     <Member Name="Today" Description="Heute" />
   </Type>
-  <Type Name="CollectionAnyAllType" />
+  <Type Name="CollectionAnyAllType">
+    <Member Name="All" Description="Alle" />
+    <Member Name="Any" Description="Irgend" />
+    <Member Name="AnyNo" Description="Irgend nicht" />
+    <Member Name="NoOne" Description="Keine" />
+  </Type>
   <Type Name="CollectionElementType">
     <Member Name="Element" Description="Element" />
     <Member Name="Element2" Description="Element (2)" />
@@ -25,6 +30,7 @@
   </Type>
   <Type Name="ColumnOptionsMode" Description="Spaltenoptionenmodus">
     <Member Name="Add" Description="Hinzufügen" />
+    <Member Name="InsertStart" Description="Einfügen beim Start" />
     <Member Name="Remove" Description="Entfernen" />
     <Member Name="Replace" Description="Ersetzen" />
   </Type>
@@ -87,7 +93,7 @@
     <Member Name="AttemptToSet0InLockedEntity1" Description="Versuche {0} in gesperrter Entität {1} festzulegen" />
   </Type>
   <Type Name="EnumEntity`1" />
-  <Type Name="ExceptionEntity" Description="Ausnahme" PluralDescription="Ausnahmen">
+  <Type Name="ExceptionEntity" Description="Ausnahme">
     <Member Name="ActionName" Description="Aktionsname" />
     <Member Name="ApplicationName" Description="Anwendungsname" />
     <Member Name="ControllerName" Description="Controllername" />
@@ -114,7 +120,10 @@
     <Member Name="UserHostName" Description="Benutzer Hostname" />
     <Member Name="Version" Description="Version" />
   </Type>
-  <Type Name="FilterGroupOperation" />
+  <Type Name="FilterGroupOperation" Description="Filtergruppeoperation">
+    <Member Name="And" Description="Und" />
+    <Member Name="Or" Description="Oder" />
+  </Type>
   <Type Name="FilterOperation" Description="Filteroperation">
     <Member Name="Contains" Description="enthält" />
     <Member Name="DistinctTo" Description="anders als" />
@@ -141,11 +150,13 @@
   </Type>
   <Type Name="IUserEntity" />
   <Type Name="JavascriptMessage">
+    <Member Name="activateTimeMachine" Description="Zeitmaschine aktivieren" />
     <Member Name="addFilter" Description="Filter hinzufügen" />
     <Member Name="cancel" Description="Abbrechen" />
     <Member Name="chooseAType" Description="Wählen Sie einen Typ" />
     <Member Name="chooseAValue" Description="Wählen Sie einen Wert" />
     <Member Name="create" Description="Erstellen" />
+    <Member Name="deactivateTimeMachine" Description="Zeitmaschine deaktivieren" />
     <Member Name="editColumn" Description="Spalte bearbeiten" />
     <Member Name="enterTheNewColumnName" Description="Geben Sie den neuen Spaltennamen ein" />
     <Member Name="error" Description="Fehler" />
@@ -181,6 +192,7 @@
     <Member Name="showFilters" Description="Filter anzeigen" />
     <Member Name="showPeriod" Description="Zeit zeigen" />
     <Member Name="showPreviousOperation" Description="Vorherige Operation zeigen" />
+    <Member Name="showRecords" Description="Datensätze anzeigen" />
     <Member Name="ungroupResults" Description="Resultate der Gruppierung aufheben" />
     <Member Name="view" Description="Ansicht" />
   </Type>
@@ -203,7 +215,6 @@
     <Member Name="ViewForType0IsNotAllowed" Description="Anzeigen des Typs {0} ist nicht zulässig" />
   </Type>
   <Type Name="NormalWindowMessage">
-    <Member Name="_0AndClose" Description="{0} und schließen" />
     <Member Name="_0Errors1" Description="{0} Fehler: {1}" />
     <Member Name="_1Error" Description="1 Fehler: {0}" />
     <Member Name="Cancel" Description="Abbrechen" />
@@ -224,7 +235,7 @@
     <Member Name="ThereAreErrors" Description="Es gibt Fehler" />
     <Member Name="Type0Id1" Description="{0} {1}" />
   </Type>
-  <Type Name="OperationLogEntity" Description="Operationen Protokoll" PluralDescription="Operationen Protokolle">
+  <Type Name="OperationLogEntity" Description="Operationenprotokoll">
     <Member Name="Duration" Description="Dauer" />
     <Member Name="End" Description="Ende" />
     <Member Name="Exception" Description="Ausnahme" />
@@ -235,6 +246,8 @@
     <Member Name="User" Description="Benutzer" />
   </Type>
   <Type Name="OperationMessage">
+    <Member Name="_0AndClose" Description="{0} &amp; Schließen" />
+    <Member Name="_0AndNew" Description="{0} &amp; Neu" />
     <Member Name="Confirm" Description="Bestätigen" />
     <Member Name="Create" Description="Erstellen..." />
     <Member Name="CreateFromRegex" Description="^(.*) aus .* erstellen$" />
@@ -244,6 +257,7 @@
     <Member Name="PleaseConfirmYouDLikeToDelete0FromTheSystem" Description="Bitte bestätigen Sie, dass Sie {0} aus dem System löschen möchten" />
     <Member Name="PleaseConfirmYouDLikeToDeleteTheEntityFromTheSystem" Description="Bitte bestätigen Sie, dass Sie die Entität aus dem System löschen möchten" />
     <Member Name="PleaseConfirmYouDLikeToDeleteTheSelectedEntitiesFromTheSystem" Description="Bitte bestätigen Sie, dass Sie die ausgewählten Elemente aus dem System löschen möchten" />
+    <Member Name="PreviousOperationLog" Description="Vorheriges Operationsprotokoll" />
     <Member Name="StateShouldBe0InsteadOf1" Description="Status sollte {0} (statt {1}) sein" />
     <Member Name="TheOperation0DidNotReturnAnEntity" Description="{0} hat keine Enität zurückgegeben" />
   </Type>
@@ -280,10 +294,12 @@
     <Member Name="Count" Description="Num" />
     <Member Name="Date" Description="Datum" />
     <Member Name="DateTime" Description="Datum und Uhrzeit" />
+    <Member Name="DateTimeOffset" Description="Datum und Uhrzeit mit Zeitzone" />
     <Member Name="Day" Description="Tag" />
     <Member Name="DayOfWeek" Description="Tag der Woche" />
     <Member Name="DayOfYear" Description="Tag des Jahres" />
     <Member Name="DecimalNumber" Description="Dezimalzahl" />
+    <Member Name="Distinct" Description="Unterschiedlich" />
     <Member Name="Embedded0" Description="eingebettet {0}" />
     <Member Name="GlobalUniqueIdentifier" Description="Globaler einzigartiger Identifikator" />
     <Member Name="HasValue" Description="Hat einen Wert" />
@@ -298,9 +314,12 @@
     <Member Name="Month" Description="Monat" />
     <Member Name="MonthStart" Description="Monatsbeginn " />
     <Member Name="MoreThanOneColumnNamed0" Description="Mehr als eine Spalte mit dem Namen {0}" />
+    <Member Name="Not" Description="Nicht" />
     <Member Name="Null" Description="Null" />
     <Member Name="Number" Description="Nummer" />
     <Member Name="Of" Description=" von " />
+    <Member Name="Quarter" Description="Quartal" />
+    <Member Name="QuarterStart" Description="Quartalsstart" />
     <Member Name="Second" Description="Sekunde" />
     <Member Name="SecondStart" Description="Start Sekunde" />
     <Member Name="Step0" Description="Schritt {0}" />
@@ -321,21 +340,26 @@
   </Type>
   <Type Name="SearchMessage">
     <Member Name="_01of2Results_N" Description="{0} - {1} von {2} Ergebnis[sen]." />
+    <Member Name="_0FiltersCollapsed" Description="{0} filter zusammengeklappt" />
     <Member Name="_0Results_N" Description="{0} Ergebnis[se]." />
     <Member Name="AddColumn" Description="Spalte hinzufügen" />
     <Member Name="AddFilter" Description="Filter hinzufügen" />
+    <Member Name="AddGroup" Description="Gruppe hinzufügen" />
     <Member Name="AddValue" Description="Wert hinzufügen" />
     <Member Name="ChooseTheDisplayNameOfTheNewColumn" Description="Wählen Sie den Anzeigenamen der neuen Spalte" />
     <Member Name="CollectionsCanNotBeAddedAsColumns" Description="Collections können nicht als Spalten hinzugefügt werden" />
+    <Member Name="Column" Description="Spalte" />
     <Member Name="Create" Description="Erstellen" />
     <Member Name="CreateNew0_G" Description="Neu[m:en|f:e|n:es] {0} erstellen" />
     <Member Name="DeleteFilter" Description="Filter löschen" />
+    <Member Name="DisableOnNull" Description="Deaktivieren bei Null" />
     <Member Name="Explore" Description="Erforsche" />
     <Member Name="Field" Description="Feld" />
     <Member Name="Filters" Description="Filter" />
     <Member Name="Find" Description="Finden" />
     <Member Name="FinderOf0" Description="Finder von {0}" />
     <Member Name="First0Results_N" Description="erste {0} Ergebnis[se]." />
+    <Member Name="Label" Description="Etikett" />
     <Member Name="Name" Description="Name" />
     <Member Name="NewColumnSName" Description="Neuer Spaltenname" />
     <Member Name="NoActionsFound" Description="Keine Aktionen gefunden" />
@@ -343,22 +367,35 @@
     <Member Name="NoFiltersSpecified" Description="Keine Filter angegeben" />
     <Member Name="NoResultsFound" Description="Keine Ergebnisse gefunden" />
     <Member Name="Of" Description="von" />
-    <Member Name="Operation" Description="Verknüpfung" />
+    <Member Name="Operation" Description="Operation" />
     <Member Name="Operations" Description="Operationen" />
+    <Member Name="ParentValue" Description="Übergeordneter Wert" />
+    <Member Name="PinnedFilter" Description="vorgewahlter Filter" />
+    <Member Name="PleaseSelectA0_G" Description="Bitte wählen Sie eine {0}" />
+    <Member Name="PleaseSelectAnEntity" Description="Bitte wählen Sie eine Entität aus" />
+    <Member Name="PleaseSelectOneOrMore0_G" Description="Wählen Sie eine oder mehrere {0}" />
+    <Member Name="PleaseSelectOneOrSeveralEntities" Description="Bitte wählen Sie eine oder mehrere Entitäten aus" />
     <Member Name="Query0IsNotAllowed" Description="Abfrage {0} ist nicht zulässig." />
     <Member Name="Query0NotAllowed" Description="Abfrage {0} ist nicht zulässig." />
     <Member Name="Query0NotRegistered" Description="Abfrage {0} ist nicht in der QueryLogic.Queries registriert." />
+    <Member Name="Refresh" Description="Aktualisieren" />
     <Member Name="Rename" Description="Umbenennen" />
+    <Member Name="Row" Description="Zeile" />
     <Member Name="Search" Description="Suche" />
     <Member Name="SearchControl_Pagination_All" Description="Alle" />
+    <Member Name="SplitText" Description="Text aufteilen" />
     <Member Name="ThereIsNo0" Description="Es gibt keine {0}" />
     <Member Name="Value" Description="Wert" />
     <Member Name="View" Description="Anzeigen" />
     <Member Name="ViewSelected" Description="Ausgewählte Ansicht" />
+    <Member Name="WhenPressedTheFilterValueWillBeSplittedAndAllTheWordsHaveToBeFound" Description="Wenn gedrückt wird, wird der Filterwert geteilt und alle Wörter müssen gefunden werden" />
+    <Member Name="WhenPressedTheFilterWillTakeNoEffectIfTheValueIsNull" Description="Wenn gedrückt wird, wird der Filter nicht wirksam, wenn der Wert Null ist." />
   </Type>
   <Type Name="SelectorMessage">
+    <Member Name="_0Selector" Description="{0}-Selektor" />
     <Member Name="ChooseAValue" Description="Wählen Sie einen Wert" />
     <Member Name="ConstructorSelector" Description="Konstruktor Selektor" />
+    <Member Name="PleaseChooseA0ToContinue" Description="Wählen Sie einen {0} wert, um fortzufahren:" />
     <Member Name="PleaseChooseAValueToContinue" Description="Bitte wählen Sie einen Wert, um fortzufahren:" />
     <Member Name="PleaseSelectAConstructor" Description="Bitte wählen Sie einen Konstruktor" />
     <Member Name="PleaseSelectAnElement" Description="Bitte wählen Sie ein Element" />
@@ -382,8 +419,16 @@
     <Member Name="EndOfSyncScript" Description="--- ENDE DES SYNCHRONISIERUNGSSKRIPTS" />
     <Member Name="StartOfSyncScriptGeneratedOn0" Description="--- ANFANG DES SYNCHRONISATIONSSKRIPTS GENERIERT AUF {0}" />
   </Type>
-  <Type Name="SystemTimeMode" />
-  <Type Name="SystemTimeProperty" />
+  <Type Name="SystemTimeMode">
+    <Member Name="All" Description="Alle" />
+    <Member Name="AsOf" Description="Zum" />
+    <Member Name="Between" Description="Zwischen" />
+    <Member Name="ContainedIn" Description="Enthalten in" />
+  </Type>
+  <Type Name="SystemTimeProperty">
+    <Member Name="SystemValidFrom" Description="System gültig von" />
+    <Member Name="SystemValidTo" Description="System gültig bis" />
+  </Type>
   <Type Name="TypeEntity" Description="Typ">
     <Member Name="ClassName" Description="Klassen Name" />
     <Member Name="CleanName" Description="Clean Name" />
@@ -395,13 +440,16 @@
     <Member Name="_0And1And2CanNotBeSetAtTheSameTime" Description="{0} und {1} und {2} können nicht zur gleichen Zeit gesetzt werden" />
     <Member Name="_0And1CanNotBeSetAtTheSameTime" Description="{0} und {1} können nicht gleichzeitig festgelegt werden" />
     <Member Name="_0DoesNotHaveAValid1Format" Description="{0} hat kein gültiges {1}-Format" />
+    <Member Name="_0DoesNotHaveAValid1IdentifierFormat" Description="'{0}' hat kein gültiges {1} Identifikatorformat." />
     <Member Name="_0HasAnInvalidFormat" Description="{0} hat ein ungültiges Format" />
+    <Member Name="_0HasAPrecisionOf1InsteadOf2" Description="{0} hat eine Genauigkeit von {1} statt {2}." />
     <Member Name="_0HasMoreThan1DecimalPlaces" Description="{0} hat mehr als {1} Dezimalstellen" />
     <Member Name="_0HasSomeRepeatedElements1" Description="{0} hat einige wiederholte Elemente: {1}" />
     <Member Name="_0HasToBeBetween1And2" Description="{0} muss zwischen {1} und {2} sein" />
     <Member Name="_0HasToBeLowercase" Description="{0} muss kleingeschrieben sein" />
     <Member Name="_0HasToBeUppercase" Description="{0} muss großgeschrieben sein" />
     <Member Name="_0Have1ElementsButAllowedOnly2" Description="{0} hat {1} Elemente, erlaubt sind aber nur {2}" />
+    <Member Name="_0IsEmpty" Description="{0} ist leer" />
     <Member Name="_0IsMandatoryWhen1IsNotSet" Description="{0} ist Pflicht, wenn {1} nicht festgesetzt ist" />
     <Member Name="_0IsMandatoryWhen1IsNotSetTo2" Description="{0} ist Pflicht, wenn {1} nicht auf {2} gesetzt ist." />
     <Member Name="_0IsMandatoryWhen1IsSet" Description="{0} ist Pflicht, wenn {1} festgesetzt ist" />
@@ -415,6 +463,7 @@
     <Member Name="_0IsSet" Description="{0} wird gesetzt" />
     <Member Name="_0Or1ShouldBeSet" Description="{0} oder {1} sollten gesetzt sein" />
     <Member Name="_0ShouldBe12" Description="{0} sollte {1} {2} sein" />
+    <Member Name="_0ShouldBe1InsteadOf2" Description="{0} sollte {1} statt {2} sein." />
     <Member Name="_0ShouldBeADateInThePast" Description="{0} sollte ein Datum in der Vergangenheit sein" />
     <Member Name="_0ShouldBeGreaterThan1" Description="{0} sollte größer als {1} sein" />
     <Member Name="_0ShouldBeGreaterThanOrEqual1" Description="{0} sollte größer oder gleich {1} sein" />
@@ -433,6 +482,7 @@
     <Member Name="_AtLeastOneValueIsNeeded" Description="Es wird mindestens ein Wert benötigt." />
     <Member Name="Be" Description="sein " />
     <Member Name="BeA0_G" Description="ei[m:n|f:ne|n:n] {0} sein" />
+    <Member Name="BeAString" Description="eine Zeichenkette sein" />
     <Member Name="BeBetween0And1" Description="zwischen {0} und {1} sein" />
     <Member Name="BeInThePast" Description="in der Vergangenheit sein" />
     <Member Name="BeNotNull" Description="darf nicht null sein" />
@@ -447,9 +497,11 @@
     <Member Name="HaveValid0Format" Description="muss ein gültiges {0}-Format haben" />
     <Member Name="InvalidDateFormat" Description="Ungültiges Datumsformat" />
     <Member Name="InvalidFormat" Description="Ungültiges Format" />
+    <Member Name="IsATimeOfTheDay" Description="Ist eine Tageszeit" />
     <Member Name="NotPossibleToaAssign0" Description="Es ist nicht möglich {0} zuzuweisen" />
     <Member Name="Numeric" Description="Numerisch" />
     <Member Name="OrBeNull" Description="oder null sein" />
+    <Member Name="PowerOf" Description="Potenz von " />
     <Member Name="Telephone" Description="Telefon" />
     <Member Name="TheLenghtOf0HasToBeEqualTo1" Description="Die Länge von {0} muss gleich {1} sein" />
     <Member Name="TheLengthOf0HasToBeGreaterOrEqualTo1" Description="Die Länge von {0} muss größer als oder gleich {1} sein" />
@@ -462,4 +514,4 @@
   <Type Name="VoidEnumMessage">
     <Member Name="Instance" Description="-" />
   </Type>
-</Translations>
+</Translations>
\ No newline at end of file

From cb9b967302ac8900459bea4a68c188ddb70bba41 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 2 Sep 2019 15:45:22 +0200
Subject: [PATCH 20/46] add SelectorMessage.chooseEnum

---
 Signum.Entities/EnumMessages.cs         |  8 ++++++--
 Signum.React/Scripts/SelectorModal.tsx  | 13 ++++++++++++-
 Signum.React/Scripts/Signum.Entities.ts |  2 ++
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/Signum.Entities/EnumMessages.cs b/Signum.Entities/EnumMessages.cs
index 2046e905dc..41f6db6a8c 100644
--- a/Signum.Entities/EnumMessages.cs
+++ b/Signum.Entities/EnumMessages.cs
@@ -213,7 +213,7 @@ public enum SelectorMessage
         ConstructorSelector,
         [Description("Please choose a value to continue:")]
         PleaseChooseAValueToContinue,
-        [Description("Please select a Constructor")]
+        [Description("Please select a constructor")]
         PleaseSelectAConstructor,
         [Description("Please select one of the following types: ")]
         PleaseSelectAType,
@@ -223,7 +223,11 @@ public enum SelectorMessage
         ValueMustBeSpecifiedFor0,
         ChooseAValue,
         SelectAnElement,
-        PleaseSelectAnElement
+        PleaseSelectAnElement,
+        [Description("{0} selector")]
+        _0Selector,
+        [Description("Please choose a {0} to continue:")]
+        PleaseChooseA0ToContinue,
     }
 
     public enum ConnectionMessage
diff --git a/Signum.React/Scripts/SelectorModal.tsx b/Signum.React/Scripts/SelectorModal.tsx
index 5077c7b0b7..ad5dc56d63 100644
--- a/Signum.React/Scripts/SelectorModal.tsx
+++ b/Signum.React/Scripts/SelectorModal.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react'
 import { openModal, IModalProps } from './Modals';
 import { SelectorMessage } from './Signum.Entities'
-import { TypeInfo } from './Reflection'
+import { TypeInfo, EnumType } from './Reflection'
 import { Modal, BsSize } from './Components';
 
 interface SelectorModalProps extends React.Props<SelectorModal>, IModalProps {
@@ -86,6 +86,17 @@ export default class SelectorModal extends React.Component<SelectorModalProps, {
       dialogClassName={dialogClassName} />);
   }
 
+  static chooseEnum<T extends string>(enumType: EnumType<T>): Promise<T | undefined>{
+    return SelectorModal.chooseElement(enumType.values(),
+      {
+        buttonDisplay: a => enumType.niceToString(a),
+        buttonName: a => a,
+        title: SelectorMessage._0Selector.niceToString(enumType.niceTypeName()),
+        message: SelectorMessage.PleaseChooseA0ToContinue.niceToString(enumType.niceTypeName()),
+        size: "md",
+      });
+  }
+
   static chooseType(options: TypeInfo[]): Promise<TypeInfo | undefined> {
     return SelectorModal.chooseElement(options,
       {
diff --git a/Signum.React/Scripts/Signum.Entities.ts b/Signum.React/Scripts/Signum.Entities.ts
index 4048c2aac8..2139dbe5f0 100644
--- a/Signum.React/Scripts/Signum.Entities.ts
+++ b/Signum.React/Scripts/Signum.Entities.ts
@@ -474,6 +474,8 @@ export module SelectorMessage {
   export const ChooseAValue = new MessageKey("SelectorMessage", "ChooseAValue");
   export const SelectAnElement = new MessageKey("SelectorMessage", "SelectAnElement");
   export const PleaseSelectAnElement = new MessageKey("SelectorMessage", "PleaseSelectAnElement");
+  export const _0Selector = new MessageKey("SelectorMessage", "_0Selector");
+  export const PleaseChooseA0ToContinue = new MessageKey("SelectorMessage", "PleaseChooseA0ToContinue");
 }
 
 export interface Symbol extends Entity {

From 8725594ef561846a8307abf3ee0ac952695c0278 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 3 Sep 2019 17:10:43 +0200
Subject: [PATCH 21/46] add MemComparer to Signum.Utilities

---
 .../JsonConverters/EntityJsonConverter.cs     | 18 +++------------
 .../DataStructures/MemComparer.cs             | 22 +++++++++++++++++++
 2 files changed, 25 insertions(+), 15 deletions(-)
 create mode 100644 Signum.Utilities/DataStructures/MemComparer.cs

diff --git a/Signum.React/JsonConverters/EntityJsonConverter.cs b/Signum.React/JsonConverters/EntityJsonConverter.cs
index 963b2c7fd7..a421ecc14d 100644
--- a/Signum.React/JsonConverters/EntityJsonConverter.cs
+++ b/Signum.React/JsonConverters/EntityJsonConverter.cs
@@ -6,6 +6,7 @@
 using Signum.Entities.Reflection;
 using Signum.React.Facades;
 using Signum.Utilities;
+using Signum.Utilities.DataStructures;
 using Signum.Utilities.ExpressionTrees;
 using Signum.Utilities.Reflection;
 using System;
@@ -389,7 +390,7 @@ public void ReadJsonProperty(JsonReader reader, JsonSerializer serializer, Modif
         private bool IsEquals(object newValue, object? oldValue)
         {
             if (newValue is byte[] && oldValue is byte[])
-                return MemCompare.Compare((byte[])newValue, (byte[])oldValue);
+                return MemComparer.Equals((byte[])newValue, (byte[])oldValue);
 
             if (newValue is DateTime && oldValue is DateTime)
                 return Math.Abs(((DateTime)newValue).Subtract((DateTime)oldValue).TotalMilliseconds) < 10; //Json dates get rounded
@@ -531,18 +532,5 @@ static Type GetEntityType(string typeStr, Type objectType)
     }
 
 
-    static class MemCompare
-    {
-        [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
-#pragma warning disable IDE1006 // Naming Styles
-        static extern int memcmp(byte[] b1, byte[] b2, long count);
-#pragma warning restore IDE1006 // Naming Styles
-
-        public static bool Compare(byte[] b1, byte[] b2)
-        {
-            // Validate buffers are the same length.
-            // This also ensures that the count does not exceed the length of either buffer.
-            return b1.Length == b2.Length && memcmp(b1, b2, b1.Length) == 0;
-        }
-    }
+   
 }
diff --git a/Signum.Utilities/DataStructures/MemComparer.cs b/Signum.Utilities/DataStructures/MemComparer.cs
new file mode 100644
index 0000000000..0553fe3ed5
--- /dev/null
+++ b/Signum.Utilities/DataStructures/MemComparer.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Signum.Utilities.DataStructures
+{
+    public static class MemComparer
+    {
+        [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
+#pragma warning disable IDE1006 // Naming Styles
+        static extern int memcmp(byte[] b1, byte[] b2, long count);
+#pragma warning restore IDE1006 // Naming Styles
+
+        public static bool Equals(byte[] b1, byte[] b2)
+        {
+            // Validate buffers are the same length.
+            // This also ensures that the count does not exceed the length of either buffer.
+            return b1.Length == b2.Length && memcmp(b1, b2, b1.Length) == 0;
+        }
+    }
+}

From 0b0e0cff677a210baa1cfaab3da1546e1428c5f7 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 3 Sep 2019 17:57:02 +0200
Subject: [PATCH 22/46] pass EntityCombo selectHtmlAttributes in readonly mode

---
 Signum.React/Scripts/Lines/EntityCombo.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Lines/EntityCombo.tsx b/Signum.React/Scripts/Lines/EntityCombo.tsx
index 74301b1b0b..ee47fc905e 100644
--- a/Signum.React/Scripts/Lines/EntityCombo.tsx
+++ b/Signum.React/Scripts/Lines/EntityCombo.tsx
@@ -166,7 +166,7 @@ class EntityComboSelect extends React.Component<EntityComboSelectProps, { data?:
     const ctx = this.props.ctx;
 
     if (ctx.readOnly)
-      return <FormControlReadonly ctx={ctx}>{ctx.value && getToString(lite, this.props.liteToString)}</FormControlReadonly>;
+      return <FormControlReadonly ctx={ctx} htmlAttributes={this.props.selectHtmlAttributes}>{ctx.value && getToString(lite, this.props.liteToString)}</FormControlReadonly>;
 
     return (
       <select className={classes(ctx.formControlClass, this.props.mandatoryClass)} onChange={this.handleOnChange} value={lite ? liteKey(lite) : ""}

From 272b12375e64d4b4e6a3d7dc0c39dd0c7352d5a3 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Tue, 10 Sep 2019 14:35:51 +0430
Subject: [PATCH 23/46] fix this.containerDiv!

---
 Signum.React/Scripts/Lines/EntityTable.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Lines/EntityTable.tsx b/Signum.React/Scripts/Lines/EntityTable.tsx
index 45a42cb6a9..281ef364ce 100644
--- a/Signum.React/Scripts/Lines/EntityTable.tsx
+++ b/Signum.React/Scripts/Lines/EntityTable.tsx
@@ -111,7 +111,7 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
   }
 
   componentDidMount() {
-    this.containerDiv!.addEventListener("scroll", (e) => {
+    this.containerDiv && this.containerDiv.addEventListener("scroll", (e) => {
       var translate = "translate(0," + this.containerDiv!.scrollTop + "px)";
       this.thead!.style.transform = translate;
     });

From 1b87fc56ce1f2cc20c2a7c1a164fa07dc98e8293 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Tue, 10 Sep 2019 14:36:11 +0430
Subject: [PATCH 24/46] fix saveFile

---
 Signum.React/Scripts/Services.ts | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Services.ts b/Signum.React/Scripts/Services.ts
index b0ab37ee57..54fc2dbd4d 100644
--- a/Signum.React/Scripts/Services.ts
+++ b/Signum.React/Scripts/Services.ts
@@ -189,11 +189,20 @@ let a = document.createElement("a");
 document.body.appendChild(a);
 a.style.display = "none";
 
-
 export function saveFile(response: Response) {
+  var fileName: string;
   const contentDisposition = response.headers.get("Content-Disposition")!;
-  const fileNamePart = contentDisposition.split(";").filter(a => a.trim().startsWith("filename=")).singleOrNull();
-  const fileName = fileNamePart ? fileNamePart.trim().after("filename=").trimStart("\"").trimEnd("\"") : "file.dat";
+  const parts = contentDisposition.split(";");
+
+  const fileNamePartUTF8 = parts.filter(a => a.trim().startsWith("filename*=")).singleOrNull();
+  const fileNamePartAscii = parts.filter(a => a.trim().startsWith("filename=")).singleOrNull();
+
+  if (fileNamePartUTF8)
+    fileName = decodeURIComponent(fileNamePartUTF8.trim().after("UTF-8''").trimEnd("\""));
+  else if (fileNamePartAscii)
+    fileName = fileNamePartAscii.trim().after("filename=").trimStart("\"").trimEnd("\"");
+  else
+    fileName = "file.dat";
 
   response.blob().then(blob => {
     saveFileBlob(blob, fileName);

From 3396ec0d6b525e160f0b4c2334793e65d5ae205b Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Tue, 10 Sep 2019 14:36:46 +0430
Subject: [PATCH 25/46] fix translation

---
 .../Filters/SignumExceptionFilterAttribute.cs | 25 +++++++++++++------
 Signum.React/Filters/SignumFilters.cs         |  4 +--
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/Signum.React/Filters/SignumExceptionFilterAttribute.cs b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
index 6e91c6751c..e864bd99dd 100644
--- a/Signum.React/Filters/SignumExceptionFilterAttribute.cs
+++ b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
@@ -24,7 +24,10 @@ namespace Signum.React.Filters
 {
     public class SignumExceptionFilterAttribute : IAsyncResourceFilter
     {
-       public static Func<Exception, bool> IncludeErrorDetails = ctx => true;
+        public static Func<Exception, bool> TranslateExceptionMessage = ex => ex is ApplicationException;
+
+
+        public static Func<Exception, bool> IncludeErrorDetails = ex => true;
 
         public static readonly List<Type> IgnoreExceptions = new List<Type> { typeof(OperationCanceledException) };
 
@@ -57,16 +60,22 @@ public async Task OnResourceExecutionAsync(ResourceExecutingContext precontext,
                         e.Form = Try(int.MaxValue, () => ReadAllBody(context.HttpContext));
                         e.Session = null;
                     });
-
+                    
                     if (ExpectsJsonResult(context))
                     {
-                        var error = new HttpError(context.Exception,IncludeErrorDetails(context.Exception));
 
-                        var response = context.HttpContext.Response;
-                        response.StatusCode = (int)statusCode;
-                        response.ContentType = "application/json";
-                        await response.WriteAsync(JsonConvert.SerializeObject(error, SignumServer.JsonSerializerSettings));
-                        context.ExceptionHandled = true;
+                        var ci = TranslateExceptionMessage(context.Exception) ? SignumCultureSelectorFilter.GetCurrentCulture(precontext) : null;
+
+                        using (ci == null ? null : CultureInfoUtils.ChangeBothCultures(ci))
+                        {
+                            var error = new HttpError(context.Exception, IncludeErrorDetails(context.Exception));
+
+                            var response = context.HttpContext.Response;
+                            response.StatusCode = (int)statusCode;
+                            response.ContentType = "application/json";
+                            await response.WriteAsync(JsonConvert.SerializeObject(error, SignumServer.JsonSerializerSettings));
+                            context.ExceptionHandled = true;
+                        }
                     }
                 }
             }
diff --git a/Signum.React/Filters/SignumFilters.cs b/Signum.React/Filters/SignumFilters.cs
index cfc9e109af..e93090f566 100644
--- a/Signum.React/Filters/SignumFilters.cs
+++ b/Signum.React/Filters/SignumFilters.cs
@@ -72,13 +72,13 @@ public SignumAuthenticationFilter() : base("Signum_User") { }
 
     public class SignumCultureSelectorFilter : IResourceFilter
     {
-        public static Func<ResourceExecutingContext, CultureInfo?> GetCurrentCultures;
+        public static Func<ResourceExecutingContext, CultureInfo?> GetCurrentCulture;
 
         const string Culture_Key = "OldCulture";
         const string UICulture_Key = "OldUICulture";
         public void OnResourceExecuting(ResourceExecutingContext context)
         {
-            var culture = GetCurrentCultures?.Invoke(context);
+            var culture = GetCurrentCulture?.Invoke(context);
             if (culture != null)
             {
                 context.HttpContext.Items[Culture_Key] = CultureInfo.CurrentCulture;

From b2e21197e4c571fbd2274cf8ec2cee76f3f170c2 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 10 Sep 2019 14:56:07 +0200
Subject: [PATCH 26/46] add Help Messages

---
 .../Translations/Signum.Entities.de.xml       |  21 +--
 .../Translations/Signum.Entities.es.xml       |   4 +-
 Signum.Entities/ValidationAttributes.cs       | 122 ++++--------------
 Signum.React/Scripts/Signum.Entities.ts       |   5 +-
 4 files changed, 44 insertions(+), 108 deletions(-)

diff --git a/Signum.Entities/Translations/Signum.Entities.de.xml b/Signum.Entities/Translations/Signum.Entities.de.xml
index e3fc483d10..f1750caffc 100644
--- a/Signum.Entities/Translations/Signum.Entities.de.xml
+++ b/Signum.Entities/Translations/Signum.Entities.de.xml
@@ -289,7 +289,7 @@
     <Member Name="And" Description=" und " />
     <Member Name="AnyEntity" Description="Jede Einheit" />
     <Member Name="As0" Description="Als {0}" />
-    <Member Name="Check" Description="check" />
+    <Member Name="BooleanValue" Description="boolescher Wert (ja oder nein)" />
     <Member Name="Column0NotFound" Description="Die Spalte {0} wurde nicht gefunden" />
     <Member Name="Count" Description="Num" />
     <Member Name="Date" Description="Datum" />
@@ -480,20 +480,21 @@
     <Member Name="_0ShouldNotHaveFinalSpaces" Description="{0} darf keine abschließenden Leerzeichen haben" />
     <Member Name="_0ShouldNotHaveInitialSpaces" Description="{0} sollte keine Leerzeichen an erster stelle haben" />
     <Member Name="_AtLeastOneValueIsNeeded" Description="Es wird mindestens ein Wert benötigt." />
-    <Member Name="Be" Description="sein " />
+    <Member Name="Be0" Description="{0} sein" />
     <Member Name="BeA0_G" Description="ei[m:n|f:ne|n:n] {0} sein" />
     <Member Name="BeAString" Description="eine Zeichenkette sein" />
+    <Member Name="BeAMultilineString" Description="eine mehrzeilige Zeichenkette sein" />
     <Member Name="BeBetween0And1" Description="zwischen {0} und {1} sein" />
     <Member Name="BeInThePast" Description="in der Vergangenheit sein" />
-    <Member Name="BeNotNull" Description="darf nicht null sein" />
+    <Member Name="BeNotNull" Description="nicht null sein" />
     <Member Name="FileName" Description="Dateiname" />
-    <Member Name="Have0Decimals" Description="haben {0} Dezimalstellen" />
-    <Member Name="HaveANumberOfElements01" Description="hat eine Nummer von Elementen {0} {1}" />
-    <Member Name="HaveAPrecisionOf" Description="haben eine Genauigkeit von " />
-    <Member Name="HaveBetween0And1Characters" Description="haben zwischen {0} und {1} Zeichen" />
+    <Member Name="Have0Decimals" Description="{0} Dezimalstellen haben" />
+    <Member Name="HaveANumberOfElements01" Description="eine Nummer von Elementen {0} {1} haben" />
+    <Member Name="HaveAPrecisionOf0" Description="eine Genauigkeit von {0} haben" />
+    <Member Name="HaveBetween0And1Characters" Description="zwischen {0} und {1} Zeichen haben" />
     <Member Name="HaveMaximum0Characters" Description="maximal {0} Zeichen haben" />
-    <Member Name="HaveMinimum0Characters" Description="haben mindestens {0} Zeichen" />
-    <Member Name="HaveNoRepeatedElements" Description="darf keine wiederholten Elementen haben" />
+    <Member Name="HaveMinimum0Characters" Description="mindestens {0} Zeichen haben" />
+    <Member Name="HaveNoRepeatedElements" Description="keine wiederholten Elementen haben" />
     <Member Name="HaveValid0Format" Description="muss ein gültiges {0}-Format haben" />
     <Member Name="InvalidDateFormat" Description="Ungültiges Datumsformat" />
     <Member Name="InvalidFormat" Description="Ungültiges Format" />
@@ -514,4 +515,4 @@
   <Type Name="VoidEnumMessage">
     <Member Name="Instance" Description="-" />
   </Type>
-</Translations>
\ No newline at end of file
+</Translations>
diff --git a/Signum.Entities/Translations/Signum.Entities.es.xml b/Signum.Entities/Translations/Signum.Entities.es.xml
index 949ac027bc..f20c51146b 100644
--- a/Signum.Entities/Translations/Signum.Entities.es.xml
+++ b/Signum.Entities/Translations/Signum.Entities.es.xml
@@ -289,7 +289,7 @@
     <Member Name="And" Description=" y " />
     <Member Name="AnyEntity" Description="cualquier entidad" />
     <Member Name="As0" Description="As {0}" />
-    <Member Name="Check" Description="verificación" />
+    <Member Name="BooleanValue" Description="valor booleano (sí o no)" />
     <Member Name="Column0NotFound" Description="La columna {0} no se ha encontrado" />
     <Member Name="Count" Description="[Num]" />
     <Member Name="Date" Description="Fecha" />
@@ -504,4 +504,4 @@
   <Type Name="VoidEnumMessage">
     <Member Name="Instance" Description="-" />
   </Type>
-</Translations>
\ No newline at end of file
+</Translations>
diff --git a/Signum.Entities/ValidationAttributes.cs b/Signum.Entities/ValidationAttributes.cs
index bbca206698..cf88da388d 100644
--- a/Signum.Entities/ValidationAttributes.cs
+++ b/Signum.Entities/ValidationAttributes.cs
@@ -80,12 +80,9 @@ public class NotNullValidatorAttribute : ValidatorAttribute
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.BeNotNull.NiceToString(); }
-        }
+        public override string HelpMessage => ValidationMessage.BeNotNull.NiceToString();
+
 
-        
     }
 
     public static class NotNullValidatorExtensions
@@ -174,7 +171,9 @@ public override string HelpMessage
                 string result =
                     min != -1 && max != -1 ? ValidationMessage.HaveBetween0And1Characters.NiceToString().FormatWith(min, max) :
                     min != -1 ? ValidationMessage.HaveMinimum0Characters.NiceToString().FormatWith(min) :
-                    max != -1 ? ValidationMessage.HaveMaximum0Characters.NiceToString().FormatWith(max) : ValidationMessage.BeAString.NiceToString();
+                    max != -1 ? ValidationMessage.HaveMaximum0Characters.NiceToString().FormatWith(max) : 
+                    MultiLine ? ValidationMessage.BeAMultilineString.NiceToString() : 
+                    ValidationMessage.BeAString.NiceToString();
                 
                 return result;
             }
@@ -217,13 +216,7 @@ public abstract string FormatName
             return ValidationMessage._0DoesNotHaveAValid1Format.NiceToString().FormatWith("{0}", FormatName);
         }
 
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.HaveValid0Format.NiceToString().FormatWith(FormatName);
-            }
-        }
+        public override string HelpMessage => ValidationMessage.HaveValid0Format.NiceToString().FormatWith(FormatName);
     }
 
     public class EMailValidatorAttribute : RegexValidatorAttribute
@@ -371,15 +364,9 @@ public FileNameValidatorAttribute()
         {
         }
 
-        public string FormatName
-        {
-            get { return ValidationMessage.FileName.NiceToString(); }
-        }
+        public string FormatName => ValidationMessage.FileName.NiceToString();
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.HaveValid0Format.NiceToString().FormatWith(FormatName); }
-        }
+        public override string HelpMessage => ValidationMessage.HaveValid0Format.NiceToString().FormatWith(FormatName);
 
         protected override string? OverrideError(object? value)
         {
@@ -427,10 +414,7 @@ public DecimalsValidatorAttribute(int decimalPlaces)
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.Have0Decimals.NiceToString().FormatWith(DecimalPlaces); }
-        }
+        public override string HelpMessage => ValidationMessage.Have0Decimals.NiceToString().FormatWith(DecimalPlaces);
     }
 
 
@@ -495,13 +479,10 @@ public NumberIsValidatorAttribute(ComparisonType comparison, long number)
             if (ok)
                 return null;
 
-            return ValidationMessage._0ShouldBe12.NiceToString().FormatWith("{0}", ComparisonType.NiceToString(), number.ToString());
+            return ValidationMessage._0ShouldBe12.NiceToString().FormatWith("{0}", ComparisonType.NiceToString().ToLower(), number.ToString());
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.Be.NiceToString() + ComparisonType.NiceToString() + " " + number.ToString(); }
-        }
+        public override string HelpMessage => ValidationMessage.Be0.NiceToString(ComparisonType.NiceToString().ToLower() + " " + number.ToString());
     }
 
     //Not using C intervals to please user!
@@ -566,10 +547,7 @@ public NumberBetweenValidatorAttribute(long min, long max)
             return ValidationMessage._0HasToBeBetween1And2.NiceToString("{0}", min, max);
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.BeBetween0And1.NiceToString(min, max); }
-        }
+        public override string HelpMessage => ValidationMessage.BeBetween0And1.NiceToString(min, max);
     }
 
 
@@ -601,10 +579,7 @@ static bool IsPowerOfTwo(long n)
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.Be.NiceToString() + ValidationMessage.PowerOf.NiceToString() + " " + 2; }
-        }
+        public override string HelpMessage => ValidationMessage.Be0.NiceToString(ValidationMessage.PowerOf.NiceToString() + " " + 2);
     }
 
     public class NoRepeatValidatorAttribute : ValidatorAttribute
@@ -620,10 +595,7 @@ public class NoRepeatValidatorAttribute : ValidatorAttribute
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.HaveNoRepeatedElements.NiceToString(); }
-        }
+        public override string HelpMessage => ValidationMessage.HaveNoRepeatedElements.NiceToString();
 
         public static string? ByKey<T, K>(IEnumerable<T> collection, Func<T, K> keySelector)
         {
@@ -664,10 +636,7 @@ public CountIsValidatorAttribute(ComparisonType comparison, int number)
             return ValidationMessage.TheNumberOfElementsOf0HasToBe12.NiceToString().FormatWith("{0}", ComparisonType.NiceToString().FirstLower(), number.ToString());
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.HaveANumberOfElements01.NiceToString().FormatWith(ComparisonType.NiceToString().FirstLower(), number.ToString()); }
-        }
+        public override string HelpMessage => ValidationMessage.HaveANumberOfElements01.NiceToString().FormatWith(ComparisonType.NiceToString().FirstLower(), number.ToString());
     }
 
     [DescriptionOptions(DescriptionOptions.Members)]
@@ -744,13 +713,7 @@ public string FormatString
             }
         }
 
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.HaveAPrecisionOf.NiceToString() + " " + Precision.NiceToString().ToLower();
-            }
-        }
+        public override string HelpMessage => ValidationMessage.HaveAPrecisionOf0.NiceToString(Precision.NiceToString().ToLower());
     }
 
     public class DateInPastValidator : ValidatorAttribute
@@ -766,13 +729,7 @@ public class DateInPastValidator : ValidatorAttribute
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.BeInThePast.NiceToString();
-            }
-        }
+        public override string HelpMessage => ValidationMessage.BeInThePast.NiceToString();
     }
 
     public class YearGreaterThanValidator : ValidatorAttribute
@@ -795,13 +752,7 @@ public YearGreaterThanValidator(int minYear)
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.BeInThePast.NiceToString();
-            }
-        }
+        public override string HelpMessage => ValidationMessage.BeInThePast.NiceToString();
     }
 
 
@@ -844,13 +795,7 @@ public string FormatString
             }
         }
 
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.HaveAPrecisionOf.NiceToString() + " " + Precision.NiceToString().ToLower();
-            }
-        }
+        public override string HelpMessage => ValidationMessage.HaveAPrecisionOf0.NiceToString(Precision.NiceToString().ToLower());
     }
 
     public class TimeOfDayValidatorAttribute : ValidatorAttribute
@@ -870,14 +815,8 @@ public TimeOfDayValidatorAttribute()
 
             return null;
         }
-       
-        public override string HelpMessage
-        {
-            get
-            {
-                return ValidationMessage.IsATimeOfTheDay.NiceToString();
-            }
-        }
+
+        public override string HelpMessage => ValidationMessage.IsATimeOfTheDay.NiceToString();
     }
 
     public class StringCaseValidatorAttribute : ValidatorAttribute
@@ -909,10 +848,7 @@ public StringCaseValidatorAttribute(StringCase textCase)
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.Be.NiceToString() + textCase.NiceToString(); }
-        }
+        public override string HelpMessage => ValidationMessage.Be0.NiceToString(textCase.NiceToString());
     }
 
     [DescriptionOptions(DescriptionOptions.Members)]
@@ -947,10 +883,7 @@ public IsAssignableToValidatorAttribute(Type type)
             return null;
         }
 
-        public override string HelpMessage
-        {
-            get { return ValidationMessage.BeA0_G.NiceToString().ForGenderAndNumber(Type.GetGender()).FormatWith(Type.NiceName()); }
-        }
+        public override string HelpMessage => ValidationMessage.BeA0_G.NiceToString().ForGenderAndNumber(Type.GetGender()).FormatWith(Type.NiceName());
     }
 
     public class IpValidatorAttribute : RegexValidatorAttribute
@@ -1109,8 +1042,8 @@ public enum ValidationMessage
         _0IsNotA1_G,
         [Description("be a {0}")]
         BeA0_G,
-        [Description("be ")]
-        Be,
+        [Description("be {0}")]
+        Be0,
         [Description("be between {0} and {1}")]
         BeBetween0And1,
         [Description("be not null")]
@@ -1121,8 +1054,8 @@ public enum ValidationMessage
         Have0Decimals,
         [Description("have a number of elements {0} {1}")]
         HaveANumberOfElements01,
-        [Description("have a precision of ")]
-        HaveAPrecisionOf,
+        [Description("have a precision of {0}")]
+        HaveAPrecisionOf0,
         [Description("have between {0} and {1} characters")]
         HaveBetween0And1Characters,
         [Description("have maximum {0} characters")]
@@ -1211,6 +1144,7 @@ public enum ValidationMessage
         _AtLeastOneValueIsNeeded,
         PowerOf,
         BeAString,
+        BeAMultilineString,
         IsATimeOfTheDay,
     }
 }
diff --git a/Signum.React/Scripts/Signum.Entities.ts b/Signum.React/Scripts/Signum.Entities.ts
index 2139dbe5f0..5687943ff7 100644
--- a/Signum.React/Scripts/Signum.Entities.ts
+++ b/Signum.React/Scripts/Signum.Entities.ts
@@ -506,13 +506,13 @@ export module ValidationMessage {
   export const _0IsSet = new MessageKey("ValidationMessage", "_0IsSet");
   export const _0IsNotA1_G = new MessageKey("ValidationMessage", "_0IsNotA1_G");
   export const BeA0_G = new MessageKey("ValidationMessage", "BeA0_G");
-  export const Be = new MessageKey("ValidationMessage", "Be");
+  export const Be0 = new MessageKey("ValidationMessage", "Be0");
   export const BeBetween0And1 = new MessageKey("ValidationMessage", "BeBetween0And1");
   export const BeNotNull = new MessageKey("ValidationMessage", "BeNotNull");
   export const FileName = new MessageKey("ValidationMessage", "FileName");
   export const Have0Decimals = new MessageKey("ValidationMessage", "Have0Decimals");
   export const HaveANumberOfElements01 = new MessageKey("ValidationMessage", "HaveANumberOfElements01");
-  export const HaveAPrecisionOf = new MessageKey("ValidationMessage", "HaveAPrecisionOf");
+  export const HaveAPrecisionOf0 = new MessageKey("ValidationMessage", "HaveAPrecisionOf0");
   export const HaveBetween0And1Characters = new MessageKey("ValidationMessage", "HaveBetween0And1Characters");
   export const HaveMaximum0Characters = new MessageKey("ValidationMessage", "HaveMaximum0Characters");
   export const HaveMinimum0Characters = new MessageKey("ValidationMessage", "HaveMinimum0Characters");
@@ -560,6 +560,7 @@ export module ValidationMessage {
   export const _AtLeastOneValueIsNeeded = new MessageKey("ValidationMessage", "_AtLeastOneValueIsNeeded");
   export const PowerOf = new MessageKey("ValidationMessage", "PowerOf");
   export const BeAString = new MessageKey("ValidationMessage", "BeAString");
+  export const BeAMultilineString = new MessageKey("ValidationMessage", "BeAMultilineString");
   export const IsATimeOfTheDay = new MessageKey("ValidationMessage", "IsATimeOfTheDay");
 }
 

From 1342c325a5a4366f2188b17a2c4b6020278051ae Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 10 Sep 2019 14:56:59 +0200
Subject: [PATCH 27/46] improve exception messages in PropertyRoute
 getErrorContext

---
 Signum.React/Scripts/Reflection.ts | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/Signum.React/Scripts/Reflection.ts b/Signum.React/Scripts/Reflection.ts
index ce860ee718..2a0734c39a 100644
--- a/Signum.React/Scripts/Reflection.ts
+++ b/Signum.React/Scripts/Reflection.ts
@@ -1378,6 +1378,8 @@ export class PropertyRoute {
 
   addMember(memberType: MemberType, memberName: string): PropertyRoute {
 
+    var getErrorContext = () => ` (adding ${memberType} ${memberName} to ${this.toString()})`;
+
     if (memberType == "Member") {
 
       if (this.propertyRouteType == "Field" ||
@@ -1392,16 +1394,16 @@ export class PropertyRoute {
           return PropertyRoute.liteEntity(this);
         }
 
-        const ti = getTypeInfos(ref).single("Ambiguity due to multiple Implementations"); //[undefined]
+        const ti = getTypeInfos(ref).single("Ambiguity due to multiple Implementations" + getErrorContext()); //[undefined]
         if (ti) {
 
           const m = ti.members[memberName];
           if (!m)
-            throw new Error(`member '${memberName}' not found`);
+            throw new Error(`member '${memberName}' not found` + getErrorContext());
 
           return PropertyRoute.member(PropertyRoute.root(ti), m);
         } else if (this.propertyRouteType == "LiteEntity") {
-          throw Error("Unexpected lite case");
+          throw Error("Unexpected lite case" + getErrorContext());
         }
       }
 
@@ -1411,30 +1413,30 @@ export class PropertyRoute {
 
       const m = this.findRootType().members[fullMemberName];
       if (!m)
-        throw new Error(`member '${fullMemberName}' not found`)
+        throw new Error(`member '${fullMemberName}' not found` + getErrorContext());
 
       return PropertyRoute.member(this, m);
     }
 
     if (memberType == "Mixin") {
       if (this.propertyRouteType != "Root")
-        throw new Error("invalid mixin at this stage");
+        throw new Error("invalid mixin at this stage" + getErrorContext());
 
       return PropertyRoute.mixin(this, memberName);
     }
 
     if (memberType == "Indexer") {
       if (this.propertyRouteType != "Field")
-        throw new Error("invalid indexer at this stage");
+        throw new Error("invalid indexer at this stage" + getErrorContext());
 
       const tr = this.typeReference();
       if (!tr.isCollection)
-        throw new Error(`${this.propertyPath()} is not a collection`);
+        throw new Error("${this.propertyPath()} is not a collection" + getErrorContext());
 
       return PropertyRoute.mlistItem(this);
     }
 
-    throw new Error("not implemented");
+    throw new Error("not implemented" + getErrorContext());
   }
 
   static generateAll(type: PseudoType): PropertyRoute[] {

From 7d90bfd70b251603a26e6908b20608783a718ac8 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 10 Sep 2019 14:57:10 +0200
Subject: [PATCH 28/46] add Collapse tag as string

---
 Signum.React/Scripts/Components/Collapse.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Components/Collapse.tsx b/Signum.React/Scripts/Components/Collapse.tsx
index e7cd425a9d..8b6c412aa1 100644
--- a/Signum.React/Scripts/Components/Collapse.tsx
+++ b/Signum.React/Scripts/Components/Collapse.tsx
@@ -4,7 +4,7 @@ import { classes } from '../Globals';
 
 interface CollapseProps {
   isOpen?: boolean;
-  tag?: React.ComponentType<React.HTMLAttributes<any>>;
+  tag?: string | React.ComponentType<React.HTMLAttributes<any>>;
   attrs?: React.HTMLAttributes<any>;
   navbar?: boolean;
 

From 8a2b7db11ebd44fea5f22352e67a1a7b8acd8b91 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 10 Sep 2019 14:57:20 +0200
Subject: [PATCH 29/46] add Array.toTree

---
 Signum.React/Scripts/Globals.ts | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/Signum.React/Scripts/Globals.ts b/Signum.React/Scripts/Globals.ts
index a89a4b4862..8e8371c70e 100644
--- a/Signum.React/Scripts/Globals.ts
+++ b/Signum.React/Scripts/Globals.ts
@@ -82,6 +82,12 @@ declare global {
     extract(this: Array<T>, filter: (element: T) => boolean): T[];
     findIndex(this: Array<T>, filter: (element: T, index: number, obj: Array<T>) => boolean): number;
     findLastIndex(this: Array<T>, filter: (element: T) => boolean): number;
+    toTree(this: Array<T>, getKey: (element: T) => string, getParentKey: (element: T) => string | null | undefined): TreeNode<T>[];
+  }
+
+  interface TreeNode<T> {
+    value: T;
+    children: TreeNode<T>[];
   }
 
   interface ArrayConstructor {
@@ -581,6 +587,33 @@ if (!Array.prototype.findLastIndex) {
   };
 }
 
+if (!Array.prototype.toTree) {
+  Array.prototype.toTree = function toTree(this: any[], getKey: (element: any) => string, getParentKey: (element: any) => string | null | undefined) {
+
+    var top: TreeNode<any> = { value: null, children: [] };
+
+    var dic: { [key: string]: TreeNode<any> } = {};
+
+    function createNode(item: any) {
+
+      var key = getKey(item);
+      if (dic[key])
+        return dic[key];
+
+      var itemNode: TreeNode<any> = { value: item, children: [] };
+
+      var parentKey = getParentKey(item);
+      var parent = parentKey ? dic[parentKey] : top;
+      parent.children.push(itemNode);
+      return dic[key] = itemNode;
+    }
+
+    this.forEach(n => createNode(n));
+
+    return top.children;
+  }
+}
+
 Array.range = function (min: number, maxNotIncluded: number) {
   const length = maxNotIncluded - min;
 

From a5e6bac1ddfa8142aa0777b72175b7729d35ba8f Mon Sep 17 00:00:00 2001
From: Frank Nussbaum <frank.nussbaum@bechtle.com>
Date: Tue, 10 Sep 2019 16:36:48 +0200
Subject: [PATCH 30/46] Fixing german gender description

---
 Signum.Entities/Translations/Signum.Entities.de.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.Entities/Translations/Signum.Entities.de.xml b/Signum.Entities/Translations/Signum.Entities.de.xml
index e3fc483d10..cb5ccd8ea4 100644
--- a/Signum.Entities/Translations/Signum.Entities.de.xml
+++ b/Signum.Entities/Translations/Signum.Entities.de.xml
@@ -371,9 +371,9 @@
     <Member Name="Operations" Description="Operationen" />
     <Member Name="ParentValue" Description="Übergeordneter Wert" />
     <Member Name="PinnedFilter" Description="vorgewahlter Filter" />
-    <Member Name="PleaseSelectA0_G" Description="Bitte wählen Sie eine {0}" />
+    <Member Name="PleaseSelectA0_G" Description="Bitte wählen Sie ein[m:en|f:e|n:] {0}" />
     <Member Name="PleaseSelectAnEntity" Description="Bitte wählen Sie eine Entität aus" />
-    <Member Name="PleaseSelectOneOrMore0_G" Description="Wählen Sie eine oder mehrere {0}" />
+    <Member Name="PleaseSelectOneOrMore0_G" Description="Wählen Sie ein[m:en|f:e|n:] oder mehrere {0}" />
     <Member Name="PleaseSelectOneOrSeveralEntities" Description="Bitte wählen Sie eine oder mehrere Entitäten aus" />
     <Member Name="Query0IsNotAllowed" Description="Abfrage {0} ist nicht zulässig." />
     <Member Name="Query0NotAllowed" Description="Abfrage {0} ist nicht zulässig." />
@@ -514,4 +514,4 @@
   <Type Name="VoidEnumMessage">
     <Member Name="Instance" Description="-" />
   </Type>
-</Translations>
\ No newline at end of file
+</Translations>

From d8f3ee1f249e6e3fcc8f7ee409e70f6c849f4f34 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Tue, 10 Sep 2019 23:45:42 +0430
Subject: [PATCH 31/46] fix OperationInfo

---
 Signum.React/Scripts/Reflection.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Signum.React/Scripts/Reflection.ts b/Signum.React/Scripts/Reflection.ts
index ce860ee718..4b74744c6d 100644
--- a/Signum.React/Scripts/Reflection.ts
+++ b/Signum.React/Scripts/Reflection.ts
@@ -59,10 +59,10 @@ export interface OperationInfo {
   key: string,
   niceName: string;
   operationType: OperationType;
-  canBeNew: boolean;
-  canBeModified: boolean;
-  hasCanExecute: boolean;
-  hasStates: boolean;
+  canBeNew?: boolean;
+  canBeModified?: boolean;
+  hasCanExecute?: boolean;
+  hasStates?: boolean;
 }
 
 export enum OperationType {

From 8430aa43db813b374fe969ece583d1e583b51b5e Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Tue, 10 Sep 2019 23:46:02 +0430
Subject: [PATCH 32/46] fix StateCanExecutes

---
 Signum.React/ApiControllers/OperationController.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.React/ApiControllers/OperationController.cs b/Signum.React/ApiControllers/OperationController.cs
index a2c24e7413..94c4d1fc62 100644
--- a/Signum.React/ApiControllers/OperationController.cs
+++ b/Signum.React/ApiControllers/OperationController.cs
@@ -217,7 +217,7 @@ public StateCanExecuteResponse StateCanExecutes([Required, FromBody]StateCanExec
                 .Select(operationKey => types.Select(t => BaseOperationRequest.ParseOperationAssert(operationKey, t)).Distinct().SingleEx())
                 .ToList();
 
-            var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols)!;
+            var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols).EmptyIfNull().ToDictionary();
             var anyReadonly = AnyReadonly.GetInvocationListTyped().Any(f => f(request.lites));
 
             return new StateCanExecuteResponse(result.SelectDictionary(a => a.Key, v => v))

From 6dc32f22a4b71909de98963d5fdbc868930d26e0 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Wed, 11 Sep 2019 00:50:04 +0430
Subject: [PATCH 33/46] fix GetContextualCanExecute

---
 Signum.Engine/Operations/OperationLogic.cs         | 8 ++++----
 Signum.React/ApiControllers/OperationController.cs | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Signum.Engine/Operations/OperationLogic.cs b/Signum.Engine/Operations/OperationLogic.cs
index 437c1a305e..33cfcb88e7 100644
--- a/Signum.Engine/Operations/OperationLogic.cs
+++ b/Signum.Engine/Operations/OperationLogic.cs
@@ -622,9 +622,9 @@ public static OperationType OperationType(Type type, OperationSymbol operationSy
             return FindOperation(type, operationSymbol).OperationType;
         }
 
-        public static Dictionary<OperationSymbol, string>? GetContextualCanExecute(IEnumerable<Lite<IEntity>> lites, List<OperationSymbol> operationSymbols)
+        public static Dictionary<OperationSymbol, string> GetContextualCanExecute(IEnumerable<Lite<IEntity>> lites, List<OperationSymbol> operationSymbols)
         {
-            Dictionary<OperationSymbol, string>? result = null;
+            Dictionary<OperationSymbol, string> result = new Dictionary<OperationSymbol, string>();
             using (ExecutionMode.Global())
             {
                 foreach (var grLites in lites.GroupBy(a => a.EntityType))
@@ -634,8 +634,8 @@ public static OperationType OperationType(Type type, OperationSymbol operationSy
                     foreach (var grOperations in operations.GroupBy(a => a.GetType().GetGenericArguments().Let(arr => Tuple.Create(arr[0], arr[1]))))
                     {
                         var dic = giGetContextualGraphCanExecute.GetInvoker(grLites.Key, grOperations.Key.Item1, grOperations.Key.Item2)(grLites, grOperations);
-                        if (result == null)
-                            result = dic;
+                        if (result.IsEmpty())
+                            result.AddRange(dic);
                         else
                         {
                             foreach (var kvp in dic)
diff --git a/Signum.React/ApiControllers/OperationController.cs b/Signum.React/ApiControllers/OperationController.cs
index 94c4d1fc62..3c04ffde8d 100644
--- a/Signum.React/ApiControllers/OperationController.cs
+++ b/Signum.React/ApiControllers/OperationController.cs
@@ -217,7 +217,7 @@ public StateCanExecuteResponse StateCanExecutes([Required, FromBody]StateCanExec
                 .Select(operationKey => types.Select(t => BaseOperationRequest.ParseOperationAssert(operationKey, t)).Distinct().SingleEx())
                 .ToList();
 
-            var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols).EmptyIfNull().ToDictionary();
+            var result = OperationLogic.GetContextualCanExecute(request.lites, operationSymbols);
             var anyReadonly = AnyReadonly.GetInvocationListTyped().Any(f => f(request.lites));
 
             return new StateCanExecuteResponse(result.SelectDictionary(a => a.Key, v => v))

From f44f6cfcf918f9512577abb37bd64595cd070103 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Fri, 13 Sep 2019 08:04:22 +0200
Subject: [PATCH 34/46] fix SignumExceptionFilterAttribute not saving the user

---
 Signum.React/Filters/SignumExceptionFilterAttribute.cs | 3 +--
 Signum.React/Filters/SignumFilters.cs                  | 6 +++++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Filters/SignumExceptionFilterAttribute.cs b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
index e864bd99dd..59eedeb711 100644
--- a/Signum.React/Filters/SignumExceptionFilterAttribute.cs
+++ b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
@@ -26,7 +26,6 @@ public class SignumExceptionFilterAttribute : IAsyncResourceFilter
     {
         public static Func<Exception, bool> TranslateExceptionMessage = ex => ex is ApplicationException;
 
-
         public static Func<Exception, bool> IncludeErrorDetails = ex => true;
 
         public static readonly List<Type> IgnoreExceptions = new List<Type> { typeof(OperationCanceledException) };
@@ -55,7 +54,7 @@ public async Task OnResourceExecutionAsync(ResourceExecutingContext precontext,
                         e.UrlReferer = Try(int.MaxValue, () => req.Headers["Referer"].ToString());
                         e.UserHostAddress = Try(100, () => connFeature.RemoteIpAddress.ToString());
                         e.UserHostName = Try(100, () => Dns.GetHostEntry(connFeature.RemoteIpAddress).HostName);
-                        e.User = UserHolder.Current?.ToLite();
+                        e.User = (UserHolder.Current ?? (IUserEntity)context.HttpContext.Items[SignumAuthenticationFilter.Signum_User_Key])?.ToLite();
                         e.QueryString = Try(int.MaxValue, () => req.QueryString.ToString());
                         e.Form = Try(int.MaxValue, () => ReadAllBody(context.HttpContext));
                         e.Session = null;
diff --git a/Signum.React/Filters/SignumFilters.cs b/Signum.React/Filters/SignumFilters.cs
index e93090f566..79ce1cffa4 100644
--- a/Signum.React/Filters/SignumFilters.cs
+++ b/Signum.React/Filters/SignumFilters.cs
@@ -43,7 +43,9 @@ public void OnResourceExecuted(ResourceExecutedContext context)
 
     public class SignumAuthenticationFilter : SignumDisposableResourceFilter
     {
-        public SignumAuthenticationFilter() : base("Signum_User") { }
+        public const string Signum_User_Key = "Signum_User";
+
+        public SignumAuthenticationFilter() : base("Signum_User_Session") { }
 
         public static readonly IList<Func<FilterContext, SignumAuthenticationResult?>> Authenticators = new List<Func<FilterContext, SignumAuthenticationResult?>>();
 
@@ -66,6 +68,8 @@ public SignumAuthenticationFilter() : base("Signum_User") { }
             if (result == null)
                 return null;
 
+            context.HttpContext.Items[Signum_User_Key] = result.User;
+
             return result.User != null ? UserHolder.UserSession(result.User) : null;
         }
     }

From 88824b3aa94dfe3a6173e6c431585c838c2b7576 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sat, 14 Sep 2019 17:14:05 +0430
Subject: [PATCH 35/46] add support for DynamicClient

---
 Signum.React/Scripts/Finder.tsx     |  4 ++++
 Signum.React/Scripts/Operations.tsx | 14 +++++++-------
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/Signum.React/Scripts/Finder.tsx b/Signum.React/Scripts/Finder.tsx
index 958927e4c8..45715abae3 100644
--- a/Signum.React/Scripts/Finder.tsx
+++ b/Signum.React/Scripts/Finder.tsx
@@ -71,6 +71,10 @@ export function getSettings(queryName: PseudoType | QueryKey): QuerySettings | u
   return querySettings[getQueryKey(queryName)];
 }
 
+export function getOrAddSettings(queryName: PseudoType | QueryKey): QuerySettings {
+  return querySettings[getQueryKey(queryName)] || (querySettings[getQueryKey(queryName)] = { queryName: queryName });
+}
+
 export const isFindableEvent: Array<(queryKey: string, fullScreen: boolean) => boolean> = [];
 
 export function isFindable(queryName: PseudoType | QueryKey, fullScreen: boolean): boolean {
diff --git a/Signum.React/Scripts/Operations.tsx b/Signum.React/Scripts/Operations.tsx
index bb4eba3eb2..7a5637f16b 100644
--- a/Signum.React/Scripts/Operations.tsx
+++ b/Signum.React/Scripts/Operations.tsx
@@ -49,7 +49,7 @@ export function clearOperationSettings() {
 }
 
 export function addSettings(...settings: OperationSettings[]) {
-  settings.forEach(s => Dic.addOrThrow(operationSettings, s.operationSymbol.key!, s));
+  settings.forEach(s => Dic.addOrThrow(operationSettings, s.operationSymbol, s));
 }
 
 
@@ -107,10 +107,10 @@ export function operationInfos(ti: TypeInfo) {
 export abstract class OperationSettings {
 
   text?: () => string;
-  operationSymbol: OperationSymbol;
+  operationSymbol: string;
 
-  constructor(operationSymbol: OperationSymbol) {
-    this.operationSymbol = operationSymbol;
+  constructor(operationSymbol: OperationSymbol | string) {
+    this.operationSymbol = typeof operationSymbol == "string" ? operationSymbol : operationSymbol.key;
   }
 }
 
@@ -124,7 +124,7 @@ export class ConstructorOperationSettings<T extends Entity> extends OperationSet
   isVisible?: (coc: ConstructorOperationContext<T>) => boolean;
   onConstruct?: (coc: ConstructorOperationContext<T>, props?: Partial<T>) => Promise<EntityPack<T> | undefined> | undefined;
 
-  constructor(operationSymbol: ConstructSymbol_Simple<T>, options: ConstructorOperationOptions<T>) {
+  constructor(operationSymbol: ConstructSymbol_Simple<T> | string, options: ConstructorOperationOptions<T>) {
     super(operationSymbol);
 
     Dic.assign(this, options);
@@ -170,7 +170,7 @@ export class ContextualOperationSettings<T extends Entity> extends OperationSett
   iconColor?: string;
   order?: number;
 
-  constructor(operationSymbol: ConstructSymbol_FromMany<any, T>, options: ContextualOperationOptions<T>) {
+  constructor(operationSymbol: ConstructSymbol_FromMany<any, T> | string, options: ContextualOperationOptions<T>) {
     super(operationSymbol);
 
     Dic.assign(this, options);
@@ -345,7 +345,7 @@ export class EntityOperationSettings<T extends Entity> extends OperationSettings
   alternatives?: (ctx: EntityOperationContext<T>) => AlternativeOperationSetting<T>[];
   keyboardShortcut?: KeyboardShortcut | null;
 
-  constructor(operationSymbol: ExecuteSymbol<T> | DeleteSymbol<T> | ConstructSymbol_From<any, T>, options: EntityOperationOptions<T>) {
+  constructor(operationSymbol: ExecuteSymbol<T> | DeleteSymbol<T> | ConstructSymbol_From<any, T> | string, options: EntityOperationOptions<T>) {
     super(operationSymbol)
 
     Dic.assign(this, options);

From 6e034c889590694fcdb903779c3b404eb5e6cf6d Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sat, 14 Sep 2019 17:14:29 +0430
Subject: [PATCH 36/46] add AutocompleteConstructor

---
 .../Scripts/Lines/AutoCompleteConfig.tsx      | 115 ++++++++++++------
 Signum.React/Scripts/Lines/EntityLine.tsx     |   4 +-
 Signum.React/Scripts/Lines/EntityStrip.tsx    |  10 +-
 Signum.React/Scripts/Navigator.tsx            |  21 +++-
 4 files changed, 103 insertions(+), 47 deletions(-)

diff --git a/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx b/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
index f0af1feb6f..c25fb65107 100644
--- a/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
+++ b/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
@@ -1,11 +1,12 @@
 import * as React from 'react'
 import * as Finder from '../Finder'
 import { AbortableRequest } from '../Services'
-import { FindOptions, FilterOptionParsed, OrderOptionParsed, OrderRequest, ResultRow, ColumnOptionParsed, ColumnRequest } from '../FindOptions'
-import { getTypeInfo, getQueryKey, QueryTokenString } from '../Reflection'
-import { ModifiableEntity, Lite, Entity, toLite, is, isLite, isEntity, getToString, liteKey } from '../Signum.Entities'
+import { FindOptions, FilterOptionParsed, OrderOptionParsed, OrderRequest, ResultRow, ColumnOptionParsed, ColumnRequest, QueryDescription } from '../FindOptions'
+import { getTypeInfo, getQueryKey, QueryTokenString, getTypeName } from '../Reflection'
+import { ModifiableEntity, Lite, Entity, toLite, is, isLite, isEntity, getToString, liteKey, SearchMessage } from '../Signum.Entities'
 import { Typeahead } from '../Components'
 import { toFilterRequests } from '../Finder';
+import { AutocompleteConstructor, getAutocompleteConstructors } from '../Navigator';
 
 export interface AutocompleteConfig<T> {
   getItems: (subStr: string) => Promise<T[]>;
@@ -13,15 +14,19 @@ export interface AutocompleteConfig<T> {
   minLength?: number;
   renderItem(item: T, subStr?: string): React.ReactNode;
   renderList?(typeahead: Typeahead): React.ReactNode;
-  getEntityFromItem(item: T): Promise<Lite<Entity> | ModifiableEntity | undefined>;
-  getDataKeyFromItem(item: T): string | undefined;
+  getEntityFromItem(item: T): Promise<Lite<Entity> | ModifiableEntity | null>;
+  getDataKeyFromItem(item: T): string | null;
   getItemFromEntity(entity: Lite<Entity> | ModifiableEntity): Promise<T>;
   abort(): void;
 }
 
-export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteConfig<Lite<T>>{
+export function isAutocompleteConstructor<T extends ModifiableEntity>(a: any): a is AutocompleteConstructor<T> {
+  return (a as AutocompleteConstructor<T>).onClick != null;
+}
+
+export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteConfig<Lite<T> | AutocompleteConstructor<T>>{
   constructor(
-    public getItemsFunction: (signal: AbortSignal, subStr: string) => Promise<Lite<T>[]>,
+    public getItemsFunction: (signal: AbortSignal, subStr: string) => Promise<(Lite<T> | AutocompleteConstructor<T>)[]>,
     public requiresInitialLoad: boolean,
     public showType: boolean) {
   }
@@ -36,7 +41,13 @@ export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteCon
     return this.abortableRequest.getData(subStr);
   }
 
-  renderItem(item: Lite<T>, subStr: string) {
+  renderItem(item: Lite<T> | AutocompleteConstructor<T>, subStr: string) {
+
+    if (isAutocompleteConstructor<T>(item)) {
+      var ti = getTypeInfo(item.type);
+      return <em>{SearchMessage.CreateNew0_G.niceToString().forGenderAndNumber(ti.gender).formatWith(ti.niceName)} "{subStr}"</em>;
+    }
+
     var toStr = getToString(item);
     var text = Typeahead.highlightedText(toStr, subStr);
     if (this.showType)
@@ -45,11 +56,19 @@ export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteCon
       return text;
   }
 
-  getEntityFromItem(item: Lite<T>): Promise<Lite<Entity> | ModifiableEntity> {
+  getEntityFromItem(item: Lite<T> | AutocompleteConstructor<T>): Promise<Lite<Entity> | ModifiableEntity | null> {
+
+    if (isAutocompleteConstructor(item))
+      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | null>;
+
     return Promise.resolve(item);
   }
 
-  getDataKeyFromItem(item: Lite<T>): string | undefined {
+  getDataKeyFromItem(item: Lite<T> | AutocompleteConstructor<T>): string | null {
+
+    if (isAutocompleteConstructor(item))
+      return "create-" + getTypeName(item.type); 
+
     return liteKey(item);
   }
 
@@ -65,7 +84,7 @@ export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteCon
 
     return this.abortableRequest.getData(lite.id!.toString()).then(lites => {
 
-      const result = lites.filter(a => is(a, lite)).firstOrNull();
+      const result = lites.filter(a => isLite(a) && is(a, lite)).firstOrNull() as Lite<T> | null;
 
       if (!result)
         throw new Error("Impossible to getInitialItem with the current implementation of getItems");
@@ -86,13 +105,18 @@ export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteCon
   }
 }
 
-export class FindOptionsAutocompleteConfig implements AutocompleteConfig<ResultRow>{
+interface FindOptionsAutocompleteConfigOptions {
+  getAutocompleteConstructor?: (str: string, foundRows: ResultRow[]) => AutocompleteConstructor<Entity>[],
+  count?: number,
+  requiresInitialLoad?: boolean,
+  showType?: boolean,
+}
+
+export class FindOptionsAutocompleteConfig implements AutocompleteConfig<ResultRow | AutocompleteConstructor<Entity>>{
 
   constructor(
     public findOptions: FindOptions,
-    public count: number = 5,
-    public requiresInitialLoad: boolean = false,
-    public showType: boolean = false,
+    public options?: FindOptionsAutocompleteConfigOptions
   ) {
     Finder.expandParentColumn(this.findOptions);
   }
@@ -102,68 +126,83 @@ export class FindOptionsAutocompleteConfig implements AutocompleteConfig<ResultR
   }
 
   parsedFilters?: FilterOptionParsed[];
-  getParsedFilters(): Promise<FilterOptionParsed[]> {
+  getParsedFilters(qd: QueryDescription): Promise<FilterOptionParsed[]> {
     if (this.parsedFilters)
       return Promise.resolve(this.parsedFilters);
 
-    return Finder.getQueryDescription(this.findOptions.queryName)
-      .then(qd => Finder.parseFilterOptions(this.findOptions.filterOptions || [], false, qd))
+    return Finder.parseFilterOptions(this.findOptions.filterOptions || [], false, qd)
       .then(filters => this.parsedFilters = filters);
   }
 
   parsedOrders?: OrderOptionParsed[];
-  getParsedOrders(): Promise<OrderOptionParsed[]> {
+  getParsedOrders(qd: QueryDescription): Promise<OrderOptionParsed[]> {
     if (this.parsedOrders)
       return Promise.resolve(this.parsedOrders);
 
-    return Finder.getQueryDescription(this.findOptions.queryName)
-      .then(qd => Finder.parseOrderOptions(this.findOptions.orderOptions || [], false, qd))
+    return  Finder.parseOrderOptions(this.findOptions.orderOptions || [], false, qd)
       .then(orders => this.parsedOrders = orders);
   }
 
   parsedColumns?: ColumnOptionParsed[];
-  getParsedColumns(): Promise<ColumnOptionParsed[]> {
+  getParsedColumns(qd: QueryDescription): Promise<ColumnOptionParsed[]> {
     if (this.parsedColumns)
       return Promise.resolve(this.parsedColumns);
 
-    return Finder.getQueryDescription(this.findOptions.queryName)
-      .then(qd => Finder.parseColumnOptions(this.findOptions.columnOptions || [], false, qd))
+    return Finder.parseColumnOptions(this.findOptions.columnOptions || [], false, qd)
       .then(columns => this.parsedColumns = columns);
   }
 
   abortableRequest = new AbortableRequest((abortController, request: Finder.API.AutocompleteQueryRequest) => Finder.API.FindRowsLike(request, abortController));
 
-  getItems(subStr: string): Promise<ResultRow[]> {
-    return this.getParsedFilters().then(filters =>
-      this.getParsedOrders().then(orders =>
-        this.getParsedColumns().then(columns =>
+  async getItems(subStr: string): Promise<(ResultRow | AutocompleteConstructor<Entity>)[]> {
+
+    return Finder.getQueryDescription(this.findOptions.queryName)
+      .then(qd => Promise.all(
+        [
+          this.getParsedFilters(qd),
+          this.getParsedOrders(qd),
+          this.getParsedColumns(qd)
+        ]).then(([filters, orders, columns]) =>
           this.abortableRequest.getData({
             queryKey: getQueryKey(this.findOptions.queryName),
             columns: columns.map(c => ({ token: c.token!.fullKey, displayName: c.displayName }) as ColumnRequest),
             filters: toFilterRequests(filters),
             orders: orders.map(o => ({ token: o.token!.fullKey, orderType: o.orderType }) as OrderRequest),
-            count: this.count,
+            count: this.options && this.options.count || 5,
             subString: subStr
-          }).then(rt => rt.rows)
+          }).then(rt => [
+            ...rt.rows,
+            ...this.options && this.options.getAutocompleteConstructor && this.options.getAutocompleteConstructor(subStr, rt.rows) || []
+          ])
         )
-      )
-    );
+      );
   }
 
-  renderItem(item: ResultRow, subStr: string) {
+  renderItem(item: ResultRow | AutocompleteConstructor<Entity>, subStr: string) {
+    if (isAutocompleteConstructor<Entity>(item)) {
+      var ti = getTypeInfo(item.type);
+      return <em>{SearchMessage.CreateNew0_G.niceToString().forGenderAndNumber(ti.gender).formatWith(ti.niceName)} "{subStr}"</em>;
+    }
+
     var toStr = getToString(item.entity!);
     var text = Typeahead.highlightedText(toStr, subStr);
-    if (this.showType)
+    if (this.options && this.options.showType)
       return <span style={{ wordBreak: "break-all" }} title={toStr}><span className="sf-type-badge">{getTypeInfo(item.entity!.EntityType).niceName}</span> {text}</span>;
     else
       return text;
   }
 
-  getEntityFromItem(item: ResultRow): Promise<Lite<Entity> | ModifiableEntity> {
+  getEntityFromItem(item: ResultRow): Promise<Lite<Entity> | ModifiableEntity | null> {
+    if (isAutocompleteConstructor(item))
+      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | null>;
+
     return Promise.resolve(item.entity!);
   }
 
-  getDataKeyFromItem(item: ResultRow): string | undefined {
+  getDataKeyFromItem(item: ResultRow): string | null {
+    if (isAutocompleteConstructor(item))
+      return "create-" + getTypeName(item.type); 
+
     return liteKey(item.entity!);
   }
 
@@ -171,13 +210,13 @@ export class FindOptionsAutocompleteConfig implements AutocompleteConfig<ResultR
 
     var lite = this.convertToLite(entity);;
 
-    if (!this.requiresInitialLoad)
+    if (!(this.options && this.options.requiresInitialLoad))
       return Promise.resolve({ entity: lite } as ResultRow);
 
     if (lite.id == undefined)
       return Promise.resolve({ entity: lite } as ResultRow);
 
-    return this.getParsedColumns().then(columns =>
+    return Finder.getQueryDescription(this.findOptions.queryName).then(qd => this.getParsedColumns(qd)).then(columns =>
 
       Finder.API.FindRowsLike({
         queryKey: getQueryKey(this.findOptions.queryName),
diff --git a/Signum.React/Scripts/Lines/EntityLine.tsx b/Signum.React/Scripts/Lines/EntityLine.tsx
index 322a1773a6..6f44f29a43 100644
--- a/Signum.React/Scripts/Lines/EntityLine.tsx
+++ b/Signum.React/Scripts/Lines/EntityLine.tsx
@@ -26,7 +26,7 @@ export class EntityLine extends EntityBase<EntityLineProps, EntityLineState> {
     super.overrideProps(state, overridenProps);
     if (state.autocomplete === undefined) {
       const type = state.type!;
-      state.autocomplete = Navigator.getAutoComplete(type, state.findOptions, state.showType);
+      state.autocomplete = Navigator.getAutoComplete(type, state.findOptions, state.ctx, state.create!, state.showType);
     }
 
     if (!state.currentItem) {
@@ -89,7 +89,7 @@ export class EntityLine extends EntityBase<EntityLineProps, EntityLineState> {
 
   handleOnSelect = (item: any, event: React.SyntheticEvent<any>) => {
     this.state.autocomplete!.getEntityFromItem(item)
-      .then(entity => entity &&
+      .then(entity => entity == null ? undefined :
         this.convert(entity)
           .then(entity => {
             this.state.autocomplete!.getItemFromEntity(entity).then(newItem => //newItem could be different to item on create new case
diff --git a/Signum.React/Scripts/Lines/EntityStrip.tsx b/Signum.React/Scripts/Lines/EntityStrip.tsx
index 9a2db4e175..980cfd7e40 100644
--- a/Signum.React/Scripts/Lines/EntityStrip.tsx
+++ b/Signum.React/Scripts/Lines/EntityStrip.tsx
@@ -33,7 +33,7 @@ export class EntityStrip extends EntityListBase<EntityStripProps, EntityStripPro
     super.overrideProps(state, overridenProps);
     if (state.autocomplete === undefined) {
       const type = state.type!;
-      state.autocomplete = Navigator.getAutoComplete(type, state.findOptions, state.showType);
+      state.autocomplete = Navigator.getAutoComplete(type, state.findOptions, state.ctx, state.create!, state.showType);
     }
   }
   renderInternal() {
@@ -78,9 +78,11 @@ export class EntityStrip extends EntityListBase<EntityStripProps, EntityStripPro
 
   handleOnSelect = (item: any, event: React.SyntheticEvent<any>) => {
     this.state.autocomplete!.getEntityFromItem(item)
-      .then(entity => entity && this.convert(entity)
-        .then(e => this.addElement(e))
-      ).done();
+      .then(entity => {
+        if (entity)
+          this.convert(entity)
+            .then(e => this.addElement(e)).done();
+      }).done();
 
     return "";
   }
diff --git a/Signum.React/Scripts/Navigator.tsx b/Signum.React/Scripts/Navigator.tsx
index 592dba263a..6cc5492344 100644
--- a/Signum.React/Scripts/Navigator.tsx
+++ b/Signum.React/Scripts/Navigator.tsx
@@ -539,14 +539,16 @@ export function defaultFindOptions(type: TypeReference): FindOptions | undefined
   return undefined;
 }
 
-export function getAutoComplete(type: TypeReference, findOptions: FindOptions | undefined, showType?: boolean): AutocompleteConfig<any> | null {
+export function getAutoComplete(type: TypeReference, findOptions: FindOptions | undefined, ctx: TypeContext<any>, create: boolean, showType?: boolean): AutocompleteConfig<any> | null {
   if (type.isEmbedded || type.name == IsByAll)
     return null;
 
   var config: AutocompleteConfig<any> | null = null;
 
   if (findOptions)
-    config = new FindOptionsAutocompleteConfig(findOptions);
+    config = new FindOptionsAutocompleteConfig(findOptions, {
+      getAutocompleteConstructor: !create ? undefined : (subStr, rows) => getAutocompleteConstructors(type, subStr, ctx, rows.map(a => a.entity!)) as AutocompleteConstructor<Entity>[]
+    });
 
   const types = getTypeInfos(type);
   var delay: number | undefined;
@@ -568,7 +570,7 @@ export function getAutoComplete(type: TypeReference, findOptions: FindOptions |
       types: type.name,
       subString: subStr,
       count: 5
-    }, signal), false, showType == null ? type.name.contains(",") : showType);
+    }, signal).then(lites => [...lites, ...(!create ? []: getAutocompleteConstructors(type, subStr, ctx, lites) as AutocompleteConstructor<Entity>[])]), false, showType == null ? type.name.contains(",") : showType);
   }
 
   if (!config.getItemsDelay) {
@@ -793,6 +795,18 @@ export interface ViewOverride<T extends ModifiableEntity> {
   override: (replacer: ViewReplacer<T>) => void;
 }
 
+export interface AutocompleteConstructor<T extends ModifiableEntity> {
+  type: PseudoType;
+  onClick: () => Promise<T | null>;
+}
+
+export function getAutocompleteConstructors(tr: TypeReference, str: string, ctx: TypeContext<any>, foundLites: Lite<Entity>[]): AutocompleteConstructor<ModifiableEntity>[]{
+  return getTypeInfos(tr.name).map(ti => {
+    var es = getSettings(ti);
+    return es && es.autocompleteConstructor && es.autocompleteConstructor(str, ctx, foundLites);
+  }).notNull();
+}
+
 export class EntitySettings<T extends ModifiableEntity> {
   typeName: string;
 
@@ -810,6 +824,7 @@ export class EntitySettings<T extends ModifiableEntity> {
   isReadOnly?: boolean;
   autocomplete?: AutocompleteConfig<any>;
   autocompleteDelay?: number;
+  autocompleteConstructor?: (str: string, ctx: TypeContext<any>, foundLites: Lite<Entity>[]) => AutocompleteConstructor<T> | null;
   findOptions?: FindOptions;
   onNavigate?: (entityOrPack: Lite<Entity & T> | T | EntityPack<T>, navigateOptions?: NavigateOptions) => Promise<void>;
   onView?: (entityOrPack: Lite<Entity & T> | T | EntityPack<T>, viewOptions?: ViewOptions) => Promise<T | undefined>;

From 049df09083eab3b924d8c5423a95ea3a9c5c4586 Mon Sep 17 00:00:00 2001
From: karimpour <mkarimpour@gmail.com>
Date: Sun, 15 Sep 2019 11:16:10 +0430
Subject: [PATCH 37/46] fix Retrieve.loadData

---
 Signum.React/Scripts/Retrieve.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Signum.React/Scripts/Retrieve.tsx b/Signum.React/Scripts/Retrieve.tsx
index 70239cf1f6..debaf7c375 100644
--- a/Signum.React/Scripts/Retrieve.tsx
+++ b/Signum.React/Scripts/Retrieve.tsx
@@ -1,4 +1,4 @@
-import * as Navigator from './Navigator';
+import * as Navigator from './Navigator';
 
 import * as React from 'react'
 import { Entity, Lite, is } from './Signum.Entities';
@@ -44,6 +44,8 @@ export class Retrieve extends React.Component<RetrieveProps, RetrieveState> {
 
     if (props.lite == null)
       this.setState({ entity: null });
+    else if (props.lite.entity)
+      this.setState({ entity: props.lite.entity });
     else {
       this.setState({ entity: undefined });
       Navigator.API.fetchAndForget(props.lite)

From ee28347f18fbb36fbd175e202b50d87e81c71966 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Mon, 16 Sep 2019 08:44:29 +0200
Subject: [PATCH 38/46] make Frame pack not nullable

---
 Signum.React/Scripts/Frames/FrameModal.tsx  | 23 ++++++++++-----------
 Signum.React/Scripts/Frames/FramePage.tsx   |  2 +-
 Signum.React/Scripts/Frames/Widgets.tsx     |  4 ++--
 Signum.React/Scripts/Lines/RenderEntity.tsx |  2 +-
 Signum.React/Scripts/QuickLinks.tsx         |  8 +++----
 Signum.React/Scripts/TypeContext.ts         |  2 +-
 6 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/Signum.React/Scripts/Frames/FrameModal.tsx b/Signum.React/Scripts/Frames/FrameModal.tsx
index 1f4a31232f..08621c3752 100644
--- a/Signum.React/Scripts/Frames/FrameModal.tsx
+++ b/Signum.React/Scripts/Frames/FrameModal.tsx
@@ -219,7 +219,7 @@ export default class FrameModal extends React.Component<FrameModalProps, FrameMo
           okDisabled={!pack}>
           {this.renderTitle()}
         </ModalHeaderButtons>
-        {pack && this.renderBody()}
+        {pack && this.renderBody(pack)}
       </Modal>
     );
   }
@@ -235,33 +235,32 @@ export default class FrameModal extends React.Component<FrameModalProps, FrameMo
 
   buttonBar?: ButtonBar | null;
 
-  renderBody() {
+  renderBody(pack: EntityPack<ModifiableEntity>) {
 
     const frame: EntityFrame = {
       frameComponent: this,
       entityComponent: this.entityComponent,
-      onReload: (pack, reloadComponent, callback) => {
-        var newPack = pack || this.state.pack!;
+      onReload: (newPack, reloadComponent, callback) => {
+        var newPackOrPack = newPack || pack;
 
         if (reloadComponent) {
-          this.setState({ getComponent: undefined }, () => this.loadComponent(newPack, callback).done()); //For AutoFocus and potentialy another view
+          this.setState({ getComponent: undefined }, () => this.loadComponent(newPackOrPack, callback).done()); //For AutoFocus and potentialy another view
         }
         else {
-          this.setPack(newPack, callback);
+          this.setPack(newPackOrPack, callback);
         }
       },
-      pack: this.state.pack,
-      onClose: (ok?: boolean) => this.props.onExited!(ok ? this.state.pack!.entity : undefined),
+      pack: pack,
+      onClose: (ok?: boolean) => this.props.onExited!(ok ? pack.entity : undefined),
       revalidate: () => this.validationErrors && this.validationErrors.forceUpdate(),
       setError: (modelState, initialPrefix = "") => {
-        GraphExplorer.setModelState(this.state.pack!.entity, modelState, initialPrefix!);
+        GraphExplorer.setModelState(pack.entity, modelState, initialPrefix!);
         this.forceUpdate();
       },
       refreshCount: this.state.refreshCount,
       allowChangeEntity: this.props.isNavigate || false,
     };
 
-    const pack = this.state.pack!;
 
     const styleOptions: StyleOptions = {
       readOnly: this.props.readOnly != undefined ? this.props.readOnly : Navigator.isReadOnly(pack),
@@ -270,13 +269,13 @@ export default class FrameModal extends React.Component<FrameModalProps, FrameMo
 
     const ctx = new TypeContext(undefined, styleOptions, this.state.propertyRoute!, new ReadonlyBinding(pack.entity, ""), this.prefix!);
 
-    const wc: WidgetContext<ModifiableEntity> = { ctx: ctx, pack: pack };
+    const wc: WidgetContext<ModifiableEntity> = { ctx: ctx, frame: frame };
 
     const embeddedWidgets = renderEmbeddedWidgets(wc);
 
     return (
       <div className="modal-body">
-        {renderWidgets({ ctx: ctx, pack: pack })}
+        {renderWidgets(wc)}
         {this.entityComponent && <ButtonBar ref={bb => this.buttonBar = bb} frame={frame} pack={pack} isOperationVisible={this.props.isOperationVisible} />}
         <ValidationErrors entity={pack.entity} ref={ve => this.validationErrors = ve} prefix={this.prefix} />
         {embeddedWidgets.top}
diff --git a/Signum.React/Scripts/Frames/FramePage.tsx b/Signum.React/Scripts/Frames/FramePage.tsx
index 99786a919c..714a8f8e23 100644
--- a/Signum.React/Scripts/Frames/FramePage.tsx
+++ b/Signum.React/Scripts/Frames/FramePage.tsx
@@ -200,7 +200,7 @@ export default class FramePage extends React.Component<FramePageProps, FramePage
 
     const wc: WidgetContext<Entity> = {
       ctx: ctx,
-      pack: this.state.pack,
+      frame: frame,
     };
 
     const embeddedWidgets = renderEmbeddedWidgets(wc);
diff --git a/Signum.React/Scripts/Frames/Widgets.tsx b/Signum.React/Scripts/Frames/Widgets.tsx
index e08b788755..f993c90778 100644
--- a/Signum.React/Scripts/Frames/Widgets.tsx
+++ b/Signum.React/Scripts/Frames/Widgets.tsx
@@ -1,11 +1,11 @@
 import * as React from 'react'
 import { EntityPack, ModifiableEntity } from '../Signum.Entities'
-import { TypeContext } from '../TypeContext'
+import { TypeContext, EntityFrame } from '../TypeContext'
 import "./Widgets.css"
 
 export interface WidgetContext<T extends ModifiableEntity> {
   ctx: TypeContext<T>;
-  pack: EntityPack<T>;
+  frame: EntityFrame;
 }
 
 export const onWidgets: Array<(ctx: WidgetContext<ModifiableEntity>) => React.ReactElement<any> | undefined> = [];
diff --git a/Signum.React/Scripts/Lines/RenderEntity.tsx b/Signum.React/Scripts/Lines/RenderEntity.tsx
index 5c57475719..d2a3b0faa9 100644
--- a/Signum.React/Scripts/Lines/RenderEntity.tsx
+++ b/Signum.React/Scripts/Lines/RenderEntity.tsx
@@ -155,7 +155,7 @@ export class RenderEntity extends React.Component<RenderEntityProps, RenderEntit
     const frame: EntityFrame = {
       frameComponent: this,
       entityComponent: this.entityComponent,
-      pack: undefined,
+      pack: { entity, canExecute: {} },
       revalidate: () => this.props.ctx.frame && this.props.ctx.frame.revalidate(),
       onClose: () => { throw new Error("Not implemented Exception"); },
       onReload: pack => { throw new Error("Not implemented Exception"); },
diff --git a/Signum.React/Scripts/QuickLinks.tsx b/Signum.React/Scripts/QuickLinks.tsx
index f52452b8e2..f245a8288f 100644
--- a/Signum.React/Scripts/QuickLinks.tsx
+++ b/Signum.React/Scripts/QuickLinks.tsx
@@ -117,7 +117,7 @@ function asArray<T>(valueOrArray: Seq<T>): T[] {
 
 export function getQuickLinkWidget(ctx: WidgetContext<ModifiableEntity>): React.ReactElement<any> {
 
-  return <QuickLinkWidget ctx={ctx} />;
+  return <QuickLinkWidget wc={ctx} />;
 }
 
 export function getQuickLinkContextMenus(ctx: ContextualItemsContext<Entity>): Promise<MenuItemBlock | undefined> {
@@ -142,12 +142,12 @@ export function getQuickLinkContextMenus(ctx: ContextualItemsContext<Entity>): P
 }
 
 export interface QuickLinkWidgetProps {
-  ctx: WidgetContext<ModifiableEntity>
+  wc: WidgetContext<ModifiableEntity>
 }
 
 export function QuickLinkWidget(p: QuickLinkWidgetProps) {
 
-  const entity = p.ctx.pack.entity;
+  const entity = p.wc.ctx.value;
 
   const links = useAPI(undefined, [p], signal => {
     if (entity.isNew || !getTypeInfo(entity.Type) || !getTypeInfo(entity.Type).entityKind)
@@ -156,7 +156,7 @@ export function QuickLinkWidget(p: QuickLinkWidgetProps) {
       return getQuickLinks({
         lite: toLiteFat(entity as Entity),
         lites: [toLiteFat(entity as Entity)],
-        widgetContext: p.ctx as WidgetContext<Entity>
+        widgetContext: p.wc as WidgetContext<Entity>
       });
   });
 
diff --git a/Signum.React/Scripts/TypeContext.ts b/Signum.React/Scripts/TypeContext.ts
index f8417407e8..d805964790 100644
--- a/Signum.React/Scripts/TypeContext.ts
+++ b/Signum.React/Scripts/TypeContext.ts
@@ -442,7 +442,7 @@ export interface IHasChanges {
 export interface EntityFrame {
   frameComponent: React.Component<any, any>;
   entityComponent: React.Component<any, any> | null | undefined;
-  pack: EntityPack<ModifiableEntity> | undefined;
+  pack: EntityPack<ModifiableEntity>;
   onReload: (pack?: EntityPack<ModifiableEntity>, reloadComponent?: boolean, callback?: () => void) => void;
   setError: (modelState: ModelState, initialPrefix?: string) => void;
   revalidate: () => void;

From b13d9037871b3a3597afb8c44f14d6f4f51e3392 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 17 Sep 2019 14:26:47 +0200
Subject: [PATCH 39/46] use undefined (instead of null) in
 AutocompleteConstructor to avoid conversion when using Navigator.view

---
 .../Scripts/Lines/AutoCompleteConfig.tsx         | 16 ++++++++--------
 Signum.React/Scripts/Navigator.tsx               |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx b/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
index c25fb65107..42e6771350 100644
--- a/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
+++ b/Signum.React/Scripts/Lines/AutoCompleteConfig.tsx
@@ -14,8 +14,8 @@ export interface AutocompleteConfig<T> {
   minLength?: number;
   renderItem(item: T, subStr?: string): React.ReactNode;
   renderList?(typeahead: Typeahead): React.ReactNode;
-  getEntityFromItem(item: T): Promise<Lite<Entity> | ModifiableEntity | null>;
-  getDataKeyFromItem(item: T): string | null;
+  getEntityFromItem(item: T): Promise<Lite<Entity> | ModifiableEntity | undefined>;
+  getDataKeyFromItem(item: T): string | undefined;
   getItemFromEntity(entity: Lite<Entity> | ModifiableEntity): Promise<T>;
   abort(): void;
 }
@@ -56,15 +56,15 @@ export class LiteAutocompleteConfig<T extends Entity> implements AutocompleteCon
       return text;
   }
 
-  getEntityFromItem(item: Lite<T> | AutocompleteConstructor<T>): Promise<Lite<Entity> | ModifiableEntity | null> {
+  getEntityFromItem(item: Lite<T> | AutocompleteConstructor<T>): Promise<Lite<Entity> | ModifiableEntity | undefined> {
 
     if (isAutocompleteConstructor(item))
-      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | null>;
+      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | undefined>;
 
     return Promise.resolve(item);
   }
 
-  getDataKeyFromItem(item: Lite<T> | AutocompleteConstructor<T>): string | null {
+  getDataKeyFromItem(item: Lite<T> | AutocompleteConstructor<T>): string | undefined {
 
     if (isAutocompleteConstructor(item))
       return "create-" + getTypeName(item.type); 
@@ -192,14 +192,14 @@ export class FindOptionsAutocompleteConfig implements AutocompleteConfig<ResultR
       return text;
   }
 
-  getEntityFromItem(item: ResultRow): Promise<Lite<Entity> | ModifiableEntity | null> {
+  getEntityFromItem(item: ResultRow): Promise<Lite<Entity> | ModifiableEntity | undefined> {
     if (isAutocompleteConstructor(item))
-      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | null>;
+      return item.onClick() as Promise<Lite<Entity> | ModifiableEntity | undefined>;
 
     return Promise.resolve(item.entity!);
   }
 
-  getDataKeyFromItem(item: ResultRow): string | null {
+  getDataKeyFromItem(item: ResultRow): string | undefined {
     if (isAutocompleteConstructor(item))
       return "create-" + getTypeName(item.type); 
 
diff --git a/Signum.React/Scripts/Navigator.tsx b/Signum.React/Scripts/Navigator.tsx
index 6cc5492344..e87d4de32b 100644
--- a/Signum.React/Scripts/Navigator.tsx
+++ b/Signum.React/Scripts/Navigator.tsx
@@ -797,7 +797,7 @@ export interface ViewOverride<T extends ModifiableEntity> {
 
 export interface AutocompleteConstructor<T extends ModifiableEntity> {
   type: PseudoType;
-  onClick: () => Promise<T | null>;
+  onClick: () => Promise<T | undefined>;
 }
 
 export function getAutocompleteConstructors(tr: TypeReference, str: string, ctx: TypeContext<any>, foundLites: Lite<Entity>[]): AutocompleteConstructor<ModifiableEntity>[]{

From 7018153b56446b00759d3b73ee10fec9df62ba43 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Tue, 17 Sep 2019 14:27:04 +0200
Subject: [PATCH 40/46] fix MultiValueLine key

---
 Signum.React/Scripts/Lines/MultiValueLine.tsx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.React/Scripts/Lines/MultiValueLine.tsx b/Signum.React/Scripts/Lines/MultiValueLine.tsx
index 6b3c6ccdb4..3a1c6c52f5 100644
--- a/Signum.React/Scripts/Lines/MultiValueLine.tsx
+++ b/Signum.React/Scripts/Lines/MultiValueLine.tsx
@@ -66,12 +66,12 @@ export class MultiValueLine extends LineBase<MultiValueLineProps, MultiValueLine
           <tbody>
             {
               mlistItemContext(s.ctx.subCtx({ formGroupStyle: "None" })).map((mlec, i) =>
-                (<ErrorBoundary>
-                  <MultiValueLineElement key={i}
+                <ErrorBoundary key={i}>
+                  <MultiValueLineElement
                     ctx={mlec}
                     onRemove={e => { e.preventDefault(); this.handleDeleteValue(i); }}
                     onRenderItem={this.props.onRenderItem} />
-                </ErrorBoundary>))
+                </ErrorBoundary>)
             }
             <tr >
               <td colSpan={4}>

From 1943a40a0f588e5343ef6c6e1a1851ed6135baeb Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Wed, 18 Sep 2019 13:41:31 +0200
Subject: [PATCH 41/46] add MaybeNull to SingleOrDefaultEx and SingleOrMany

---
 Signum.Engine/Administrator.cs                      | 2 +-
 Signum.Engine/CodeGeneration/EntityCodeGenerator.cs | 4 ++--
 Signum.Engine/Database.cs                           | 2 +-
 Signum.Engine/DynamicQuery/AutoCompleteUtils.cs     | 6 +++---
 Signum.Engine/Engine/SchemaSynchronizer.cs          | 2 +-
 Signum.Engine/Engine/Sys.Tables.cs                  | 2 +-
 Signum.Engine/Exceptions.cs                         | 2 +-
 Signum.Entities/DynamicQuery/ResultTable.cs         | 4 ++--
 Signum.Entities/DynamicQuery/Tokens/QueryToken.cs   | 2 +-
 Signum.Entities/Reflection/Reflector.cs             | 8 ++++----
 Signum.Test/LinqProvider/SingleFirstTest.cs         | 4 ++--
 Signum.Utilities/Extensions/ArgsExtensions.cs       | 5 +++--
 Signum.Utilities/Extensions/EnumExtensions.cs       | 4 ++--
 Signum.Utilities/Extensions/EnumerableExtensions.cs | 9 +++++++++
 14 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/Signum.Engine/Administrator.cs b/Signum.Engine/Administrator.cs
index 18e3544691..e35218ea70 100644
--- a/Signum.Engine/Administrator.cs
+++ b/Signum.Engine/Administrator.cs
@@ -41,7 +41,7 @@ from c in t.Columns()
                  select new DiffColumn
                  {
                      Name = c.name,
-                     SqlDbType = SchemaSynchronizer.ToSqlDbType(c.Type().name),
+                     SqlDbType = SchemaSynchronizer.ToSqlDbType(c.Type()!.name),
                      UserTypeName = null,
                      Identity = c.is_identity,
                      Nullable = c.is_nullable,
diff --git a/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs b/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs
index 24b80413ce..d814bae1ae 100644
--- a/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs
+++ b/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs
@@ -498,7 +498,7 @@ protected virtual string GetTicksColumnAttribute(DiffTable table)
 
         protected virtual string? GetPrimaryKeyAttribute(DiffTable table)
         {
-            DiffColumn primaryKey = GetPrimaryKeyColumn(table);
+            DiffColumn? primaryKey = GetPrimaryKeyColumn(table);
 
             if (primaryKey == null)
                 return null;
@@ -529,7 +529,7 @@ protected virtual string GetTicksColumnAttribute(DiffTable table)
             return null;
         }
 
-        protected virtual DiffColumn GetPrimaryKeyColumn(DiffTable table)
+        protected virtual DiffColumn? GetPrimaryKeyColumn(DiffTable table)
         {
             return table.Columns.Values.SingleOrDefaultEx(a => a.PrimaryKey);
         }
diff --git a/Signum.Engine/Database.cs b/Signum.Engine/Database.cs
index 6d0874409f..801ba0a4dd 100644
--- a/Signum.Engine/Database.cs
+++ b/Signum.Engine/Database.cs
@@ -166,7 +166,7 @@ public static T Retrieve<T>(PrimaryKey id) where T : Entity
                     }
                 }
 
-                T retrieved = Database.Query<T>().SingleOrDefaultEx(a => a.Id == id);
+                T? retrieved = Database.Query<T>().SingleOrDefaultEx(a => a.Id == id);
 
                 if (retrieved == null)
                     throw new EntityNotFoundException(typeof(T), id);
diff --git a/Signum.Engine/DynamicQuery/AutoCompleteUtils.cs b/Signum.Engine/DynamicQuery/AutoCompleteUtils.cs
index b4370f9331..ad20851936 100644
--- a/Signum.Engine/DynamicQuery/AutoCompleteUtils.cs
+++ b/Signum.Engine/DynamicQuery/AutoCompleteUtils.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
@@ -299,7 +299,7 @@ public static List<Lite<T>> Autocomplete<T>(this IQueryable<Lite<T>> query, stri
 
                 if (TryParsePrimaryKey(subString, typeof(T), out PrimaryKey id))
                 {
-                    Lite<T> entity = query.SingleOrDefaultEx(e => e.Id == id);
+                    Lite<T>? entity = query.SingleOrDefaultEx(e => e.Id == id);
 
                     if (entity != null)
                         results.Add(entity);
@@ -358,7 +358,7 @@ public static List<Lite<T>> Autocomplete<T>(this IEnumerable<Lite<T>> collection
 
                 if (TryParsePrimaryKey(subString, typeof(T), out PrimaryKey id))
                 {
-                    Lite<T> entity = collection.SingleOrDefaultEx(e => e.Id == id);
+                    Lite<T>? entity = collection.SingleOrDefaultEx(e => e.Id == id);
 
                     if (entity != null)
                         results.Add(entity);
diff --git a/Signum.Engine/Engine/SchemaSynchronizer.cs b/Signum.Engine/Engine/SchemaSynchronizer.cs
index d4245d7e5b..34454db4b7 100644
--- a/Signum.Engine/Engine/SchemaSynchronizer.cs
+++ b/Signum.Engine/Engine/SchemaSynchronizer.cs
@@ -1053,7 +1053,7 @@ public class DiffTable
     {
         public ObjectName Name;
 
-        public ObjectName PrimaryKeyName;
+        public ObjectName? PrimaryKeyName;
 
         public Dictionary<string, DiffColumn> Columns;
 
diff --git a/Signum.Engine/Engine/Sys.Tables.cs b/Signum.Engine/Engine/Sys.Tables.cs
index 8195d40006..58a5f872ba 100644
--- a/Signum.Engine/Engine/Sys.Tables.cs
+++ b/Signum.Engine/Engine/Sys.Tables.cs
@@ -196,7 +196,7 @@ public class SysColumns : IView
         public GeneratedAlwaysType generated_always_type;
 
         [AutoExpressionField]
-        public SysTypes Type() => 
+        public SysTypes? Type() => 
             As.Expression(() => Database.View<SysTypes>().SingleOrDefaultEx(a => a.system_type_id == this.system_type_id));
     }
 
diff --git a/Signum.Engine/Exceptions.cs b/Signum.Engine/Exceptions.cs
index 8b760437d9..7d36b13834 100644
--- a/Signum.Engine/Exceptions.cs
+++ b/Signum.Engine/Exceptions.cs
@@ -150,7 +150,7 @@ public ForeignKeyException(Exception inner) : base(null, inner)
                                     .Select(p => p.Key)
                                     .SingleOrDefaultEx();
 
-                    ReferedTableType = EnumEntity.Extract(ReferedTableType) ?? ReferedTableType;
+                    ReferedTableType = ReferedTableType == null ? null : EnumEntity.Extract(ReferedTableType) ?? ReferedTableType;
                 }
             }
         }
diff --git a/Signum.Entities/DynamicQuery/ResultTable.cs b/Signum.Entities/DynamicQuery/ResultTable.cs
index 8341d198d2..e9fd0c858b 100644
--- a/Signum.Entities/DynamicQuery/ResultTable.cs
+++ b/Signum.Entities/DynamicQuery/ResultTable.cs
@@ -218,7 +218,7 @@ static object DeserializeLite(string str, Type defaultEntityType)
     [Serializable]
     public class ResultTable
     {
-        internal ResultColumn entityColumn;
+        internal ResultColumn? entityColumn;
         public ColumnDescription? EntityColumn
         {
             get { return entityColumn == null ? null : ((ColumnToken)entityColumn.Column.Token).Column; }
@@ -435,7 +435,7 @@ internal ResultRow(int index, ResultTable table)
 
         public Lite<Entity> Entity
         {
-            get { return (Lite<Entity>)Table.entityColumn.Values[Index]; }
+            get { return (Lite<Entity>)Table.entityColumn!.Values[Index]; }
         }
 
         public Lite<Entity>? TryEntity
diff --git a/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs b/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
index 2945690771..7339731681 100644
--- a/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
+++ b/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
@@ -52,7 +52,7 @@ public virtual bool IsGroupable
                                 var pp = Validator.TryGetPropertyValidator(route);
                                 if (pp != null)
                                 {
-                                    DateTimePrecisionValidatorAttribute datetimePrecision = pp.Validators.OfType<DateTimePrecisionValidatorAttribute>().SingleOrDefaultEx();
+                                    DateTimePrecisionValidatorAttribute? datetimePrecision = pp.Validators.OfType<DateTimePrecisionValidatorAttribute>().SingleOrDefaultEx();
 
                                     if (datetimePrecision != null && datetimePrecision.Precision == DateTimePrecision.Days)
                                         return true;
diff --git a/Signum.Entities/Reflection/Reflector.cs b/Signum.Entities/Reflection/Reflector.cs
index 44dfe6c331..c659cb56b6 100644
--- a/Signum.Entities/Reflection/Reflector.cs
+++ b/Signum.Entities/Reflection/Reflector.cs
@@ -408,19 +408,19 @@ public static bool QueryableProperty(Type type, PropertyInfo pi)
             var pp = Validator.TryGetPropertyValidator(simpleRoute);
             if (pp != null)
             {
-                DateTimePrecisionValidatorAttribute datetimePrecision = pp.Validators.OfType<DateTimePrecisionValidatorAttribute>().SingleOrDefaultEx();
+                DateTimePrecisionValidatorAttribute? datetimePrecision = pp.Validators.OfType<DateTimePrecisionValidatorAttribute>().SingleOrDefaultEx();
                 if (datetimePrecision != null)
                     return datetimePrecision.FormatString;
 
-                TimeSpanPrecisionValidatorAttribute timeSpanPrecision = pp.Validators.OfType<TimeSpanPrecisionValidatorAttribute>().SingleOrDefaultEx();
+                TimeSpanPrecisionValidatorAttribute? timeSpanPrecision = pp.Validators.OfType<TimeSpanPrecisionValidatorAttribute>().SingleOrDefaultEx();
                 if (timeSpanPrecision != null)
                     return timeSpanPrecision.FormatString;
 
-                DecimalsValidatorAttribute decimals = pp.Validators.OfType<DecimalsValidatorAttribute>().SingleOrDefaultEx();
+                DecimalsValidatorAttribute? decimals = pp.Validators.OfType<DecimalsValidatorAttribute>().SingleOrDefaultEx();
                 if (decimals != null)
                     return "N" + decimals.DecimalPlaces;
 
-                StringCaseValidatorAttribute stringCase = pp.Validators.OfType<StringCaseValidatorAttribute>().SingleOrDefaultEx();
+                StringCaseValidatorAttribute? stringCase = pp.Validators.OfType<StringCaseValidatorAttribute>().SingleOrDefaultEx();
                 if (stringCase != null)
                     return stringCase.TextCase == StringCase.Lowercase ? "L" : "U";
             }
diff --git a/Signum.Test/LinqProvider/SingleFirstTest.cs b/Signum.Test/LinqProvider/SingleFirstTest.cs
index be7ed09dbd..aba93dd365 100644
--- a/Signum.Test/LinqProvider/SingleFirstTest.cs
+++ b/Signum.Test/LinqProvider/SingleFirstTest.cs
@@ -27,12 +27,12 @@ public void SelectFirstOrDefault()
 
             var bands1 = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.FirstOrDefault().Name }).ToList();
             var bands2 = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.FirstEx().Name }).ToList();
-            var bands3 = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleOrDefaultEx().Name }).ToList();
+            var bands3 = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleOrDefaultEx()!.Name }).ToList();
             var bands4 = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleEx().Name }).ToList();
 
             var bands1b = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.FirstOrDefault(a => a.Sex == Sex.Female).Name }).ToList();
             var bands2b = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.FirstEx(a => a.Sex == Sex.Female).Name }).ToList();
-            var bands3b = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleOrDefaultEx(a => a.Sex == Sex.Female).Name }).ToList();
+            var bands3b = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleOrDefaultEx(a => a.Sex == Sex.Female)!.Name }).ToList();
             var bands4b = Database.Query<BandEntity>().Select(b => new { b.Name, Member = b.Members.SingleEx(a => a.Sex == Sex.Female).Name }).ToList();
         }
 
diff --git a/Signum.Utilities/Extensions/ArgsExtensions.cs b/Signum.Utilities/Extensions/ArgsExtensions.cs
index 135dc7dbf4..9c821f4cd1 100644
--- a/Signum.Utilities/Extensions/ArgsExtensions.cs
+++ b/Signum.Utilities/Extensions/ArgsExtensions.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using Signum.Utilities.Reflection;
 using Signum.Utilities.ExpressionTrees;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Signum.Utilities
 {
@@ -14,10 +15,10 @@ public static T GetArg<T>(this IEnumerable<object>? args)
             return args.SmartConvertTo<T>().SingleEx(() => "{0} in the argument list".FormatWith(typeof(T))); ;
         }
 
+        [return: MaybeNull]
         public static T TryGetArgC<T>(this IEnumerable<object>? args) where T : class
         {
-            return args.SmartConvertTo<T>().SingleOrDefaultEx(
-                () => "There are more than one {0} in the argument list".FormatWith(typeof(T)));
+            return args.SmartConvertTo<T>().SingleOrDefaultEx(() => "There are more than one {0} in the argument list".FormatWith(typeof(T)))!;
         }
 
         public static T? TryGetArgS<T>(this IEnumerable<object>? args) where T : struct
diff --git a/Signum.Utilities/Extensions/EnumExtensions.cs b/Signum.Utilities/Extensions/EnumExtensions.cs
index 68f1403684..8547b55611 100644
--- a/Signum.Utilities/Extensions/EnumExtensions.cs
+++ b/Signum.Utilities/Extensions/EnumExtensions.cs
@@ -108,13 +108,13 @@ public static IEnumerable<Enum> UntypedGetValues(Type type)
         public static T? GetByCode<T>(string code)
             where T: struct, Enum
         {
-            return (T?)(object)EnumFieldCache.Get(typeof(T))
+            return (T?)(object?)EnumFieldCache.Get(typeof(T))
                 .Where(kvp => kvp.Value.GetCustomAttribute<CodeAttribute>().Code == code)
                 .Select(kvp => kvp.Key)
                 .SingleOrDefaultEx();
         }
 
-        public static string GetCode<T>(string key)
+        public static string? GetCode<T>(string key)
         {
             return (EnumFieldCache.Get(typeof(T))
                 .Where(kvp => kvp.Key.NiceToString() == key)
diff --git a/Signum.Utilities/Extensions/EnumerableExtensions.cs b/Signum.Utilities/Extensions/EnumerableExtensions.cs
index 38f82ddc60..78efddc1de 100644
--- a/Signum.Utilities/Extensions/EnumerableExtensions.cs
+++ b/Signum.Utilities/Extensions/EnumerableExtensions.cs
@@ -158,6 +158,7 @@ static Exception NewException(bool forEndUser, string message)
         }
 
         [MethodExpander(typeof(UniqueExExpander))]
+        [return: MaybeNull]
         public static T SingleOrDefaultEx<T>(this IEnumerable<T> collection, Func<T, bool> predicate)
         {
             if (collection == null)
@@ -184,11 +185,13 @@ public static T SingleOrDefaultEx<T>(this IEnumerable<T> collection, Func<T, boo
         }
 
         [MethodExpander(typeof(UniqueExExpander))]
+        [return: MaybeNull]
         public static T SingleOrDefaultEx<T>(this IQueryable<T> query, Expression<Func<T, bool>> predicate)
         {
             return query.Where(predicate).SingleOrDefaultEx();
         }
 
+        [return: MaybeNull]
         public static T SingleOrDefaultEx<T>(this IEnumerable<T> collection)
         {
             if (collection == null)
@@ -208,6 +211,7 @@ public static T SingleOrDefaultEx<T>(this IEnumerable<T> collection)
             throw new InvalidOperationException("Sequence contains more than one {0}".FormatWith(typeof(T).TypeName()));
         }
 
+        [return: MaybeNull]
         public static T SingleOrDefaultEx<T>(this IEnumerable<T> collection, Func<string> errorMoreThanOne, bool forEndUser = false)
         {
             if (collection == null)
@@ -280,17 +284,20 @@ public static T FirstEx<T>(this IEnumerable<T> collection, Func<string> errorZer
         }
 
         [MethodExpander(typeof(UniqueExExpander))]
+        [return: MaybeNull]
         public static T SingleOrManyEx<T>(this IEnumerable<T> collection, Func<T, bool> predicate)
         {
             return collection.Where(predicate).FirstEx();
         }
 
         [MethodExpander(typeof(UniqueExExpander))]
+        [return: MaybeNull]
         public static T SingleOrManyEx<T>(this IQueryable<T> query, Expression<Func<T, bool>> predicate)
         {
             return query.Where(predicate).FirstEx();
         }
 
+        [return: MaybeNull]
         public static T SingleOrManyEx<T>(this IEnumerable<T> collection)
         {
             if (collection == null)
@@ -310,6 +317,7 @@ public static T SingleOrManyEx<T>(this IEnumerable<T> collection)
             }
         }
 
+        [return: MaybeNull]
         public static T SingleOrManyEx<T>(this IEnumerable<T> collection, Func<string> errorZero, bool forEndUser = false)
         {
             if (collection == null)
@@ -330,6 +338,7 @@ public static T SingleOrManyEx<T>(this IEnumerable<T> collection, Func<string> e
         }
 
         //Throws exception if 0, returns if one, returns default if many
+        [return: MaybeNull]
         public static T SingleOrMany<T>(this IEnumerable<T> collection)
         {
             if (collection == null)

From ba7541386fb917f290d9065f05e7b985a25d1c1b Mon Sep 17 00:00:00 2001
From: Thomas Muenzer <thomas.muenzer@bechtle.com>
Date: Wed, 18 Sep 2019 16:41:13 +0200
Subject: [PATCH 42/46] Allow collections in CSV

---
 Signum.Utilities/Csv.cs | 128 +++++++++++++++++++++++++++++-----------
 1 file changed, 95 insertions(+), 33 deletions(-)

diff --git a/Signum.Utilities/Csv.cs b/Signum.Utilities/Csv.cs
index dc38f7023f..90a5a1182e 100644
--- a/Signum.Utilities/Csv.cs
+++ b/Signum.Utilities/Csv.cs
@@ -10,6 +10,7 @@
 using System.Reflection;
 using System.Collections.Concurrent;
 using System.Collections;
+using Signum.Utilities.ExpressionTrees;
 
 namespace Signum.Utilities
 {
@@ -21,7 +22,7 @@ public static class Csv
         public static CultureInfo? DefaultCulture = null;
 
         public static string ToCsvFile<T>(this IEnumerable<T> collection, string fileName, Encoding? encoding = null, CultureInfo? culture = null, bool writeHeaders = true, bool autoFlush = false, bool append = false,
-            Func<CsvColumnInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
+            Func<CsvMemberInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
         {
             using (FileStream fs = append ? new FileStream(fileName, FileMode.Append, FileAccess.Write) : File.Create(fileName))
                 ToCsv<T>(collection, fs, encoding, culture, writeHeaders, autoFlush, toStringFactory);
@@ -30,7 +31,7 @@ public static string ToCsvFile<T>(this IEnumerable<T> collection, string fileNam
         }
 
         public static byte[] ToCsvBytes<T>(this IEnumerable<T> collection, Encoding? encoding = null, CultureInfo? culture = null, bool writeHeaders = true, bool autoFlush = false,
-            Func<CsvColumnInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
+            Func<CsvMemberInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
         {
             using (MemoryStream ms = new MemoryStream())
             {
@@ -40,7 +41,7 @@ public static byte[] ToCsvBytes<T>(this IEnumerable<T> collection, Encoding? enc
         }
 
         public static void ToCsv<T>(this IEnumerable<T> collection, Stream stream, Encoding? encoding = null, CultureInfo? culture = null, bool writeHeaders = true, bool autoFlush = false,
-            Func<CsvColumnInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
+            Func<CsvMemberInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory = null)
         {
             var defEncoding = encoding ?? DefaultEncoding;
             var defCulture = culture ?? DefaultCulture ?? CultureInfo.CurrentCulture;
@@ -71,29 +72,48 @@ public static void ToCsv<T>(this IEnumerable<T> collection, Stream stream, Encod
             }
             else
             {
-                var columns = ColumnInfoCache<T>.Columns;
-                var members = columns.Select(c => c.MemberEntry).ToList();
-                var toString = columns.Select(c => GetToString(defCulture, c, toStringFactory)).ToList();
+                var members = CsvMemberCache<T>.Members;
+                var toString = members.Select(c => GetToString(defCulture, c, toStringFactory)).ToList();
 
                 using (StreamWriter sw = new StreamWriter(stream, encoding) { AutoFlush = autoFlush })
                 {
                     if (writeHeaders)
-                        sw.WriteLine(members.ToString(m => HandleSpaces(m.Name), separator));
+                        sw.WriteLine(members.ToString(m => HandleSpaces(m.MemberInfo.Name), separator));
 
                     foreach (var item in collection)
                     {
                         for (int i = 0; i < members.Count; i++)
                         {
-                            var obj = members[i].Getter!(item);
+                            var member = members[i];
+                            var toStr = toString[i];
+                            if (!member.IsCollection)
+                            {
+                                if (i != 0)
+                                    sw.Write(separator);
 
-                            var str = EncodeCsv(toString[i](obj), defCulture);
+                                var obj = member.MemberEntry.Getter!(item);
 
-                            sw.Write(str);
-                            if (i < members.Count - 1)
-                                sw.Write(separator);
+                                var str = EncodeCsv(toStr(obj), defCulture);
+
+                                sw.Write(str);
+                            }
                             else
-                                sw.WriteLine();
+                            {
+                                var list = (IList?)member.MemberEntry.Getter!(item);
+
+                                for (int j = 0; j < list!.Count; j++)
+                                {
+                                    if (!(i == 0 && j == 0))
+                                        sw.Write(separator);
+
+                                    var str = EncodeCsv(toStr(list[j]), defCulture);
+
+                                    sw.Write(str);
+                                }
+                            }
                         }
+
+                        sw.WriteLine();
                     }
                 }
             }
@@ -114,7 +134,7 @@ public static void ToCsv<T>(this IEnumerable<T> collection, Stream stream, Encod
             return p;
         }
 
-        private static Func<object?, string?> GetToString<T>(CultureInfo culture, CsvColumnInfo<T> column, Func<CsvColumnInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory)
+        private static Func<object?, string?> GetToString<T>(CultureInfo culture, CsvMemberInfo<T> column, Func<CsvMemberInfo<T>, CultureInfo, Func<object?, string?>>? toStringFactory)
         {
             if (toStringFactory != null)
             {
@@ -164,9 +184,8 @@ static string HandleSpaces(string p)
             var defCulture = culture ?? DefaultCulture ?? CultureInfo.CurrentCulture;
             var defOptions = options ?? new CsvReadOptions<T>();
 
-            var columns = ColumnInfoCache<T>.Columns;
-            var members = columns.Select(c => c.MemberEntry).ToList();
-            var parsers = columns.Select(c => GetParser(defCulture, c, defOptions.ParserFactory)).ToList();
+            var members = CsvMemberCache<T>.Members;
+            var parsers = members.Select(m => GetParser(defCulture, m, defOptions.ParserFactory)).ToList();
 
             Regex regex = GetRegex(defCulture, defOptions.RegexTimeout);
 
@@ -256,14 +275,14 @@ public static T ReadLine<T>(string csvLine, CultureInfo? culture = null, CsvRead
 
             Match m = regex.Match(csvLine);
 
-            var columns = ColumnInfoCache<T>.Columns;
+            var members = CsvMemberCache<T>.Members;
 
             return ReadObject<T>(m,
-                columns.Select(c => c.MemberEntry).ToList(),
-                columns.Select(c => GetParser(defCulture, c, defOptions.ParserFactory)).ToList());
+                members,
+                members.Select(c => GetParser(defCulture, c, defOptions.ParserFactory)).ToList());
         }
 
-        private static Func<string, object?> GetParser<T>(CultureInfo culture, CsvColumnInfo<T> column, Func<CsvColumnInfo<T>, CultureInfo, Func<string, object?>>? parserFactory)
+        private static Func<string, object?> GetParser<T>(CultureInfo culture, CsvMemberInfo<T> column, Func<CsvMemberInfo<T>, CultureInfo, Func<string, object?>?>? parserFactory)
         {
             if (parserFactory != null)
             {
@@ -273,10 +292,12 @@ public static T ReadLine<T>(string csvLine, CultureInfo? culture = null, CsvRead
                     return result;
             }
 
-            return str => ConvertTo(str, column.MemberInfo.ReturningType(), culture, column.Format);
+            var type = column.IsCollection ? column.MemberInfo.ReturningType().ElementType()! : column.MemberInfo.ReturningType();
+
+            return str => ConvertTo(str, type, culture, column.Format);
         }
 
-        static T ReadObject<T>(Match m, List<MemberEntry<T>> members, List<Func<string, object?>> parsers) where T : new()
+        static T ReadObject<T>(Match m, List<CsvMemberInfo<T>> members, List<Func<string, object?>> parsers) where T : new()
         {
             var vals = m.Groups["val"].Captures;
 
@@ -284,16 +305,37 @@ public static T ReadLine<T>(string csvLine, CultureInfo? culture = null, CsvRead
                 throw new FormatException("Only {0} columns found (instead of {1}) in line: {2}".FormatWith(vals.Count, members.Count, m.Value));
 
             T t = new T();
+
             for (int i = 0; i < members.Count; i++)
             {
-                string? str = null; 
+                var member = members[i];
+                var parser = parsers[i];
+                string? str = null;
                 try
                 {
-                    str = DecodeCsv(vals[i].Value);
+                    if (!member.IsCollection)
+                    {
+                        str = DecodeCsv(vals[i].Value);
 
-                    object? val = parsers[i](str);
+                        object? val = parser(str);
 
-                    members[i].Setter!(t, val);
+                        member.MemberEntry.Setter!(t, val);
+                    }
+                    else
+                    {
+                        var list = (IList)Activator.CreateInstance(member.MemberInfo.ReturningType());
+
+                        for (int j = i; j < vals.Count; j++)
+                        {
+                            str = DecodeCsv(vals[j].Value);
+
+                            object? val = parser(str);
+
+                            list.Add(val);
+                        }
+
+                        member.MemberEntry.Setter!(t, list);
+                    }
                 }
                 catch (Exception e)
                 {
@@ -317,10 +359,28 @@ static Regex GetRegex(CultureInfo culture, TimeSpan timeout)
                 new Regex(BaseRegex.Replace('\'', '"').Replace(';', s), RegexOptions.Multiline | RegexOptions.ExplicitCapture, timeout));
         }
 
-        static class ColumnInfoCache<T>
+        static class CsvMemberCache<T>
         {
-            public static List<CsvColumnInfo<T>> Columns = MemberEntryFactory.GenerateList<T>(MemberOptions.Fields | MemberOptions.Properties | MemberOptions.Typed | MemberOptions.Setters | MemberOptions.Getter)
-                .Select((me, i) => new CsvColumnInfo<T>(i, me, me.MemberInfo.GetCustomAttribute<FormatAttribute>()?.Format)).ToList();
+            static CsvMemberCache()
+            {
+                var memberEntries = MemberEntryFactory.GenerateList<T>(MemberOptions.Fields | MemberOptions.Properties | MemberOptions.Typed | MemberOptions.Setters | MemberOptions.Getter);
+                Members = memberEntries.Select((me, i) =>
+                {
+                    var type = me.MemberInfo.ReturningType();
+                    var isCollection = typeof(IList).IsAssignableFrom(type);
+                    if (isCollection)
+                    {
+                        if (type.IsArray)
+                            throw new InvalidOperationException($"{me.MemberInfo.Name} is an array, use a List<T> instead");
+
+                        if (i != memberEntries.Count - 1)
+                            throw new InvalidOperationException($"{me.MemberInfo.Name} is of {type} but is not the last member");
+                    }
+                    return new CsvMemberInfo<T>(i, me, me.MemberInfo.GetCustomAttribute<FormatAttribute>()?.Format, isCollection);
+                }).ToList();
+            }
+
+            public static List<CsvMemberInfo<T>> Members;
         }
 
         static string DecodeCsv(string s)
@@ -361,29 +421,31 @@ static string DecodeCsv(string s)
 
     public class CsvReadOptions<T> where T: class
     {
-        public Func<CsvColumnInfo<T>, CultureInfo, Func<string, object>>? ParserFactory;
+        public Func<CsvMemberInfo<T>, CultureInfo, Func<string, object?>?>? ParserFactory;
         public bool AsumeSingleLine = false;
         public Func<Exception, Match?, bool>? SkipError;
         public TimeSpan RegexTimeout = Regex.InfiniteMatchTimeout;
     }
 
 
-    public class CsvColumnInfo<T>
+    public class CsvMemberInfo<T>
     {
         public readonly int Index;
         public readonly MemberEntry<T> MemberEntry;
         public readonly string? Format;
+        public readonly bool IsCollection;
 
         public MemberInfo MemberInfo
         {
             get { return this.MemberEntry.MemberInfo; }
         }
 
-        internal CsvColumnInfo(int index, MemberEntry<T> memberEntry, string? format)
+        internal CsvMemberInfo(int index, MemberEntry<T> memberEntry, string? format, bool isCollection)
         {
             this.Index = index;
             this.MemberEntry = memberEntry;
             this.Format = format;
+            this.IsCollection = isCollection;
         }
     }
 

From fdc161a5a9d2338d719da8f17af354f7c58a2e33 Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Thu, 19 Sep 2019 09:49:04 +0200
Subject: [PATCH 43/46] update MSBuildTask

---
 Signum.Engine/Signum.Engine.csproj     | 2 +-
 Signum.Entities/Signum.Entities.csproj | 2 +-
 Signum.Test/Signum.Test.csproj         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Signum.Engine/Signum.Engine.csproj b/Signum.Engine/Signum.Engine.csproj
index f7328a63bd..e5bdf2c13c 100644
--- a/Signum.Engine/Signum.Engine.csproj
+++ b/Signum.Engine/Signum.Engine.csproj
@@ -12,7 +12,7 @@
 
   <ItemGroup>
     <PackageReference Include="Signum.Analyzer" Version="2.4.5" />
-    <PackageReference Include="Signum.MSBuildTask" Version="1.0.6" />
+    <PackageReference Include="Signum.MSBuildTask" Version="1.0.7" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Signum.Entities/Signum.Entities.csproj b/Signum.Entities/Signum.Entities.csproj
index 51556cfbc7..1225b1164f 100644
--- a/Signum.Entities/Signum.Entities.csproj
+++ b/Signum.Entities/Signum.Entities.csproj
@@ -12,7 +12,7 @@
 
   <ItemGroup>
     <PackageReference Include="Signum.Analyzer" Version="2.4.5" />
-    <PackageReference Include="Signum.MSBuildTask" Version="1.0.6" />
+    <PackageReference Include="Signum.MSBuildTask" Version="1.0.7" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Signum.Test/Signum.Test.csproj b/Signum.Test/Signum.Test.csproj
index 0336712b3c..39cd5d6fec 100644
--- a/Signum.Test/Signum.Test.csproj
+++ b/Signum.Test/Signum.Test.csproj
@@ -35,7 +35,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Signum.MSBuildTask" Version="1.0.6" />
+    <PackageReference Include="Signum.MSBuildTask" Version="1.0.7" />
 
   </ItemGroup>
 

From 9595f9571a34c8a76d54a227fbaf1504708dec09 Mon Sep 17 00:00:00 2001
From: Frank Nussbaum <frank.nussbaum@bechtle.com>
Date: Thu, 19 Sep 2019 15:11:51 +0200
Subject: [PATCH 44/46] German grammar correction

---
 Signum.Entities/Translations/Signum.Entities.de.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Signum.Entities/Translations/Signum.Entities.de.xml b/Signum.Entities/Translations/Signum.Entities.de.xml
index 3b5dc6d58b..ab65caa625 100644
--- a/Signum.Entities/Translations/Signum.Entities.de.xml
+++ b/Signum.Entities/Translations/Signum.Entities.de.xml
@@ -507,7 +507,7 @@
     <Member Name="TheLenghtOf0HasToBeEqualTo1" Description="Die Länge von {0} muss gleich {1} sein" />
     <Member Name="TheLengthOf0HasToBeGreaterOrEqualTo1" Description="Die Länge von {0} muss größer als oder gleich {1} sein" />
     <Member Name="TheLengthOf0HasToBeLesserOrEqualTo1" Description="Die Länge von {0} muss kleiner als oder gleich {1} sein" />
-    <Member Name="TheNumberOf0IsBeingMultipliedBy1" Description="Die Anzahl von {0} wird mit {1} multipliziert" />
+    <Member Name="TheNumberOf0IsBeingMultipliedBy1" Description="Die Anzahl der {0} wird mit {1} multipliziert" />
     <Member Name="TheNumberOfElementsOf0HasToBe12" Description="Die Anzahl der Elemente von {0} muss {1} {2} sein" />
     <Member Name="TheRowsAreBeingGroupedBy0" Description="Die Zeilen werden nach {0} gruppiert" />
     <Member Name="Type0NotAllowed" Description="Der Typ {0} ist nicht zulässig" />

From 9d50e3b29edff0be668cb82e7c541f0b98ee4ff2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=BCnzer?= <thomas.muenzer@bechtle.com>
Date: Fri, 20 Sep 2019 16:45:38 +0200
Subject: [PATCH 45/46] Collapsing equal cells.

---
 .../Scripts/Lines/DynamicComponent.tsx        |  63 ++++++-----
 Signum.React/Scripts/Lines/EntityTable.tsx    | 102 +++++++++++++-----
 Signum.React/Scripts/Lines/MultiValueLine.tsx |   4 +-
 Signum.React/Scripts/Signum.Entities.t4s      |  10 +-
 Signum.React/Scripts/Signum.Entities.ts       |  10 +-
 5 files changed, 131 insertions(+), 58 deletions(-)

diff --git a/Signum.React/Scripts/Lines/DynamicComponent.tsx b/Signum.React/Scripts/Lines/DynamicComponent.tsx
index 17262399b7..46142eb004 100644
--- a/Signum.React/Scripts/Lines/DynamicComponent.tsx
+++ b/Signum.React/Scripts/Lines/DynamicComponent.tsx
@@ -1,13 +1,14 @@
 import * as React from 'react'
 import { Dic } from '../Globals'
-import { getTypeInfos } from '../Reflection'
+import { getTypeInfos, TypeReference } from '../Reflection'
 import { ModifiableEntity } from '../Signum.Entities'
 import * as Navigator from '../Navigator'
 import { ViewReplacer } from '../Frames/ReactVisitor'
-import { ValueLine, EntityLine, EntityCombo, EntityDetail, EntityStrip, TypeContext, EntityCheckboxList, EnumCheckboxList, EntityTable } from '../Lines'
+import { ValueLine, EntityLine, EntityCombo, EntityDetail, EntityStrip, TypeContext, EntityCheckboxList, EnumCheckboxList, EntityTable, PropertyRoute } from '../Lines'
 import { Type } from '../Reflection';
 import { EntityRepeater } from './EntityRepeater';
 import { MultiValueLine } from './MultiValueLine';
+import { faUnderline } from '@fortawesome/free-solid-svg-icons';
 
 export default class DynamicComponent extends React.Component<{ ctx: TypeContext<ModifiableEntity>, viewName?: string }> {
   render() {
@@ -47,78 +48,88 @@ export default class DynamicComponent extends React.Component<{ ctx: TypeContext
   }
 
   static getAppropiateComponent(ctx: TypeContext<any>): React.ReactElement<any> | undefined {
-    const mi = ctx.propertyRoute.member;
+    return DynamicComponent.getAppropiateComponentFactory(ctx.propertyRoute)(ctx);
+  }
 
+  static getAppropiateComponentFactory(pr: PropertyRoute): (ctx: TypeContext<any>) => React.ReactElement<any> | undefined {
+    const mi = pr.member;
     if (mi && (mi.name == "Id" || mi.notVisible == true))
-      return undefined;
+      return ctx => undefined;
 
-    const ccProp = DynamicComponent.customPropertyComponent[ctx.propertyRoute.toString()];
+    const ccProp = DynamicComponent.customPropertyComponent[pr.toString()];
     if (ccProp) {
-      return ccProp(ctx) || undefined;
+      return ctx => ccProp(ctx) || undefined;
     }
 
-    const tr = ctx.propertyRoute.typeReference();
+    const tr = pr.typeReference();
     const ccType = DynamicComponent.customTypeComponent[tr.name];
     if (ccType) {
-      var result = ccType(ctx);
-      if (result != "continue")
-        return result || undefined;
+      var basic = DynamicComponent.getAppropiateComponentFactoryBasic(tr);
+
+      return ctx => {
+        var result = ccType(ctx);
+        return result == "continue" ? basic(ctx) : result || undefined;
+      };
     }
 
+    return DynamicComponent.getAppropiateComponentFactoryBasic(tr);
+  }
+
+  static getAppropiateComponentFactoryBasic(tr: TypeReference): (ctx: TypeContext<any>) => React.ReactElement<any> | undefined {
     let tis = getTypeInfos(tr);
     if (tis.length == 1 && tis[0] == undefined)
       tis = [];
 
     if (tr.isCollection) {
       if (tr.name == "[ALL]")
-        return <EntityStrip ctx={ctx} />;
+        return ctx => <EntityStrip ctx={ctx} />;
 
       if (tis.length) {
         if (tis.length == 1 && tis.first().kind == "Enum")
-          return <EnumCheckboxList ctx={ctx} />;
+          return ctx => <EnumCheckboxList ctx={ctx} />;
 
         if (tis.length == 1 && (tis.first().entityKind == "Part" || tis.first().entityKind == "SharedPart"))
-          return <EntityTable ctx={ctx} />;
+          return ctx => <EntityTable ctx={ctx} />;
 
         if (tis.every(t => t.entityKind == "Part" || t.entityKind == "SharedPart"))
-          return <EntityRepeater ctx={ctx} />;
+          return ctx => <EntityRepeater ctx={ctx} />;
 
         if (tis.every(t => t.isLowPopulation == true))
-          return <EntityCheckboxList ctx={ctx} />;
+          return ctx => <EntityCheckboxList ctx={ctx} />;
 
-        return <EntityStrip ctx={ctx} />;
+        return ctx => <EntityStrip ctx={ctx} />;
       }
 
       if (tr.isEmbedded)
-        return <EntityTable ctx={ctx} />;
+        return ctx => <EntityTable ctx={ctx} />;
 
-      return <MultiValueLine ctx={ctx} />;
+      return ctx => <MultiValueLine ctx={ctx} />;
 
     } else {
 
       if (tr.name == "[ALL]")
-        return <EntityLine ctx={ctx} />;
+        return ctx => <EntityLine ctx={ctx} />;
 
       if (tis.length) {
         if (tis.length == 1 && tis.first().kind == "Enum")
-          return <ValueLine ctx={ctx} />;
+          return ctx => <ValueLine ctx={ctx} />;
 
         if (tis.every(t => t.entityKind == "Part" || t.entityKind == "SharedPart"))
-          return <EntityDetail ctx={ctx} />;
+          return ctx => <EntityDetail ctx={ctx} />;
 
         if (tis.every(t => t.isLowPopulation == true))
-          return <EntityCombo ctx={ctx} />;
+          return ctx => <EntityCombo ctx={ctx} />;
 
-        return <EntityLine ctx={ctx} />;
+        return ctx => <EntityLine ctx={ctx} />;
       }
 
       if (tr.isEmbedded)
-        return <EntityDetail ctx={ctx} />;
+        return ctx =><EntityDetail ctx={ctx} />;
 
       if (ValueLine.getValueLineType(tr) != undefined)
-        return <ValueLine ctx={ctx} />;
+        return ctx =><ValueLine ctx={ctx} />;
 
-      return undefined;
+      return ctx => undefined;
     }
   }
 }
diff --git a/Signum.React/Scripts/Lines/EntityTable.tsx b/Signum.React/Scripts/Lines/EntityTable.tsx
index 281ef364ce..b45abde93d 100644
--- a/Signum.React/Scripts/Lines/EntityTable.tsx
+++ b/Signum.React/Scripts/Lines/EntityTable.tsx
@@ -2,13 +2,14 @@ import * as React from 'react'
 import { classes, Dic, DomUtils } from '../Globals'
 import { TypeContext } from '../TypeContext'
 import * as Navigator from '../Navigator'
-import { ModifiableEntity, MList, EntityControlMessage, newMListElement, Entity, Lite, is } from '../Signum.Entities'
+import { ModifiableEntity, MList, EntityControlMessage, newMListElement, Entity, Lite, is, isEntity } from '../Signum.Entities'
 import { EntityBase, TitleManager } from './EntityBase'
 import { EntityListBase, EntityListBaseProps, DragConfig } from './EntityListBase'
 import DynamicComponent from './DynamicComponent'
 import { MaxHeightProperty } from 'csstype';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 
+
 export interface EntityTableProps extends EntityListBaseProps {
   createAsLink?: boolean | ((er: EntityTable) => React.ReactElement<any>);
   /**Consider using EntityTable.typedColumns to get Autocompletion**/
@@ -26,12 +27,13 @@ export interface EntityTableProps extends EntityListBaseProps {
   createOnBlurLastRow?: boolean;
 }
 
-export interface EntityTableColumn<T, RS> {
+export interface EntityTableColumn<T, RS = undefined> {
   property?: ((a: T) => any) | string;
   header?: React.ReactNode | null;
   headerHtmlAttributes?: React.ThHTMLAttributes<any>;
   cellHtmlAttributes?: (ctx: TypeContext<T>, row: EntityTableRow, rowState: RS) => React.TdHTMLAttributes<any> | null | undefined;
   template?: (ctx: TypeContext<T>, row: EntityTableRow, rowState: RS) => React.ReactChild | null | undefined | false;
+  mergeCells?: (boolean | ((a: T) => any) | string)
 }
 
 export class EntityTable extends EntityListBase<EntityTableProps, EntityTableProps> {
@@ -41,11 +43,7 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
     scrollable: false
   };
 
-  static typedColumns<T extends ModifiableEntity>(columns: (EntityTableColumn<T, any> | false | null | undefined)[]): EntityTableColumn<ModifiableEntity, any>[] {
-    return columns.filter(a => a != null && a != false) as EntityTableColumn<ModifiableEntity, any>[];
-  }
-
-  static typedColumnsWithRowState<T extends ModifiableEntity, RS>(columns: (EntityTableColumn<T, RS> | false | null | undefined)[]): EntityTableColumn<ModifiableEntity, RS>[] {
+  static typedColumns<T extends ModifiableEntity, RS = undefined>(columns: (EntityTableColumn<T, any> | false | null | undefined)[]): EntityTableColumn<ModifiableEntity, RS>[] {
     return columns.filter(a => a != null && a != false) as EntityTableColumn<ModifiableEntity, RS>[];
   }
 
@@ -68,6 +66,33 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
           property: eval("(function(e){ return e." + memberName.firstLower() + "; })")
         }) as EntityTableColumn<ModifiableEntity, any>);
     }
+
+    var pr = state.ctx.propertyRoute.addMember("Indexer", "");
+    state.columns.forEach(c => {
+      if (c.template === undefined) {
+        if (c.property == null)
+          throw new Error("Column has no property and no template");
+
+        var factory = DynamicComponent.getAppropiateComponentFactory(c.property == "string" ? pr.addMember("Member", c.property) : pr.addLambda(c.property!));
+
+        c.template = (ctx, row, state) => {
+          var subCtx = typeof c.property == "string" ? ctx.subCtx(c.property) : ctx.subCtx(c.property!);
+          return factory(subCtx);
+        };
+      }
+
+      if (c.mergeCells == true) {
+        if (c.property == null)
+          throw new Error("Column has no property but mergeCells is true");
+
+        c.mergeCells = c.property;
+      }
+
+      if (typeof c.mergeCells == "string") {
+        const prop = c.mergeCells;
+        c.mergeCells = a => (a as any)[prop];
+      }
+    });
   }
 
 
@@ -175,6 +200,8 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
 
     var isEmpty = this.props.avoidEmptyTable && ctx.value.length == 0;
 
+    const s = this.state;
+    var firstColumnVisible = !(s.readOnly || s.remove == false && s.move == false && s.view == false);
     return (
       <div ref={d => this.containerDiv = d}
         className={this.props.scrollable ? "sf-scroll-table-container table-responsive" : undefined}
@@ -184,7 +211,7 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
             !isEmpty &&
             <thead ref={th => this.thead = th}>
               <tr className={this.props.theadClasses || "bg-light"}>
-                <th></th>
+                {firstColumnVisible && <th></th>}
                 {
                   this.state.columns!.map((c, i) => <th key={i} {...c.headerHtmlAttributes}>
                     {c.header === undefined && c.property ? elementPr.addLambda(c.property).member!.niceName : c.header}
@@ -196,15 +223,17 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
           <tbody>
             {
               this.getMListItemContext(ctx)
-                .map(mlec => <EntityTableRow key={this.keyGenerator.getKey(mlec.value)}
-                  index={mlec.index!}
+                .map((mlec, i, array) => <EntityTableRow key={this.keyGenerator.getKey(mlec.value)}
+                  ctx={this.props.rowSubContext ? this.props.rowSubContext(mlec) : mlec}
+                  array={array}
+                  index={i}
+                  firstColumnVisible={firstColumnVisible}
                   onRowHtmlAttributes={this.props.onRowHtmlAttributes}
                   fetchRowState={this.props.fetchRowState}
                   onRemove={this.canRemove(mlec.value) && !readOnly ? e => this.handleRemoveElementClick(e, mlec.index!) : undefined}
                   onView={this.canView(mlec.value) && !readOnly ? e => this.handleViewElement(e, mlec.index!) : undefined}
                   draggable={this.canMove(mlec.value) && !readOnly ? this.getDragConfig(mlec.index!, "v") : undefined}
                   columns={this.state.columns!}
-                  ctx={this.props.rowSubContext ? this.props.rowSubContext(mlec) : mlec}
                   onBlur={this.props.createOnBlurLastRow && this.state.create && !readOnly? this.handleBlur : undefined}
                 />
                 )
@@ -279,7 +308,9 @@ export class EntityTable extends EntityListBase<EntityTableProps, EntityTablePro
 
 export interface EntityTableRowProps {
   ctx: TypeContext<ModifiableEntity>;
+  array: TypeContext<ModifiableEntity>[];
   index: number;
+  firstColumnVisible: boolean;
   columns: EntityTableColumn<ModifiableEntity, any>[],
   onRemove?: (event: React.MouseEvent<any>) => void;
   onView?: (event: React.MouseEvent<any>) => void;
@@ -313,7 +344,7 @@ export class EntityTableRow extends React.Component<EntityTableRowProps, { rowSt
         onDrop={drag && drag.onDrop}
         className={drag && drag.dropClass}
         onBlur={this.props.onBlur && (e => this.props.onBlur!(this, e))}>
-        <td>
+        {this.props.firstColumnVisible && < td >
           <div className="item-group">
             {this.props.onRemove && <a href="#" className={classes("sf-line-button", "sf-remove")}
               onClick={this.props.onRemove}
@@ -334,8 +365,39 @@ export class EntityTableRow extends React.Component<EntityTableRowProps, { rowSt
               {EntityBase.viewIcon}
             </a>}
           </div>
-        </td>
-        {this.props.columns.map((c, i) => <td key={i} {...c.cellHtmlAttributes && c.cellHtmlAttributes(ctx, this, this.state.rowState)}>{this.getTemplate(c)}</td>)}
+        </td>}
+        {this.props.columns.map((c, i) => {
+
+          var td = <td key={i} {...c.cellHtmlAttributes && c.cellHtmlAttributes(ctx, this, this.state.rowState)}>{this.getTemplate(c)}</td>;
+
+          var mc = c.mergeCells as ((a: any) => any) | undefined
+
+          if (!mc)
+            return td;
+
+          var equals = (a: any, b: any) => {
+            var ka = mc!(a);
+            var kb = mc!(b);
+            return ka == kb || is(ka, kb, false, false);
+          }
+
+          var current = this.props.ctx.value;
+          if (this.props.index > 0 && equals(this.props.array[this.props.index - 1].value, current))
+            return null;
+
+          var rowSpan = 1;
+          for (var i = this.props.index + 1; i < this.props.array.length; i++) {
+            if (equals(this.props.array[i].value, current))
+              rowSpan++;
+            else
+              break;
+          }
+
+          if (rowSpan == 1)
+            return td;
+
+          return React.cloneElement(td, { rowSpan });
+        })}
       </tr>
     );
   }
@@ -346,16 +408,6 @@ export class EntityTableRow extends React.Component<EntityTableRowProps, { rowSt
     if (col.template === null)
       return null;
 
-    if (col.template !== undefined)
-      return col.template(this.props.ctx, this, this.state.rowState);
-
-    if (col.property == null)
-      throw new Error("Column has no property and no template");
-
-    if (typeof col.property == "string")
-      return DynamicComponent.getAppropiateComponent(this.props.ctx.subCtx(col.property)); /*string overload*/
-    else
-      return DynamicComponent.getAppropiateComponent(this.props.ctx.subCtx(col.property)); /*lambda overload*/
-
+    return col.template!(this.props.ctx, this, this.state.rowState);
   }
 }
diff --git a/Signum.React/Scripts/Lines/MultiValueLine.tsx b/Signum.React/Scripts/Lines/MultiValueLine.tsx
index 3a1c6c52f5..9eb99464bb 100644
--- a/Signum.React/Scripts/Lines/MultiValueLine.tsx
+++ b/Signum.React/Scripts/Lines/MultiValueLine.tsx
@@ -100,6 +100,8 @@ export class MultiValueLineElement extends React.Component<MultiValueLineElement
   render() {
     const ctx = this.props.ctx;
 
+    var renderItem = this.props.onRenderItem || DynamicComponent.getAppropiateComponentFactory(ctx.propertyRoute)
+
     return (
       <tr>
         <td>
@@ -111,7 +113,7 @@ export class MultiValueLineElement extends React.Component<MultiValueLineElement
             </a>}
         </td>
         <td>
-          {this.props.onRenderItem ? this.props.onRenderItem(ctx) : DynamicComponent.getAppropiateComponent(ctx)}
+          {renderItem(ctx)}
         </td>
       </tr>
     );
diff --git a/Signum.React/Scripts/Signum.Entities.t4s b/Signum.React/Scripts/Signum.Entities.t4s
index 354eaec83c..7c34782606 100644
--- a/Signum.React/Scripts/Signum.Entities.t4s
+++ b/Signum.React/Scripts/Signum.Entities.t4s
@@ -170,7 +170,7 @@ export function parseLite(lite: string): Lite<Entity> {
   };
 }
 
-export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<T> | T | null | undefined, compareTicks = false) {
+export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<T> | T | null | undefined, compareTicks = false, assertTypesFound = true) {
 
   if (a == undefined && b == undefined)
     return true;
@@ -181,8 +181,12 @@ export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<
   const aType = (a as T).Type || (a as Lite<T>).EntityType;
   const bType = (b as T).Type || (b as Lite<T>).EntityType;
 
-  if (!aType || !bType)
-    throw new Error("No Type found");
+  if (!aType || !bType) {
+    if (assertTypesFound)
+      throw new Error("No Type found");
+    else
+      return false;
+  }
 
   if (aType != bType)
     return false;
diff --git a/Signum.React/Scripts/Signum.Entities.ts b/Signum.React/Scripts/Signum.Entities.ts
index 5687943ff7..7ecf95c66b 100644
--- a/Signum.React/Scripts/Signum.Entities.ts
+++ b/Signum.React/Scripts/Signum.Entities.ts
@@ -177,7 +177,7 @@ export function parseLite(lite: string): Lite<Entity> {
   };
 }
 
-export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<T> | T | null | undefined, compareTicks = false) {
+export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<T> | T | null | undefined, compareTicks = false, assertTypesFound = true) {
 
   if (a == undefined && b == undefined)
     return true;
@@ -188,8 +188,12 @@ export function is<T extends Entity>(a: Lite<T> | T | null | undefined, b: Lite<
   const aType = (a as T).Type || (a as Lite<T>).EntityType;
   const bType = (b as T).Type || (b as Lite<T>).EntityType;
 
-  if (!aType || !bType)
-    throw new Error("No Type found");
+  if (!aType || !bType) {
+    if (assertTypesFound)
+      throw new Error("No Type found");
+    else
+      return false;
+  }
 
   if (aType != bType)
     return false;

From 3c0bf875ae06196e12337319924c52d9a89310cc Mon Sep 17 00:00:00 2001
From: Olmo del Corral Cano <olmo.delcorralcano@bechtle.com>
Date: Wed, 25 Sep 2019 17:29:47 +0200
Subject: [PATCH 46/46] update to VS 16.3

---
 Signum.Engine/Basics/ExceptionLogic.cs        | 14 +++++-----
 Signum.Engine/Basics/PropertyRouteLogic.cs    |  2 +-
 Signum.Engine/Basics/QueryLogic.cs            |  4 +--
 Signum.Engine/Basics/SemiSymbolLogic.cs       |  4 +--
 Signum.Engine/Basics/SymbolLogic.cs           |  6 ++---
 Signum.Engine/Connection/Connector.cs         |  2 +-
 Signum.Engine/Connection/Transaction.cs       | 26 +++++++++----------
 .../DynamicQuery/DynamicQueryContainer.cs     |  4 +--
 Signum.Engine/Engine/SchemaSynchronizer.cs    |  2 +-
 Signum.Engine/Engine/SqlBuilder.cs            |  4 +--
 Signum.Engine/Engine/Synchronizer.cs          |  2 +-
 Signum.Engine/EntityCache.cs                  |  2 +-
 Signum.Engine/Linq/AliasGenerator.cs          |  2 +-
 Signum.Engine/Operations/GraphState.cs        |  8 +++---
 Signum.Engine/Operations/OperationLogic.cs    |  4 +--
 Signum.Engine/Schema/EntityEvents.cs          | 22 ++++++++--------
 Signum.Engine/Schema/ObjectName.cs            |  8 +++---
 Signum.Engine/Schema/Schema.cs                |  4 +--
 Signum.Engine/Schema/UniqueIndex.cs           |  2 +-
 Signum.Entities/Basics/IUserEntity.cs         |  4 +--
 Signum.Entities/DynamicQuery/ResultTable.cs   |  2 +-
 .../DynamicQuery/Tokens/ExtensionToken.cs     |  2 +-
 .../DynamicQuery/Tokens/QueryToken.cs         |  2 +-
 Signum.Entities/EnumEntity.cs                 |  2 +-
 Signum.Entities/ModifiableEntity.cs           |  2 +-
 Signum.Entities/Patterns/CorruptEntity.cs     |  4 +--
 Signum.Entities/PropertyAttributes.cs         |  3 ++-
 Signum.Entities/PropertyRoute.cs              |  4 +--
 Signum.Entities/ValidationAttributes.cs       |  2 +-
 Signum.Entities/Validator.cs                  |  2 +-
 .../ApiControllers/OperationController.cs     |  2 +-
 Signum.React/Facades/ReflectionServer.cs      | 10 +++----
 Signum.React/Facades/SignumServer.cs          | 23 ++++++++--------
 .../Filters/SignumExceptionFilterAttribute.cs |  2 +-
 Signum.React/Filters/SignumFilters.cs         |  2 +-
 .../JsonConverters/EntityJsonConverter.cs     |  4 +--
 .../DataStructures/RecentsDictionary.cs       |  2 +-
 .../ReferenceEqualityComparer.cs              |  4 +--
 Signum.Utilities/DescriptionManager.cs        |  4 +--
 Signum.Utilities/Disposable.cs                |  2 +-
 .../Extensions/StreamExtensions.cs            |  2 +-
 Signum.Utilities/Extensions/TreeHelper.cs     |  4 +--
 Signum.Utilities/MyRandom.cs                  |  4 +--
 Signum.Utilities/ProgressProxy.cs             |  2 +-
 .../Reflection/ReflectionTools.cs             |  2 +-
 Signum.Utilities/StartParameters.cs           |  6 ++---
 Signum.Utilities/Synchronization/ResetLazy.cs |  2 +-
 47 files changed, 114 insertions(+), 114 deletions(-)

diff --git a/Signum.Engine/Basics/ExceptionLogic.cs b/Signum.Engine/Basics/ExceptionLogic.cs
index 76647c935d..21d7f7866b 100644
--- a/Signum.Engine/Basics/ExceptionLogic.cs
+++ b/Signum.Engine/Basics/ExceptionLogic.cs
@@ -14,8 +14,6 @@ namespace Signum.Engine.Basics
 {
 	public static class ExceptionLogic
 	{
-		public static Func<string> GetCurrentVersion;
-
 		public static void Start(SchemaBuilder sb)
 		{
 			if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
@@ -111,21 +109,21 @@ static ExceptionEntity SaveForceNew(this ExceptionEntity entity)
 			}
 		}
 
-		public static string DefaultEnvironment { get; set; }
+		public static string? DefaultEnvironment { get; set; }
 
-		public static string CurrentEnvironment { get { return overridenEnvironment.Value ?? DefaultEnvironment; } }
+		public static string? CurrentEnvironment { get { return overridenEnvironment.Value ?? DefaultEnvironment; } }
 
-		static readonly Variable<string> overridenEnvironment = Statics.ThreadVariable<string>("exceptionEnviroment");
+		static readonly Variable<string?> overridenEnvironment = Statics.ThreadVariable<string?>("exceptionEnviroment");
 
-		public static IDisposable OverrideEnviroment(string newEnviroment)
+		public static IDisposable OverrideEnviroment(string? newEnviroment)
 		{
-			string oldEnviroment = overridenEnvironment.Value;
+			string? oldEnviroment = overridenEnvironment.Value;
 			overridenEnvironment.Value = newEnviroment;
 			return new Disposable(() => overridenEnvironment.Value = oldEnviroment);
 		}
 
 
-		public static event Action<DeleteLogParametersEmbedded, StringBuilder, CancellationToken> DeleteLogs;
+		public static event Action<DeleteLogParametersEmbedded, StringBuilder, CancellationToken>? DeleteLogs;
 
 		public static int DeleteLogsTimeOut = 10 * 60 * 1000;
 
diff --git a/Signum.Engine/Basics/PropertyRouteLogic.cs b/Signum.Engine/Basics/PropertyRouteLogic.cs
index a341055224..27eab8b31a 100644
--- a/Signum.Engine/Basics/PropertyRouteLogic.cs
+++ b/Signum.Engine/Basics/PropertyRouteLogic.cs
@@ -16,7 +16,7 @@ public static class PropertyRouteLogic
         public static bool IsPropertyRoute(this PropertyRouteEntity prdn, PropertyRoute pr) =>
             As.Expression(() => prdn.RootType == pr.RootType.ToTypeEntity() && prdn.Path == pr.PropertyString());
 
-        public static ResetLazy<Dictionary<TypeEntity, Dictionary<string, PropertyRouteEntity>>> Properties;
+        public static ResetLazy<Dictionary<TypeEntity, Dictionary<string, PropertyRouteEntity>>> Properties = null!;
 
         public static void Start(SchemaBuilder sb)
         {
diff --git a/Signum.Engine/Basics/QueryLogic.cs b/Signum.Engine/Basics/QueryLogic.cs
index 4968ad0d97..08eb308830 100644
--- a/Signum.Engine/Basics/QueryLogic.cs
+++ b/Signum.Engine/Basics/QueryLogic.cs
@@ -14,10 +14,10 @@ namespace Signum.Engine.Basics
 {
     public static class QueryLogic
     {
-        static ResetLazy<Dictionary<string, object>> queryNamesLazy;
+        static ResetLazy<Dictionary<string, object>> queryNamesLazy = null!;
         public static Dictionary<string, object> QueryNames => queryNamesLazy.Value;
 
-        static ResetLazy<Dictionary<object, QueryEntity>> queryNameToEntityLazy;
+        static ResetLazy<Dictionary<object, QueryEntity>> queryNameToEntityLazy = null!;
         public static Dictionary<object, QueryEntity> QueryNameToEntity => queryNameToEntityLazy.Value;
 
         public static DynamicQueryContainer Queries { get; } = new DynamicQueryContainer();
diff --git a/Signum.Engine/Basics/SemiSymbolLogic.cs b/Signum.Engine/Basics/SemiSymbolLogic.cs
index 63c5a73c71..c2475322bb 100644
--- a/Signum.Engine/Basics/SemiSymbolLogic.cs
+++ b/Signum.Engine/Basics/SemiSymbolLogic.cs
@@ -11,8 +11,8 @@ namespace Signum.Engine.Extensions.Basics
     public static class SemiSymbolLogic<T>
         where T : SemiSymbol
     {
-        static ResetLazy<Dictionary<string, T>> lazy;
-        static Func<IEnumerable<T>> getSemiSymbols;
+        static ResetLazy<Dictionary<string, T>> lazy = null!;
+        static Func<IEnumerable<T>> getSemiSymbols = null!;
 
         [ThreadStatic]
         static bool avoidCache;
diff --git a/Signum.Engine/Basics/SymbolLogic.cs b/Signum.Engine/Basics/SymbolLogic.cs
index ee27736c57..6367890f04 100644
--- a/Signum.Engine/Basics/SymbolLogic.cs
+++ b/Signum.Engine/Basics/SymbolLogic.cs
@@ -12,7 +12,7 @@ namespace Signum.Engine
 
     public static class SymbolLogic
     {
-        public static event Action OnLoadAll;
+        public static event Action? OnLoadAll;
 
         public static void LoadAll()
         {
@@ -23,8 +23,8 @@ public static void LoadAll()
     public static class SymbolLogic<T>
         where T: Symbol
     {
-        static ResetLazy<Dictionary<string, T>> lazy;
-        static Func<IEnumerable<T>> getSymbols;
+        static ResetLazy<Dictionary<string, T>> lazy = null!;
+        static Func<IEnumerable<T>> getSymbols = null!;
 
         [ThreadStatic]
         static bool avoidCache;
diff --git a/Signum.Engine/Connection/Connector.cs b/Signum.Engine/Connection/Connector.cs
index 80132e02fc..39aaa9b355 100644
--- a/Signum.Engine/Connection/Connector.cs
+++ b/Signum.Engine/Connection/Connector.cs
@@ -33,7 +33,7 @@ public static Connector Current
             get { return currentConnector.Value ?? Default; }
         }
 
-        static Connector @default;
+        static Connector @default = null!;
         public static Connector Default
         {
             get { return @default; }
diff --git a/Signum.Engine/Connection/Transaction.cs b/Signum.Engine/Connection/Transaction.cs
index b1e6debd57..fd7436c2b3 100644
--- a/Signum.Engine/Connection/Transaction.cs
+++ b/Signum.Engine/Connection/Transaction.cs
@@ -24,9 +24,9 @@ public class Transaction : IDisposableException
 
         interface ICoreTransaction
         {
-            event Action<Dictionary<string, object>?> PostRealCommit;
+            event Action<Dictionary<string, object>?>? PostRealCommit;
             void CallPostRealCommit();
-            event Action<Dictionary<string, object>?> PreRealCommit;
+            event Action<Dictionary<string, object>?>? PreRealCommit;
             DbConnection? Connection { get; }
             DbTransaction? Transaction { get; }
 
@@ -60,13 +60,13 @@ public FakedTransaction(ICoreTransaction parent)
                 this.parent = parent;
             }
 
-            public event Action<Dictionary<string, object>?> PostRealCommit
+            public event Action<Dictionary<string, object>?>? PostRealCommit
             {
                 add { parent.PostRealCommit += value; }
                 remove { parent.PostRealCommit -= value; }
             }
 
-            public event Action<Dictionary<string, object>?> PreRealCommit
+            public event Action<Dictionary<string, object>?>? PreRealCommit
             {
                 add { parent.PreRealCommit += value; }
                 remove { parent.PreRealCommit -= value; }
@@ -118,9 +118,9 @@ class RealTransaction : ICoreTransaction
             public DbTransaction? Transaction { get; private set; }
             public Exception? IsRolledback { get; private set; }
             public bool Started { get; private set; }
-            public event Action<Dictionary<string, object>?> PostRealCommit;
-            public event Action<Dictionary<string, object>?> PreRealCommit;
-            public event Action<Dictionary<string, object>?> Rolledback;
+            public event Action<Dictionary<string, object>?>? PostRealCommit;
+            public event Action<Dictionary<string, object>?>? PreRealCommit;
+            public event Action<Dictionary<string, object>?>? Rolledback;
 
             IsolationLevel? IsolationLevel;
 
@@ -219,10 +219,10 @@ class NamedTransaction : ICoreTransaction
             string savePointName;
             public Exception? IsRolledback { get; private set; }
             public bool Started { get; private set; }
-            public event Action<Dictionary<string, object>?> PostRealCommit;
+            public event Action<Dictionary<string, object>?>? PostRealCommit;
 
-            public event Action<Dictionary<string, object>?> PreRealCommit;
-            public event Action<Dictionary<string, object>?> Rolledback;
+            public event Action<Dictionary<string, object>?>? PreRealCommit;
+            public event Action<Dictionary<string, object>?>? Rolledback;
 
             public NamedTransaction(ICoreTransaction parent, string savePointName)
             {
@@ -297,9 +297,9 @@ class NoneTransaction : ICoreTransaction
             public DbTransaction? Transaction { get { return null; } }
             public Exception? IsRolledback { get; private set; }
             public bool Started { get; private set; }
-            public event Action<Dictionary<string, object>?> PostRealCommit;
-            public event Action<Dictionary<string, object>?> PreRealCommit;
-            public event Action<Dictionary<string, object>?> Rolledback;
+            public event Action<Dictionary<string, object>?>? PostRealCommit;
+            public event Action<Dictionary<string, object>?>? PreRealCommit;
+            public event Action<Dictionary<string, object>?>? Rolledback;
 
             public NoneTransaction(ICoreTransaction? parent)
             {
diff --git a/Signum.Engine/DynamicQuery/DynamicQueryContainer.cs b/Signum.Engine/DynamicQuery/DynamicQueryContainer.cs
index cf52f9dd01..6624a023b2 100644
--- a/Signum.Engine/DynamicQuery/DynamicQueryContainer.cs
+++ b/Signum.Engine/DynamicQuery/DynamicQueryContainer.cs
@@ -102,7 +102,7 @@ async Task<T> ExecuteAsync<T>(ExecuteType executeType, object queryName, BaseQue
             }
         }
 
-        public event Func<ExecuteType, object, BaseQueryRequest?, IDisposable?> QueryExecuted;
+        public event Func<ExecuteType, object, BaseQueryRequest?, IDisposable?>? QueryExecuted;
 
         public enum ExecuteType
         {
@@ -166,7 +166,7 @@ public DQueryable<object> GetDQueryable(DQueryableRequest request)
             return Execute(ExecuteType.GetDQueryable, request.QueryName, null, dqb => dqb.Core.Value.GetDQueryable(request));
         }
 
-        public event Func<object, bool, bool> AllowQuery;
+        public event Func<object, bool, bool>? AllowQuery;
 
         public bool QueryAllowed(object queryName, bool fullScreen)
         {
diff --git a/Signum.Engine/Engine/SchemaSynchronizer.cs b/Signum.Engine/Engine/SchemaSynchronizer.cs
index 34454db4b7..c8251cadcf 100644
--- a/Signum.Engine/Engine/SchemaSynchronizer.cs
+++ b/Signum.Engine/Engine/SchemaSynchronizer.cs
@@ -16,7 +16,7 @@ public static class SchemaSynchronizer
     {
         public static Func<SchemaName, bool> DropSchema = s => !s.Name.Contains(@"\");
 
-        public static Action<Dictionary<string, DiffTable>> SimplifyDiffTables;
+        public static Action<Dictionary<string, DiffTable>>? SimplifyDiffTables;
 
         public static SqlPreCommand? SynchronizeTablesScript(Replacements replacements)
         {
diff --git a/Signum.Engine/Engine/SqlBuilder.cs b/Signum.Engine/Engine/SqlBuilder.cs
index 6321ca4f12..c3214a6a2b 100644
--- a/Signum.Engine/Engine/SqlBuilder.cs
+++ b/Signum.Engine/Engine/SqlBuilder.cs
@@ -367,9 +367,9 @@ public static int DuplicateCount(UniqueIndex uniqueIndex, Replacements rep)
 (
     SELECT MIN({oldPrimaryKey})
     FROM {oldTableName}
-    {(string.IsNullOrWhiteSpace(uniqueIndex.Where) ? "" : "WHERE " + uniqueIndex.Where.Replace(columnReplacement))}
+    {(!uniqueIndex.Where.HasText() ? "" : "WHERE " + uniqueIndex.Where.Replace(columnReplacement))}
     GROUP BY {oldColumns}
-){(string.IsNullOrWhiteSpace(uniqueIndex.Where) ? "" : "AND " + uniqueIndex.Where.Replace(columnReplacement))}")!;
+){(!uniqueIndex.Where.HasText() ? "" : "AND " + uniqueIndex.Where.Replace(columnReplacement))}")!;
         }
 
         public static SqlPreCommand? RemoveDuplicatesIfNecessary(UniqueIndex uniqueIndex, Replacements rep)
diff --git a/Signum.Engine/Engine/Synchronizer.cs b/Signum.Engine/Engine/Synchronizer.cs
index f61fbbce68..d8c57341d2 100644
--- a/Signum.Engine/Engine/Synchronizer.cs
+++ b/Signum.Engine/Engine/Synchronizer.cs
@@ -327,7 +327,7 @@ public AutoReplacementContext(string replacementKey, string oldValue, List<strin
             }
         }
 
-        public static Func<AutoReplacementContext, Selection?> AutoReplacement;
+        public static Func<AutoReplacementContext, Selection?>? AutoReplacement;
 
         private static Selection SelectInteractive(string oldValue, List<string> newValues, string replacementsKey, bool interactive)
         {
diff --git a/Signum.Engine/EntityCache.cs b/Signum.Engine/EntityCache.cs
index de11500ce6..aa42a98407 100644
--- a/Signum.Engine/EntityCache.cs
+++ b/Signum.Engine/EntityCache.cs
@@ -195,7 +195,7 @@ public static T Construct<T>(PrimaryKey id) where T : Entity
 
         static class Constructor<T> where T : Entity
         {
-            static Func<T> call;
+            static Func<T>? call;
             public static Func<T> Call
             {
                 get
diff --git a/Signum.Engine/Linq/AliasGenerator.cs b/Signum.Engine/Linq/AliasGenerator.cs
index 3dd9bff0ad..868872bff8 100644
--- a/Signum.Engine/Linq/AliasGenerator.cs
+++ b/Signum.Engine/Linq/AliasGenerator.cs
@@ -46,7 +46,7 @@ public Alias NextTableAlias(string tableName)
             string? abv = tableName.Any(char.IsUpper) ? new string(tableName.Where(c => char.IsUpper(c)).ToArray()) :
                 tableName.Any(a => a == '_') ? new string(tableName.SplitNoEmpty('_' ).Select(s => s[0]).ToArray()) : null;
 
-            if (string.IsNullOrEmpty(abv))
+            if (!abv.HasText())
                 abv = tableName.TryStart(3)!;
             else
                 abv = abv.ToLower();
diff --git a/Signum.Engine/Operations/GraphState.cs b/Signum.Engine/Operations/GraphState.cs
index 677c4a78eb..358982e888 100644
--- a/Signum.Engine/Operations/GraphState.cs
+++ b/Signum.Engine/Operations/GraphState.cs
@@ -281,7 +281,7 @@ protected Graph()
             throw new InvalidOperationException("OperationGraphs should not be instantiated");
         }
 
-        static Expression<Func<T, S>> getState;
+        static Expression<Func<T, S>> getState = null!;
         public static Expression<Func<T, S>> GetState
         {
             get { return getState; }
@@ -292,11 +292,11 @@ public static Expression<Func<T, S>> GetState
             }
         }
 
-        public static Func<T, S> GetStateFunc{get; private set;}
+        public static Func<T, S> GetStateFunc { get; private set; } = null!;
 
 
-        public static Action<T, S> EnterState { get; set; }
-        public static Action<T, S> ExitState { get; set; }
+        public static Action<T, S>? EnterState { get; set; }
+        public static Action<T, S>? ExitState { get; set; }
 
 
 
diff --git a/Signum.Engine/Operations/OperationLogic.cs b/Signum.Engine/Operations/OperationLogic.cs
index 33cfcb88e7..73fb9cb13e 100644
--- a/Signum.Engine/Operations/OperationLogic.cs
+++ b/Signum.Engine/Operations/OperationLogic.cs
@@ -205,8 +205,8 @@ static void EntityEventsGlobal_Saving(Entity ident)
 
         #region Events
 
-        public static event SurroundOperationHandler SurroundOperation;
-        public static event AllowOperationHandler AllowOperation;
+        public static event SurroundOperationHandler? SurroundOperation;
+        public static event AllowOperationHandler? AllowOperation;
 
         internal static IDisposable? OnSuroundOperation(IOperation operation, OperationLogEntity log, IEntity? entity, object[]? args)
         {
diff --git a/Signum.Engine/Schema/EntityEvents.cs b/Signum.Engine/Schema/EntityEvents.cs
index 8eb35b80fd..f992d943fe 100644
--- a/Signum.Engine/Schema/EntityEvents.cs
+++ b/Signum.Engine/Schema/EntityEvents.cs
@@ -12,24 +12,24 @@ namespace Signum.Engine.Maps
     public class EntityEvents<T> : IEntityEvents
             where T : Entity
     {
-        public event PreSavingEventHandler<T> PreSaving;
-        public event SavingEventHandler<T> Saving;
-        public event SavedEventHandler<T> Saved;
+        public event PreSavingEventHandler<T>? PreSaving;
+        public event SavingEventHandler<T>? Saving;
+        public event SavedEventHandler<T>? Saved;
 
-        public event AlternativeRetriveEventHandler<T> AlternativeRetrive;
-        public event RetrievedEventHandler<T> Retrieved;
+        public event AlternativeRetriveEventHandler<T>? AlternativeRetrive;
+        public event RetrievedEventHandler<T>? Retrieved;
 
         public CacheControllerBase<T>? CacheController { get; set; }
 
-        public event FilterQueryEventHandler<T> FilterQuery;
+        public event FilterQueryEventHandler<T>? FilterQuery;
 
-        public event PreUnsafeDeleteHandler<T> PreUnsafeDelete;
-        public event PreUnsafeMListDeleteHandler<T> PreUnsafeMListDelete;
+        public event PreUnsafeDeleteHandler<T>? PreUnsafeDelete;
+        public event PreUnsafeMListDeleteHandler<T>? PreUnsafeMListDelete;
 
-        public event PreUnsafeUpdateHandler<T> PreUnsafeUpdate;
+        public event PreUnsafeUpdateHandler<T>? PreUnsafeUpdate;
 
-        public event PreUnsafeInsertHandler<T> PreUnsafeInsert;
-        public event BulkInsetHandler<T> PreBulkInsert;
+        public event PreUnsafeInsertHandler<T>? PreUnsafeInsert;
+        public event BulkInsetHandler<T>? PreBulkInsert;
 
         public Dictionary<PropertyRoute, IAdditionalBinding>? AdditionalBindings { get; private set; }
 
diff --git a/Signum.Engine/Schema/ObjectName.cs b/Signum.Engine/Schema/ObjectName.cs
index 5ac881516a..2e4746f9a5 100644
--- a/Signum.Engine/Schema/ObjectName.cs
+++ b/Signum.Engine/Schema/ObjectName.cs
@@ -50,7 +50,7 @@ public override int GetHashCode()
 
         public static ServerName? Parse(string? name)
         {
-            if (string.IsNullOrEmpty(name))
+            if (!name.HasText())
                 return null;
 
             return new ServerName(name.UnScapeSql());
@@ -103,7 +103,7 @@ public override int GetHashCode()
 
         public static DatabaseName? Parse(string? name)
         {
-            if (string.IsNullOrEmpty(name))
+            if (!name.HasText())
                 return null;
 
             var tuple = ObjectName.SplitLast(name);
@@ -174,7 +174,7 @@ public override int GetHashCode()
 
         public static SchemaName Parse(string? name)
         {
-            if (string.IsNullOrEmpty(name))
+            if (!name.HasText())
                 return SchemaName.Default;
 
             var tuple = ObjectName.SplitLast(name);
@@ -220,7 +220,7 @@ public override int GetHashCode()
 
         public static ObjectName Parse(string? name)
         {
-            if (string.IsNullOrEmpty(name))
+            if (!name.HasText())
                 throw new ArgumentNullException(nameof(name));
 
             var tuple = SplitLast(name);
diff --git a/Signum.Engine/Schema/Schema.cs b/Signum.Engine/Schema/Schema.cs
index 86ac830e99..5a880534ab 100644
--- a/Signum.Engine/Schema/Schema.cs
+++ b/Signum.Engine/Schema/Schema.cs
@@ -36,7 +36,7 @@ public Version Version
             set { this.version = value; }
         }
 
-        public event Action OnMetadataInvalidated;
+        public event Action? OnMetadataInvalidated;
         public void InvalidateMetadata()
         {
             this.OnMetadataInvalidated?.Invoke();
@@ -66,7 +66,7 @@ public Dictionary<Type, Table> Tables
 
         #region Events
 
-        public event Func<Type, bool, string?> IsAllowedCallback;
+        public event Func<Type, bool, string?>? IsAllowedCallback;
 
         public string? IsAllowed(Type type, bool inUserInterface)
         {
diff --git a/Signum.Engine/Schema/UniqueIndex.cs b/Signum.Engine/Schema/UniqueIndex.cs
index c145105dbe..4dc59b607c 100644
--- a/Signum.Engine/Schema/UniqueIndex.cs
+++ b/Signum.Engine/Schema/UniqueIndex.cs
@@ -99,7 +99,7 @@ public string? ViewName
         {
             get
             {
-                if (string.IsNullOrEmpty(Where))
+                if (!Where.HasText())
                     return null;
 
                 if (Connector.Current.AllowsIndexWithWhere(Where))
diff --git a/Signum.Entities/Basics/IUserEntity.cs b/Signum.Entities/Basics/IUserEntity.cs
index d92ceebc0c..fb25d832e7 100644
--- a/Signum.Entities/Basics/IUserEntity.cs
+++ b/Signum.Entities/Basics/IUserEntity.cs
@@ -1,4 +1,4 @@
-using Signum.Utilities;
+using Signum.Utilities;
 using System;
 
 namespace Signum.Entities.Basics
@@ -10,7 +10,7 @@ public interface IUserEntity : IEntity
     public static class UserHolder
     {
         public static readonly string UserSessionKey = "user";
-        public static event Action CurrentUserChanged;
+        public static event Action? CurrentUserChanged;
 
         public static readonly SessionVariable<IUserEntity> CurrentUserVariable = Statics.SessionVariable<IUserEntity>(UserSessionKey);
         public static IUserEntity Current
diff --git a/Signum.Entities/DynamicQuery/ResultTable.cs b/Signum.Entities/DynamicQuery/ResultTable.cs
index e9fd0c858b..d7be1928fa 100644
--- a/Signum.Entities/DynamicQuery/ResultTable.cs
+++ b/Signum.Entities/DynamicQuery/ResultTable.cs
@@ -468,6 +468,6 @@ public T GetValue<T>(ResultColumn column)
             return result;
         }
 
-        public event PropertyChangedEventHandler PropertyChanged;
+        public event PropertyChangedEventHandler? PropertyChanged;
     }
 }
diff --git a/Signum.Entities/DynamicQuery/Tokens/ExtensionToken.cs b/Signum.Entities/DynamicQuery/Tokens/ExtensionToken.cs
index b5ea070108..c35dc4e2dd 100644
--- a/Signum.Entities/DynamicQuery/Tokens/ExtensionToken.cs
+++ b/Signum.Entities/DynamicQuery/Tokens/ExtensionToken.cs
@@ -70,7 +70,7 @@ protected override List<QueryToken> SubTokensOverride(SubTokensOptions options)
             return base.SubTokensBase(type, options, implementations);
         }
 
-        public static Func<Type, string, Expression, Expression> BuildExtension;
+        public static Func<Type, string, Expression, Expression>? BuildExtension;
 
         protected override Expression BuildExpressionInternal(BuildExpressionContext context)
         {
diff --git a/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs b/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
index 7339731681..0a3d03510e 100644
--- a/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
+++ b/Signum.Entities/DynamicQuery/Tokens/QueryToken.cs
@@ -217,7 +217,7 @@ public static IEnumerable<QueryToken> OnEntityExtension(QueryToken parent)
             return EntityExtensions(parent);
         }
 
-        public static Func<QueryToken, IEnumerable<QueryToken>> EntityExtensions;
+        public static Func<QueryToken, IEnumerable<QueryToken>>? EntityExtensions;
 
 
         public static List<QueryToken> DateTimeProperties(QueryToken parent, DateTimePrecision precision)
diff --git a/Signum.Entities/EnumEntity.cs b/Signum.Entities/EnumEntity.cs
index 93c6f84797..5b8f9ed02b 100644
--- a/Signum.Entities/EnumEntity.cs
+++ b/Signum.Entities/EnumEntity.cs
@@ -118,7 +118,7 @@ public static Type Generate(Type enumType)
 
     class FromEnumMethodExpander : IMethodExpander
     {
-        internal static MethodInfo miQuery;
+        internal static MethodInfo miQuery = null!; /*Initialized in Logic*/
         static readonly MethodInfo miSingleOrDefault = ReflectionTools.GetMethodInfo(() => Enumerable.SingleOrDefault<int>(null, i => true)).GetGenericMethodDefinition();
 
         public Expression Expand(Expression instance, Expression[] arguments, System.Reflection.MethodInfo mi)
diff --git a/Signum.Entities/ModifiableEntity.cs b/Signum.Entities/ModifiableEntity.cs
index d1df1603ec..138e289ac1 100644
--- a/Signum.Entities/ModifiableEntity.cs
+++ b/Signum.Entities/ModifiableEntity.cs
@@ -211,7 +211,7 @@ protected virtual void ChildPropertyChanged(object sender, PropertyChangedEventA
         #endregion
 
         [field: NonSerialized, Ignore]
-        public event PropertyChangedEventHandler PropertyChanged;
+        public event PropertyChangedEventHandler? PropertyChanged;
 
         [NonSerialized, Ignore]
         ModifiableEntity? parentEntity;
diff --git a/Signum.Entities/Patterns/CorruptEntity.cs b/Signum.Entities/Patterns/CorruptEntity.cs
index 02f3e819d5..d2538b0de6 100644
--- a/Signum.Entities/Patterns/CorruptEntity.cs
+++ b/Signum.Entities/Patterns/CorruptEntity.cs
@@ -52,14 +52,14 @@ public static class Corruption
             return new Disposable(() => allowed.Value = true);
         }
 
-        public static event Action<Entity, Dictionary<Guid, IntegrityCheck>> SaveCorrupted;
+        public static event Action<Entity, Dictionary<Guid, IntegrityCheck>>? SaveCorrupted;
 
         public static void OnSaveCorrupted(Entity corruptEntity, Dictionary<Guid, IntegrityCheck> integrity)
         {
             SaveCorrupted?.Invoke(corruptEntity, integrity);
         }
 
-        public static event Action<Entity> CorruptionRemoved;
+        public static event Action<Entity>? CorruptionRemoved;
 
         public static void OnCorruptionRemoved(Entity corruptEntity)
         {
diff --git a/Signum.Entities/PropertyAttributes.cs b/Signum.Entities/PropertyAttributes.cs
index fc7607cf69..6b6536b016 100644
--- a/Signum.Entities/PropertyAttributes.cs
+++ b/Signum.Entities/PropertyAttributes.cs
@@ -1,3 +1,4 @@
+using Signum.Utilities;
 using System;
 using System.Collections.Generic;
 
@@ -31,7 +32,7 @@ public class UnitAttribute : Attribute
 
         public static string? GetTranslation(string? unitName)
         {
-            if (string.IsNullOrEmpty(unitName))
+            if (!unitName.HasText())
                 return null;
 
             if (UnitTranslations.TryGetValue(unitName, out var func))
diff --git a/Signum.Entities/PropertyRoute.cs b/Signum.Entities/PropertyRoute.cs
index 19e8f037b4..1bbfb4fd36 100644
--- a/Signum.Entities/PropertyRoute.cs
+++ b/Signum.Entities/PropertyRoute.cs
@@ -349,7 +349,7 @@ public static void SetFindImplementationsCallback(Func<PropertyRoute, Implementa
             FindImplementations = findImplementations;
         }
 
-        static Func<PropertyRoute, Implementations> FindImplementations;
+        static Func<PropertyRoute, Implementations>? FindImplementations;
 
         public Implementations? TryGetImplementations()
         {
@@ -372,7 +372,7 @@ public static void SetIsAllowedCallback(Func<PropertyRoute, string?> isAllowed)
             IsAllowedCallback = isAllowed;
         }
 
-        static Func<PropertyRoute, string?> IsAllowedCallback;
+        static Func<PropertyRoute, string?>? IsAllowedCallback;
 
         public string? IsAllowed()
         {
diff --git a/Signum.Entities/ValidationAttributes.cs b/Signum.Entities/ValidationAttributes.cs
index cf88da388d..6663e967c8 100644
--- a/Signum.Entities/ValidationAttributes.cs
+++ b/Signum.Entities/ValidationAttributes.cs
@@ -836,7 +836,7 @@ public StringCaseValidatorAttribute(StringCase textCase)
         protected override string? OverrideError(object? value)
         {
             string? str = (string?)value;
-            if (string.IsNullOrEmpty(str))
+            if (!str.HasText())
                 return null;
             
             if ((this.textCase == StringCase.Uppercase) && (str != str.ToUpper()))
diff --git a/Signum.Entities/Validator.cs b/Signum.Entities/Validator.cs
index 1fa7771a0f..ccc21b2e67 100644
--- a/Signum.Entities/Validator.cs
+++ b/Signum.Entities/Validator.cs
@@ -25,7 +25,7 @@ public static IDisposable ModelBinderScope()
             return new Disposable(() => inModelBinderVariable.Value = old);
         }
 
-        public static Func<ModifiableEntity, PropertyInfo, string?> GlobalValidation { get; set; }
+        public static Func<ModifiableEntity, PropertyInfo, string?>? GlobalValidation { get; set; }
 
         static readonly Polymorphic<Dictionary<string, IPropertyValidator>> validators =
             new Polymorphic<Dictionary<string, IPropertyValidator>>(PolymorphicMerger.InheritDictionary, typeof(ModifiableEntity));
diff --git a/Signum.React/ApiControllers/OperationController.cs b/Signum.React/ApiControllers/OperationController.cs
index 3c04ffde8d..7d11345b3b 100644
--- a/Signum.React/ApiControllers/OperationController.cs
+++ b/Signum.React/ApiControllers/OperationController.cs
@@ -227,7 +227,7 @@ public StateCanExecuteResponse StateCanExecutes([Required, FromBody]StateCanExec
         }
 
 
-        public static Func<Lite<Entity>[], bool> AnyReadonly; 
+        public static Func<Lite<Entity>[], bool>? AnyReadonly; 
 
 #pragma warning disable CS8618 // Non-nullable field is uninitialized.
         public class StateCanExecuteRequest
diff --git a/Signum.React/Facades/ReflectionServer.cs b/Signum.React/Facades/ReflectionServer.cs
index 6c5a6d1353..3a33e244cf 100644
--- a/Signum.React/Facades/ReflectionServer.cs
+++ b/Signum.React/Facades/ReflectionServer.cs
@@ -35,7 +35,7 @@ public static object GetCurrentValidCulture()
         public static ConcurrentDictionary<object, Dictionary<string, TypeInfoTS>> cache =
          new ConcurrentDictionary<object, Dictionary<string, TypeInfoTS>>();
 
-        public static Dictionary<Assembly, HashSet<string>> EntityAssemblies;
+        public static Dictionary<Assembly, HashSet<string>> EntityAssemblies = null!;
 
         public static ResetLazy<Dictionary<string, Type>> TypesByName = new ResetLazy<Dictionary<string, Type>>(
             () => GetTypes().Where(t => typeof(ModifiableEntity).IsAssignableFrom(t) ||
@@ -64,7 +64,7 @@ internal static void Start()
         const BindingFlags instanceFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
         const BindingFlags staticFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
 
-        public static event Action<TypeInfoTS, Type> AddTypeExtension;
+        public static event Action<TypeInfoTS, Type>? AddTypeExtension;
         static TypeInfoTS OnAddTypeExtension(TypeInfoTS ti, Type t)
         {
             foreach (var a in AddTypeExtension.GetInvocationListTyped())
@@ -73,7 +73,7 @@ static TypeInfoTS OnAddTypeExtension(TypeInfoTS ti, Type t)
             return ti;
         }
 
-        public static event Action<MemberInfoTS, PropertyRoute> AddPropertyRouteExtension;
+        public static event Action<MemberInfoTS, PropertyRoute>? AddPropertyRouteExtension;
         static MemberInfoTS OnAddPropertyRouteExtension(MemberInfoTS mi, PropertyRoute m)
         {
             if (AddPropertyRouteExtension == null)
@@ -86,7 +86,7 @@ static MemberInfoTS OnAddPropertyRouteExtension(MemberInfoTS mi, PropertyRoute m
         }
 
 
-        public static event Action<MemberInfoTS, FieldInfo> AddFieldInfoExtension;
+        public static event Action<MemberInfoTS, FieldInfo>? AddFieldInfoExtension;
         static MemberInfoTS OnAddFieldInfoExtension(MemberInfoTS mi, FieldInfo m)
         {
             if (AddFieldInfoExtension == null)
@@ -98,7 +98,7 @@ static MemberInfoTS OnAddFieldInfoExtension(MemberInfoTS mi, FieldInfo m)
             return mi;
         }
 
-        public static event Action<OperationInfoTS, OperationInfo, Type> AddOperationExtension;
+        public static event Action<OperationInfoTS, OperationInfo, Type>? AddOperationExtension;
         static OperationInfoTS OnAddOperationExtension(OperationInfoTS oi, OperationInfo o, Type type)
         {
             if (AddOperationExtension == null)
diff --git a/Signum.React/Facades/SignumServer.cs b/Signum.React/Facades/SignumServer.cs
index 57b5cd25a7..c66590cbdc 100644
--- a/Signum.React/Facades/SignumServer.cs
+++ b/Signum.React/Facades/SignumServer.cs
@@ -19,7 +19,7 @@ namespace Signum.React.Facades
 {
     public static class SignumServer
     {
-        public static JsonSerializerSettings JsonSerializerSettings;
+        public static JsonSerializerSettings JsonSerializerSettings = null!;
 
         public static MvcJsonOptions AddSignumJsonConverters(this MvcJsonOptions jsonOptions)
         {
@@ -88,17 +88,18 @@ public static EntityPackTS GetEntityPack(Entity entity)
                 canExecutes.ToDictionary(a => a.Key.Key, a => a.Value)
             );
 
-            foreach (var action in EntityPackTS.AddExtension.GetInvocationListTyped())
-            {
-                try
-                {
-                    action(result);
-                }
-                catch (Exception) when (StartParameters.IgnoredDatabaseMismatches != null)
+            if (EntityPackTS.AddExtension != null)
+                foreach (var action in EntityPackTS.AddExtension.GetInvocationListTyped())
                 {
-
+                    try
+                    {
+                        action(result);
+                    }
+                    catch (Exception) when (StartParameters.IgnoredDatabaseMismatches != null)
+                    {
+
+                    }
                 }
-            }
 
             return result;
         }
@@ -112,7 +113,7 @@ public class EntityPackTS
         [JsonExtensionData]
         public Dictionary<string, object?> extension { get; set; } = new Dictionary<string, object?>();
 
-        public static Action<EntityPackTS> AddExtension;
+        public static Action<EntityPackTS>? AddExtension;
 
         public EntityPackTS(Entity entity, Dictionary<string, string> canExecute)
         {
diff --git a/Signum.React/Filters/SignumExceptionFilterAttribute.cs b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
index 59eedeb711..82c225d6f6 100644
--- a/Signum.React/Filters/SignumExceptionFilterAttribute.cs
+++ b/Signum.React/Filters/SignumExceptionFilterAttribute.cs
@@ -63,7 +63,7 @@ public async Task OnResourceExecutionAsync(ResourceExecutingContext precontext,
                     if (ExpectsJsonResult(context))
                     {
 
-                        var ci = TranslateExceptionMessage(context.Exception) ? SignumCultureSelectorFilter.GetCurrentCulture(precontext) : null;
+                        var ci = TranslateExceptionMessage(context.Exception) ? SignumCultureSelectorFilter.GetCurrentCulture?.Invoke(precontext) : null;
 
                         using (ci == null ? null : CultureInfoUtils.ChangeBothCultures(ci))
                         {
diff --git a/Signum.React/Filters/SignumFilters.cs b/Signum.React/Filters/SignumFilters.cs
index 79ce1cffa4..71e85fc107 100644
--- a/Signum.React/Filters/SignumFilters.cs
+++ b/Signum.React/Filters/SignumFilters.cs
@@ -76,7 +76,7 @@ public SignumAuthenticationFilter() : base("Signum_User_Session") { }
 
     public class SignumCultureSelectorFilter : IResourceFilter
     {
-        public static Func<ResourceExecutingContext, CultureInfo?> GetCurrentCulture;
+        public static Func<ResourceExecutingContext, CultureInfo?>? GetCurrentCulture;
 
         const string Culture_Key = "OldCulture";
         const string UICulture_Key = "OldUICulture";
diff --git a/Signum.React/JsonConverters/EntityJsonConverter.cs b/Signum.React/JsonConverters/EntityJsonConverter.cs
index a421ecc14d..be763edc40 100644
--- a/Signum.React/JsonConverters/EntityJsonConverter.cs
+++ b/Signum.React/JsonConverters/EntityJsonConverter.cs
@@ -222,7 +222,7 @@ private static PropertyRoute GetCurrentPropertyRoute(object value)
             return pr;
         }
 
-        public static Func<PropertyRoute, string> CanReadPropertyRoute;
+        public static Func<PropertyRoute, string>? CanReadPropertyRoute;
 
         public void WriteJsonProperty(JsonWriter writer, JsonSerializer serializer, ModifiableEntity mod, string lowerCaseName, PropertyConverter pc, PropertyRoute route)
         {
@@ -402,7 +402,7 @@ private bool IsEquals(object newValue, object? oldValue)
         }
 
 
-        public static Func<PropertyRoute, string> CanWritePropertyRoute;
+        public static Func<PropertyRoute, string>? CanWritePropertyRoute;
         public static void AssertCanWrite(PropertyRoute pr)
         {
             string? error = CanWritePropertyRoute?.Invoke(pr);
diff --git a/Signum.Utilities/DataStructures/RecentsDictionary.cs b/Signum.Utilities/DataStructures/RecentsDictionary.cs
index 8fe5d0c11c..b040e94d88 100644
--- a/Signum.Utilities/DataStructures/RecentsDictionary.cs
+++ b/Signum.Utilities/DataStructures/RecentsDictionary.cs
@@ -168,7 +168,7 @@ public int Count
         /// <summary>
         /// Event that is fired when an item falls outside of the cache
         /// </summary>
-        public event Action<K,V> Purged;
+        public event Action<K,V>? Purged;
 
         public override string ToString()
         {
diff --git a/Signum.Utilities/DataStructures/ReferenceEqualityComparer.cs b/Signum.Utilities/DataStructures/ReferenceEqualityComparer.cs
index c8a7f16d69..049fbad77f 100644
--- a/Signum.Utilities/DataStructures/ReferenceEqualityComparer.cs
+++ b/Signum.Utilities/DataStructures/ReferenceEqualityComparer.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Collections;
@@ -8,7 +8,7 @@ namespace Signum.Utilities.DataStructures
     [Serializable]
     public class ReferenceEqualityComparer<T> : IEqualityComparer<T>, IEqualityComparer where T : class
     {
-        static ReferenceEqualityComparer<T> _default;
+        static ReferenceEqualityComparer<T>? _default;
 
         ReferenceEqualityComparer() { }
 
diff --git a/Signum.Utilities/DescriptionManager.cs b/Signum.Utilities/DescriptionManager.cs
index bf9cef10b3..f0567f9bfb 100644
--- a/Signum.Utilities/DescriptionManager.cs
+++ b/Signum.Utilities/DescriptionManager.cs
@@ -123,7 +123,7 @@ public static class DescriptionManager
 
         public static event Func<Type, DescriptionOptions?> DefaultDescriptionOptions = t => t.IsEnum && t.Name.EndsWith("Message") ? DescriptionOptions.Members : (DescriptionOptions?)null;
         public static event Func<MemberInfo, bool> ShouldLocalizeMemeber = m => true;
-        public static event Action<CultureInfo, MemberInfo> NotLocalizedMember;
+        public static event Action<CultureInfo, MemberInfo>? NotLocalizedMember;
 
         public static Dictionary<Type, Func<MemberInfo, string>> ExternalEnums = new Dictionary<Type, Func<MemberInfo, string>>
         {
@@ -348,7 +348,7 @@ public static bool OnShouldLocalizeMember(MemberInfo m)
             return true;
         }
 
-        public static Action Invalidated;
+        public static Action? Invalidated;
         public static void Invalidate()
         {
             localizations.Clear();
diff --git a/Signum.Utilities/Disposable.cs b/Signum.Utilities/Disposable.cs
index 7d900d835b..bf497c9e83 100644
--- a/Signum.Utilities/Disposable.cs
+++ b/Signum.Utilities/Disposable.cs
@@ -39,7 +39,7 @@ public void Dispose()
                 () => { try { first!.Dispose(); } finally { second!.Dispose(); } });
         }
 
-        public static IDisposable? Combine<Del>(Del delegated, Func<Del, IDisposable?> invoke) where Del : class, ICloneable, ISerializable
+        public static IDisposable? Combine<Del>(Del? delegated, Func<Del, IDisposable?> invoke) where Del : class, ICloneable, ISerializable
         {
             if (delegated == null)
                 return null;
diff --git a/Signum.Utilities/Extensions/StreamExtensions.cs b/Signum.Utilities/Extensions/StreamExtensions.cs
index 7ae5153457..1c9c38be32 100644
--- a/Signum.Utilities/Extensions/StreamExtensions.cs
+++ b/Signum.Utilities/Extensions/StreamExtensions.cs
@@ -139,7 +139,7 @@ public class ProgressStream : Stream
     {
         readonly Stream InnerStream;
 
-        public event EventHandler ProgressChanged;
+        public event EventHandler? ProgressChanged;
 
         public ProgressStream(Stream innerStream)
         {
diff --git a/Signum.Utilities/Extensions/TreeHelper.cs b/Signum.Utilities/Extensions/TreeHelper.cs
index a77a250cac..cc263eb9ca 100644
--- a/Signum.Utilities/Extensions/TreeHelper.cs
+++ b/Signum.Utilities/Extensions/TreeHelper.cs
@@ -160,8 +160,8 @@ public override string ToString()
 
         void Never()
         {
-            PropertyChanged(null, null);
+            PropertyChanged?.Invoke(null, null);
         }
-        public event PropertyChangedEventHandler PropertyChanged;
+        public event PropertyChangedEventHandler? PropertyChanged;
     }
 }
diff --git a/Signum.Utilities/MyRandom.cs b/Signum.Utilities/MyRandom.cs
index 1bbef6140f..cdea03c6f8 100644
--- a/Signum.Utilities/MyRandom.cs
+++ b/Signum.Utilities/MyRandom.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -7,7 +7,7 @@ namespace Signum.Utilities
     public static class MyRandom
     {
         [ThreadStatic]
-        static Random random;
+        static Random? random;
 
         public static Random Current
         {
diff --git a/Signum.Utilities/ProgressProxy.cs b/Signum.Utilities/ProgressProxy.cs
index ed7cc94d47..1117f43fb6 100644
--- a/Signum.Utilities/ProgressProxy.cs
+++ b/Signum.Utilities/ProgressProxy.cs
@@ -12,7 +12,7 @@ public class ProgressProxy
         private int max;
         private int position;
 
-        public event EventHandler<ProgressArgs> Changed;
+        public event EventHandler<ProgressArgs>? Changed;
 
         public ProgressProxy()
         {
diff --git a/Signum.Utilities/Reflection/ReflectionTools.cs b/Signum.Utilities/Reflection/ReflectionTools.cs
index 0ac202c6b8..084a4006b7 100644
--- a/Signum.Utilities/Reflection/ReflectionTools.cs
+++ b/Signum.Utilities/Reflection/ReflectionTools.cs
@@ -580,7 +580,7 @@ public static bool TryParse(string? value, Type type, CultureInfo ci, out object
 
             result = null;
 
-            if (string.IsNullOrEmpty(value))
+            if (!value.HasText())
             {
                 if (Nullable.GetUnderlyingType(type) == null && type.IsValueType)
                 {
diff --git a/Signum.Utilities/StartParameters.cs b/Signum.Utilities/StartParameters.cs
index 23da701431..b27789ca31 100644
--- a/Signum.Utilities/StartParameters.cs
+++ b/Signum.Utilities/StartParameters.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace Signum.Utilities
@@ -8,10 +8,10 @@ public static class StartParameters
         //The best development experience is to throw an exception when starting but in some scenarios is better to try to start at all costs:
 
         // * Green / Blue deployments where the Application and the DB could be mistmatched for a while     
-        public static List<Exception> IgnoredDatabaseMismatches; //Initialize to enable
+        public static List<Exception>? IgnoredDatabaseMismatches; //Initialize to enable
 
         // * Dynamic code where everithing could happen (like duplicated entities, entities without operations, etc..)
-        public static List<Exception> IgnoredCodeErrors;//Initialize to enable
+        public static List<Exception>? IgnoredCodeErrors;//Initialize to enable
 
 
         public static List<R> SelectCatch<T, R>(this IEnumerable<T> elements, Func<T, R> selectorOrCrash)
diff --git a/Signum.Utilities/Synchronization/ResetLazy.cs b/Signum.Utilities/Synchronization/ResetLazy.cs
index 7e3420c266..2b51d4954c 100644
--- a/Signum.Utilities/Synchronization/ResetLazy.cs
+++ b/Signum.Utilities/Synchronization/ResetLazy.cs
@@ -169,6 +169,6 @@ ResetLazyStats IResetLazy.Stats()
             };
         }
 
-        public event EventHandler OnReset; 
+        public event EventHandler? OnReset; 
     }
 }