/// <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();
            //default customer role mappings
            var defaultPermissions = permissionProvider.GetDefaultPermissions().ToList();

            foreach (var permission in permissions)
            {
                var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
                if (permission1 != null)
                {
                    continue;
                }

                //new permission (install it)
                permission1 = new PermissionRecord
                {
                    Name       = permission.Name,
                    SystemName = permission.SystemName,
                    Category   = permission.Category,
                };

                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);
            }
        }
Example #3
0
        /// <summary>
        /// Install permissions
        /// </summary>
        /// <param name="permissionProvider">Permission provider</param>
        public virtual void InstallPermissions(IPermissionProvider permissionProvider)
        {
            //install new permissions
            var permissions = permissionProvider.GetPermissions();
            //default customer role mappings
            var defaultPermissions = permissionProvider.GetDefaultPermissions().ToList();

            foreach (var permission in permissions)
            {
                var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
                if (permission1 != null)
                {
                    continue;
                }

                //new permission (install it)
                permission1 = new PermissionRecord
                {
                    Name       = permission.Name,
                    SystemName = permission.SystemName,
                    Category   = permission.Category
                };

                //save new permission
                InsertPermissionRecord(permission1);

                foreach (var defaultPermission in defaultPermissions)
                {
                    var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.systemRoleName);
                    if (customerRole == null)
                    {
                        //new role (save it)
                        customerRole = new CustomerRole
                        {
                            Name       = defaultPermission.systemRoleName,
                            Active     = true,
                            SystemName = defaultPermission.systemRoleName
                        };
                        _customerService.InsertCustomerRole(customerRole);
                    }

                    var defaultMappingProvided = defaultPermission.permissions.Any(p => p.SystemName == permission1.SystemName);

                    if (!defaultMappingProvided)
                    {
                        continue;
                    }

                    InsertPermissionRecordCustomerRoleMapping(new PermissionRecordCustomerRoleMapping {
                        CustomerRoleId = customerRole.Id, PermissionRecordId = permission1.Id
                    });
                }

                //save localization
                _localizationService.SaveLocalizedPermissionName(permission1);
            }
        }
        /// <summary>
        /// Install permissions
        /// </summary>
        /// <param name="permissionProvider">Permission provider</param>
        public virtual async Task InstallPermissions(IPermissionProvider permissionProvider)
        {
            //install new permissions
            var permissions = permissionProvider.GetPermissions();

            foreach (var permission in permissions)
            {
                var permission1 = await 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 = await _customerService.GetCustomerRoleBySystemName(defaultPermission.CustomerRoleSystemName);

                        if (customerRole == null)
                        {
                            //new role (save it)
                            customerRole = new CustomerRole
                            {
                                Name       = defaultPermission.CustomerRoleSystemName,
                                Active     = true,
                                SystemName = defaultPermission.CustomerRoleSystemName
                            };
                            await _customerService.InsertCustomerRole(customerRole);
                        }


                        var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
                                                      where p.SystemName == permission1.SystemName
                                                      select p).Any();
                        if (defaultMappingProvided)
                        {
                            permission1.CustomerRoles.Add(customerRole.Id);
                        }
                    }

                    //save new permission
                    await InsertPermissionRecord(permission1);

                    //save localization
                    await permission1.SaveLocalizedPermissionName(_localizationService, _languageService);
                }
            }
        }
Example #5
0
        /// <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);
                }
            }
        }
Example #6
0
        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)
                {
                    continue;
                }

                //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.CustomerRoles.Add(userRole);
                    }
                }

                //save new permission
                InsertPermissionRecord(permission1);
            }
        }
        public async Task InstallPermissions(IPermissionProvider permissionProvider)
        {
            //install new permissions
            var permissions = permissionProvider.GetPermissions();

            foreach (var permission in permissions)
            {
                var permission1 = await GetPermissionRecordBySystemName(permission.SystemName);

                //List<Role> listRoleToAdd = new List<Role>();
                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 role =await _roleService.GetRoleByName(defaultPermission.CustomerRoleSystemName);
                        //if (role != null)
                        //{
                        //    var permissionOfRole = await GetPermissionRecorsOfRole(role);
                        //    var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
                        //                                  where p.SystemName == permission1.SystemName
                        //                                  select p).Any();
                        //    var mappingExists = (from p in permissionOfRole
                        //                         where p.SystemName == permission1.SystemName
                        //                         select p).Any();
                        //    if (defaultMappingProvided && !mappingExists)
                        //    {
                        //        //add role for permission
                        //        //listRoleToAdd.Add(role);
                        //    }
                        //}
                    }

                    //save new permission
                    await InsertAsync(permission1);

                    //foreach (var role in listRoleToAdd)
                    //{
                    //    await AddRoleToPermissionRecord(role, permission1);
                    //}
                }
            }
        }
