public bool RemoveContentPermissions(ContentTreeViewModel model)
{
try
{
var permissionsModel = new PermissionsModel
{
PageId = model.PageId,
UserId = model.UserId,
};
var success = _umbracoService.RemoveContentPermissions(permissionsModel);
if (!success)
{
return(false);
}
//_databaseService.RemoveUserPermissions(permissionsModel);
return(true);
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
}
public bool SetContentPermissions(ContentTreeViewModel model)
{
try
{
var user = _userControlService.LookupUserById(model.UserId);
var permissionsModel = new PermissionsModel
{
PageId = model.PageId,
UserId = model.UserId,
Created = DateTime.Now,
FullName = user.FullName,
PageName = model.PageName,
EmailAddress = user.EmailAddress
};
var success = _umbracoService.SetContentPermissions(permissionsModel);
if (!success)
{
return(false);
}
//_databaseService.AddUserPermissions(permissionsModel);
return(true);
}
catch (Exception ex)
{
ex.ToExceptionless().Submit();
throw;
}
}
/// <summary>
/// Set default permissions for user on supplied page
/// </summary>
/// <param name="model">PermissionsModel contains user Id and page Id</param>
public void SetUserPagePermissions(PermissionsModel model)
{
// I = Culture and Hostnames
// Z = Audit Trail
// F = Browse Node
// 7 = Change Document Type
// O = Copy
// D = Delete
// M = Move
// C = Create
// P = Public access
// U = Publish
// R = Permissions
// K = Rollback
// 5 = Send To Translation
// S = Sort
// H = Send to publish
// 4 = Translate
// A = Update
// Get default permissions list from web.config
var defaultPerms = ConfigurationManager.AppSettings["defaultUserPermissions"];
var permissionList = defaultPerms.ToCharArray();
ReplaceUserPagePermissions(model.UserId, model.PageId, permissionList);
}
public ActionResult SaveMenuPermissions(PermissionsModel model)
{
try
{
var entity = new PermissionsDto
{
Id = model.Id,
MenuId = model.MenuId,
Name = model.Name,
Action = model.Action,
Code = model.Code,
Type = model.Type,
Remark = model.Remark
};
var response = _permissionsService.SavePermissions(new SavePermissionsRequest
{
Entity = entity
});
if (!response.IsSuccess)
{
return(ToJsonErrorResult(1, response.MessageText));
}
return(ToJsonResult(new { status = 0 }));
}
catch (Exception ex)
{
LogManager.DefaultLogger.ErrorFormat("保存菜单权限出错：{0}", new { model, err = ex.ToString() }.ToJson());
return(ToJsonFatalResult("保存菜单权限出错"));
}
}
public bool updatePermission()
{
string column = Request.Form["column"];
string roleIdS = Request.Form["roleId"];
string isCheckedS = Request.Form["isChecked"];
if (isCheckedS != "true" && isCheckedS != "false")
{
return(false);
}
bool isChecked;
if (isCheckedS == "true")
{
isChecked = true;
}
else
{
isChecked = false;
}
int roleId;
bool isNumeric = int.TryParse(roleIdS, out roleId);
if (!isNumeric)
{
return(false);
}
return(PermissionsModel.updatePermission(column, roleId, isChecked));
}
public virtual ActionResult ApplyWidgetPermissions(PermissionsModel model)
{
var widgetService = ServiceLocator.Current.GetInstance <IPageWidgetService>();
PageWidget pageWidget = widgetService.Find(model.EntityId);
if (pageWidget != null && pageWidget.Widget != null)
{
ICoreWidget coreWidget =
MvcApplication.Widgets.FirstOrDefault(wd => wd.Identifier == pageWidget.Widget.Identifier);
ICorePrincipal currentPrincipal = this.CorePrincipal();
bool isOwner = currentPrincipal != null && pageWidget.User != null &&
currentPrincipal.PrincipalId == pageWidget.User.PrincipalId;
if (coreWidget != null && coreWidget is BaseWidget && permissionService.IsAllowed(((BaseWidget)coreWidget).PermissionOperationCode, currentPrincipal, coreWidget.GetType(), pageWidget.Id, isOwner, PermissionOperationLevel.Object))
{
permissionHelper.ApplyPermissions(model, coreWidget.GetType());
if (permissionService.IsAllowed(((BaseWidget)coreWidget).PermissionOperationCode, currentPrincipal, coreWidget.GetType(), pageWidget.Id, isOwner, PermissionOperationLevel.Object))
{
return(Content(Url.Action(MVC.Pages.Show(pageWidget.Page.Url))));
}
}
}
return(Content(Url.Action(MVC.Home.Index())));
}
/// <summary>
/// 根据类型获得权限信息
/// </summary>
/// <param name="type">权限类型</param>
/// <returns></returns>
public List <PermissionsModel> GetPermissionsInfoByType(PermissionsTypesEnum type)
{
List <T_Permissions> perInfos = _dal.GetPermissionsInfoByTypeAndEnable(type, null);
List <PermissionsModel> listM = PermissionsModel.GetList(perInfos, null);
return(listM);
}
private static void GetPermissionsInformationsFromJson()
{
string permissionsObjectSerialized = File.ReadAllText($"{inputFolderPath}/permissions.json");
pagePermissions = JsonConvert.DeserializeObject <PermissionsModel>(permissionsObjectSerialized);
pagePermissions.FormatUsers();
pagePermissions.FormatToMibUserType();
}
public ActionResult UserPermissions(string userName)
{
var model = new PermissionsModel {
Username = userName
};
return(View("UserPermissions/Index", model));
}
public void UmbracoUserControlTestSetup()
{
passWordResetModel = new PasswordResetModel();
passWordResetModelOut = new PasswordResetModel();
umbracoUserModel = new UmbracoUserModel();
umbracoUserModelListOut = new List <UmbracoUserModel>();
findUserModel = new FindUserModel();
contentTreeViewModel = new ContentTreeViewModel();
contentTreeViewModelListOut = new List <ContentTreeViewModel>();
permissionsModel = new PermissionsModel();
permissionsModelsListOut = new List <PermissionsModel>();
mockPermissionsControlService = new Mock <IPermissionsControlService>().Object;
mockEmailService = new Mock <IEmailService>().Object;
var userControlServiceMock = new Mock <IUserControlService>();
userControlServiceMock.Setup(x => x.LookupUserById(2))
.Returns(contentTreeViewModel);
mockUserControlService = userControlServiceMock.Object;
var umbracoServiceMock = new Mock <IUmbracoService>();
umbracoServiceMock.Setup(x => x.GetAllUsersByEmail("Email"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetAllUsersByUsername("Username"))
.Returns(umbracoUserModelListOut);
umbracoServiceMock.Setup(x => x.GetContentRoot())
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.GetContentChild(1))
.Returns(contentTreeViewModelListOut);
umbracoServiceMock.Setup(x => x.SetContentPermissions(permissionsModel))
.Returns(true);
mockUmbracoService = umbracoServiceMock.Object;
var databaseServiceMock = new Mock <IDatabaseService>();
databaseServiceMock.Setup(x => x.GetResetDetails(passWordResetModel))
.Returns(passWordResetModelOut);
//databaseServiceMock.Setup(x => x.CheckUserPermissions(1))
// .Returns(permissionsModelsListOut);
mockDatabaseService = databaseServiceMock.Object;
timelimit = DateTime.Now;
//umbracoService = new UmbracoService();
//databaseService = new DatabaseService();
//emailService = new EmailService(mockDatabaseService);
//userControlService = new UserControlService(mockDatabaseService, mockUmbracoService, mockEmailService);
//permissionsControlService = new PermissionsControlService(mockDatabaseService, mockUmbracoService, mockUserControlService);
}
/// <summary>
/// 根据类型和拥有权限获得权限组信息
/// </summary>
/// <param name="type">权限类型</param>
/// <param name="hasIDs">拥有权限</param>
/// <returns>权限信息</returns>
private PermissionsGroupModel GetEnablePermissionsInfoByUserGroupIDAndTypeAndHsID(PermissionsTypesEnum type, Guid[] hasIDs, PermissionsModelModeEnum mode)
{
List <T_Permissions> perInfos = _dal.GetPermissionsInfoByTypeAndEnable(type, true);
PermissionsGroupModel tempM = new PermissionsGroupModel
{
Type = type,
Items = PermissionsModel.GetList(perInfos, true, hasIDs, mode)
};
return(tempM);
}
//[UmbracoAuthorize(Permissions = new[] { FixedPermissionIds.Permissions })]
public virtual JsonResult PermissionsForm(PermissionsModel model)
{
using (var uow = Hive.Create <IContentStore>())
{
var entity = uow.Repositories.Get <TypedEntity>(model.Id);
if (entity == null)
{
throw new NullReferenceException("Could not find entity with id " + model.Id);
}
foreach (var userGroupPermissionsModel in model.UserGroupPermissions)
{
var exists = uow.Repositories.Exists <UserGroup>(userGroupPermissionsModel.UserGroupId);
if (!exists)
{
throw new NullReferenceException("Could not find entity with id " + userGroupPermissionsModel.UserGroupId);
}
// Populate metadatum collection based on selection
var metaDataumList = new List <RelationMetaDatum>();
foreach (var permissionModel in userGroupPermissionsModel.Permissions)
{
var permission = BackOfficeRequestContext.RegisteredComponents.Permissions.SingleOrDefault(x => x.Metadata.Id == permissionModel.PermissionId);
if (permission == null)
{
throw new NullReferenceException("Could not find permission with id " + permissionModel.PermissionId);
}
metaDataumList.Add(BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <RelationMetaDatum>(permissionModel));
}
// Change permissions relation
uow.Repositories.ChangeOrCreateRelationMetadata(userGroupPermissionsModel.UserGroupId, entity.Id, FixedRelationTypes.PermissionRelationType, metaDataumList.ToArray());
}
uow.Complete();
var successMsg = "Permissions.Success.Message".Localize(this, new
{
Name = entity.GetAttributeValue(NodeNameAttributeDefinition.AliasValue, "Name")
});
Notifications.Add(new NotificationMessage(
successMsg,
"Permissions.Title".Localize(this), NotificationType.Success));
return(new CustomJsonResult(new
{
success = true,
notifications = Notifications,
msg = successMsg
}.ToJsonString));
}
}
public PermissionsModel GetPermissions()
{
try
{
return(PermissionsModel.FromJson(HTMLGet($"{_baseURL}api/access/permissions")));
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// 添加权限值
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public bool AddPermissions(PermissionsRequestModel permissionsRequest)
{
PermissionsModel permissions = new PermissionsModel()
{
PermissionsName = permissionsRequest.PermissionsName,
PermissionsValue = permissionsRequest.PermissionsValue,
Remark = permissionsRequest.Remark,
};
return(_permissionsDataAccess.AddPermissions(permissions));
}
/// <summary>
/// Saves the resource permissions.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="type">The type.</param>
public bool ApplyPermissions(PermissionsModel model, Type type)
{
var result = true;
var roleService = ServiceLocator.Current.GetInstance <IRoleService>();
var permissionsService = ServiceLocator.Current.GetInstance <IPermissionService>();
var entityTypeService = ServiceLocator.Current.GetInstance <IEntityTypeService>();
var permissibleItem = MvcApplication.PermissibleObjects.FirstOrDefault(
perm =>
perm.GetType() ==
type);
if (permissibleItem != null)
{
var operations =
permissibleItem.Operations.Where(
operation =>
operation.OperationLevel != PermissionOperationLevel.Type).ToList();
var roles = roleService.GetAll();
var permissions = permissionsService.GetResourcePermissions(type, model.EntityId, false);
var entityType = entityTypeService.GetByType(type);
foreach (var role in roles)
{
var rolePermission = permissions.Where(permission => permission.Role == role).FirstOrDefault();
if (rolePermission == null)
{
rolePermission = new Permission
{
Role = role,
EntityId = model.EntityId,
EntityType = entityType,
};
}
foreach (var operation in operations)
{
if (model.Actions == null || !model.Actions.Contains(String.Format("{0}_{1}", role.Id, operation.Key)))
{
rolePermission.Permissions = rolePermission.Permissions & (~operation.Key);
}
else
{
rolePermission.Permissions = rolePermission.Permissions | operation.Key;
}
}
result = result && permissionsService.Save(rolePermission);
}
}
return(result);
}
public async Task Update(int userId, [FromBody] PermissionsModel model)
{
if (userId == HttpContext.User.GetUserId())
{
throw new NoPermissionsForOperationException(ErrorMessages.NoPermissionsForOperation);
}
using (_context.Scope())
{
await _permissionsDataProvider.UpdatePermissionsForUserAsync(userId, model.Permissions);
}
}
public HttpResponseMessage PostSetPermissions(PermissionsModel model)
{
try
{
_userAdminService.SetUserPagePermissions(model);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public async Task <OperationDataResult <PermissionsModel> > GetGroupPermissions(int groupId)
{
try
{
SecurityGroup group = await _dbContext.SecurityGroups.FirstOrDefaultAsync(x => x.Id == groupId);
if (group == null)
{
return(new OperationDataResult <PermissionsModel>(false,
_localizationService.GetString("SecurityGroupNotFound")));
}
var permissionModels = await _dbContext.Permissions
.Select(x => new PermissionModel()
{
Id = x.Id,
ClaimName = x.ClaimName,
PermissionName = x.PermissionName,
PermissionType = x.PermissionType.Name,
PermissionTypeId = x.PermissionTypeId,
IsEnabled = _dbContext.GroupPermissions.Any(g => g.SecurityGroupId == groupId &&
g.PermissionId == x.Id)
})
.ToListAsync();
var permissionTypes = permissionModels
.OrderBy(x => x.PermissionType)
.GroupBy(x => x.PermissionType)
.Select(g => new PermissionTypeModel()
{
Name = g.Key,
Permissions = g.Select(permission => permission).ToList()
}).ToList();
var result = new PermissionsModel
{
GroupId = groupId,
GroupName = group.Name,
PermissionTypes = permissionTypes
};
return(new OperationDataResult <PermissionsModel>(true, result));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(new OperationDataResult <PermissionsModel>(false,
_localizationService.GetString("ErrorWhileObtainingPermissions")));
}
}
public ActionResult Menu()
{
Helper.executeNonQUery("update BaseDynamicColumnList set show=0 where name='id' and listID in(select L.id from BaseDynamicColumnList B INNER JOIN BaseDynamicList L ON L.id=B.listID where L.name in ( select TABLE_NAME from INFORMATION_SCHEMA.COLUMNS where DATA_TYPE='uniqueidentifier' and COLUMN_NAME='id' ))", db);
try
{
Helper.InsertControllerAndActions();
}
catch (System.Exception)
{
}
PermissionsModel model = new PermissionsModel();
return(PartialView(model));
}
public void UpdatePermissionsToUpDown(string data)
{
try
{
ApiModel apimodel = JsonConvert.DeserializeObject <ApiModel>(data);
if (apimodel.ResultData != null)
{
PermissionsModel permodel = JsonConvert.DeserializeObject <PermissionsModel>(apimodel.ResultData.ToString());
db.UpdatePermissionsToUpDown(permodel, apimodel.UpDown);
}
TDCommom.Logs.Info(string.Format("菜单排序:接收数据：{0} \r\n此方法无返回数据\r\n", data));
}
catch (Exception ex)
{
TDCommom.Logs.Error(string.Format("菜单排序异常：接收数据：{0}\r\n 异常信息：{1}\r\n", data, ex.Message));
}
}
/// <summary>
/// Remove user permissions on page by setting user default permissions
/// default permissions are defined on UserType in Umbraco
/// </summary>
/// <param name="model">PermissionsModel contains user Id and page Id</param>
public void RemoveUserPagePermissions(PermissionsModel model)
{
// Set user permissions for page to default
var user = _userService.GetUserById(model.UserId);
string permList = null;
foreach (var perm in user.DefaultPermissions)
{
permList += perm;
}
if (permList != null)
{
ReplaceUserPagePermissions(user.Id, model.PageId, permList.ToCharArray());
}
}
public virtual ActionResult Permissions(HiveId id)
{
var model = new PermissionsModel {
Id = id
};
// Get all permissions
var permissions = BackOfficeRequestContext.RegisteredComponents.Permissions
.Where(x => x.Metadata.Type == FixedPermissionTypes.EntityAction)
.Select(x => x.Metadata)
.OrderBy(x => x.Name)
.ToList();
// Create user groups permission model
var usersHive = BackOfficeRequestContext.Application.Hive.GetReader <ISecurityStore>(new Uri("security://user-groups/"));
using (var uow = usersHive.CreateReadonly())
{
var userGroupPermissionsModels = uow.Repositories.GetEntityByRelationType <UserGroup>(FixedRelationTypes.DefaultRelationType, FixedHiveIds.UserGroupVirtualRoot)
.Where(x => x.Name != "Administrator")
.OrderBy(x => x.Name)
.Select(x => BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <UserGroupPermissionsModel>(x))
.ToList();
foreach (var userGroupPermissionsModel in userGroupPermissionsModels)
{
var permissionStatusModels = permissions.Select(x => BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <PermissionStatusModel>(x)).ToList();
foreach (var permissionStatusModel in permissionStatusModels)
{
// Set status
permissionStatusModel.Status = BackOfficeRequestContext.Application.Security.GetExplicitPermission(permissionStatusModel.PermissionId, new[] { userGroupPermissionsModel.UserGroupId }, id).Status;
// Set inherited status
permissionStatusModel.InheritedStatus = BackOfficeRequestContext.Application.Security.GetInheritedPermission(permissionStatusModel.PermissionId, new[] { userGroupPermissionsModel.UserGroupId }, id).Status;
}
userGroupPermissionsModel.Permissions = permissionStatusModels;
}
model.UserGroupPermissions = userGroupPermissionsModels;
}
return(View(model));
}
public virtual ActionResult ApplyPagePermissions(PermissionsModel model)
{
Page page = pageService.Find(model.EntityId);
if (page != null)
{
if (permissionService.IsAllowed((Int32)PageOperations.Permissions, this.CorePrincipal(), typeof(Page), page.Id, IsPageOwner(page), PermissionOperationLevel.Object))
{
permissionHelper.ApplyPermissions(model, typeof(Page));
}
if (permissionService.IsAllowed((Int32)PageOperations.Permissions, this.CorePrincipal(), typeof(Page), page.Id, IsPageOwner(page), PermissionOperationLevel.Object))
{
return(Content(Url.Action(MVC.Pages.Show(page.Url))));
}
}
return(Content(Url.Action(MVC.Home.Index())));
}
public virtual ActionResult ApplyPermissions(PermissionsModel model)
{
var form = _formsService.Find(model.EntityId);
if (form != null)
{
if (_permissionService.IsAllowed((Int32)FormOperations.Permissions, this.CorePrincipal(), typeof(Form), form.Id, IsFormOwner(form), PermissionOperationLevel.Object))
{
_permissionsHelper.ApplyPermissions(model, typeof(Form));
}
if (_permissionService.IsAllowed((Int32)FormOperations.Permissions, this.CorePrincipal(), typeof(Form), form.Id, IsFormOwner(form), PermissionOperationLevel.Object))
{
return(Content(Url.Action("ShowPermissions", "Forms", new { formId = form.Id })));
}
}
return(Content(Url.Action("ShowAll")));
}
/// <summary>
/// Check permissions for selected user
/// Do not include "Browse" as this is the minimum and indicates NO Permission for a page
/// </summary>
/// <param name="userId">Target user</param>
/// <returns>User page permission set</returns>
public IList <PermissionsModel> CheckUserPermissions(int userId)
{
var helper = new UmbracoHelper(UmbracoContext.Current);
var user = _userService.GetUserById(userId);
IList <PermissionsModel> permList = new List <PermissionsModel>();
// This only gets permissions that have been explicitly set, unless a page(s) Id is passed then it returns
// at least the default permissions
var userPermissions = _userService.GetPermissions(user);
foreach (var userPerm in userPermissions)
{
// Assume:
// if no permissions at all, then there will be only one element which will contain a "-"
// If only the default permission then there will only be one element which will contain "F" (Browse Node)
if (userPerm.AssignedPermissions.Count() > 1 ||
(userPerm.AssignedPermissions[0] != "-" && userPerm.AssignedPermissions[0] != "F"))
{
var contentNode = _contentService.GetById(userPerm.EntityId);
if (contentNode.Trashed)
{
continue;
}
var p = new PermissionsModel
{
UserId = userPerm.UserId,
Username = user.Username,
FullName = user.Name,
EmailAddress = user.Email,
UserLocked = !user.IsApproved,
PageId = userPerm.EntityId,
PageName = contentNode.Name,
PagePath = PageBreadcrumb(contentNode),
PageUrl = helper.NiceUrl(contentNode.Id)
};
permList.Add(p);
}
}
return(permList);
}
public string UpdatePermissions(string data)
{
try
{
PermissionsModel model = JsonConvert.DeserializeObject <PermissionsModel>(data);
bool flag = db.UpdatePermissions(model);
string res = JsonConvert.SerializeObject(new ApiModel()
{
ResultCode = flag ? 1 : 0
});
TDCommom.Logs.Info(string.Format("修改菜单成功：接收数据：{0}\r\n 返回数据：{1}\r\n", data, res));
return(res);
}
catch (Exception ex)
{
TDCommom.Logs.Error(string.Format("修改菜单异常：接收数据：{0}\r\n 异常信息：{1}\r\n", data, ex.Message));
return(null);
}
}
/// <summary>
/// Copy specifically assigned permissions (not default group permissions) from one user to another
/// </summary>
/// <param name="model">Source and Target users</param>
public void ClonePermissions(PermissionsModel model)
{
var sourceUser = _userService.GetUserById(model.UserId);
var userPermissions = _userService.GetPermissions(sourceUser);
var targetUser = new List <int> {
model.TargetId
};
foreach (var permissions in userPermissions)
{
var content = _contentService.GetById(permissions.EntityId);
foreach (var permission in permissions.AssignedPermissions)
{
_contentService.AssignContentPermission(content, permission[0], targetUser);
}
}
}
public virtual ActionResult ApplyPermissions(PermissionsModel model)
{
var form = formsService.Find(model.EntityId);
if (form != null)
{
if (permissionService.IsAllowed((Int32)FormOperations.Permissions, this.CorePrincipal(), typeof(Form), form.Id, IsFormOwner(form), PermissionOperationLevel.Object))
{
permissionsHelper.ApplyPermissions(model, typeof(Form));
}
if (permissionService.IsAllowed((Int32)FormOperations.Permissions, this.CorePrincipal(), typeof(Form), form.Id, IsFormOwner(form), PermissionOperationLevel.Object))
{
Success(HttpContext.Translate("Messages.PermitionsSuccess", ResourceHelper.GetControllerScope(this)) /*"Successfully apply permissions."*/);
return(Content(Url.Action("ShowPermissions", "Forms", new { formId = form.Id })));
}
Error(String.Format(HttpContext.Translate("Messages.PermitionsUnSuccess", ResourceHelper.GetControllerScope(this)) /*"Could not apply permissions to Form Entity: {0}"*/, model.EntityId));
}
Error(String.Format(HttpContext.Translate("Messages.NotFoundEntity", ResourceHelper.GetControllerScope(this)) /*"Could not found Form Entity: {0}"*/, model.EntityId));
return(Content(Url.Action("ShowAll")));
}
public virtual ActionResult ApplyPermissions(PermissionsModel model)
{
var article = articleService.Find(model.EntityId);
if (article != null)
{
if (permissionService.IsAllowed((Int32)ArticleOperations.Permissions, this.CorePrincipal(), typeof(Article), article.Id, IsArticleOwner(article), PermissionOperationLevel.Object))
{
permissionsHelper.ApplyPermissions(model, typeof(Article));
}
if (permissionService.IsAllowed((Int32)ArticleOperations.Permissions, this.CorePrincipal(), typeof(Article), article.Id, IsArticleOwner(article), PermissionOperationLevel.Object))
{
Success(HttpContext.Translate("Messages.PermitionsSuccess", ResourceHelper.GetControllerScope(this)));
return(Content(Url.Action("ShowPermissions", "Article", new { articleId = article.Id })));
}
Error(String.Format(HttpContext.Translate("Messages.PermitionsUnSuccess", ResourceHelper.GetControllerScope(this)), model.EntityId));
}
Error(String.Format(HttpContext.Translate("Messages.NotFoundEntity", ResourceHelper.GetControllerScope(this)), model.EntityId));
return(Content(Url.Action("Show")));
}
public virtual ActionResult ApplyPermissions(PermissionsModel model)
{
var category = categoryService.Find(model.EntityId);
if (category != null)
{
if (permissionService.IsAllowed((Int32)CategoryOperations.Permissions, this.CorePrincipal(), typeof(WebContentCategory), category.Id, IsCategoryOwner(category), PermissionOperationLevel.Object))
{
permissionsHelper.ApplyPermissions(model, typeof(WebContentCategory));
}
if (permissionService.IsAllowed((Int32)CategoryOperations.Permissions, this.CorePrincipal(), typeof(WebContentCategory), category.Id, IsCategoryOwner(category), PermissionOperationLevel.Object))
{
Success(HttpContext.Translate("Messages.PermitionsSuccess", ResourceHelper.GetControllerScope(this)));
return(Content(Url.Action("ShowPermissions", "WebContentCategory", new { categoryId = category.Id })));
}
Error(String.Format(HttpContext.Translate("Messages.PermitionsUnSuccess", ResourceHelper.GetControllerScope(this)), model.EntityId));
}
Error(String.Format(HttpContext.Translate("Messages.NotFoundEntity", ResourceHelper.GetControllerScope(this)), model.EntityId));
return(Content(Url.Action("Show")));
}
