public Dictionary <PropertyRoute, Implementations> FindAllImplementations(Type root)
{
try
{
if (!Tables.ContainsKey(root))
{
return(null);
}
var table = Table(root);
return(PropertyRoute.GenerateRoutes(root)
.Select(r => r.Type.IsMList() ? r.Add("Item") : r)
.Where(r => r.Type.CleanType().IsIEntity())
.ToDictionary(r => r, r => FindImplementations(r)));
}
catch (Exception e)
{
e.Data["rootType"] = root.TypeName();
throw;
}
}
static SqlPreCommand SynchronizeTypes(Replacements replacements, SyncData data)
{
var dic = Database.Query <EntityHelpEntity>().ToList();
if (dic.IsEmpty())
{
return(null);
}
var typesByTableName = Schema.Current.Tables.ToDictionary(kvp => kvp.Value.Name.Name, kvp => kvp.Key);
var replace = replacements.TryGetC(Replacements.KeyTables);
var table = Schema.Current.Table <EntityHelpEntity>();
using (replacements.WithReplacedDatabaseName())
return(dic.Select(eh =>
{
Type type = typesByTableName.TryGetC(replace.TryGetC(eh.Type.TableName) ?? eh.Type.TableName);
if (type == null)
{
return null; //PreDeleteSqlSync
}
var repProperties = replacements.TryGetC(PropertyRouteLogic.PropertiesFor.FormatWith(type.FullName));
var routes = PropertyRoute.GenerateRoutes(type).ToDictionary(pr => { var ps = pr.PropertyString(); return repProperties.TryGetC(ps) ?? ps; });
eh.Properties.RemoveAll(p => !routes.ContainsKey(p.Property.Path));
foreach (var prop in eh.Properties)
{
prop.Description = SynchronizeContent(prop.Description, replacements, data);
}
eh.Description = SynchronizeContent(eh.Description, replacements, data);
return table.UpdateSqlSync(eh);
}).Combine(Spacing.Simple));
}
public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
AuthLogic.AssertStarted(sb);
PropertyRouteLogic.Start(sb);
sb.Include <RulePropertyEntity>()
.WithUniqueIndex(rt => new { rt.Resource, rt.Role });
cache = new AuthCache <RulePropertyEntity, PropertyAllowedRule, PropertyRouteEntity, PropertyRoute, PropertyAllowed>(sb,
toKey: PropertyRouteEntity.ToPropertyRouteFunc,
toEntity: PropertyRouteLogic.ToPropertyRouteEntity,
isEquals: (p1, p2) => p1 == p2,
merger: new PropertyMerger(),
invalidateWithTypes: true,
coercer: PropertyCoercer.Instance);
sb.Schema.EntityEvents <RoleEntity>().PreUnsafeDelete += query =>
{
Database.Query <RulePropertyEntity>().Where(r => query.Contains(r.Role.Entity)).UnsafeDelete();
return(null);
};
PropertyRoute.SetIsAllowedCallback(pp => pp.GetAllowedFor(PropertyAllowed.Read));
AuthLogic.ExportToXml += exportAll => cache.ExportXml("Properties", "Property", p => TypeLogic.GetCleanName(p.RootType) + "|" + p.PropertyString(), pa => pa.ToString(),
exportAll ? TypeLogic.TypeToEntity.Keys.SelectMany(t => PropertyRoute.GenerateRoutes(t)).ToList() : null);
AuthLogic.ImportFromXml += (x, roles, replacements) =>
{
Dictionary <Type, Dictionary <string, PropertyRoute> > routesDicCache = new Dictionary <Type, Dictionary <string, PropertyRoute> >();
var groups = x.Element("Properties").Elements("Role").SelectMany(r => r.Elements("Property")).Select(p => new PropertyPair(p.Attribute("Resource").Value))
.AgGroupToDictionary(a => a.Type, gr => gr.Select(pp => pp.Property).ToHashSet());
foreach (var item in groups)
{
Type?type = TypeLogic.NameToType.TryGetC(replacements.Apply(TypeAuthCache.typeReplacementKey, item.Key));
if (type == null)
{
continue;
}
var dic = PropertyRoute.GenerateRoutes(type).ToDictionary(a => a.PropertyString());
replacements.AskForReplacements(
item.Value,
dic.Keys.ToHashSet(),
AuthPropertiesReplacementKey(type));
routesDicCache[type] = dic;
}
var routes = Database.Query <PropertyRouteEntity>().ToDictionary(a => a.ToPropertyRoute());
return(cache.ImportXml(x, "Properties", "Property", roles, s =>
{
var pp = new PropertyPair(s);
Type?type = TypeLogic.NameToType.TryGetC(replacements.Apply(TypeAuthCache.typeReplacementKey, pp.Type));
if (type == null)
{
return null;
}
PropertyRoute?route = routesDicCache[type].TryGetC(replacements.Apply(AuthPropertiesReplacementKey(type), pp.Property));
if (route == null)
{
return null;
}
var property = routes.GetOrCreate(route, () => new PropertyRouteEntity
{
RootType = TypeLogic.TypeToEntity[route.RootType],
Path = route.PropertyString()
}.Save());
return property;
}, EnumExtensions.ToEnum <PropertyAllowed>));
};
sb.Schema.Table <PropertyRouteEntity>().PreDeleteSqlSync += new Func <Entity, SqlPreCommand>(AuthCache_PreDeleteSqlSync);
}
}
public static AuthThumbnail?GetAllowedThumbnail(Lite <RoleEntity> role, Type entityType)
{
return(PropertyRoute.GenerateRoutes(entityType).Select(pr => cache.GetAllowed(role, pr)).Collapse());
}
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 EntityHelp(Type type, CultureInfo culture, EntityHelpEntity entity)
{
Type = type;
Culture = culture;
Info = HelpGenerator.GetEntityHelp(type);
Properties = PropertyRoute.GenerateRoutes(type)
.ToDictionary(
pp => pp,
pp => new PropertyHelp(pp, HelpGenerator.GetPropertyHelp(pp)));
var allOperations = HelpLogic.CachedOperationsHelp();
Operations = OperationLogic.GetAllOperationInfos(type).Select(oi => allOperations.GetOrThrow(oi.OperationSymbol)).ToDictionary(a => a.OperationSymbol);
var allQueries = HelpLogic.CachedQueriesHelp();
Queries = HelpLogic.TypeToQuery.Value.TryGetC(this.Type).EmptyIfNull().Select(a => allQueries.GetOrThrow(a)).ToDictionary(qh => qh.QueryName);
if (entity != null)
{
HasEntity = true;
Description = entity.Description;
foreach (var tranProp in entity.Properties)
{
Properties.GetOrThrow(tranProp.Property.ToPropertyRoute()).UserDescription = tranProp.Description;
}
foreach (var transOper in entity.Operations)
{
Operations.GetOrThrow(transOper.Operation).UserDescription = transOper.Description;
}
}
Entity = new Lazy <EntityHelpEntity>(() => HelpLogic.GlobalContext(() =>
{
if (entity == null)
{
entity = new EntityHelpEntity
{
Culture = this.Culture.ToCultureInfoEntity(),
Type = this.Type.ToTypeEntity(),
}
}
;
entity.Properties.AddRange(
PropertyRouteLogic.RetrieveOrGenerateProperties(this.Type.ToTypeEntity())
.Except(entity.Properties.Select(a => a.Property))
.Select(pr => new PropertyRouteHelpEmbedded
{
Property = pr,
Description = null,
}));
entity.Operations.AddRange(this.Operations.Values.Select(o => o.Entity.Value).ToList());
entity.Queries.AddRange(this.Queries.Values.Select(a => a.Entity.Value).ToList());
return(entity);
}));
}