ConfigGroup configGroup, ConfigItem... configItemsToSetManually) { List<ConfigGroup> existentConfigGroups = configurationService.getConfiguration(configType); boolean settingsDefined = false; if (existentConfigItem == null) { existentConfigGroup.addConfigItem(configItem); configurationService.updateConfiguration(existentConfigGroup); } else if (!existentConfigItem.getValue().equals(configItem.getValue())) { existentConfigItem.setValue(configItem.getValue()); configurationService.updateConfiguration(existentConfigGroup); configurationService.addConfiguration(configGroup);
@Test public void removeConfigurationWithNamespaceTest() { final ConfigGroup config = configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace", "config", "description"); configurationService.addConfiguration(config); configurationService.removeConfiguration(config); final List<ConfigGroup> configGroups = configurationService.getConfiguration(ConfigType.REPOSITORY, "namespace"); assertEquals(0, configGroups.size()); }
public void refreshRepository(final Repository repository) { final Space space = repository.getSpace(); final Map<String, List<ConfigGroup>> repoConfigsBySpace = configurationService.getConfigurationByNamespace(REPOSITORY); final List<ConfigGroup> repoConfigs = repoConfigsBySpace.get(space.getName()); repoConfigs.stream().filter(c -> c.getName().equals(repository.getAlias())).findFirst().ifPresent(repoConfig -> { final Repository updatedRepo = repositoryFactory.newRepository(repoConfig); update(space, updatedRepo); }); } }
@Override public void removeOrganizationalUnit(String groupName) { final ConfigGroup thisGroupConfig = findGroupConfig(groupName); if (thisGroupConfig != null) { OrganizationalUnit ou = null; try { configurationService.startBatch(); configurationService.removeConfiguration(thisGroupConfig); ou = registeredOrganizationalUnits.remove(groupName); } finally { configurationService.endBatch(); if (ou != null) { removeOrganizationalUnitEvent.fire(new RemoveOrganizationalUnitEvent(ou, getUserInfo(sessionInfo))); } } } }
private void checkIfRepositoryContributorsIsNotSet(final ConfigGroup repoConfig, final Repository repository, final Space space) { if (repoConfig.getConfigItem("contributors") == null) { final Optional<ConfigGroup> spaceConfig = configurationService.getConfiguration(SPACE).stream().filter(s -> s.getName().equals(space.getName())).findFirst(); ConfigItem<List<Contributor>> spaceContributors = spaceConfig.get().getConfigItem("space-contributors"); if (spaceContributors != null) { spaceContributors.getValue().forEach(c -> repository.getContributors().add(c)); repoConfig.addConfigItem(configurationFactory.newConfigItem("contributors", repository.getContributors())); configurationService.updateConfiguration(repoConfig); } } }
public void bootstrapConfig() { ConfigGroup deploymentServiceTypeConfig = null; List<ConfigGroup> configGroups = configurationService.getConfiguration( ConfigType.GLOBAL ); if ( configGroups != null ) { for ( ConfigGroup configGroup : configGroups ) { if ( DEPLOYMENT_SERVICE_TYPE_CONFIG.equals( configGroup.getName() ) ) { deploymentServiceTypeConfig = configGroup; break; } } } if ( deploymentServiceTypeConfig == null ) { deploymentServiceTypeConfig = configurationFactory.newConfigGroup( ConfigType.GLOBAL, DEPLOYMENT_SERVICE_TYPE_CONFIG, "" ); deploymentServiceTypeConfig.addConfigItem( configurationFactory.newConfigItem( "type", "kjar" ) ); configurationService.addConfiguration( deploymentServiceTypeConfig ); } deploymentServiceType = deploymentServiceTypeConfig.getConfigItemValue( "type" ); }
protected ConfigGroup findRepositoryConfig(final String alias) { final Collection<ConfigGroup> groups = configurationService.getConfiguration(ConfigType.REPOSITORY); if (groups != null) { for (ConfigGroup groupConfig : groups) { if (groupConfig.getName().equals(alias)) { return groupConfig; } } } return null; }
configurationService.startBatch(); configurationService.updateConfiguration(thisRepositoryConfig); throw new RuntimeException(e); } finally { configurationService.endBatch();
@Test public void removeConfigurationWithoutNamespaceTest() { final ConfigGroup config = configurationFactory.newConfigGroup(ConfigType.GLOBAL, "config", "description"); configurationService.removeConfiguration(config); final List<ConfigGroup> configGroups = configurationService.getConfiguration(ConfigType.GLOBAL); assertEquals(0, configGroups.size()); }
space2RepoConfigs); when(configurationService.getConfigurationByNamespace(REPOSITORY)).thenReturn(repoConfigsBySpace); final List<ConfigGroup> spaces = Arrays.asList(createSpaceConfigGroup(SPACE1, Collections.singletonList(new Contributor("admin1", ContributorType.OWNER))), createSpaceConfigGroup(SPACE2, Collections.singletonList(new Contributor("admin2", ContributorType.OWNER)))); when(configurationService.getConfiguration(SPACE)).thenReturn(spaces);
@SuppressWarnings({"unchecked", "rawtypes"}) @Override public void removeGroup(final Project project, final String group) { final ConfigGroup thisProjectConfig = resourceResolver.findProjectConfig(project.getRootPath()); if (thisProjectConfig != null) { final ConfigItem<List> groups = backward.compat(thisProjectConfig).getConfigItem("security:groups"); groups.getValue().remove(group); configurationService.updateConfiguration(thisProjectConfig); } else { throw new IllegalArgumentException("Project " + project.getProjectName() + " not found"); } }
private void mockConfigurations() { //doReturn( new ArrayList<ConfigGroup>() ).when( configurationService ).getConfiguration( any( ConfigType.class ) ); doReturn(true).when(configurationService).updateConfiguration(any(ConfigGroup.class)); doReturn(true).when(configurationService).addConfiguration(any(ConfigGroup.class)); doReturn(new ConfigGroup()).when(configurationFactory).newConfigGroup(any(ConfigType.class), anyString(), anyString()); }
@Test public void addAndGetConfigurationByNamespaceTest() { configurationService.addConfiguration(configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace1", "repo1", "repo1-description")); configurationService.addConfiguration(configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace1", "repo2", "repo2-description")); configurationService.addConfiguration(configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace2", "repo3", "repo3-description")); final Map<String, List<ConfigGroup>> configGroupsByNamespace = configurationService.getConfigurationByNamespace(ConfigType.REPOSITORY); assertEquals(2, configGroupsByNamespace.size()); final List<ConfigGroup> repositoryNamespace1ConfigGroups = configGroupsByNamespace.get("namespace1"); assertEquals(2, repositoryNamespace1ConfigGroups.size()); assertEquals("repo1", repositoryNamespace1ConfigGroups.get(0).getName()); assertEquals("repo2", repositoryNamespace1ConfigGroups.get(1).getName()); final List<ConfigGroup> repositoryNamespace2ConfigGroups = configGroupsByNamespace.get("namespace2"); assertEquals(1, repositoryNamespace2ConfigGroups.size()); assertEquals("repo3", repositoryNamespace2ConfigGroups.get(0).getName()); }
configurationService.startBatch(); final ConfigGroup groupConfig = configurationFactory.newConfigGroup(ConfigType.ORGANIZATIONAL_UNIT, name, groupConfig.addConfigItem(configurationFactory.newConfigItem("security:groups", new ArrayList<String>())); configurationService.addConfiguration(groupConfig); configurationService.endBatch(); if (newOrganizationalUnit != null) { newOrganizationalUnitEvent.fire(new NewOrganizationalUnitEvent(newOrganizationalUnit,
private Repository createRepository(final ConfigGroup repositoryConfig, final Space space) { final Repository repository = repositoryFactory.newRepository(repositoryConfig); configurationService.addConfiguration(repositoryConfig); configuredRepositories.add(space, repository); return repository; }
@Test public void testContributorsWereSetOnReload() { final Map<String, List<ConfigGroup>> repoBySpace = configurationService.getConfigurationByNamespace(REPOSITORY); repoBySpace.keySet().forEach(space -> { repoBySpace.get(space).forEach(repoConfigGroup -> { if (space.equals(SPACE1.getName())) { verify(configurationService, never()).updateConfiguration(repoConfigGroup); } else { verify(repoConfigGroup).addConfigItem(contributorsArgumentCaptor.capture()); verify(configurationService).updateConfiguration(repoConfigGroup); final ConfigItem<List<Contributor>> configItem = contributorsArgumentCaptor.getValue(); assertEquals("contributors", configItem.getName()); final List<Contributor> contributors = configItem.getValue(); } }); }); } }
@Override public void removeDeployment(String identifier) { ConfigGroup deploymentConfig = configurationFactory.newConfigGroup(ConfigType.DEPLOYMENT, identifier, ""); configurationService.removeConfiguration(deploymentConfig); registeredDeployments.remove(identifier); }
@Test(expected = RuntimeException.class) public void addAndGetConfigurationWithNamespaceButTypeDoesNotSupportNamespacesTest() { configurationService.addConfiguration(configurationFactory.newConfigGroup(ConfigType.GLOBAL, "global1", "global1-description")); configurationService.getConfiguration(ConfigType.GLOBAL, "namespace1"); }
protected ConfigGroup findGroupConfig(final String name) { final Collection<ConfigGroup> groups = configurationService.getConfiguration(ConfigType.ORGANIZATIONAL_UNIT); if (groups != null) { for (ConfigGroup groupConfig : groups) { if (groupConfig.getName().equals(name)) { return groupConfig; } } } return null; }
@PostConstruct public void loadOrganizationalUnits() { Collection<ConfigGroup> groups = configurationService.getConfiguration(ConfigType.ORGANIZATIONAL_UNIT); if (groups != null) { for (ConfigGroup groupConfig : groups) { // Make sure existing Organizational Units are correctly initialized with a default group id. String ouName = groupConfig.getName(); String defaultGroupId = groupConfig.getConfigItemValue("defaultGroupId"); if (defaultGroupId == null || defaultGroupId.trim().isEmpty()) { groupConfig.setConfigItem(configurationFactory.newConfigItem("defaultGroupId", getSanitizedDefaultGroupId(ouName))); configurationService.updateConfiguration(groupConfig); } OrganizationalUnit ou = organizationalUnitFactory.newOrganizationalUnit(groupConfig); registeredOrganizationalUnits.put(ou.getName(), ou); } } }