Example #8
0
        /// <summary>
        /// Installe les permissions
        /// </summary>
        /// <param name="permissionProvider"></param>
        public virtual void InstallPermissions(IPermissionProvider permissionProvider)
        {
            IEnumerable <PermissionRecord> permissions = permissionProvider.GetPermissions();

            List <DefaultPermissionRecord> defaultPermissions = permissionProvider.GetDefaultPermissions().ToList();

            foreach (PermissionRecord permission in permissions)
            {
                PermissionRecord perm = GetPermissionRecordBySystemName(permission.SystemName);
                if (perm != null)
                {
                    continue;
                }

                perm = new PermissionRecord
                {
                    Name       = permission.Name,
                    SystemName = permission.SystemName
                };

                foreach (DefaultPermissionRecord defaultPermission in defaultPermissions)
                {
                    Role role = _roleService.Get(x => x.Name == defaultPermission.RoleSystemName).FirstOrDefault();
                    if (role == null)
                    {
                        role = new Role
                        {
                            Name       = defaultPermission.RoleSystemName,
                            Active     = true,
                            SystemName = defaultPermission.RoleSystemName
                        };
                        _roleService.Insert(role);
                    }

                    bool defaultMappingProvided = (from p in defaultPermission.PermissionRecords
                                                   where p.SystemName == perm.SystemName
                                                   select p).Any();

                    bool mappingExists = (from mapping in role.PermissionRecordRoleMappings
                                          where mapping.PermissionRecord.SystemName == perm.SystemName
                                          select mapping.PermissionRecord).Any();

                    if (defaultMappingProvided && !mappingExists)
                    {
                        perm.PermissionRecordRoleMappings.Add(new PermissionRecordRoleMapping {
                            AdministratorRole = role
                        });
                    }
                }
                InsertPermissionRecord(perm);
            }
        }
Example #9
0
        /// <summary>
        /// Install permissions
        /// </summary>
        public async Task InstallPermissionsAsync(IPermissionProvider permissionProvider)
        {
            var permissions        = permissionProvider.GetPermissions();
            var defaultPermissions = permissionProvider.GetDefaultPermissions();

            foreach (var permission in permissions)
            {
                var permission1 = GetPermissionBySystemName(permission.SystemName);
                if (permission1 != null)
                {
                    continue;
                }

                //new permission (install it)
                permission1 = new Permission
                {
                    Name       = permission.Name,
                    SystemName = permission.SystemName,
                    Category   = permission.Category,
                };

                foreach (var defaultPermission in defaultPermissions)
                {
                    var role = _userService.GetRoleBySystemName(defaultPermission.RoleSystemName);
                    if (role == null)
                    {
                        //new role (save it)
                        role = new Role
                        {
                            Name       = defaultPermission.RoleSystemName,
                            Active     = true,
                            SystemName = defaultPermission.RoleSystemName,
                        };
                        await _userService.InsertRoleAsync(role);
                    }

                    var defaultMappingProvided = defaultPermission.Permissions.Any(dp => dp.SystemName == permission1.SystemName);
                    var mappingExists          = role.PermissionRoles.Any(pr => pr.Permission.SystemName == permission1.SystemName);

                    if (defaultMappingProvided && !mappingExists)
                    {
                        permission1.PermissionRoles.Add(new PermissionRoles {
                            Role = role
                        });
                    }
                }

                InsertPermission(permission1);
            }
        }
Example #10
0
        public void InstallPermissions(IPermissionProvider permissionProvider)
        {
            var permissions = permissionProvider.GetPermissions();

            foreach (var permission in permissions)
            {
                var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
                if (permission1 == null)
                {
                    permission1 = new PermissionRecord()
                    {
                        Name       = permission.Name,
                        SystemName = permission.SystemName,
                        Category   = permission.Category
                    };

                    var defaultPermissions = permissionProvider.GetDefaultPermissions();
                    foreach (var defaultPermission in defaultPermissions)
                    {
                        var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.CustomerRoleSystemName);
                        if (customerRole == null)
                        {
                            customerRole = new CustomerRole()
                            {
                                Name       = defaultPermission.CustomerRoleSystemName,
                                Active     = true,
                                SystemName = defaultPermission.CustomerRoleSystemName
                            };
                            _customerService.InsertCustomerRole(customerRole);
                        }

                        var defaultMappingProvider = (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 (defaultMappingProvider && !mappingExists)
                        {
                            permission1.CustomerRoles.Add(customerRole);
                        }
                    }

                    InsertPermissionRecord(permission1);
                    permission1.SaveLocalizedPermissionName(_localizationService, _languageService);
                }
            }
        }
