internal static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <ChartScriptSymbol> .Start(sb, () => Scripts.Keys);
ChartRequestModel.GetChartScriptFunc = s => Scripts.GetOrThrow(s);
RegisterScript(new BarsChartScript());
RegisterScript(new ColumnsChartScript());
RegisterScript(new LineChartScript());
RegisterScript(new MultiBarsChartScript());
RegisterScript(new MultiColumnsChartScript());
RegisterScript(new MultiLinesChartScript());
RegisterScript(new StackedBarsChartScript());
RegisterScript(new StackedColumnsChartScript());
RegisterScript(new StackedLinesChartScript());
RegisterScript(new PieChartScript());
RegisterScript(new BubblePackChartScript());
RegisterScript(new ScatterplotChartScript());
RegisterScript(new BubbleplotChartScript());
RegisterScript(new ParallelCoordiantesChartScript());
RegisterScript(new PunchcardChartScript());
RegisterScript(new CalendarStreamChartScript());
RegisterScript(new TreeMapChartScript());
RegisterScript(new HeatmapChartScript());
RegisterScript(new MarkermapChartScript());
}
}
public static Dictionary <string, TypeInfoTS> GetSymbolContainers(IEnumerable <Type> allTypes)
{
SymbolLogic.LoadAll();
var result = (from type in allTypes
where type.IsStaticClass() && type.HasAttribute <AutoInitAttribute>()
select KVP.Create(GetTypeName(type), OnAddTypeExtension(new TypeInfoTS
{
Kind = KindOfType.SymbolContainer,
FullName = type.FullName,
Members = type.GetFields(staticFlags)
.Select(f => GetSymbolInfo(f))
.Where(s =>
s.FieldInfo != null && /*Duplicated like in Dynamic*/
s.IdOrNull.HasValue /*Not registered*/)
.ToDictionary(s => s.FieldInfo.Name, s => OnAddFieldInfoExtension(new MemberInfoTS
{
NiceName = s.FieldInfo.NiceName(),
Id = s.IdOrNull.Value.Object
}, s.FieldInfo))
}, type)))
.Where(a => a.Value.Members.Any())
.ToDictionaryEx("symbols");
return(result);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <ModelConverterSymbol> .Start(sb, dqm, () => Converters.Keys);
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
AuthLogic.AssertStarted(sb);
OperationLogic.AssertStarted(sb);
OperationLogic.AllowOperation += OperationLogic_AllowOperation;
cache = new AuthCache <RuleOperationEntity, OperationAllowedRule, OperationSymbol, OperationSymbol, OperationAllowed>(sb,
s => s,
s => s,
merger: new OperationMerger(),
invalidateWithTypes: true,
coercer: OperationCoercer.Instance);
AuthLogic.ExportToXml += exportAll => cache.ExportXml("Operations", "Operation", s => s.Key, b => b.ToString(),
exportAll ? OperationLogic.RegisteredOperations.ToList() : null);
AuthLogic.ImportFromXml += (x, roles, replacements) =>
{
string replacementKey = "AuthRules:" + typeof(OperationSymbol).Name;
replacements.AskForReplacements(
x.Element("Operations").Elements("Role").SelectMany(r => r.Elements("Operation")).Select(p => p.Attribute("Resource").Value).ToHashSet(),
SymbolLogic <OperationSymbol> .AllUniqueKeys(),
replacementKey);
return(cache.ImportXml(x, "Operations", "Operation", roles,
s => SymbolLogic <OperationSymbol> .TryToSymbol(replacements.Apply(replacementKey, s)), EnumExtensions.ToEnum <OperationAllowed>));
};
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <TypeConditionSymbol> .Start(sb, () => infos.SelectMany(a => a.Value.Keys).ToHashSet());
}
}
public static OperationSymbol ParseOperationAssert(string operationKey, Type entityType, object[]?args = null)
{
var symbol = SymbolLogic <OperationSymbol> .ToSymbol(operationKey);
OperationLogic.AssertOperationAllowed(symbol, entityType, inUserInterface: true);
return(symbol);
}
public static OperationSymbol ParseOperationAssert(string operationKey)
{
var symbol = SymbolLogic <OperationSymbol> .ToSymbol(operationKey);
OperationLogic.AssertOperationAllowed(symbol, inUserInterface: true);
return(symbol);
}
public string[] AvailableDevices(string algorithmKey)
{
var key = SymbolLogic <PredictorAlgorithmSymbol> .ToSymbol(algorithmKey);
var alg = PredictorLogic.Algorithms.GetOrThrow(key);
return(alg.GetAvailableDevices());
}
public static OperationSymbol GetOperationKeyAssert(this ControllerBase controller, Type entityType)
{
var operationFullKey = controller.ControllerContext.RequestContext.HttpContext.Request["operationFullKey"];
var operationSymbol = SymbolLogic <OperationSymbol> .ToSymbol(operationFullKey);
OperationLogic.AssertOperationAllowed(operationSymbol, entityType, inUserInterface: true);
return(operationSymbol);
}
private static MList <RuleTypeConditionEmbedded> Conditions(XElement xr, Replacements replacements)
{
return((from xc in xr.Elements("Condition")
let cn = SymbolLogic <TypeConditionSymbol> .TryToSymbol(replacements.Apply(typeConditionReplacementKey, xc.Attribute("Name").Value))
where cn != null
select new RuleTypeConditionEmbedded
{
Condition = cn,
Allowed = xc.Attribute("Allowed").Value.ToEnum <TypeAllowed>()
}).ToMList());
}
public FileStreamResult DownloadFilePathEmbedded(string fileTypeKey, string suffix, string fileName)
{
var fileType = SymbolLogic <FileTypeSymbol> .ToSymbol(fileTypeKey);
var virtualFile = new FilePathEmbedded(fileType)
{
Suffix = suffix,
FileName = fileName,
};
return(GetFileStreamResult(virtualFile.OpenRead(), virtualFile.FileName));
}
public HttpResponseMessage DownloadFilePathEmbedded(string fileTypeKey, string suffix, string fileName)
{
var fileType = SymbolLogic <FileTypeSymbol> .ToSymbol(fileTypeKey);
var virtualFile = new FilePathEmbedded(fileType)
{
Suffix = suffix,
FileName = fileName,
};
return(GetHttpReponseMessage(virtualFile.OpenRead(), virtualFile.FileName));
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <FileTypeSymbol> .Start(sb, () => FileTypes.Keys.ToHashSet());
sb.Include <FileTypeSymbol>()
.WithQuery(() => f => new
{
Entity = f,
f.Key
});
}
}
internal SqlPreCommand?ImportXml(XElement element, Dictionary <string, Lite <RoleEntity> > roles, Replacements replacements)
{
var current = Database.RetrieveAll <RuleTypeEntity>().GroupToDictionary(a => a.Role);
var xRoles = (element.Element("Types")?.Elements("Role")).EmptyIfNull();
var should = xRoles.ToDictionary(x => roles.GetOrThrow(x.Attribute("Name").Value));
Table table = Schema.Current.Table(typeof(RuleTypeEntity));
replacements.AskForReplacements(
xRoles.SelectMany(x => x.Elements("Type")).Select(x => x.Attribute("Resource").Value).ToHashSet(),
TypeLogic.NameToType.Where(a => !a.Value.IsEnumEntity()).Select(a => a.Key).ToHashSet(), typeReplacementKey);
replacements.AskForReplacements(
xRoles.SelectMany(x => x.Elements("Type")).SelectMany(t => t.Elements("Condition")).Select(x => x.Attribute("Name").Value).ToHashSet(),
SymbolLogic <TypeConditionSymbol> .AllUniqueKeys(),
typeConditionReplacementKey);
Func <string, TypeEntity?> getResource = s =>
{
Type?type = TypeLogic.NameToType.TryGetC(replacements.Apply(typeReplacementKey, s));
if (type == null)
{
return(null);
}
return(TypeLogic.TypeToEntity.GetOrThrow(type));
};
return(Synchronizer.SynchronizeScript(Spacing.Double, should, current,
createNew: (role, x) =>
{
var dic = (from xr in x.Elements("Type")
let t = getResource(xr.Attribute("Resource").Value)
where t != null
select KVP.Create(t, new
{
Allowed = xr.Attribute("Allowed").Value.ToEnum <TypeAllowed>(),
Condition = Conditions(xr, replacements)
})).ToDictionaryEx("Type rules for {0}".FormatWith(role));
SqlPreCommand?restSql = dic.Select(kvp => table.InsertSqlSync(new RuleTypeEntity
{
Resource = kvp.Key,
Role = role,
Allowed = kvp.Value.Allowed,
Conditions = kvp.Value.Condition ! /*CSBUG*/
}, comment: Comment(role, kvp.Key, kvp.Value.Allowed))).Combine(Spacing.Simple)?.Do(p => p.GoBefore = true);
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
AuthLogic.AssertStarted(sb);
sb.Include <PermissionSymbol>();
SymbolLogic <PermissionSymbol> .Start(sb, () => RegisteredPermission.ToHashSet());
sb.Include <RulePermissionEntity>()
.WithUniqueIndex(rt => new { rt.Resource, rt.Role });
cache = new AuthCache <RulePermissionEntity, PermissionAllowedRule, PermissionSymbol, PermissionSymbol, bool>(sb,
toKey: p => p,
toEntity: p => p,
isEquals: (p1, p2) => p1 == p2,
merger: new PermissionMerger(),
invalidateWithTypes: false);
sb.Schema.EntityEvents <RoleEntity>().PreUnsafeDelete += query =>
{
Database.Query <RulePermissionEntity>().Where(r => query.Contains(r.Role.Entity)).UnsafeDelete();
return(null);
};
RegisterPermissions(BasicPermission.AdminRules,
BasicPermission.AutomaticUpgradeOfProperties,
BasicPermission.AutomaticUpgradeOfOperations,
BasicPermission.AutomaticUpgradeOfQueries);
AuthLogic.ExportToXml += exportAll => cache.ExportXml("Permissions", "Permission", a => a.Key, b => b.ToString(),
exportAll ? PermissionAuthLogic.RegisteredPermission.ToList() : null);
AuthLogic.ImportFromXml += (x, roles, replacements) =>
{
string replacementKey = "AuthRules:" + typeof(PermissionSymbol).Name;
replacements.AskForReplacements(
x.Element("Permissions").Elements("Role").SelectMany(r => r.Elements("Permission")).Select(p => p.Attribute("Resource").Value).ToHashSet(),
SymbolLogic <PermissionSymbol> .Symbols.Select(s => s.Key).ToHashSet(),
replacementKey);
return(cache.ImportXml(x, "Permissions", "Permission", roles,
s => SymbolLogic <PermissionSymbol> .TryToSymbol(replacements.Apply(replacementKey, s)), bool.Parse));
};
sb.Schema.Table <PermissionSymbol>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(AuthCache_PreDeleteSqlSync);
}
}
public static OperationSymbol TryGetOperationKeyAsset(this ControllerBase controller)
{
var operationFullKey = controller.ControllerContext.RequestContext.HttpContext.Request["operationFullKey"];
if (operationFullKey == null)
{
return(null);
}
var operationSymbol = SymbolLogic <OperationSymbol> .ToSymbol(operationFullKey);
OperationLogic.AssertOperationAllowed(operationSymbol, inUserInterface: true);
return(operationSymbol);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <FileTypeSymbol> .Start(sb, dqm, () => FileTypes.Keys.ToHashSet());
sb.Include <FileTypeSymbol>()
.WithQuery(dqm, () => f => new
{
Entity = f,
f.Key
});
sb.Schema.SchemaCompleted += Schema_SchemaCompleted;
}
}
public static Dictionary <string, TypeInfoTS> GetSymbolContainers(IEnumerable <Type> allTypes)
{
SymbolLogic.LoadAll();
var result = (from type in allTypes
where type.IsStaticClass() && type.HasAttribute <AutoInitAttribute>()
select KVP.Create(GetTypeName(type), OnAddTypeExtension(new TypeInfoTS
{
Kind = KindOfType.SymbolContainer,
Members = type.GetFields(staticFlags).Where(f => GetSymbol(f).IdOrNull.HasValue).ToDictionary(fi => fi.Name, fi => OnAddFieldInfoExtension(new MemberInfoTS
{
NiceName = fi.NiceName(),
Id = GetSymbol(fi).Id.Object
}, fi))
}, type))).ToDictionaryEx("symbols");
return(result);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <OperationLogEntity>();
SymbolLogic <OperationSymbol> .Start(sb, () => RegisteredOperations);
dqm.RegisterQuery(typeof(OperationSymbol), () =>
from os in Database.Query <OperationSymbol>()
select new
{
Entity = os,
os.Id,
os.Key
});
dqm.RegisterQuery(typeof(OperationLogEntity), () =>
from lo in Database.Query <OperationLogEntity>()
select new
{
Entity = lo,
lo.Id,
lo.Target,
lo.Operation,
lo.User,
lo.Start,
lo.End,
lo.Exception
});
dqm.RegisterExpression((OperationSymbol o) => o.Logs(), () => OperationMessage.Logs.NiceToString());
dqm.RegisterExpression((Entity o) => o.OperationLogs(), () => typeof(OperationLogEntity).NicePluralName());
sb.Schema.EntityEventsGlobal.Saving += EntityEventsGlobal_Saving;
sb.Schema.Table <OperationSymbol>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(Operation_PreDeleteSqlSync);
sb.Schema.Table <TypeEntity>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(Type_PreDeleteSqlSync);
sb.Schema.SchemaCompleted += OperationLogic_Initializing;
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <OperationLogEntity>()
.WithQuery(() => lo => new
{
Entity = lo,
lo.Id,
lo.Target,
lo.Operation,
lo.User,
lo.Start,
lo.End,
lo.Exception
});
SymbolLogic <OperationSymbol> .Start(sb, () => RegisteredOperations);
sb.Include <OperationSymbol>()
.WithQuery(() => os => new
{
Entity = os,
os.Id,
os.Key
});
QueryLogic.Expressions.Register((OperationSymbol o) => o.Logs(), () => OperationMessage.Logs.NiceToString());
QueryLogic.Expressions.Register((Entity o) => o.OperationLogs(), () => typeof(OperationLogEntity).NicePluralName());
sb.Schema.EntityEventsGlobal.Saving += EntityEventsGlobal_Saving;
sb.Schema.Table <OperationSymbol>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(Operation_PreDeleteSqlSync);
sb.Schema.Table <TypeEntity>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(Type_PreDeleteSqlSync);
sb.Schema.SchemaCompleted += OperationLogic_Initializing;
sb.Schema.SchemaCompleted += () => RegisterCurrentLogs(sb.Schema);
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var request = (OperationController.BaseOperationRequest)Activator.CreateInstance(objectType);
serializer.Populate(reader, request);
var operationSymbol = SymbolLogic <OperationSymbol> .ToSymbol(request.operationKey);
if (request.args != null)
{
for (int i = 0; i < request.args.Length; i++)
{
if (request.args[i] is JToken jtoken)
{
request.args[i] = ConvertObject(jtoken, serializer, operationSymbol);
}
}
}
return(request);
}
internal static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
SymbolLogic <SimpleTaskSymbol> .Start(sb, dqm, () => tasks.Keys.ToHashSet());
SchedulerLogic.ExecuteTask.Register((SimpleTaskSymbol st, ScheduledTaskContext ctx) =>
{
Func <ScheduledTaskContext, Lite <IEntity> > func = tasks.GetOrThrow(st);
return(func(ctx));
});
sb.Include <SimpleTaskSymbol>()
.WithQuery(dqm, () => ct => new
{
Entity = ct,
ct.Id,
ct.Key,
});
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
AuthLogic.AssertStarted(sb);
sb.Include <PermissionSymbol>();
SymbolLogic <PermissionSymbol> .Start(sb, dqm, () => RegisteredPermission.ToHashSet());
cache = new AuthCache <RulePermissionEntity, PermissionAllowedRule, PermissionSymbol, PermissionSymbol, bool>(sb,
s => s,
s => s,
merger: new PermissionMerger(),
invalidateWithTypes: false);
RegisterPermissions(BasicPermission.AdminRules,
BasicPermission.AutomaticUpgradeOfProperties,
BasicPermission.AutomaticUpgradeOfOperations,
BasicPermission.AutomaticUpgradeOfQueries);
AuthLogic.ExportToXml += exportAll => cache.ExportXml("Permissions", "Permission", a => a.Key, b => b.ToString(),
exportAll ? PermissionAuthLogic.RegisteredPermission.ToList() : null);
AuthLogic.ImportFromXml += (x, roles, replacements) =>
{
string replacementKey = "AuthRules:" + typeof(PermissionSymbol).Name;
replacements.AskForReplacements(
x.Element("Permissions").Elements("Role").SelectMany(r => r.Elements("Permission")).Select(p => p.Attribute("Resource").Value).ToHashSet(),
SymbolLogic <PermissionSymbol> .Symbols.Select(s => s.Key).ToHashSet(),
replacementKey);
return(cache.ImportXml(x, "Permissions", "Permission", roles,
s => SymbolLogic <PermissionSymbol> .TryToSymbol(replacements.Apply(replacementKey, s)), bool.Parse));
};
}
}
public PermissionSymbol?TryPermission(string permissionKey)
{
return(SymbolLogic <PermissionSymbol> .TryToSymbol(permissionKey));
}
static void RegisterTypes()
{
Navigator.AddSetting(new EmbeddedEntitySettings <TypeConditionRuleEmbedded>());
string viewPrefix = "~/authAdmin/Views/{0}.cshtml";
Navigator.AddSetting(new ModelEntitySettings <TypeRulePack>
{
PartialViewName = e => viewPrefix.FormatWith("types"),
MappingDefault = new EntityMapping <TypeRulePack>(false)
.SetProperty(m => m.Rules,
new MListDictionaryMapping <TypeAllowedRule, TypeEntity>(a => a.Resource,
new EntityMapping <TypeAllowedRule>(false)
.SetProperty(p => p.Allowed, ctx => new TypeAllowedAndConditions(
ParseTypeAllowed(ctx.Inputs.SubDictionary("Fallback")),
ctx.Inputs.SubDictionary("Conditions").IndexSubDictionaries().Select(d =>
new TypeConditionRuleEmbedded(
SymbolLogic <TypeConditionSymbol> .ToSymbol(d["ConditionName"]),
ParseTypeAllowed(d.SubDictionary("Allowed")))
).ToMList()))
))
});
RegisterSaveButton <TypeRulePack>("types", false);
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <WordTemplateEntity>()
.WithSave(WordTemplateOperation.Save)
.WithDelete(WordTemplateOperation.Delete)
.WithQuery(dqm, () => e => new
{
Entity = e,
e.Id,
e.Name,
e.Query,
e.Culture,
e.Template.Entity.FileName
});
PermissionAuthLogic.RegisterPermissions(WordTemplatePermission.GenerateReport);
SystemWordTemplateLogic.Start(sb, dqm);
SymbolLogic <WordTransformerSymbol> .Start(sb, dqm, () => Transformers.Keys.ToHashSet());
SymbolLogic <WordConverterSymbol> .Start(sb, dqm, () => Converters.Keys.ToHashSet());
sb.Include <WordTransformerSymbol>()
.WithQuery(dqm, () => f => new
{
Entity = f,
f.Key
});
sb.Include <WordConverterSymbol>()
.WithQuery(dqm, () => f => new
{
Entity = f,
f.Key
});
ToDataTableProviders.Add("Model", new ModelDataTableProvider());
ToDataTableProviders.Add("UserQuery", new UserQueryDataTableProvider());
ToDataTableProviders.Add("UserChart", new UserChartDataTableProvider());
dqm.RegisterExpression((SystemWordTemplateEntity e) => e.WordTemplates(), () => typeof(WordTemplateEntity).NiceName());
new Graph <WordTemplateEntity> .Execute(WordTemplateOperation.CreateWordReport)
{
CanExecute = et =>
{
if (et.SystemWordTemplate != null && SystemWordTemplateLogic.RequiresExtraParameters(et.SystemWordTemplate))
{
return(WordTemplateMessage._01RequiresExtraParameters.NiceToString(typeof(SystemWordTemplateEntity).NiceName(), et.SystemWordTemplate));
}
return(null);
},
Execute = (et, args) =>
{
throw new InvalidOperationException("UI-only operation");
}
}
.Register();
WordTemplatesLazy = sb.GlobalLazy(() => Database.Query <WordTemplateEntity>()
.ToDictionary(et => et.ToLite()), new InvalidateWith(typeof(WordTemplateEntity)));
TemplatesByQueryName = sb.GlobalLazy(() =>
{
return(WordTemplatesLazy.Value.Values.GroupToDictionary(a => a.Query.ToQueryName()));
}, new InvalidateWith(typeof(WordTemplateEntity)));
TemplatesByEntityType = sb.GlobalLazy(() =>
{
return((from wr in WordTemplatesLazy.Value.Values
let imp = DynamicQueryManager.Current.GetEntityImplementations(wr.Query.ToQueryName())
where !imp.IsByAll
from t in imp.Types
select KVP.Create(t, wr))
.GroupToDictionary(a => a.Key, a => a.Value));
}, new InvalidateWith(typeof(WordTemplateEntity)));
Schema.Current.Synchronizing += Schema_Synchronize_Tokens;
Validator.PropertyValidator((WordTemplateEntity e) => e.Template).StaticPropertyValidation += ValidateTemplate;
}
}
public static WikiLink LinkParser(string content)
{
Match m = HelpLogic.HelpLinkRegex.Match(content);
if (m.Success)
{
string letter = m.Groups["letter"].ToString();
string link = m.Groups["link"].ToString();
string text = m.Groups["text"].ToString();
switch (letter)
{
case WikiFormat.EntityLink:
Type t = TypeLogic.TryGetType(link);
return(new WikiLink(
HelpUrls.EntityUrl(t),
text.HasText() ? text : t.NiceName()));
case WikiFormat.Hyperlink:
return(new WikiLink(link, text));
case WikiFormat.OperationLink:
OperationSymbol operation = SymbolLogic <OperationSymbol> .TryToSymbol(link);
List <Type> types = OperationLogic.FindTypes(operation).Where(TypeLogic.TypeToEntity.ContainsKey).ToList();
if (types.Count == 1)
{
return(new WikiLink(
HelpUrls.OperationUrl(types[0], operation),
text.HasText() ? text : operation.NiceToString()));
}
else
{
return(new MultiWikiLink(operation.NiceToString())
{
Links = types.Select(currentType =>
new WikiLink(
HelpUrls.OperationUrl(currentType, operation),
currentType.NiceName(), operation.NiceToString())).ToList()
});
}
case WikiFormat.PropertyLink:
PropertyRoute route = PropertyRoute.Parse(TypeLogic.TryGetType(link.Before('.')), link.After('.'));
while (route.PropertyRouteType == PropertyRouteType.LiteEntity ||
route.PropertyRouteType == PropertyRouteType.Mixin ||
route.PropertyRouteType == PropertyRouteType.MListItems)
{
route = route.Parent;
}
return(new WikiLink(HelpUrls.PropertyUrl(route), route.PropertyInfo.NiceName()));
case WikiFormat.QueryLink:
object o = QueryLogic.TryToQueryName(link);
if (o as Enum != null)
{
Enum query = (Enum)o;
return(new WikiLink(
HelpUrls.QueryUrl(query),
text.HasText() ? text : QueryUtils.GetNiceName(query)));
}
else
{
Type query = (Type)o;
return(new WikiLink(
HelpUrls.QueryUrl(query),
text.HasText() ? text : QueryUtils.GetNiceName(query)));
}
case WikiFormat.NamespaceLink:
NamespaceHelp nameSpace = HelpLogic.GetNamespaceHelp(link);
return(new WikiLink(
HelpUrls.NamespaceUrl(link),
text.HasText() ? text : link,
nameSpace != null ? "" : "unavailable"));
case WikiFormat.AppendixLink:
AppendixHelp appendix = HelpLogic.GetAppendixHelp(link);
return(new WikiLink(
HelpUrls.AppendixUrl(link),
text.HasText() ? text : link,
appendix != null ? "" : "unavailable"));
}
}
return(null);
}
static string SynchronizeContent(string content, Replacements r, SyncData data)
{
if (content == null)
{
return(null);
}
return(WikiMarkup.WikiParserExtensions.TokenRegex.Replace(content, m =>
{
var m2 = HelpLinkRegex.Match(m.Groups["content"].Value);
if (!m2.Success)
{
return m.Value;
}
string letter = m2.Groups["letter"].Value;
string link = m2.Groups["link"].Value;
string text = m2.Groups["text"].Value;
switch (letter)
{
case WikiFormat.EntityLink:
{
string type = r.SelectInteractive(link, TypeLogic.NameToType.Keys, "Type", data.StringDistance);
if (type == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, type, text);
}
case WikiFormat.PropertyLink:
{
string type = r.SelectInteractive(link.Before("."), TypeLogic.NameToType.Keys, "Type", data.StringDistance);
if (type == null)
{
return Link(letter + "-error", link, text);
}
var routes = PropertyRoute.GenerateRoutes(TypeLogic.GetType(type)).Select(a => a.PropertyString()).ToList();
string pr = r.SelectInteractive(link.After('.'), routes, "PropertyRoutes-" + type, data.StringDistance);
if (pr == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, type + "." + pr, text);
}
case WikiFormat.QueryLink:
{
string query = r.SelectInteractive(link, QueryLogic.QueryNames.Keys, "Query", data.StringDistance);
if (query == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, query, text);
}
case WikiFormat.OperationLink:
{
string operation = r.SelectInteractive(link, SymbolLogic <OperationSymbol> .AllUniqueKeys(), "Operation", data.StringDistance);
if (operation == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, operation, text);
}
case WikiFormat.Hyperlink: return m.Value;
case WikiFormat.NamespaceLink:
{
string @namespace = r.SelectInteractive(link, data.Namespaces, "Namespace", data.StringDistance);
if (@namespace == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, @namespace, text);
}
case WikiFormat.AppendixLink:
{
string appendix = r.SelectInteractive(link, data.Appendices, "Appendices", data.StringDistance);
if (appendix == null)
{
return Link(letter + "-error", link, text);
}
return Link(letter, appendix, text);
}
default:
break;
}
return m.Value;
}));
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <ProcessAlgorithmSymbol>()
.WithQuery(dqm, () => pa => new
{
Entity = pa,
pa.Id,
pa.Key
});
sb.Include <ProcessEntity>()
.WithQuery(dqm, () => p => new
{
Entity = p,
p.Id,
p.Algorithm,
p.Data,
p.State,
p.MachineName,
p.ApplicationName,
p.CreationDate,
p.PlannedDate,
p.CancelationDate,
p.QueuedDate,
p.ExecutionStart,
p.ExecutionEnd,
p.SuspendDate,
p.ExceptionDate,
});
sb.Include <ProcessExceptionLineEntity>()
.WithQuery(dqm, () => p => new
{
Entity = p,
p.Line,
p.Process,
p.Exception,
});
PermissionAuthLogic.RegisterPermissions(ProcessPermission.ViewProcessPanel);
SymbolLogic <ProcessAlgorithmSymbol> .Start(sb, dqm, () => registeredProcesses.Keys.ToHashSet());
OperationLogic.AssertStarted(sb);
ProcessGraph.Register();
dqm.RegisterExpression((ProcessAlgorithmSymbol p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName());
dqm.RegisterExpression((ProcessAlgorithmSymbol p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString());
dqm.RegisterExpression((IProcessDataEntity p) => p.Processes(), () => typeof(ProcessEntity).NicePluralName());
dqm.RegisterExpression((IProcessDataEntity p) => p.LastProcess(), () => ProcessMessage.LastProcess.NiceToString());
dqm.RegisterExpression((IProcessLineDataEntity p) => p.ExceptionLines(), () => ProcessMessage.ExceptionLines.NiceToString());
PropertyAuthLogic.AvoidAutomaticUpgradeCollection.Add(PropertyRoute.Construct((ProcessEntity p) => p.User));
ExceptionLogic.DeleteLogs += ExceptionLogic_DeleteLogs;
}
}
public static void Start(bool file, bool embeddedFile, bool filePath, bool embeddedFilePath)
{
if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod()))
{
Navigator.RegisterArea(typeof(FilesClient));
UrlsRepository.DefaultSFUrls.AddRange(new Dictionary <string, Func <UrlHelper, string> >
{
{ "uploadFile", url => url.Action <FileController>(fc => fc.Upload()) },
{ "uploadDroppedFile", url => url.Action <FileController>(fc => fc.UploadDropped()) },
});
if (file)
{
RegisterFileConstructor <FileEntity>(data =>
{
return(new FileEntity {
FileName = data.FileName, BinaryFile = data.Content
}.Save());
});
RegisterDownloadUrlConstructor <FileEntity>(fp =>
{
return(RouteHelper.New().Action((FileController fc) => fc.Download(new RuntimeInfo(fp).ToString())));
});
RegisterFileDownloadResult <FileEntity>(ri =>
{
FileEntity f = (FileEntity)ri.ToLite().Retrieve();
return(new StaticContentResult(f.BinaryFile, f.FileName));
});
var es = new EntitySettings <FileEntity>();
Navigator.AddSetting(es);
var baseMapping = (Mapping <FileEntity>)es.MappingLine.AsEntityMapping().RemoveProperty(fp => fp.BinaryFile);
es.MappingLine = ctx =>
{
RuntimeInfo runtimeInfo = ctx.GetRuntimeInfo();
if (runtimeInfo == null)
{
return(null);
}
else
{
if (runtimeInfo.IsNew)
{
HttpPostedFileBase hpf = GetHttpRequestFile(ctx);
if (hpf != null)
{
return(new FileEntity
{
FileName = Path.GetFileName(hpf.FileName),
BinaryFile = hpf.InputStream.ReadAllBytes()
});
}
else
{
throw new InvalidOperationException("Impossible to create new FileEntity {0}".FormatWith(ctx.Prefix));
}
}
else
{
return(baseMapping(ctx));
}
}
};
FileLogic.DownloadFileUrl = DownloadFileUrl;
var lm = new LiteMapping <FileEntity>();
lm.EntityHasChanges = ctx => ctx.GetRuntimeInfo().IsNew;
Mapping.RegisterValue <Lite <FileEntity> >(lm.GetValue);
}
if (embeddedFile)
{
RegisterFileConstructor <FileEmbedded>(data =>
{
return(new FileEmbedded {
FileName = data.FileName, BinaryFile = data.Content
});
});
var es = new EmbeddedEntitySettings <FileEmbedded>();
Navigator.AddSetting(es);
var baseMapping = (Mapping <FileEmbedded>)es.MappingDefault.AsEntityMapping().RemoveProperty(fp => fp.BinaryFile);
es.MappingDefault = ctx =>
{
RuntimeInfo runtimeInfo = ctx.GetRuntimeInfo();
if (runtimeInfo == null)
{
return(null);
}
else
{
HttpPostedFileBase hpf = GetHttpRequestFile(ctx);
if (hpf != null && hpf.ContentLength != 0)
{
return(new FileEmbedded()
{
FileName = Path.GetFileName(hpf.FileName),
BinaryFile = hpf.InputStream.ReadAllBytes()
});
}
else if (ctx.Inputs.ContainsKey(EntityBaseKeys.EntityState))
{
return((FileEmbedded)Navigator.Manager.DeserializeEntity(ctx.Inputs[EntityBaseKeys.EntityState]));
}
else
{
return(baseMapping(ctx));
}
}
};
}
if (filePath)
{
RegisterFileConstructor <FilePathEntity>(data =>
{
if (!data.FileType.HasText())
{
throw new InvalidOperationException("Couldn't create FilePath with unknown FileType for file '{0}'".FormatWith(data.FileName));
}
return(new FilePathEntity(SymbolLogic <FileTypeSymbol> .ToSymbol(data.FileType))
{
FileName = data.FileName,
BinaryFile = data.Content,
CalculatedDirectory = data.CalculatedDirectory
}.Save());
});
RegisterDownloadUrlConstructor <FilePathEntity>(fp =>
{
return(RouteHelper.New().Action((FileController fc) => fc.Download(new RuntimeInfo(fp).ToString())));
});
RegisterFileDownloadResult <FilePathEntity>(ri =>
{
FilePathEntity fp = (FilePathEntity)ri.ToLite().Retrieve();
return(new FilePathResult(fp.FullPhysicalPath(), MimeMapping.GetMimeMapping(fp.FullPhysicalPath()))
{
FileDownloadName = fp.FileName
});
});
Navigator.AddSettings(new List <EntitySettings>
{
new EntitySettings <FilePathEntity> {
PartialViewName = e => ViewPrefix.FormatWith("FilePath")
},
});
var es = Navigator.EntitySettings <FilePathEntity>();
var baseMapping = (Mapping <FilePathEntity>)es.MappingLine.AsEntityMapping().RemoveProperty(fp => fp.BinaryFile);
es.MappingLine = ctx =>
{
RuntimeInfo runtimeInfo = ctx.GetRuntimeInfo();
if (runtimeInfo == null)
{
return(null);
}
else
{
if (runtimeInfo.IsNew)
{
HttpPostedFileBase hpf = GetHttpRequestFile(ctx);
if (hpf != null)
{
string fileType = ctx.Inputs[FileLineKeys.FileType];
return(new FilePathEntity(SymbolLogic <FileTypeSymbol> .ToSymbol(fileType))
{
FileName = Path.GetFileName(hpf.FileName),
BinaryFile = hpf.InputStream.ReadAllBytes(),
});
}
else
{
throw new InvalidOperationException("Impossible to create new FilePath {0}".FormatWith(ctx.Prefix));
}
}
else
{
return(baseMapping(ctx));
}
}
};
es.MappingMain = es.MappingLine;
var lm = new LiteMapping <FilePathEntity>();
lm.EntityHasChanges = ctx => ctx.GetRuntimeInfo().IsNew;
Mapping.RegisterValue <Lite <FilePathEntity> >(lm.GetValue);
}
if (embeddedFilePath)
{
RegisterFileConstructor <FilePathEmbedded>(data =>
{
if (!data.FileType.HasText())
{
throw new InvalidOperationException("Couldn't create FilePath with unknown FileType for file '{0}'".FormatWith(data.FileName));
}
return(new FilePathEmbedded(SymbolLogic <FileTypeSymbol> .ToSymbol(data.FileType))
{
FileName = data.FileName,
BinaryFile = data.Content,
CalculatedDirectory = data.CalculatedDirectory
}.SaveFile());
});
RegisterDownloadUrlConstructor <FilePathEmbedded>(fp =>
{
return(RouteHelper.New().Action((FileController fc) => fc.DownloadEmbedded(fp.FileType.ToLite(), fp.Suffix, fp.FileName)));
});
Navigator.AddSettings(new List <EntitySettings>
{
new EmbeddedEntitySettings <FilePathEmbedded> {
PartialViewName = e => ViewPrefix.FormatWith("EmbeddedFilePath")
},
});
var es = Navigator.EmbeddedEntitySettings <FilePathEmbedded>();
var baseMapping = (Mapping <FilePathEmbedded>)es.MappingDefault.AsEntityMapping().RemoveProperty(fp => fp.BinaryFile);
es.MappingDefault = ctx =>
{
RuntimeInfo runtimeInfo = ctx.GetRuntimeInfo();
if (runtimeInfo == null)
{
return(null);
}
else
{
HttpPostedFileBase hpf = GetHttpRequestFile(ctx);
if (hpf != null)
{
string fileType = ctx.Inputs[FileLineKeys.FileType];
return(new FilePathEmbedded(SymbolLogic <FileTypeSymbol> .ToSymbol(fileType))
{
FileName = Path.GetFileName(hpf.FileName),
BinaryFile = hpf.InputStream.ReadAllBytes(),
});
}
else if (ctx.Inputs.ContainsKey(EntityBaseKeys.EntityState))
{
return((FilePathEmbedded)Navigator.Manager.DeserializeEntity(ctx.Inputs[EntityBaseKeys.EntityState]));
}
else
{
return(baseMapping(ctx));
}
}
};
}
if (filePath || embeddedFilePath)
{
Navigator.AddSetting(new EntitySettings <FileTypeSymbol>());
}
var dqm = DynamicQueryManager.Current;
QuerySettings.FormatRules.Add(new FormatterRule("WebImage",
col => col.Type == typeof(WebImage),
col => new CellFormatter((help, obj) =>
(obj == null || ((WebImage)obj)?.FullWebPath.HasText() == false) ? null :
new HtmlTag("img")
.Attr("src", RouteHelper.New().Content(((WebImage)obj).FullWebPath))
.Attr("alt", typeof(WebImage).NiceName())
.Attr("style", "width:80px").ToHtmlSelf())
{
TextAlign = "center"
}
));
QuerySettings.FormatRules.Add(new FormatterRule("WebDownload",
col => col.Type == typeof(WebDownload),
col => new CellFormatter((help, obj) => ((WebDownload)obj)?.FullWebPath.HasText() == false ? null :
new MvcHtmlString("<a href='{0}'>{1}</a>".FormatWith(RouteHelper.New().Content(((WebDownload)obj).FullWebPath), ((WebDownload)obj).FileName ?? typeof(WebDownload).NiceName())))
{
TextAlign = "center"
}
));
}
}