public void Remove(Guid resourceId)
        {
            LogStart();
            _permissionsLock.EnterWriteLock();
            try
            {
                var oldPermissions = new WindowsGroupPermission[_permissions.Count];
                _permissions.CopyTo(oldPermissions);

                var removedCount = _permissions.RemoveAll(p => !p.IsServer && p.ResourceID == resourceId);

                if(removedCount > 0)
                {
                    RaisePermissionsModified(oldPermissions, _permissions);

                    // This will trigger a FileSystemWatcher file changed event
                    // which in turn will cause the permissions to be re-read.
                    WritePermissions(_permissions);
                }
            }
            finally
            {
                _permissionsLock.ExitWriteLock();
            }
            LogEnd();
        }

        public void GivenItHasWith(string groupName, string groupRights)
        {
            var groupPermssions = new WindowsGroupPermission
            {
                WindowsGroup = groupName,
                ResourceID = Guid.Empty,
                IsServer = true
            };
            var permissionsStrings = groupRights.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
            foreach(var permissionsString in permissionsStrings)
            {
                SecPermissions permission;
                if(Enum.TryParse(permissionsString.Replace(" ", ""), true, out permission))
                {
                    groupPermssions.Permissions |= permission;
                }
            }
            Data.Settings.Settings settings = new Data.Settings.Settings
            {
                Security = new SecuritySettingsTO(new List<WindowsGroupPermission> { groupPermssions })
            };

            var environmentModel = ScenarioContext.Current.Get<IEnvironmentModel>("environment");
            EnsureEnvironmentConnected(environmentModel);
            environmentModel.ResourceRepository.WriteSettings(environmentModel, settings);
            environmentModel.Disconnect();
        }

        public void AuthorizationHelpers_Matches_SecurityPermissionIsServer_True()
        {
            //------------Setup for test--------------------------
            var securityPermission = new WindowsGroupPermission { IsServer = true };

            //------------Execute Test---------------------------
            var authorized = securityPermission.Matches(null);

            //------------Assert Results-------------------------
            Assert.IsTrue(authorized);
        }

        public void WindowsGroupPermission_Permissions_SetExecute_CorrectlyApplied()
        {
            //------------Setup for test--------------------------            

            //------------Execute Test---------------------------
            var p = new WindowsGroupPermission { Permissions = Permissions.Execute };

            //------------Assert Results-------------------------
            Assert.IsFalse(p.View);
            Assert.IsTrue(p.Execute);
            Assert.IsFalse(p.Contribute);
            Assert.IsFalse(p.DeployTo);
            Assert.IsFalse(p.DeployFrom);
            Assert.IsFalse(p.Administrator);
        }

 public void SecurityWrite_Execute_SecuritySettingsValuePassedValidJSON_ShouldWriteFile()
 {
     //------------Setup for test--------------------------
     var permission = new WindowsGroupPermission { Administrator = true, IsServer = true, WindowsGroup = Environment.UserName };
     var windowsGroupPermissions = new List<WindowsGroupPermission> { permission };
     var securitySettings = new SecuritySettingsTO(windowsGroupPermissions) { CacheTimeout = new TimeSpan(0, 2, 0) };
     var securitySettingsValue = JsonConvert.SerializeObject(securitySettings);
     var securityWrite = new SecurityWrite();
     //------------Execute Test---------------------------
     securityWrite.Execute(new Dictionary<string, StringBuilder> { { "SecuritySettings", new StringBuilder(securitySettingsValue) } }, null);
     //------------Assert Results-------------------------
     Assert.IsTrue(File.Exists("secure.config"));
     var fileData = File.ReadAllText("secure.config");
     Assert.IsFalse(fileData.StartsWith("{"));
     Assert.IsFalse(fileData.EndsWith("}"));
     Assert.IsFalse(fileData.Contains("IsServer"));
     File.Delete("secure.config");
 }

        public void AuthorizationServiceBase_IsAuthorized_UserIsInResourceRoleAndResourceToBeVerifiedIsNull_False()
        {
            //------------Setup for test--------------------------
            var securityPermission = new WindowsGroupPermission { IsServer = false, ResourceName = "Category\\Test1", ResourceID = Guid.NewGuid() };

            var securityService = new Mock<ISecurityService>();
            securityService.SetupGet(p => p.Permissions).Returns(new List<WindowsGroupPermission> { securityPermission });

            var user = new Mock<IPrincipal>();
            user.Setup(u => u.IsInRole(It.IsAny<string>())).Returns(true);

            var authorizationService = new TestAuthorizationServiceBase(securityService.Object) { User = user.Object };

            //------------Execute Test---------------------------
            var authorized = authorizationService.IsAuthorized(AuthorizationContext.Contribute, null);

            //------------Assert Results-------------------------
            Assert.IsFalse(authorized);
        }

 int Compare(WindowsGroupPermission px, WindowsGroupPermission py)
 {
     switch(_sortMemberPath)
     {
         case "ResourceName":
             return System.String.Compare(px.ResourceName, py.ResourceName, System.StringComparison.InvariantCulture);
         case "WindowsGroup":
             return System.String.Compare(px.WindowsGroup, py.WindowsGroup, System.StringComparison.InvariantCulture);
         case "View":
             return px.View.CompareTo(py.View);
         case "Execute":
             return px.Execute.CompareTo(py.Execute);
         case "Contribute":
             return px.Contribute.CompareTo(py.Contribute);
         case "DeployTo":
             return px.DeployTo.CompareTo(py.DeployTo);
         case "DeployFrom":
             return px.DeployFrom.CompareTo(py.DeployFrom);
         case "Administrator":
             return px.Administrator.CompareTo(py.Administrator);
     }
     return 0;
 }

 WindowsGroupPermission CreateNewPermission(bool isServer)
 {
     var permission = new WindowsGroupPermission { IsNew = true, IsServer = isServer };
     RegisterPropertyChanged(permission);
     return permission;
 }

 static void UpdateForAdministratorPermissions(WindowsGroupPermission windowsGroupPermission)
 {
     windowsGroupPermission.DeployFrom = true;
     windowsGroupPermission.DeployTo = true;
     windowsGroupPermission.Contribute = true;
 }

 static void UpdateForContributePermissions(WindowsGroupPermission windowsGroupPermission)
 {
     windowsGroupPermission.View = true;
     windowsGroupPermission.Execute = true;
 }

 static void SwitchAdminPermissionsOff(WindowsGroupPermission windowsGroupPermission, string propertyName)
 {
     if(!windowsGroupPermission.DeployTo && propertyName == "DeployTo"
        || !windowsGroupPermission.DeployFrom && propertyName == "DeployFrom"
        || !windowsGroupPermission.Contribute && propertyName == "Contribute")
     {
         windowsGroupPermission.Administrator = false;
     }
 }

 static void SwitchContributePermissionsOff(WindowsGroupPermission windowsGroupPermission, string propertyName)
 {
     if(!windowsGroupPermission.View && propertyName == "View"
        || !windowsGroupPermission.Execute && propertyName == "Execute")
     {
         windowsGroupPermission.Contribute = false;
     }
 }

 public void WindowsGroupPermissions_CanRemove_Server_True()
 {
     //------------Setup for test--------------------------
     var p = new WindowsGroupPermission { IsServer = true, WindowsGroup = "xxx" };
     //------------Execute Test---------------------------
     var canRemove = p.CanRemove;
     //------------Assert Results-------------------------
     Assert.IsTrue(canRemove);
 }

        void Verify_IsAuthorized(Permissions configPermissions, TestAuthorizationRequest authorizationRequest, bool isServer)
        {
            var configPermission = new WindowsGroupPermission { WindowsGroup = TestAuthorizationRequest.UserRole, IsServer = isServer, Permissions = configPermissions };

            if(!isServer && !string.IsNullOrEmpty(authorizationRequest.Resource))
            {
                Guid resourceID;
                if(Guid.TryParse(authorizationRequest.Resource, out resourceID))
                {
                    configPermission.ResourceID = resourceID;
                    configPermission.ResourceName = "TestCategory\\";
                }
                else
                {
                    configPermission.ResourceID = Guid.NewGuid();
                    configPermission.ResourceName = string.Format("TestCategory\\{0}", authorizationRequest.Resource);
                }
            }

            authorizationRequest.UserIsInRole = false;
            Verify_IsAuthorized(configPermission, authorizationRequest);

            authorizationRequest.UserIsInRole = true;
            Verify_IsAuthorized(configPermission, authorizationRequest);
        }

        public void SettingsWrite_Execute_SettingsWriteValuePassedValidJSON_ShouldDoSecurityWrite()
        {
            //------------Setup for test--------------------------
            var permission = new WindowsGroupPermission { Administrator = true, IsServer = true, WindowsGroup = Environment.UserName };
            var windowsGroupPermissions = new List<WindowsGroupPermission> { permission };
            var settings = new Settings { Security = new SecuritySettingsTO(windowsGroupPermissions) };
            var serializeObject = JsonConvert.SerializeObject(settings);
            var settingsWrite = new SettingsWrite();
            //------------Execute Test---------------------------
            StringBuilder execute = settingsWrite.Execute(new Dictionary<string, StringBuilder> { { "Settings", new StringBuilder(serializeObject) } }, null);
            //------------Assert Results-------------------------
            Assert.IsTrue(File.Exists("secure.config"));
            File.Delete("secure.config");

            var msg = ToMsg(execute);

            StringAssert.Contains(msg.Message.ToString(), "Success");
        }

        public void WindowsGroupPermission_IsValid_IsServerAndWindowsGroupIsEmpty_False()
        {
            //------------Setup for test--------------------------            

            //------------Execute Test---------------------------
            var p = new WindowsGroupPermission { IsServer = true, WindowsGroup = string.Empty };

            //------------Assert Results-------------------------
            Assert.IsFalse(p.IsValid);
        }

        public void GivenResourceHasRights(string resourceName, string resourceRights, string groupName)
        {
            var environmentModel = ScenarioContext.Current.Get<IEnvironmentModel>("environment");
            EnsureEnvironmentConnected(environmentModel);
            var resourceRepository = environmentModel.ResourceRepository;
            var settings = resourceRepository.ReadSettings(environmentModel);
            environmentModel.ForceLoadResources();

            var resourceModel = resourceRepository.FindSingle(model => model.Category.Equals(resourceName, StringComparison.InvariantCultureIgnoreCase));
            Assert.IsNotNull(resourceModel, "Did not find: " + resourceName);
            SecPermissions resourcePermissions = SecPermissions.None;
            var permissionsStrings = resourceRights.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
            foreach(var permissionsString in permissionsStrings)
            {
                SecPermissions permission;
                if(Enum.TryParse(permissionsString.Replace(" ", ""), true, out permission))
                {
                    resourcePermissions |= permission;
                }
            }
            settings.Security.WindowsGroupPermissions.RemoveAll(permission => permission.ResourceID == resourceModel.ID);
            var windowsGroupPermission = new WindowsGroupPermission { WindowsGroup = groupName, ResourceID = resourceModel.ID, ResourceName = resourceName, IsServer = false, Permissions = resourcePermissions };
            settings.Security.WindowsGroupPermissions.Add(windowsGroupPermission);
            resourceRepository.WriteSettings(environmentModel, settings);
        }

        public void WindowsGroupPermission_IsValid_IsNotServerAndResourceNameIsEmpty_False()
        {
            //------------Setup for test--------------------------            

            //------------Execute Test---------------------------
            var p = new WindowsGroupPermission { IsServer = false, WindowsGroup = "xxx", ResourceName = string.Empty };

            //------------Assert Results-------------------------
            Assert.IsFalse(p.IsValid);
        }

 public void WindowsGroup_RemoveRow_DeleteTrue_DeletefalseEnableCellEditingTrue()
 {
     //------------Setup for test--------------------------
     var p = new WindowsGroupPermission { IsDeleted = true };
     //------------Execute Test---------------------------
     p.RemoveRow.Execute(null);
     //------------Assert Results-------------------------
     Assert.IsFalse(p.IsDeleted);
     Assert.IsTrue(p.EnableCellEditing);
 }

 public void WindowsGroupPermissions_CanRemoveRow_WindowsGroupChanges_CanExecuteChangedFires()
 {
     //------------Setup for test--------------------------
     var p = new WindowsGroupPermission { IsDeleted = false };
     var hitCount=0;
     p.RemoveRow.CanExecuteChanged += (sender, args) =>
     {
         hitCount++;
     };
     //------------Execute Test---------------------------
     p.WindowsGroup = "TestGroup";
     //------------Assert Results-------------------------
     Assert.AreEqual(1,hitCount);
 }