Example #11
0
        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();
        }
Example #12
0
        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());
        }
Example #13
0
        /// <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
                    {
                        Id         = Guid.NewGuid(),
                        Name       = permission.Name,
                        SystemName = permission.SystemName,
                        Category   = permission.Category,
                        Created    = DateTime.UtcNow,
                        Modified   = DateTime.UtcNow
                    };

                    //save new permission
                    InsertPermissionRecord(permission1);

                    //default customer role mappings
                    var defaultPermissions = permissionProvider.GetDefaultPermissions();
                    foreach (var defaultPermission in defaultPermissions)
                    {
                        var role = m_SystemUserService.GetRoleBySystemName(defaultPermission.RoleSystemName);
                        if (role == null)
                        {
                            //new role (save it)
                            role = new Role
                            {
                                Id         = Guid.NewGuid(),
                                Name       = defaultPermission.RoleSystemName,
                                Active     = true,
                                SystemName = defaultPermission.RoleSystemName,
                                Created    = DateTime.UtcNow,
                                Modified   = DateTime.UtcNow
                            };
                            m_SystemUserService.InsertRole(role);
                        }

                        role = m_SystemUserService.GetRoleById(role.Id, false);

                        var defaultMappingProvided = (from p in defaultPermission.PermissionRecords
                                                      where p.SystemName == permission1.SystemName
                                                      select p).Any();
                        var mappingExists = (from p in role.RolePermissionRecords.Select(rpr => rpr.PermissionRecord)
                                             where p.SystemName == permission1.SystemName
                                             select p).Any();
                        if (defaultMappingProvided && !mappingExists)
                        {
                            InsertRolePermissionRecord(new RolePermissionRecord
                            {
                                Id                 = Guid.NewGuid(),
                                Created            = DateTime.UtcNow,
                                Modified           = DateTime.UtcNow,
                                RoleId             = role.Id,
                                PermissionRecordId = permission1.Id
                            });
                        }
                    }
                }
            }

            ClearCache();
        }
Example #14
0
        /// <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)
        {
            //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);
                }
            }
        }
Example #16
0
        /// <summary>
        /// Install permissions
        /// </summary>
        /// <param name="permissionProvider">Permission provider</param>
        public virtual void InstallPermissions(IPermissionProvider permissionProvider)
        {
            //install new permissions
            var permissions = permissionProvider.GetPermissions();
            //default customer role mappings
            var defaultPermissions = permissionProvider.GetDefaultPermissions().ToList();

            foreach (var permission in permissions)
            {
                var permission1 = GetPermissionRecordBySystemName(permission.SystemName);
                if (permission1 != null)
                {
                    continue;
                }

                //new permission (install it)
                permission1 = new PermissionRecord
                {
                    Name       = permission.Name,
                    SystemName = permission.SystemName,
                    Category   = permission.Category
                };

                //save new permission
                InsertPermissionRecord(permission1);

                foreach (var defaultPermission in defaultPermissions)
                {
                    var customerRole = _customerService.GetCustomerRoleBySystemName(defaultPermission.systemRoleName);
                    if (customerRole == null)
                    {
                        //new role (save it)
                        customerRole = new CustomerRole
                        {
                            Name       = defaultPermission.systemRoleName,
                            Active     = true,
                            SystemName = defaultPermission.systemRoleName
                        };
                        _customerService.InsertCustomerRole(customerRole);
                    }
                    //TODO: issue - 239 redundant code?
                    var defaultMappingProvided = defaultPermission.permissions.Any(p => p.SystemName == permission1.SystemName);

                    var mappingExists = (from mapping in _permissionRecordCustomerRoleMappingRepository.Table.Where(prcm => prcm.CustomerRoleId == customerRole.Id)
                                         join pr in _permissionRecordRepository.Table on mapping.PermissionRecordId equals pr.Id
                                         where pr.SystemName == permission1.SystemName
                                         select mapping.PermissionRecordId).Any();
                    // issue - 239
                    if (defaultMappingProvided && !mappingExists)
                    {
                        //permission1.CustomerRoles.Add(customerRole);
                        InsertPermissionRecordCustomerRoleMapping(new PermissionRecordCustomerRoleMapping {
                            CustomerRoleId = customerRole.Id, PermissionRecordId = permission1.Id
                        });
                    }
                }

                //save localization
                _localizationService.SaveLocalizedPermissionName(permission1);
            }
        }
Example #17
0
        /// <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
                    });
                }
            }
        }
        /// <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);
                }
            }
        }
Example #19
0
        /// <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
                    });
                }
            }
        }
        /// <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();
        }
Example #21
0
        /// <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();
            }
        }