public PermissionResolver(AzManager azManager, IPermissionProvider permissionProvider)
{
if (azManager == null) throw new ArgumentNullException("azManager");
if (permissionProvider == null) throw new ArgumentNullException("permissionProvider");
this.azManager = azManager;
}
public AzManager(IRoleProvider roleProvider, IPermissionProvider permissionProvider)
: this()
{
if (roleProvider == null) throw new ArgumentNullException("roleProvider");
if (permissionProvider == null) throw new ArgumentNullException("permissionProvider");
this.roleProvider = roleProvider;
this.permissionProvider = permissionProvider;
}
public AuthorizationService(
IRepository<UserGroup> userGroupRepository,
IAuthorizationRule[] rules,
IPermissionProvider[] providers
)
{
this.userGroupRepository = userGroupRepository;
this.rules = rules;
this.providers = providers;
}
public static string ConvertPermissionProviderToXml(IPermissionProvider permissionProvider)
{
var xmlString = new StringBuilder();
xmlString.AppendFormat("<{0}>", "permissionProvider");
#region Permissions
xmlString.AppendFormat("<{0}>", "permissions");
foreach(var permission in permissionProvider.GetPermissions())
{
xmlString.Append(SerializePermission(permission));
}
xmlString.AppendFormat("</{0}>", "permissions");
#endregion
#region Default Permissions
xmlString.AppendFormat("<{0}>", "defaultPermissions");
foreach (var defaultPermission in permissionProvider.GetDefaultPermissions())
{
xmlString.AppendLine(SerializeDefaultPermission(defaultPermission));
}
xmlString.AppendFormat("</{0}>", "defaultPermissions");
#endregion
xmlString.AppendFormat("</{0}>", "permissionProvider");
return xmlString.ToString();
}
public void UninstallPermissions(IPermissionProvider permissionProvider)
{
throw new NotImplementedException();
}
public ConfigController(IPermissionProvider permissionManage,
IAdminUser adminUserRepository, ISysSetting systemSettingService)
: base(permissionManage, adminUserRepository)
{
_systemSettingService = systemSettingService;
}
/// <summary>
/// CTOR
/// </summary>
/// <param name="permissionProvider"></param>
/// <param name="authenticationManager"></param>
public PermissionManager(IPermissionProvider permissionProvider, IAuthenticationManager authenticationManager)
{
_permissionProvider = permissionProvider;
_authenticationManager = authenticationManager;
}
protected abstract void UpdatePermission(IUser user, IPermissionProvider permissions,
IPermissionEntity target, string permissionToUpdate);
internal CachingPermissionProvider(IPermissionProvider inner)
{
this.inner = inner;
}
/// <summary>
/// Uninstall permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void Uninstall(IPermissionProvider permissionProvider)
{
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetBySystemName(permission.SystemName);
if (permission1 != null)
{
Delete(permission1);
}
}
}
static void RegisterPermissions(UserSecurityContext context)
{
IPermissionProvider perms = AuthorizationManager.Instance.GetPermissionProvider(context);
Permission p;
if (!perms.Exists(InstrumentUtils.InstrumentTypeCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "InstrumentType"), InstrumentUtils.InstrumentTypeCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentTypeCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentTypeGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "InstrumentType"), InstrumentUtils.InstrumentTypeGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentTypeGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentTypeUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "InstrumentType"), InstrumentUtils.InstrumentTypeUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentTypeUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentTypeDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "InstrumentType"), InstrumentUtils.InstrumentTypeDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentTypeDeletePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentFamilyCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "InstrumentFamily"), InstrumentUtils.InstrumentFamilyCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentFamilyCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentFamilyGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "InstrumentFamily"), InstrumentUtils.InstrumentFamilyGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentFamilyGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentFamilyUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "InstrumentFamily"), InstrumentUtils.InstrumentFamilyUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentFamilyUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentFamilyDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "InstrumentFamily"), InstrumentUtils.InstrumentFamilyDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentFamilyDeletePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "Instrument"), InstrumentUtils.InstrumentCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "Instrument"), InstrumentUtils.InstrumentGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "Instrument"), InstrumentUtils.InstrumentUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "Instrument"), InstrumentUtils.InstrumentDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentDeletePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorTypeCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "SensorType"), InstrumentUtils.SensorTypeCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorTypeCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorTypeGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "SensorType"), InstrumentUtils.SensorTypeGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorTypeGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorTypeUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "SensorType"), InstrumentUtils.SensorTypeUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorTypeUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorTypeDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "SensorType"), InstrumentUtils.SensorTypeDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorTypeDeletePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "Sensor"), InstrumentUtils.SensorCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "Sensor"), InstrumentUtils.SensorGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "Sensor"), InstrumentUtils.SensorUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.SensorDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "Sensor"), InstrumentUtils.SensorDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.SensorDeletePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentKnownArchetypeCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "InstrumentKnownArchetype"), InstrumentUtils.InstrumentKnownArchetypeCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentKnownArchetypeCreatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentKnownArchetypeGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "InstrumentKnownArchetype"), InstrumentUtils.InstrumentKnownArchetypeGetPermissionId);
Console.Write("Registering Permission: Get " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentKnownArchetypeGetPermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentKnownArchetypeUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "InstrumentKnownArchetype"), InstrumentUtils.InstrumentKnownArchetypeUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentKnownArchetypeUpdatePermissionId));
}
if (!perms.Exists(InstrumentUtils.InstrumentKnownArchetypeDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "InstrumentKnownArchetype"), InstrumentUtils.InstrumentKnownArchetypeDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(InstrumentUtils.InstrumentKnownArchetypeDeletePermissionId));
}
}
public PermissionValidator(IPermissionProvider permissionProvider, ILogger logger)
{
_permissionProvider = permissionProvider.NotNull();
_logger = logger.NotNull();
}
public PledgeController(IServiceProvider services, IPermissionProvider <Pledge, PledgeCreateModel> pledgePermissionProvider) : base(services)
{
_pledgePermissionProvider = pledgePermissionProvider;
}
public EntWebController(IPermissionProvider permissionProvider, IEntWechatServices entWechatServices)
{
_permissionProvider = permissionProvider;
_entWechatServices = entWechatServices;
}
public void Execute(ICommandContext context)
{
ICommandProvider cmdProvider = context.Container.Resolve <ICommandProvider>();
ICommandHandler cmdHandler = context.Container.Resolve <ICommandHandler>();
IPermissionProvider permissionProvider = context.Container.Resolve <IPermissionProvider>();
string rootPrefix = context.RootContext.CommandPrefix;
IEnumerable <ICommand> childs = cmdProvider.Commands.OrderBy(c => c.Name);
if (context.Parameters.Length > 0)
{
ICommand cmd = null;
string prefix = rootPrefix;
int i = 0;
foreach (string commandNode in context.Parameters)
{
cmd = childs?.GetCommand(commandNode, context.User);
if (cmd == null || !HasAccess(cmd, context.User))
{
context.User.SendMessage("Command was not found: " + prefix + commandNode, Color.Red);
return;
}
childs = cmd.ChildCommands?.OrderBy(c => c.Name).Cast <ICommand>();
if (i != context.Parameters.Length - 1)
{
prefix += commandNode + " ";
}
i++;
}
context.User.SendMessage(GetCommandUsage(cmd, prefix), Color.Blue);
if (cmd.Description != null)
{
context.User.SendMessage(cmd.Description, Color.Cyan);
}
List <ICommand> childCommands =
(cmd.ChildCommands?.Cast <ICommand>().ToList() ?? new List <ICommand>())
.Where(c => HasAccess(c, context.User))
.OrderBy(c => c.Name)
.ToList();
if (childCommands.Count == 0)
{
return;
}
foreach (ICommand subCmd in childCommands)
{
context.User.SendMessage(GetCommandUsage(subCmd, rootPrefix + cmd.Name.ToLower() + " "),
Color.Blue);
}
return;
}
context.User.SendMessage("Available commands: ", Color.Green);
foreach (ICommand cmd in cmdProvider.Commands.OrderBy(c => c.Name))
{
if (HasAccess(cmd, context.User))
{
context.User.SendMessage(GetCommandUsage(cmd, rootPrefix), Color.Blue);
}
}
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
//NB Can we find a way to automatically delete permissions?
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetSystemPermissionBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new SystemPermission
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
DateCreated = DateTime.UtcNow,
DateUpdated = DateTime.UtcNow
};
//save new permission
InsertSystemPermission(permission1);
//default customer role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var role = SystemUserService.GetSystemRoleBySystemName(defaultPermission.RoleSystemName);
if (role == null)
{
//new role (save it)
role = new SystemRole
{
Name = defaultPermission.RoleSystemName,
Active = true,
SystemName = defaultPermission.RoleSystemName,
DateCreated = DateTime.UtcNow,
DateModified = DateTime.UtcNow
};
SystemUserService.InsertRole(role);
}
role = SystemUserService.GetSystemRoleById(role.SystemRoleId, false);
var defaultMappingProvided = (from p in defaultPermission.SystemPermissions
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in role.SystemRolePermissions.Select(rpr => rpr.SystemPermission)
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
InsertSystemRolePermission(new SystemRolePermission
{
DateCreated = DateTime.UtcNow,
SystemRoleId = role.SystemRoleId,
SystemPermissionId = permission1.SystemPermissionId
});
}
}
}
}
ClearCache();
}
public OpenController(IPermmisionService permmisionService, IPermissionProvider permissionProvider)
{
_permmisionService = permmisionService;
_permissionProvider = permissionProvider;
}
public BaseController(IPermissionProvider permissionProvider)
{
this.permissionProvider = permissionProvider;
}
public ProjectController(IServiceProvider services, IAvatarProvider avatar, IPermissionProvider <Project, ProjectCreateModel> permission) : base(services)
{
_avatar = avatar;
_permission = permission;
}
public WebController(IAccountPayService accountPayService, IPermissionProvider permissionProvider, IXiaoTuanService IXiaoTuanService)
{
_accountPayService = accountPayService;
_permissionProvider = permissionProvider;
_IXiaoTuanService = IXiaoTuanService;
}
public F2Controller(IPermissionProvider permissionProvider)
{
_permissionProvider = permissionProvider;
}
/// <summary>
/// Uninstall permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
/// <remarks></remarks>
public virtual void UninstallPermissions(IPermissionProvider permissionProvider)
{
//TODO:Stored procedure
}
public bool HandleCommand(IUser user, IPlayer player, string commandLine, string prefix)
{
GuardUser(user);
commandLine = commandLine.Trim();
string[] args = commandLine.Split(' ');
IDependencyContainer contextContainer = container.CreateChildContainer();
IRocketSettingsProvider settings = contextContainer.Resolve <IRocketSettingsProvider>();
if (settings.Settings.Logging.EnableCommandExecutionsLogs)
{
contextContainer.Resolve <ILogger>().LogInformation($"{user.ToString()} executed command: \"{commandLine}\"");
}
CommandContext context = new CommandContext(contextContainer,
user, player, prefix, null,
args[0], args.Skip(1).ToArray(), null, null);
ICommand target = context.Container.Resolve <ICommandProvider>()
.Commands.GetCommand(context.CommandAlias, user);
if (target == null)
{
return(false); // only return false when the command was not found
}
context.Command = target;
List <ICommand> tree = new List <ICommand> {
context.Command
};
context = GetChild(context, context, tree);
var permission = GetPermission(context);
#if !DEBUG
try
{
#endif
IPermissionProvider provider = container.Resolve <IPermissionProvider>();
if (provider.CheckPermission(user, permission) != PermissionResult.Grant)
{
var logger = container.Resolve <ILogger>();
logger.LogInformation($"{user.ToString()} does not have permissions to execute: \"{commandLine}\"");
throw new NotEnoughPermissionsException(user, permission);
}
context.Command.Execute(context);
#if !DEBUG
}
catch (Exception e)
{
if (e is ICommandFriendlyException exception)
{
exception.SendErrorMessage(context);
return(true);
}
context.User.SendMessage("An internal error occured.", Color.DarkRed);
throw new Exception($"Command {commandLine} of user {user.ToString()} caused an exception: ", e);
}
#endif
return(true);
}
public PermissionInstaller(IPermissionGroupService groupService, IPermissionGroupProvider groupProvider, IPermissionService permissionService, IPermissionProvider permissionProvider, IRoleService roleService)
{
_groupService = groupService;
_groupProvider = groupProvider;
_permissionService = permissionService;
_permissionProvider = permissionProvider;
_roleService = roleService;
}
public AppPrincipal(IPermissionProvider permissionProvider, IIdentity ntIdentity) :
base((ClaimsIdentity)ntIdentity)
{
_PermissionProvider = permissionProvider;
}
public AzManager(IRoleProvider roleProvider, IPermissionProvider permissionProvider)
: this()
{
this.roleProvider = roleProvider ?? throw new ArgumentNullException("roleProvider");
this.permissionProvider = permissionProvider ?? throw new ArgumentNullException("permissionProvider");
}
protected abstract Task UpdateGroupAsync(IUser user, IPermissionProvider permissions,
IUser targetUser, IPermissionGroup groupToUpdate);
public async Task InitAsync()
{
Container = new UnityDependencyContainer();
Container.AddTransient <IRuntime>(this);
Container.AddSingleton <ILogger, NullLogger>();
var assembly = typeof(Runtime).Assembly.FullName;
ReflectionExtensions.GetVersionIndependentName(assembly, out string extactedVersion);
Version version;
try
{
version = new Version(extactedVersion);
}
catch
{
Console.WriteLine("Failed to get RocketMod version.");
version = new Version(0, 0, 0, 0);
}
Container.Activate(typeof(RegistrationByConvention));
await Container.Resolve <ICommandProvider>().InitAsync();
var settingsProvider = Container.Resolve <IRocketConfigurationProvider>();
await settingsProvider.LoadAsync();
int p = (int)Environment.OSVersion.Platform;
bool isLinux = (p == 4) || (p == 6) || (p == 128);
string mode = settingsProvider.Configuration.Logging.ConsoleMode;
if (!mode.Equals("Compat", StringComparison.OrdinalIgnoreCase))
{
// use ANSI logging
if ((isLinux && mode.Equals("Default", StringComparison.OrdinalIgnoreCase)) || mode.Equals("ANSI", StringComparison.OrdinalIgnoreCase))
{
Container.AddSingleton <ILogger, AnsiConsoleLogger>("console_logger");
}
// use RGB logging (windows only)
//else if (!isLinux && (mode.Equals("Default", StringComparison.OrdinalIgnoreCase) || mode.Equals("RGB", StringComparison.OrdinalIgnoreCase)))
// Container.RegisterSingletonType<ILogger, RgbConsoleLogger>("console_logger");
}
IHost impl = Container.Resolve <IHost>();
Version = version;
string rocketInitializeMessage = "Initializing RocketMod Runtime v" + version;
impl.Console.WriteLine(rocketInitializeMessage, Color.DarkGreen);
impl.Console.WriteLine(@"
,:
,' |
/ :
--' /
\/ />/
/ <//_\
__/ /
)'-. /
./ :\
/.' '
'/'
+
'
`.
.-"" -
( |
. .- ' '.
((. )8:
.' / (_ )
_. :(. )8P `
. ( `-' ( `. .
. : ( .a8a)
/ _`(""a `a. )""'
((/ . ' )=='
(( ) .8"" +
(`'8a.( _( (
..-. `8P) ` ) +
-' ( -ab: )
' _ ` (8P""Ya
_(( )b -`. ) +
(8)(_.aP"" _a \( \ *
+ ) / (8P(88))
("" `"" `", Color.Cyan);
if (!Container.IsRegistered <ILogger>("default_file_logger"))
{
string logsDirectory = Path.Combine(WorkingDirectory, "Logs");
if (!Directory.Exists(logsDirectory))
{
Directory.CreateDirectory(logsDirectory);
}
Container.AddSingleton <ILogger, FileLogger>("default_file_logger");
FileLogger fl = (FileLogger)Container.Resolve <ILogger>("default_file_logger");
fl.File = Path.Combine(logsDirectory, "Rocket.log");
fl.LogInformation(rocketInitializeMessage, Color.DarkGreen);
}
IPermissionProvider permissions = Container.Resolve <IPermissionProvider>();
if (!Directory.Exists(WorkingDirectory))
{
Directory.CreateDirectory(WorkingDirectory);
}
await permissions.LoadAsync(this);
Container.Resolve <ILogger>().LogInformation($"Initializing host: {impl.Name}", Color.Green);
await impl.InitAsync(this);
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
/// <param name="reInstall">If true and the provider has already been installed, it will re add the permissions with the associated default permissions.
/// If not, nothing will be done with the permissions.</param>
/// <remarks></remarks>
public virtual void InstallPermissions(IPermissionProvider permissionProvider, bool reInstall = false)
{
var providerName = permissionProvider.GetType().Name;
if (reInstall)
{
_permissionsInstalledCollection.Remove(Query <PermissionInstalled> .EQ(x => x.Name, providerName));
}
else
if (_permissionsInstalledCollection.Count(Query <PermissionInstalled> .EQ(x => x.Name, providerName)) == 1)
{
return;
}
_permissionsInstalledCollection.Insert(new PermissionInstalled {
Name = providerName
});
foreach (var permission in permissionProvider.GetPermissions())
{
var existing = _permissionPecordCollection.FindOne(Query <PermissionRecord> .EQ(x => x.SystemName, permission.SystemName)) ?? new PermissionRecord();
existing.Category = permission.Category;
existing.Name = permission.Name;
existing.SystemName = permission.SystemName;
if (existing.Id == ObjectId.Empty)
{
_permissionPecordCollection.Insert(existing);
}
else
{
_permissionPecordCollection.Update(Query <PermissionRecord> .EQ(x => x.Id, existing.Id), Update <PermissionRecord> .Replace(existing));
}
}
foreach (var defaultPermission in permissionProvider.GetDefaultPermissions())
{
var role = _userRoleCollection.FindOne(Query <UserRole> .EQ(x => x.SystemName, defaultPermission.UserRoleSystemName));
if (role == null)
{
role = new UserRole
{
Active = true,
IsSystemRole = false,
Name = defaultPermission.UserRoleSystemName,
SystemName = defaultPermission.UserRoleSystemName
};
_userRoleCollection.Insert(role);
}
foreach (var defaultPermissionRecord in defaultPermission.PermissionRecords)
{
var dbPermissionRecord = _permissionPecordCollection.FindOne(Query <PermissionRecord> .EQ(x => x.SystemName, defaultPermissionRecord.SystemName));
if (dbPermissionRecord == null)
{
throw new InvalidOperationException("The permission provider " + providerName + " is trying to install a default permission for permission " + defaultPermissionRecord.SystemName + " but it isn't provided via GetDefaultPermissions or another IPermissionProvider");
}
var query = Query.And(Query <RolePermissionMap> .EQ(x => x.PermissionRecordId, dbPermissionRecord.Id), Query <RolePermissionMap> .EQ(x => x.UserRoleId, role.Id));
var existing = _rolePermissionMapCollection.FindOne(query);
if (existing != null)
{
continue;
}
_rolePermissionMapCollection.Insert(new RolePermissionMap
{
PermissionRecordId = dbPermissionRecord.Id,
UserRoleId = role.Id
});
}
}
}
public PermissionController(IPermissionProvider permissionProvider)
: base(permissionProvider)
{
this.permissionProvider = permissionProvider;
}
/// <summary>
/// Uninstall permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
/// <remarks></remarks>
public virtual void UninstallPermissions(IPermissionProvider permissionProvider)
{
//TODO:Stored procedure
}
static void RegisterPermissions(UserSecurityContext context)
{
IPermissionProvider perms = AuthorizationManager.Instance.GetPermissionProvider(context);
Permission p;
if (!perms.Exists(ProjectUtils.ProjectCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "Project"), ProjectUtils.ProjectCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectCreatePermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "Project"), ProjectUtils.ProjectDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectDeletePermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "Project"), ProjectUtils.ProjectGetPermissionId);
Console.Write("Registering Permission: Retrive " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectGetPermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "Project"), ProjectUtils.ProjectUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectUpdatePermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectStatusTypeCreatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Create, "ProjectStatusType"), ProjectUtils.ProjectStatusTypeCreatePermissionId);
Console.Write("Registering Permission: Create " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectStatusTypeCreatePermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectStatusTypeDeletePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Delete, "ProjectStatusType"), ProjectUtils.ProjectStatusTypeDeletePermissionId);
Console.Write("Registering Permission: Delete " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectStatusTypeDeletePermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectStatusTypeGetPermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Retrive, "ProjectStatusType"), ProjectUtils.ProjectStatusTypeGetPermissionId);
Console.Write("Registering Permission: Retrive " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectStatusTypeGetPermissionId));
}
if (!perms.Exists(ProjectUtils.ProjectStatusTypeUpdatePermissionId))
{
p = new Permission(PermissionUtils.PermissionName(OperationType.Update, "ProjectStatusType"), ProjectUtils.ProjectStatusTypeUpdatePermissionId);
Console.Write("Registering Permission: Update " + p.Name + " ");
perms.RegisterPermission(p);
Console.WriteLine(perms.Exists(ProjectUtils.ProjectStatusTypeUpdatePermissionId));
}
}
protected abstract void UpdateGroup(IUser user, IPermissionProvider permissions,
IUserInfo targetUser, IPermissionGroup groupToUpdate);
private Task <IEnumerable <PermissionInfo> > GetProviderPermissions(IPermissionProvider provider)
{
return(Task.FromResult(provider.GetPermissions()));
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new PermissionRecord()
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
};
//default account role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var accountRole = _accountService.GetAccountRoleBySystemName(defaultPermission.AccountRoleSystemName);
if (accountRole == null)
{
//new role (save it)
accountRole = new AccountRole()
{
Name = defaultPermission.AccountRoleSystemName,
Active = true,
SystemName = defaultPermission.AccountRoleSystemName
};
_accountService.InsertAccountRole(accountRole);
}
var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in accountRole.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
permission1.AccountRoles.Add(accountRole);
}
}
//save new permission
InsertPermissionRecord(permission1);
}
}
}
public BaseController(IPermissionProvider permissionProvider, IAdminUser adminUserRepository)
{
this.permissionProvider = permissionProvider;
this.adminUserRepository = adminUserRepository;
}
/// <summary>
/// Uninstall permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void UninstallPermissions(IPermissionProvider permissionProvider)
{
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
if (permission1 != null)
{
DeletePermissionRecord(permission1);
//delete permission locales
permission1.DeleteLocalizedPermissionName(_localizationService, _languageService);
}
}
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
////install new permissions
//var permissions = permissionProvider.GetPermissions();
//foreach (var permission in permissions)
//{
// var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
// if (permission1 == null)
// {
// //new permission (install it)
// permission1 = new PermissionRecord
// {
// Name = permission.Name,
// SystemName = permission.SystemName,
// Category = permission.Category,
// };
// //default customer role mappings
// var defaultPermissions = permissionProvider.GetDefaultPermissions();
// foreach (var defaultPermission in defaultPermissions)
// {
// var customerRole = _userService.GetUserRoleBySystemName(defaultPermission.CustomerRoleSystemName);
// if (customerRole == null)
// {
// //new role (save it)
// customerRole = new UserRole
// {
// Name = defaultPermission.CustomerRoleSystemName,
// Active = true,
// SystemName = defaultPermission.CustomerRoleSystemName
// };
// _userService.InsertCustomerRole(customerRole);
// }
// var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
// where p.SystemName == permission1.SystemName
// select p).Any();
// var mappingExists = (from p in customerRole.PermissionRecords
// where p.SystemName == permission1.SystemName
// select p).Any();
// if (defaultMappingProvided && !mappingExists)
// {
// permission1.CustomerRoles.Add(customerRole);
// }
// }
// //save new permission
// InsertPermissionRecord(permission1);
// //save localization
// permission1.SaveLocalizedPermissionName(_localizationService, _languageService);
// }
//}
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
using (var scope = new DbContextScope(_permissionRecordRepository.Context, autoDetectChanges: false, autoCommit: false))
{
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new PermissionRecord()
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
};
// default customer role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.CustomerRoleSystemName);
if (customerRole == null)
{
//new role (save it)
customerRole = new CustomerRole()
{
Name = defaultPermission.CustomerRoleSystemName,
Active = true,
SystemName = defaultPermission.CustomerRoleSystemName
};
_customerService.InsertCustomerRole(customerRole);
}
var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in customerRole.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
permission1.CustomerRoles.Add(customerRole);
}
}
//save new permission
InsertPermissionRecord(permission1);
}
}
scope.Commit();
}
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new PermissionRecord
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
};
//default customer role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.CustomerRoleSystemName);
if (customerRole == null)
{
//new role (save it)
customerRole = new CustomerRole
{
Name = defaultPermission.CustomerRoleSystemName,
Active = true,
SystemName = defaultPermission.CustomerRoleSystemName
};
_customerService.InsertCustomerRole(customerRole);
}
var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in customerRole.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
permission1.CustomerRoles.Add(customerRole);
}
}
//save new permission
InsertPermissionRecord(permission1);
//save localization
permission1.SaveLocalizedPermissionName(_localizationService, _languageService);
}
}
}
public RoleValidator(IServiceContainer serviceContainer)
: base(serviceContainer)
{
this.permissionProvider = serviceContainer.GetService <IPermissionProvider>();
this.translationManager = serviceContainer.GetService <ITranslationManager>();
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void Install(IPermissionProvider permissionProvider)
{
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new PermissionRecord()
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
};
//default customer role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var userRole = userService.GetUserRoleBySystemName(defaultPermission.UserRoleSystemName);
if (userRole == null)
{
//new role (save it)
userRole = new UserRole()
{
Name = defaultPermission.UserRoleSystemName,
Active = true,
SystemName = defaultPermission.UserRoleSystemName
};
userService.InsertUserRole(userRole);
}
var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in userRole.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
permission1.UserRoles.Add(userRole);
}
}
//save new permission
Insert(permission1);
}
}
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
using (var scope = new DbContextScope(_permissionRecordRepository.Context, autoDetectChanges: false))
{
try
{
_permissionRecordRepository.AutoCommitEnabled = false;
_customerRoleRepository.AutoCommitEnabled = false;
//install new permissions
var permissions = permissionProvider.GetPermissions();
foreach (var permission in permissions)
{
var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
if (permission1 == null)
{
//new permission (install it)
permission1 = new PermissionRecord()
{
Name = permission.Name,
SystemName = permission.SystemName,
Category = permission.Category,
};
// default customer role mappings
var defaultPermissions = permissionProvider.GetDefaultPermissions();
foreach (var defaultPermission in defaultPermissions)
{
var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.CustomerRoleSystemName);
if (customerRole == null)
{
//new role (save it)
customerRole = new CustomerRole()
{
Name = defaultPermission.CustomerRoleSystemName,
Active = true,
SystemName = defaultPermission.CustomerRoleSystemName
};
_customerService.InsertCustomerRole(customerRole);
}
var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
var mappingExists = (from p in customerRole.PermissionRecords
where p.SystemName == permission1.SystemName
select p).Any();
if (defaultMappingProvided && !mappingExists)
{
permission1.CustomerRoles.Add(customerRole);
}
}
//save new permission
InsertPermissionRecord(permission1);
}
}
scope.Commit();
}
finally
{
_permissionRecordRepository.AutoCommitEnabled = true;
_customerRoleRepository.AutoCommitEnabled = true;
}
}
}
public void UninstallPermissions(IPermissionProvider permissionProvider)
{
//TODO
throw new NotImplementedException();
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
/// <param name="reInstall">If true and the provider has already been installed, it will re add the permissions with the associated default permissions.
/// If not, nothing will be done with the permissions.</param>
/// <remarks></remarks>
public virtual void InstallPermissions(IPermissionProvider permissionProvider, bool reInstall = false)
{
var providerName = permissionProvider.GetType().Name;
if(reInstall)
_permissionsInstalledCollection.Remove(Query<PermissionInstalled>.EQ(x => x.Name, providerName));
else
if (_permissionsInstalledCollection.Count(Query<PermissionInstalled>.EQ(x => x.Name, providerName)) == 1)
return;
_permissionsInstalledCollection.Insert(new PermissionInstalled { Name = providerName });
foreach(var permission in permissionProvider.GetPermissions())
{
var existing = _permissionPecordCollection.FindOne(Query<PermissionRecord>.EQ(x => x.SystemName, permission.SystemName)) ?? new PermissionRecord();
existing.Category = permission.Category;
existing.Name = permission.Name;
existing.SystemName = permission.SystemName;
if(existing.Id == ObjectId.Empty)
_permissionPecordCollection.Insert(existing);
else
_permissionPecordCollection.Update(Query<PermissionRecord>.EQ(x => x.Id, existing.Id), Update<PermissionRecord>.Replace(existing));
}
foreach(var defaultPermission in permissionProvider.GetDefaultPermissions())
{
var role = _userRoleCollection.FindOne(Query<UserRole>.EQ(x => x.SystemName, defaultPermission.UserRoleSystemName));
if(role == null)
{
role = new UserRole
{
Active = true,
IsSystemRole = false,
Name = defaultPermission.UserRoleSystemName,
SystemName = defaultPermission.UserRoleSystemName
};
_userRoleCollection.Insert(role);
}
foreach(var defaultPermissionRecord in defaultPermission.PermissionRecords)
{
var dbPermissionRecord = _permissionPecordCollection.FindOne(Query<PermissionRecord>.EQ(x => x.SystemName, defaultPermissionRecord.SystemName));
if(dbPermissionRecord == null)
throw new InvalidOperationException("The permission provider " + providerName + " is trying to install a default permission for permission " + defaultPermissionRecord.SystemName + " but it isn't provided via GetDefaultPermissions or another IPermissionProvider");
var query = Query.And(Query<RolePermissionMap>.EQ(x => x.PermissionRecordId, dbPermissionRecord.Id), Query<RolePermissionMap>.EQ(x => x.UserRoleId, role.Id));
var existing = _rolePermissionMapCollection.FindOne(query);
if(existing != null)
continue;
_rolePermissionMapCollection.Insert(new RolePermissionMap
{
PermissionRecordId = dbPermissionRecord.Id,
UserRoleId = role.Id
});
}
}
}
