public static void Start(HttpConfiguration config)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage));
EntityJsonConverter.AfterDeserilization.Register((EmailTemplateEntity et) =>
{
if (et.Query != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(et.Query.ToQueryName());
et.ParseData(qd);
}
});
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
var templates = EmailTemplateLogic.GetApplicableEmailTemplates(type, null, EmailTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("emailTemplates", templates);
}
};
}
public static void Start(IApplicationBuilder app)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(CachePermission), () => CachePermission.ViewCache.IsAuthorized());
SchemaMap.GetColorProviders += GetMapColors;
}
public static void Start(HttpConfiguration config, ITranslator translator, bool copyNewTranslationsToRootFolder = true)
{
ReflectionServer.RegisterLike(typeof(TranslationMessage));
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
Translator = translator;
if (copyNewTranslationsToRootFolder)
{
string path = Path.Combine(Path.GetDirectoryName(Path.GetDirectoryName(new Uri(typeof(DescriptionManager).Assembly.CodeBase).LocalPath)), "Translations");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var existingFiles = Directory.GetFiles(path).ToHashSet();
foreach (string fromFile in Directory.GetFiles(DescriptionManager.TranslationDirectory))
{
string toFile = Path.Combine(path, Path.GetFileName(fromFile));
if (!existingFiles.Contains(toFile) || File.GetLastWriteTime(toFile) < File.GetLastWriteTime(fromFile))
{
File.Copy(fromFile, toFile, overwrite: true);
}
}
DescriptionManager.TranslationDirectory = path;
}
}
public static void Start(IApplicationBuilder app, ITranslator translator)
{
ReflectionServer.RegisterLike(typeof(TranslationMessage), () => TranslationPermission.TranslateCode.IsAuthorized() || TranslationPermission.TranslateInstances.IsAuthorized());
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
Translator = translator;
}
public static void Start(IApplicationBuilder app)
{
TypeHelpServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage));
EntityJsonConverter.AfterDeserilization.Register((EmailTemplateEntity et) =>
{
if (et.Query != null)
{
var qd = QueryLogic.Queries.QueryDescription(et.Query.ToQueryName());
et.ParseData(qd);
}
});
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
if (Schema.Current.IsAllowed(typeof(EmailTemplateEntity), true) == null)
{
var templates = EmailTemplateLogic.GetApplicableEmailTemplates(type, null, EmailTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("emailTemplates", templates);
}
}
};
}
public static void Start(HttpConfiguration config)
{
ReflectionServer.RegisterLike(typeof(MapMessage));
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
SchemaMap.GetColorProviders += GetMapColors;
}
public static void Start(IApplicationBuilder app, ITranslator translator)
{
ReflectionServer.RegisterLike(typeof(TranslationMessage));
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
Translator = translator;
}
public static void Start(IApplicationBuilder app)
{
if (started)
{
return;
}
started = true;
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(QueryTokenEmbedded), () => UserAssetPermission.UserAssetsToXML.IsAuthorized() ||
TypeAuthLogic.GetAllowed(typeof(UserQueryEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None ||
TypeAuthLogic.GetAllowed(typeof(UserChartEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None
);
//EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(QueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx()));
//EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(PinnedQueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx().Pinned));
var pcs = SignumServer.WebEntityJsonConverterFactory.GetPropertyConverters(typeof(QueryTokenEmbedded));
pcs.Add("token", new PropertyConverter
{
CustomWriteJsonProperty = (Utf8JsonWriter writer, WriteJsonPropertyContext ctx) =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
writer.WritePropertyName(ctx.LowerCaseName);
JsonSerializer.Serialize(writer, qte.TryToken == null ? null : new QueryTokenTS(qte.TryToken, true), ctx.JsonSerializerOptions);
},
AvoidValidate = true,
CustomReadJsonProperty = (ref Utf8JsonReader reader, ReadJsonPropertyContext ctx) =>
{
var result = JsonSerializer.Deserialize <object>(ref reader, ctx.JsonSerializerOptions);
//Discard
}
});
pcs.Add("parseException", new PropertyConverter
{
CustomWriteJsonProperty = (Utf8JsonWriter writer, WriteJsonPropertyContext ctx) =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
writer.WritePropertyName(ctx.LowerCaseName);
writer.WriteStringValue(qte.ParseException?.Message);
},
AvoidValidate = true,
CustomReadJsonProperty = (ref Utf8JsonReader reader, ReadJsonPropertyContext ctx) =>
{
var result = reader.GetString();
//Discard
}
});
pcs.GetOrThrow("tokenString").CustomWriteJsonProperty = (Utf8JsonWriter writer, WriteJsonPropertyContext ctx) =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
writer.WritePropertyName(ctx.LowerCaseName);
writer.WriteStringValue(qte.TryToken?.FullKey() ?? qte.TokenString);
};
}
public static void Start(HttpConfiguration config)
{
ReflectionServer.RegisterLike(typeof(MapMessage));
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "namespace",
NiceName = MapMessage.Namespace.NiceToString(),
},
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "entityKind",
NiceName = typeof(EntityKind).Name,
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "columns",
NiceName = MapMessage.Columns.NiceToString(),
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "entityData",
NiceName = typeof(EntityData).Name,
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "rows",
NiceName = MapMessage.Rows.NiceToString(),
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "tableSize",
NiceName = MapMessage.TableSize.NiceToString(),
}
};
}
private static string TypeScriptType(Type type)
{
type = CleanMList(type);
type = type.UnNullify().CleanType();
return(BasicType(type) ?? ReflectionServer.GetTypeName(type) ?? "any");
}
public static void Start(IApplicationBuilder app)
{
if (started)
{
return;
}
started = true;
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(QueryTokenEmbedded));
EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(QueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx()));
EntityJsonConverter.DefaultPropertyRoutes.Add(typeof(PinnedQueryFilterEmbedded), PropertyRoute.Construct((UserQueryEntity e) => e.Filters.FirstEx().Pinned));
var pcs = PropertyConverter.GetPropertyConverters(typeof(QueryTokenEmbedded));
pcs.Add("token", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.TryToken == null ? null : new QueryTokenTS(qte.TryToken, true));
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.Add("parseException", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.ParseException?.Message);
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.GetOrThrow("tokenString").CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(qte.TryToken?.FullKey() ?? qte.TokenString);
};
}
public static void Start(HttpConfiguration config)
{
if (started)
{
return;
}
started = true;
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(QueryTokenEmbedded));
var pcs = PropertyConverter.GetPropertyConverters(typeof(QueryTokenEmbedded));
pcs.Add("token", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.TryToken == null ? null : new QueryTokenTS(qte.TryToken, true));
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.Add("parseException", new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, qte.ParseException?.Message);
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var result = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
pcs.GetOrThrow("tokenString").CustomWriteJsonProperty = ctx =>
{
var qte = (QueryTokenEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonWriter.WriteValue(qte.TryToken?.FullKey() ?? qte.TokenString);
};
}
public static void Start(IApplicationBuilder app, IWebHostEnvironment hostingEnvironment, Assembly mainAsembly)
{
Schema.Current.ApplicationName = hostingEnvironment.ContentRootPath;
SignumControllerFactory.RegisterArea(typeof(EntitiesController));
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod() !);
ReflectionServer.Start();
ReflectionServer.RegisterLike(typeof(SearchMessage), () => UserHolder.Current != null);
ReflectionServer.RegisterLike(typeof(PaginationMode), () => UserHolder.Current != null);
ReflectionServer.OverrideIsNamespaceAllowed.Add(typeof(DayOfWeek).Namespace !, () => UserHolder.Current != null);
ReflectionServer.OverrideIsNamespaceAllowed.Add(typeof(CollectionMessage).Namespace !, () => UserHolder.Current != null);
}
public static void Start(IApplicationBuilder app, params IOmniboxResultGenerator[] generators)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
QueryTokenJsonConverter.GetQueryTokenTS = qt => new QueryTokenTS(qt, true);
QueryNameJsonConverter.GetQueryKey = qn => QueryUtils.GetKey(qn);
OmniboxParser.Manager = new ReactOmniboxManager();
ReflectionServer.RegisterLike(typeof(OmniboxMessage), () => OmniboxPermission.ViewOmnibox.IsAuthorized());
foreach (var g in generators)
{
OmniboxParser.Generators.Add(g);
}
}
public static void Start(HttpConfiguration config, params IOmniboxResultGenerator[] generators)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
QueryTokenJsonConverter.GetQueryTokenTS = qt => new QueryTokenTS(qt, true);
QueryNameJsonConverter.GetQueryKey = qn => QueryUtils.GetKey(qn);
OmniboxParser.Manager = new ReactOmniboxManager();
ReflectionServer.RegisterLike(typeof(OmniboxMessage));
foreach (var g in generators)
{
OmniboxParser.Generators.Add(g);
}
}
public ActionResult <Dictionary <string, TypeInfoTS> > Types()
{
this.Response.GetTypedHeaders().LastModified = ReflectionServer.LastModified;
var requestHeaders = this.Request.GetTypedHeaders();
if (requestHeaders.IfModifiedSince.HasValue &&
(ReflectionServer.LastModified - requestHeaders.IfModifiedSince.Value).TotalSeconds < 1)
{
return(this.StatusCode(StatusCodes.Status304NotModified));
}
return(ReflectionServer.GetTypeInfoTS());
}
public static void WebStart(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime lifetime)
{
SignumServer.Start(app, env, typeof(Startup).Assembly);
AuthServer.Start(app, () => Starter.Configuration.Value.AuthTokens, "IMPORTANT SECRET FROM Southwind. CHANGE THIS STRING!!!");
CacheServer.Start(app);
FilesServer.Start(app);
UserQueryServer.Start(app);
DashboardServer.Start(app);
WordServer.Start(app);
ExcelServer.Start(app);
ChartServer.Start(app);
MapServer.Start(app);
ToolbarServer.Start(app);
TranslationServer.Start(app,
new AlreadyTranslatedTranslator(),
new AzureTranslator(
() => Starter.Configuration.Value.Translation.AzureCognitiveServicesAPIKey,
() => Starter.Configuration.Value.Translation.AzureCognitiveServicesRegion),
new DeepLTranslator(() => Starter.Configuration.Value.Translation.DeepLAPIKey)
); //TranslationServer
SchedulerServer.Start(app, lifetime);
ProcessServer.Start(app);
MailingServer.Start(app);
ProfilerServer.Start(app);
DiffLogServer.Start(app);
RestServer.Start(app);
RestLogServer.Start(app);
PredictorServer.Start(app);
WorkflowServer.Start(app);
AlertsServer.Start(app);
DynamicServer.Start(app);
OmniboxServer.Start(app,
new EntityOmniboxResultGenenerator(),
new DynamicQueryOmniboxResultGenerator(),
new ChartOmniboxResultGenerator(),
new DashboardOmniboxResultGenerator(DashboardLogic.Autocomplete),
new UserQueryOmniboxResultGenerator(UserQueryLogic.Autocomplete),
new UserChartOmniboxResultGenerator(UserChartLogic.Autocomplete),
new MapOmniboxResultGenerator(type => OperationLogic.TypeOperations(type).Any()),
new ReactSpecialOmniboxGenerator()
//new HelpModuleOmniboxResultGenerator(),
); //Omnibox
ReflectionServer.RegisterLike(typeof(RegisterUserModel), () => true);
SignumCultureSelectorFilter.GetCurrentCulture = (ctx) => GetCulture(ctx);
}
public static void Start(IApplicationBuilder app)
{
TypeHelpServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(DynamicViewMessage), () => UserEntity.Current != null);
EntityJsonConverter.AfterDeserilization.Register((PropertyRouteEntity wc) =>
{
var route = PropertyRouteLogic.TryGetPropertyRouteEntity(wc.RootType, wc.Path);
if (route != null)
{
wc.SetId(route.Id);
wc.SetIsNew(false);
wc.SetCleanModified(false);
}
});
}
public TypeHelpTS GetTypeHelp(string typeName, TypeHelpMode mode)
{
Type type = TypeLogic.TryGetType(typeName);
if (type == null)
{
return(null);
}
var isEnum = EnumEntity.IsEnumEntity(type);
var members = new List <TypeMemberHelpTS>();
if (isEnum)
{
var enumType = EnumEntity.Extract(type);
var values = EnumEntity.GetValues(enumType).ToList();
members.AddRange(values.Select(ev => new TypeMemberHelpTS(ev)));
}
else
{
var routes = PropertyRoute.GenerateRoutes(type);
var root = TreeHelper.ToTreeC(routes, a => a.Parent).SingleEx();
members = root.Children
.Where(a => mode == TypeHelpMode.CSharp || ReflectionServer.InTypeScript(a.Value))
.Select(pr => new TypeMemberHelpTS(pr, mode)).ToList();
if (mode == TypeHelpMode.CSharp)
{
var expressions = DynamicQueryManager.Current.RegisteredExtensions.GetValue(type);
members.AddRange(expressions.Values.Select(ex => new TypeMemberHelpTS(ex)));
}
}
return(new TypeHelpTS
{
type = (isEnum ? EnumEntity.Extract(type).Name : type.Name),
cleanTypeName = typeName,
isEnum = isEnum,
members = members
});
}
public TypeMemberHelpTS(Node <PropertyRoute> node, TypeHelpMode mode)
{
var pr = node.Value;
this.propertyString = pr.PropertyString();
this.name = mode == TypeHelpMode.Typescript ?
pr.PropertyInfo?.Name.FirstLower() :
pr.PropertyInfo?.Name;
this.type = mode == TypeHelpMode.Typescript && ReflectionServer.IsId(pr) ?
PrimaryKey.Type(pr.RootType).Nullify().TypeName():
pr.Type.TypeName();
this.isExpression = false;
this.isEnum = pr.Type.UnNullify().IsEnum;
this.cleanTypeName = GetCleanTypeName(pr.Type.UnNullify().IsEnum ? EnumEntity.Generate(pr.Type.UnNullify()) : pr.Type);
this.subMembers = node.Children.Select(a => new TypeMemberHelpTS(a, mode)).ToList();
}
public static void Start(IApplicationBuilder app)
{
TypeHelpServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage));
CustomizeFiltersModel();
EntityPackTS.AddExtension += ep =>
{
if (ep.entity.IsNew || !WordTemplatePermission.GenerateReport.IsAuthorized())
{
return;
}
var wordTemplates = WordTemplateLogic.TemplatesByEntityType.Value.TryGetC(ep.entity.GetType());
if (wordTemplates != null)
{
var applicable = wordTemplates.Where(a => a.IsApplicable(ep.entity));
if (applicable.HasItems())
{
ep.extension.Add("wordTemplates", applicable.Select(a => a.ToLite()).ToList());
}
}
};
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
if (Schema.Current.IsAllowed(typeof(WordTemplateEntity), true) == null)
{
var templates = WordTemplateLogic.GetApplicableWordTemplates(type, null, WordTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("wordTemplates", templates);
}
}
};
}
public static void Start(HttpConfiguration config)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(ExcelMessage));
}
public static void Start(IApplicationBuilder app)
{
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage), () =>
TypeAuthLogic.GetAllowed(typeof(EmailTemplateEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None ||
TypeAuthLogic.GetAllowed(typeof(WordTemplateEntity)).MaxUI() > Entities.Authorization.TypeAllowedBasic.None);
}
public static void Start(IApplicationBuilder app)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TreeEntity), () => Schema.Current.Tables.Keys.Where(p => typeof(TreeEntity).IsAssignableFrom(p)).Any(t => TypeAuthLogic.GetAllowed(t).MaxUI() > TypeAllowedBasic.None));
}
public static void Start(IApplicationBuilder app)
{
ReflectionServer.RegisterLike(typeof(MapMessage), () => MapPermission.ViewMap.IsAuthorized());
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "namespace",
NiceName = MapMessage.Namespace.NiceToString(),
},
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "entityKind",
NiceName = typeof(EntityKind).Name,
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "columns",
NiceName = MapMessage.Columns.NiceToString(),
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "entityData",
NiceName = typeof(EntityData).Name,
}
};
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "rows",
NiceName = MapMessage.Rows.NiceToString(),
}
};
if (Schema.Current.Tables.Any(a => a.Value.SystemVersioned != null))
{
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "rows_history",
NiceName = MapMessage.RowsHistory.NiceToString(),
}
};
}
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "tableSize",
NiceName = MapMessage.TableSize.NiceToString(),
}
};
if (Schema.Current.Tables.Any(a => a.Value.SystemVersioned != null))
{
SchemaMap.GetColorProviders += () => new[]
{
new MapColorProvider
{
Name = "tableSize_history",
NiceName = MapMessage.TableSizeHistory.NiceToString(),
}
};
}
}
public static void Start(IApplicationBuilder app, Func <AuthTokenConfigurationEmbedded> tokenConfig, string hashableEncryptionKey)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
AuthTokenServer.Start(tokenConfig, hashableEncryptionKey);
ReflectionServer.GetContext = () => new
{
Culture = ReflectionServer.GetCurrentValidCulture(),
Role = UserEntity.Current == null ? null : RoleEntity.Current,
};
AuthLogic.OnRulesChanged += () => ReflectionServer.cache.Clear();
if (TypeAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (typeof(Entity).IsAssignableFrom(t))
{
var ta = UserEntity.Current != null?TypeAuthLogic.GetAllowed(t) : null;
ti.Extension.Add("maxTypeAllowed", ta == null ? TypeAllowedBasic.None : ta.MaxUI());
ti.Extension.Add("minTypeAllowed", ta == null ? TypeAllowedBasic.None : ta.MinUI());
ti.RequiresEntityPack |= ta != null && ta.Conditions.Any();
}
};
EntityPackTS.AddExtension += ep =>
{
var typeAllowed =
UserEntity.Current == null ? TypeAllowedBasic.None :
ep.entity.IsNew ? TypeAuthLogic.GetAllowed(ep.entity.GetType()).MaxUI() :
TypeAuthLogic.IsAllowedFor(ep.entity, TypeAllowedBasic.Write, true) ? TypeAllowedBasic.Write :
TypeAuthLogic.IsAllowedFor(ep.entity, TypeAllowedBasic.Read, true) ? TypeAllowedBasic.Read :
TypeAllowedBasic.None;
ep.extension.Add("typeAllowed", typeAllowed);
};
OperationController.AnyReadonly += (Lite <Entity>[] lites) =>
{
return(lites.GroupBy(ap => ap.EntityType).Any(gr =>
{
var ta = TypeAuthLogic.GetAllowed(gr.Key);
if (ta.Min(inUserInterface: true) == TypeAllowedBasic.Write)
{
return false;
}
if (ta.Max(inUserInterface: true) <= TypeAllowedBasic.Read)
{
return true;
}
return giCountReadonly.GetInvoker(gr.Key)() > 0;
}));
};
}
if (QueryAuthLogic.IsStarted)
{
ReflectionServer.AddTypeExtension += (ti, t) =>
{
if (ti.QueryDefined)
{
ti.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(t));
}
};
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.DeclaringType !.Name.EndsWith("Query"))
{
mi.Extension.Add("queryAllowed", UserEntity.Current == null ? QueryAllowed.None : QueryAuthLogic.GetQueryAllowed(fi.GetValue(null) !));
}
};
}
if (PropertyAuthLogic.IsStarted)
{
ReflectionServer.AddPropertyRouteExtension += (mi, pr) =>
{
mi.Extension.Add("propertyAllowed", UserEntity.Current == null ? PropertyAllowed.None : pr.GetPropertyAllowed());
};
}
if (OperationAuthLogic.IsStarted)
{
ReflectionServer.AddOperationExtension += (oits, oi, type) =>
{
oits.Extension.Add("operationAllowed",
UserEntity.Current == null ? false :
OperationAuthLogic.GetOperationAllowed(oi.OperationSymbol, type, inUserInterface: true));
};
}
if (PermissionAuthLogic.IsStarted)
{
ReflectionServer.AddFieldInfoExtension += (mi, fi) =>
{
if (fi.FieldType == typeof(PermissionSymbol))
{
mi.Extension.Add("permissionAllowed",
UserEntity.Current == null ? false :
PermissionAuthLogic.IsAuthorized((PermissionSymbol)fi.GetValue(null) !));
}
};
}
var piPasswordHash = ReflectionTools.GetPropertyInfo((UserEntity e) => e.PasswordHash);
var pcs = PropertyConverter.GetPropertyConverters(typeof(UserEntity));
pcs.GetOrThrow("passwordHash").CustomWriteJsonProperty = ctx => { };
pcs.Add("newPassword", new PropertyConverter
{
AvoidValidate = true,
CustomWriteJsonProperty = ctx => { },
CustomReadJsonProperty = ctx =>
{
EntityJsonConverter.AssertCanWrite(ctx.ParentPropertyRoute.Add(piPasswordHash));
var password = (string)ctx.JsonReader.Value !;
var error = UserEntity.OnValidatePassword(password);
if (error != null)
{
throw new ApplicationException(error);
}
((UserEntity)ctx.Entity).PasswordHash = Security.EncodePassword(password);
}
});
public string GetConstructorType([Required, FromBody] EmailModelEntity model)
{
var type = EmailModelLogic.GetEntityType(model.ToType());
return(ReflectionServer.GetTypeName(type));
}
public Dictionary <string, TypeInfoTS> Types()
{
return(ReflectionServer.GetTypeInfoTS());
}
public static void Start(IApplicationBuilder app)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(DiffLogMessage));
}
public static void Start(IApplicationBuilder app)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
void RegisterFilePathEmbeddedProperty(string propertyName, Func <FilePathEmbedded, object?> getter)
{
PropertyConverter.GetPropertyConverters(typeof(FilePathEmbedded)).Add(propertyName, new PropertyConverter()
{
CustomWriteJsonProperty = ctx =>
{
var fpe = (FilePathEmbedded)ctx.Entity;
ctx.JsonWriter.WritePropertyName(ctx.LowerCaseName);
ctx.JsonSerializer.Serialize(ctx.JsonWriter, getter(fpe));
},
AvoidValidate = true,
CustomReadJsonProperty = ctx =>
{
var list = ctx.JsonSerializer.Deserialize(ctx.JsonReader);
//Discard
}
});
}
RegisterFilePathEmbeddedProperty("fullWebPath", fpe => fpe.FullWebPath());
RegisterFilePathEmbeddedProperty("entityId", fpe => fpe.EntityId);
RegisterFilePathEmbeddedProperty("mListRowId", fpe => fpe.MListRowId);
RegisterFilePathEmbeddedProperty("propertyRoute", fpe => fpe.PropertyRoute);
RegisterFilePathEmbeddedProperty("rootType", fpe => fpe.RootType);
var s = Schema.Current.Settings;
ReflectionServer.PropertyRouteExtension += (mi, pr) =>
{
var dft = s.FieldAttributes(pr)?.OfType <DefaultFileTypeAttribute>().SingleOrDefaultEx();
if (dft != null)
{
if (dft.FileTypeSymbol == null)
{
dft.FileTypeSymbol = SymbolLogic <FileTypeSymbol> .Symbols
.Where(a => a.Key.After(".") == dft.SymbolName && (dft.SymbolContainer == null || dft.SymbolContainer == a.Key.Before(".")))
.SingleEx(
() => $"No FileTypeSymbol with name {dft.SymbolContainer}.{dft.SymbolName} is registered",
() => $"More than one FileTypeSymbol with name {dft.SymbolContainer}.{dft.SymbolName} are registered. Consider desambiguating using symbolContainer argument in {pr}"
);
}
var alg = FileTypeLogic.GetAlgorithm(dft.FileTypeSymbol);
mi.Extension.Add("defaultFileTypeInfo", new
{
key = dft.FileTypeSymbol.Key,
onlyImages = alg.OnlyImages,
maxSizeInBytes = alg.MaxSizeInBytes,
});
}
return(mi);
};
FilePathEntity.ToAbsolute = FilePathEmbedded.ToAbsolute = url => SignumCurrentContextFilter.Url == null?Content(url) : SignumCurrentContextFilter.Url !.Content(url);
ReflectionServer.RegisterLike(typeof(FileMessage), () => true);
}
