/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <param name="customer">Customer</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual bool Authorize(PermissionRecord permission, PersonalInformation person)
{
bool answer = false;
if (permission == null)
return answer;
if (person == null)
return answer;
var query = from p in _permissionRecordRepository.Table
where p.Id == person.Id && p.Description.ToLower() == permission.Description.ToLower()
//where p.Name == permission.Name && p.Description.ToLower() == permission.Description.ToLower()
select p;
if (query.Count() == 0)
{
query = from p in _rolePermissionRep.Table
where p.TelehireRole.RoleName.ToLower() == person.UserRole.ToLower() && p.Permission.Description.ToLower() == permission.Description.ToLower()
select p.Permission;
if (query.Count() > 0)
answer = true;
}
else
answer = true;
return answer;
//throw new NotImplementedException();
}
/// <summary>
/// Delete a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual async Task DeletePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
await _permissionRecordRepository.DeleteAsync(permission);
await _cacheBase.RemoveByPrefix(CacheKey.PERMISSIONS_PATTERN_KEY);
}
/// <summary>
/// Install permissions
/// </summary>
/// <param name="permissionProvider">Permission provider</param>
public virtual void InstallPermissions(IPermissionProvider permissionProvider)
{
//install new permissions
var permissions = permissionProvider.GetPermissions();
//default user 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 userRole = _userService.GetUserRoleBySystemName(defaultPermission.systemRoleName);
if (userRole == null)
{
//new role (save it)
userRole = new UserRole
{
Name = defaultPermission.systemRoleName,
Active = true,
SystemName = defaultPermission.systemRoleName
};
_userService.InsertUserRole(userRole);
}
var defaultMappingProvided = defaultPermission.permissions.Any(p => p.SystemName == permission1.SystemName);
if (!defaultMappingProvided)
{
continue;
}
InsertPermissionRecordUserRoleMapping(new PermissionRecordUserRoleMapping {
UserRoleId = userRole.Id, PermissionRecordId = permission1.Id
});
}
}
}
private void AddMapping(PermissionRecord permission, CustomerRole role, bool allow)
{
permission.PermissionRoleMappings.Add(new PermissionRoleMapping
{
CustomerRoleId = role.Id,
CustomerRole = role,
PermissionRecordId = permission.Id,
PermissionRecord = permission,
Allow = allow
});
}
/// <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);
}
}
}
/// <summary>
/// Updates the permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void UpdatePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
//todo...mapping
base.SubmitContext();
}
/// <summary>
/// 添加权限项
/// </summary>
/// <param name="permission">权限项</param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
_permissionRecordRepository.Insert(permission);
_cacheManager.RemoveByPattern(PERMISSIONS_PATTERN_KEY);
}
public void DeletePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
_permissionPecordRepository.Delete(permission);
//这个是干嘛的
_cacheManager.RemoveByPattern(PERMISSIONS_PATTERN_KEY);
}
/// <summary>
/// Updates the permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void UpdatePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
_permissionRecordRepository.Update(permission);
_cacheManager.RemoveByPattern(PERMISSIONS_PATTERN_KEY);
}
/// <summary>
/// Updates the permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void UpdatePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
_permissionRecordRepository.Update(permission);
//_unitOfWork.Commit();
}
/// <summary>
/// Inserts a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual async Task InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
await _permissionRecordRepository.InsertAsync(permission);
await _cacheManager.RemoveByPrefix(PERMISSIONS_PATTERN_KEY);
}
/// <summary>
/// Delete a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual async Task DeletePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
await _permissionRecordRepository.DeleteAsync(permission);
_cacheManager.RemoveByPattern(PERMISSIONS_PATTERN_KEY);
}
public void UpdateRole(int id, string roleName, IEnumerable <string> rolePermissions)
{
var roleRecord = GetRole(id);
var currentRoleName = roleRecord.Name;
var currentPermissions = roleRecord.RolesPermissions.ToDictionary(x => x.Permission.Name);
roleRecord.Name = roleName;
roleRecord.RolesPermissions.Clear();
if (!String.Equals(currentRoleName, roleName))
{
_roleEventHandlers.Renamed(new RoleRenamedContext {
Role = roleRecord, NewRoleName = roleName, PreviousRoleName = currentRoleName
});
}
foreach (var rolePermission in rolePermissions)
{
string permission = rolePermission;
if (_permissionRepository.Get(x => x.Name == permission) == null)
{
_permissionRepository.Create(new PermissionRecord
{
Description = GetPermissionDescription(permission),
Name = permission,
FeatureName = GetFeatureName(permission)
});
}
PermissionRecord permissionRecord = _permissionRepository.Get(x => x.Name == permission);
roleRecord.RolesPermissions.Add(new RolesPermissionsRecord {
Permission = permissionRecord, Role = roleRecord
});
if (!currentPermissions.ContainsKey(permission))
{
_roleEventHandlers.PermissionAdded(new PermissionAddedContext {
Role = roleRecord, Permission = permissionRecord
});
}
else
{
currentPermissions.Remove(permission);
}
}
foreach (var permission in currentPermissions.Values)
{
_roleEventHandlers.PermissionRemoved(new PermissionRemovedContext {
Role = roleRecord, Permission = permission.Permission
});
}
TriggerSignal();
}
/// <summary>
/// Inserts a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
_dataContext.PermissionRecords.InsertOnSubmit(permission);
base.SubmitContext();
}
public void Can_save_and_load_permissionRecord()
{
var permissionRecord = new PermissionRecord
{
SystemName = "SystemName 2"
};
var fromDb = SaveAndLoadEntity(permissionRecord);
fromDb.ShouldNotBeNull();
fromDb.SystemName.ShouldEqual("SystemName 2");
}
/// <summary>
/// Inserts a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
_permissionRecordRepository.Insert(permission);
//event notification
_eventPublisher.EntityInserted(permission);
}
public void EntityCreatedHandler_UpdatesExistsUserPermissions()
{
var expPr = new PermissionRecord("c", "r", "u", "d");
var ecr = new EntityConfigRecord {
Type = typeof(TestClass), PermissionRecord = expPr
};
var sp = new Mock <IServiceProvider>();
sp.Setup(s => s.GetService(typeof(IEnumerable <EntityConfigRecord>))).Returns(new[] { ecr });
var userId = "uId";
var dbUp = new UserPermissions
{
UserId = userId,
EntityPermissions = new[] {
new EntityPermission
{
EntityId = "eId",
EntityKey = "ek",
PermissionKeys = new[] { "r1", "u1", "d1", },
},
}
};
var pm = new Mock <IPermissionManager>();
pm.Setup(p => p.GetUserPermissions(It.IsAny <string>())).ReturnsAsync(dbUp);
sp.Setup(s => s.GetService(typeof(IPermissionManager))).Returns(pm.Object);
var data = new TestClass
{
Value = 123
};
var ed = new DomainEvent
{
Data = data,
PerformedByUserId = userId,
WorkContext = new WorkContext {
CurrentEntityConfigRecord = ecr
},
};
var ph = new DefaultPermissionsEventsHandler(sp.Object);
ph.PermissionCreatedHandler(ed);
Thread.Sleep(250);
pm.Verify(p => p.UpdateUserPermissions(It.Is <UserPermissions>(
up => up.UserId == userId &&
up.EntityPermissions.Count() == 2 &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.ReadKey) &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.UpdateKey) &&
up.EntityPermissions.ElementAt(1).PermissionKeys.Contains(expPr.DeleteKey))),
Times.Once);
}
/// <summary>
/// Delete a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void DeletePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
_permissionRecordRepository.Delete(permission);
//event notification
// _eventPublisher.EntityDeleted(permission);
}
/// <summary>
/// Insère une nouvelle permission
/// </summary>
/// <param name="permission"></param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
permission.CreatedOnUtc = DateTime.UtcNow;
permission.UpdatedOnUtc = DateTime.UtcNow;
_permissionRecordRepository.Insert(permission);
}
/// <summary>
/// Updates the permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void UpdatePermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
_permissionRecordRepository.Update(permission);
_cacheManager.RemoveByPattern(NopSecurityDefaults.PermissionsPatternCacheKey);
_staticCacheManager.RemoveByPattern(NopSecurityDefaults.PermissionsPatternCacheKey);
}
public bool Authorize(PermissionRecord permission, Customer customer)
{
if (permission == null)
{
return(false);
}
if (customer == null)
{
return(false);
}
return(Authorize(permission.SystemName, customer));
}
/// <summary>
/// Inserts a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException(nameof(permission));
}
_permissionRecordRepository.Insert(permission);
_cacheManager.RemoveByPrefix(NopSecurityDefaults.PermissionsPrefixCacheKey);
_staticCacheManager.RemoveByPrefix(NopSecurityDefaults.PermissionsPrefixCacheKey);
}
/// <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);
}
}
public ActionResult ConfigureProvider(string systemName, string listUrl)
{
var provider = _providerManager.GetProvider(systemName);
if (provider == null || !provider.Metadata.IsConfigurable)
{
return(HttpNotFound());
}
PermissionRecord requiredPermission = StandardPermissionProvider.AccessAdminPanel;
var listUrl2 = Url.Action("List");
var metadata = provider.Metadata;
//if (metadata.ProviderType == typeof(IPaymentMethod))
//{
// requiredPermission = StandardPermissionProvider.ManagePaymentMethods;
// listUrl2 = Url.Action("Providers", "Payment");
//}
//if (metadata.ProviderType == typeof(ITaxProvider))
//{
// requiredPermission = StandardPermissionProvider.ManageTaxSettings;
// listUrl2 = Url.Action("Providers", "Tax");
//}
//else if (metadata.ProviderType == typeof(IShippingRateComputationMethod))
//{
// requiredPermission = StandardPermissionProvider.ManageShippingSettings;
// listUrl2 = Url.Action("Providers", "Shipping");
//}
// else
if (metadata.ProviderType == typeof(IWidget))
{
requiredPermission = StandardPermissionProvider.ManageWidgets;
listUrl2 = Url.Action("Providers", "Widget");
}
else if (metadata.ProviderType == typeof(IExternalAuthenticationMethod))
{
requiredPermission = StandardPermissionProvider.ManageExternalAuthenticationMethods;
listUrl2 = Url.Action("Providers", "ExternalAuthentication");
}
if (!_permissionService.Authorize(requiredPermission))
{
return(AccessDeniedView());
}
var model = _pluginMediator.ToProviderModel(provider);
ViewBag.ListUrl = listUrl.NullEmpty() ?? listUrl2;
return(View(model));
}
public virtual void InsertPermissionRecord(string moduleName, string featureName, string featureActionName)
{
int displayOrder = 0;
var module = _moduleRepository.GetAll().FirstOrDefault(m => m.Name == moduleName);
if (module == null)
{
displayOrder = _moduleRepository.GetAll().Max(m => m.DisplayOrder);
module = new Module {
Name = moduleName, Description = moduleName + " Module", DisplayOrder = displayOrder + 1
};
_moduleRepository.InsertAndCommit(module);
}
var feature = _featureRepository.GetAll().FirstOrDefault(f => f.Name == featureName);
if (feature == null)
{
displayOrder = _featureRepository.GetAll().Where(f => f.ModuleId == module.Id).Max(m => m.DisplayOrder);
feature = new Feature {
Name = moduleName, Description = featureName + " Feature", DisplayOrder = displayOrder + 1
};
_featureRepository.InsertAndCommit(feature);
}
var featureAction = _featureActionRepository.GetAll().FirstOrDefault(f => f.Name == featureActionName);
if (module == null)
{
displayOrder = _featureActionRepository.GetAll().Where(f => f.FeatureId == feature.Id).Max(m => m.DisplayOrder);
featureAction = new FeatureAction {
Name = featureActionName, Description = featureActionName, DisplayOrder = displayOrder + 1
};
_featureActionRepository.InsertAndCommit(featureAction);
}
var permissionRecord = _permissionRecordRepository.GetAll()
.FirstOrDefault(p => p.ModuleId == module.Id && p.FeatureId == feature.Id && p.FeatureActionId == featureAction.Id);
if (permissionRecord == null)
{
permissionRecord = new PermissionRecord
{
ModuleId = module.Id,
FeatureId = feature.Id,
FeatureActionId = featureAction.Id,
Name = string.Format("{0}.{1}.{2}", module.Name.Replace(" ", ""), feature.Name.Replace(" ", ""), featureAction.Name.Replace(" ", ""))
};
_permissionRecordRepository.InsertAndCommit(permissionRecord);
}
}
public virtual bool Authorize(PermissionRecord permission, User user)
{
if (permission == null)
{
return(false);
}
if (user == null)
{
return(false);
}
return(Authorize(permission.SystemName, user));
}
/// <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);
}
}
public void ManageSiteMap(SiteMapNode rootNode)
{
var permissionService = EngineContext.Current.Resolve <IPermissionService>();
var permissionRecord = new PermissionRecord
{
Category = "Plugin",
SystemName = "ManagerWarehouse",
Name = "Admin area. Manager Warehouse"
};
//if (permissionService.Authorize(permissionRecord))
//{
var parentNode = new SiteMapNode
{
SystemName = "ManagerWarehouse",
Title = "Manager Of Warehouse",
//ActionName = " ",
ControllerName = "ManagerWarehouse",
Visible = true,
RouteValues = new RouteValueDictionary {
{ "area", null }
}
};
var manageState = new SiteMapNode
{
SystemName = "WidgetPromoSlider",
Title = "States of Flow",//_localizationService.GetResource("Plugins.Widget.PromoSlider.Menu.ManagerSliders"),
ActionName = "WarehouseState",
ControllerName = "ManagerWarehouse",
Visible = true,
RouteValues = new RouteValueDictionary {
{ "area", null }
}
};
parentNode.ChildNodes.Add(manageState);
var pluginNode = rootNode.ChildNodes.FirstOrDefault(x => x.SystemName == "ManagerWarehouse");
if (pluginNode != null)
{
pluginNode.ChildNodes.Add(parentNode);
}
else
{
rootNode.ChildNodes.Add(parentNode);
}
//}
}
/// <summary>
/// Inserts a permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void InsertPermissionRecord(PermissionRecord permission)
{
if (permission == null)
{
throw new ArgumentNullException("permission");
}
using (var context = SCMSEntities.Define())
{
context.PermissionRecords.Add(permission);
context.SaveChanges();
}
ClearCache();
}
/// <summary>
/// Updates an existing permission record
/// </summary>
/// <param name="permissionRecord">Permission record to be updated</param>
public void UpdatePermissionRecord(PermissionRecord permissionRecord)
{
if (permissionRecord == null)
{
throw new ArgumentException("Permission record cannot be null.", nameof(permissionRecord));
}
if (!_permissionRepository.Any(permissionRecord.PermissionRecordId))
{
throw new ArgumentException($"No permission record exists for id = {permissionRecord.PermissionRecordId}", nameof(permissionRecord.PermissionRecordId));
}
_permissionRepository.Update(permissionRecord);
}
/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <param name="customer">Customer</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual async Task <bool> Authorize(PermissionRecord permission, Customer customer)
{
if (permission == null)
{
return(false);
}
if (customer == null)
{
return(false);
}
return(await Authorize(permission.SystemName, customer));
}
public void CreatePermission(PermissionRecord permmision)
{
try
{
AuditTrail trail = new AuditTrail();
trail.TimeStamp = CurrentDate;
trail.UserId = PersonalInformation.UserId;
trail.UserIP = _UtilityService.RemoteIP;
trail.AuditActionId = (int)Telehire.Core.Utility.SystemEnums.AuditActionEnum.Create_Permission;
trail.Details = PersonalInformation.FullName + " created Permission: " + permmision.Name;
//trail.AirlineId = PersonalInformation.AirlineId;
_AuditTrailRep.SaveOrUpdate(trail);
}
catch
{
}
}
/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <param name="account">Account</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual bool Authorize(PermissionRecord permission, Account account)
{
if (permission == null)
return false;
if (account == null)
return false;
//old implementation of Authorize method
//var accountRoles = account.AccountRoles.Where(cr => cr.Active);
//foreach (var role in accountRoles)
// foreach (var permission1 in role.PermissionRecords)
// if (permission1.SystemName.Equals(permission.SystemName, StringComparison.InvariantCultureIgnoreCase))
// return true;
//return false;
return Authorize(permission.SystemName, account);
}
/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual bool Authorize(PermissionRecord permission)
{
return Authorize(permission, _currentActivity.CurrentAccount);
}
private static string SerializePermission(PermissionRecord permission)
{
var xmlString = new StringBuilder();
xmlString.AppendFormat("<{0}>", "permission");
xmlString.AppendFormat("<name>{0}</name>", permission.Name);
xmlString.AppendFormat("<systemName>{0}</systemName>", permission.SystemName);
xmlString.AppendFormat("<category>{0}</category>", permission.Category);
xmlString.AppendFormat("</{0}>", "permission");
return xmlString.ToString();
}
/// <summary>
/// Updates the permission
/// </summary>
/// <param name="permission">Permission</param>
public virtual void UpdatePermissionRecord(PermissionRecord permission)
{
if (permission == null)
throw new ArgumentNullException("permission");
_permissionRecordRepository.Update(permission);
_cacheManager.RemoveByPattern(PERMISSIONS_PATTERN_KEY);
}
/// <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);
}
}
}
/// <summary>
/// Authorize permission
/// </summary>
/// <param name="permission">Permission record</param>
/// <returns>true - authorized; otherwise, false</returns>
public virtual bool Authorize(PermissionRecord permission)
{
return Authorize(permission, _workContext.CurrentCustomer);
}
/// <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 bool Authorize(PermissionRecord permission)
{
return Authorize(permission, _workContext.CurrentUserPersonalInformation);
}
