Пример #1
0
        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);
            }
        }
Пример #2
0
        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));
                };
            }
        }