improve performance for api/types (most of the code in Southwind)

Signum.React/Filters/ETagMiddleware.cs

@@ -0,0 +1,83 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Net.Http.Headers;
+using System.IO;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Signum.React.Filters
+{
+    public class ETagMiddleware
+    {
+        private readonly RequestDelegate _next;
+
+        public ETagMiddleware(RequestDelegate next)
+        {
+            _next = next;
+        }
+
+        public async Task InvokeAsync(HttpContext context)
+        {
+            var response = context.Response;
+            var originalStream = response.Body;
+
+            using (var ms = new MemoryStream())
+            {
+                response.Body = ms;
+
+                await _next(context);
+
+                if (IsEtagSupported(response))
+                {
+                    string checksum = CalculateChecksum(ms);
+
+                    response.Headers[HeaderNames.ETag] = checksum;
+
+                    if (context.Request.Headers.TryGetValue(HeaderNames.IfNoneMatch, out var etag) && checksum == etag)
+                    {
+                        response.StatusCode = StatusCodes.Status304NotModified;
+                        return;
+                    }
+                }
+
+                ms.Position = 0;
+                await ms.CopyToAsync(originalStream);
+            }
+        }
+
+        private static bool IsEtagSupported(HttpResponse response)
+        {
+            if (response.StatusCode != StatusCodes.Status200OK)
+                return false;
+
+            // The 20kb length limit is not based in science. Feel free to change
+            if (response.Body.Length > 10 * 1024 * 1024)
+                return false;
+
+            if (response.Headers.ContainsKey(HeaderNames.ETag))
+                return false;
+
+            return true;
+        }
+
+        private static string CalculateChecksum(MemoryStream ms)
+        {
+            using (var algo = SHA1.Create())
+            {
+                ms.Position = 0;
+                byte[] bytes = algo.ComputeHash(ms);
+                return WebEncoders.Base64UrlEncode(bytes);
+            }
+        }
+    }
+
+    public static class ApplicationBuilderExtensions
+    {
+        public static void UseETagger(this IApplicationBuilder app)
+        {
+            app.UseMiddleware<ETagMiddleware>();
+        }
+    }
+}

Signum.React/Scripts/AppContext.tsx

@@ -11,7 +11,10 @@ import { Entity, EntityPack, Lite, ModifiableEntity } from "./Signum.Entities";
 
 Dic.skipClasses.push(React.Component);
 
-
+export let currentCulture: string | undefined;
+export function setCurrentCulture(culture: string | undefined) {
+  currentCulture = culture;
+}
 
 export let currentUser: IUserEntity | undefined;
 export function setCurrentUser(user: IUserEntity | undefined) {

Signum.React/Scripts/Reflection.ts

@@ -4,8 +4,8 @@ import { Dic } from './Globals';
 import { ModifiableEntity, Entity, Lite, MListElement, ModelState, MixinEntity } from './Signum.Entities'; //ONLY TYPES or Cyclic problems in Webpack!
 import { ajaxGet } from './Services';
 import { MList } from "./Signum.Entities";
-import QueryTokenBuilder from './SearchControl/QueryTokenBuilder';
-import { AggregateType } from './FindOptions';
+import * as AppContext from './AppContext';
+import { QueryString } from './QueryString';
 
 export function getEnumInfo(enumTypeName: string, enumId: number): MemberInfo {
 
@@ -427,7 +427,12 @@ export function isQueryDefined(queryName: PseudoType | QueryKey): boolean {
 }
 
 export function reloadTypes(): Promise<void> {
-  return ajaxGet<TypeInfoDictionary>({ url: "~/api/reflection/types" })
+  return ajaxGet<TypeInfoDictionary>({
+    url: "~/api/reflection/types?" + QueryString.stringify({
+      user: AppContext.currentUser?.id,
+      culture: AppContext.currentCulture
+    })
+  })
     .then(types => {
       setTypes(types);
       onReloadTypes();