protected override DriverResult Editor(ContentPermissionsPart part, dynamic shapeHelper)
        {
            return(ContentShape("Parts_ContentPermissions_Edit", () => {
                // ensure the current user is allowed to define permissions
                if (!_authorizer.Authorize(Permissions.GrantPermission))
                {
                    return null;
                }

                var settings = part.Settings.TryGetModel <ContentPermissionsPartSettings>();

                var allRoles = _roleService.GetRoles().Select(x => x.Name).OrderBy(x => x).ToList();

                if (settings == null)
                {
                    settings = new ContentPermissionsPartSettings {
                        View = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        ViewOwn = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewOwnContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        Publish = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        PublishOwn = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishOwnContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        Edit = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        EditOwn = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditOwnContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        Delete = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        DeleteOwn = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteOwnContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        Preview = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        PreviewOwn = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewOwnContent, UserSimulation.Create(x), null)
                        }).ToList()),
                        DisplayedRoles = ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                            Role = x, Checked = true
                        }).ToList()),
                    };
                }

                ContentPermissionsPartViewModel model;

                // copy defaults settings if new content item
                if (!part.Enabled && !part.ContentItem.HasDraft() && !part.ContentItem.HasPublished())
                {
                    model = new ContentPermissionsPartViewModel {
                        ViewRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.View),
                        ViewOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.ViewOwn),
                        PublishRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.Publish),
                        PublishOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.PublishOwn),
                        EditRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.Edit),
                        EditOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.EditOwn),
                        DeleteRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.Delete),
                        DeleteOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.DeleteOwn),
                        PreviewRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.Preview),
                        PreviewOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.PreviewOwn),
                        AllRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.DisplayedRoles)
                    };
                }
                else
                {
                    model = new ContentPermissionsPartViewModel {
                        ViewRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.ViewContent),
                        ViewOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.ViewOwnContent),
                        PublishRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.PublishContent),
                        PublishOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.PublishOwnContent),
                        EditRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.EditContent),
                        EditOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.EditOwnContent),
                        DeleteRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.DeleteContent),
                        DeleteOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.DeleteOwnContent),
                        PreviewRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.PreviewContent),
                        PreviewOwnRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, part.PreviewOwnContent),
                        AllRoles = ContentPermissionsPartViewModel.ExtractRoleEntries(allRoles, settings.DisplayedRoles)
                    };
                }

                // disable permissions the current user doesn't have
                model.ViewRoles = model.ViewRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.ViewContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.ViewOwnRoles = model.ViewOwnRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.ViewOwnContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewOwnContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.PublishRoles = model.PublishRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PublishContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.PublishOwnRoles = model.PublishOwnRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PublishOwnContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishOwnContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.EditRoles = model.EditRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.EditContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.EditOwnRoles = model.EditOwnRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.EditOwnContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditOwnContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.DeleteRoles = model.DeleteRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.DeleteContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.DeleteOwnRoles = model.DeleteOwnRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.DeleteOwnContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteOwnContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.PreviewRoles = model.PreviewRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PreviewContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewContent, UserSimulation.Create(x.Role), null)
                }).ToList();
                model.PreviewOwnRoles = model.PreviewOwnRoles.Select(x => new RoleEntry {
                    Role = x.Role, Checked = x.Checked, Enabled = _authorizer.Authorize(Core.Contents.Permissions.PreviewOwnContent, part.ContentItem), Default = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewOwnContent, UserSimulation.Create(x.Role), null)
                }).ToList();

                model.Enabled = part.Enabled;

                return shapeHelper.EditorTemplate(TemplateName: TemplateName, Model: model, Prefix: Prefix);
            }));
        }
        private void OverrideDefaultPermissions(ContentPermissionsPart part, List <string> allRoles, ContentPermissionsPartSettings settings)
        {
            // reset permissions the user can't change
            if (!_authorizer.Authorize(Core.Contents.Permissions.ViewContent, part.ContentItem))
            {
                part.ViewContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewContent, UserSimulation.Create(x), null)
                })) : settings.View;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.ViewOwnContent, part.ContentItem))
            {
                part.ViewOwnContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.ViewOwnContent, UserSimulation.Create(x), null)
                })) : settings.ViewOwn;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.PublishContent, part.ContentItem))
            {
                part.PublishContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishContent, UserSimulation.Create(x), null)
                })) : settings.Publish;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.PublishOwnContent, part.ContentItem))
            {
                part.PublishOwnContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PublishOwnContent, UserSimulation.Create(x), null)
                })) : settings.PublishOwn;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.EditContent, part.ContentItem))
            {
                part.EditContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditContent, UserSimulation.Create(x), null)
                })) : settings.Edit;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.EditOwnContent, part.ContentItem))
            {
                part.EditOwnContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.EditOwnContent, UserSimulation.Create(x), null)
                })) : settings.EditOwn;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.DeleteContent, part.ContentItem))
            {
                part.DeleteContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteContent, UserSimulation.Create(x), null)
                })) : settings.Delete;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.DeleteOwnContent, part.ContentItem))
            {
                part.DeleteOwnContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.DeleteOwnContent, UserSimulation.Create(x), null)
                })) : settings.DeleteOwn;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.PreviewContent, part.ContentItem))
            {
                part.PreviewContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewContent, UserSimulation.Create(x), null)
                })) : settings.Preview;
            }

            if (!_authorizer.Authorize(Core.Contents.Permissions.PreviewOwnContent, part.ContentItem))
            {
                part.PreviewOwnContent = settings == null?ContentPermissionsPartViewModel.SerializePermissions(allRoles.Select(x => new RoleEntry {
                    Role = x, Checked = _authorizationService.TryCheckAccess(Core.Contents.Permissions.PreviewOwnContent, UserSimulation.Create(x), null)
                })) : settings.PreviewOwn;
            }
        }