@Override public ChangeConfigurationNotification deleteConfigurationRecord( String schemaId, String groupId, String deactivatedUsername) { ChangeConfigurationNotification configurationNotification = null; validateSqlId(schemaId, "Incorrect configuration schema id " + schemaId + "."); validateSqlId(groupId, "Incorrect group id " + groupId + "."); ConfigurationDto configurationDto = getDto(configurationDao.deactivateOldConfiguration( schemaId, groupId, deactivatedUsername)); if (configurationDto != null) { HistoryDto historyDto = addHistory(configurationDto, ChangeType.REMOVE_CONF); ChangeNotificationDto changeNotificationDto = createNotification( configurationDto, historyDto); configurationNotification = new ChangeConfigurationNotification(); configurationNotification.setConfigurationDto(configurationDto); configurationNotification.setChangeNotificationDto(changeNotificationDto); } Configuration configuration = configurationDao.findInactiveBySchemaIdAndGroupId( schemaId, groupId); if (configuration != null) { configurationDao.removeById(idToString(configuration)); } return configurationNotification; }
@Override public List<ConfigurationDto> findConfigurationsByEndpointGroupId(String endpointGroupId) { validateSqlId(endpointGroupId, "Incorrect endpoint group id " + endpointGroupId); return convertDtoList(configurationDao.findActiveByEndpointGroupId(endpointGroupId)); }
@Override public Collection<ConfigurationRecordDto> findAllConfigurationRecordsByEndpointGroupId( String endpointGroupId, boolean includeDeprecated) { Collection<ConfigurationDto> configurations = convertDtoList( configurationDao.findActualByEndpointGroupId(endpointGroupId)); List<ConfigurationRecordDto> records = ConfigurationRecordDto.convertToConfigurationRecords(configurations); if (includeDeprecated) { List<VersionDto> schemas = findVacantSchemasByEndpointGroupId(endpointGroupId); for (VersionDto schema : schemas) { ConfigurationDto deprecatedConfiguration = getDto( configurationDao.findLatestDeprecated(schema.getId(), endpointGroupId)); if (deprecatedConfiguration != null) { ConfigurationRecordDto record = new ConfigurationRecordDto(); record.setActiveStructureDto(deprecatedConfiguration); records.add(record); } } } Collections.sort(records); return records; }
ChangeConfigurationNotification configurationNotification; validateSqlId(id, "Incorrect configuration id. Can't activate configuration with id " + id); Configuration oldConfiguration = configurationDao.findById(id); if (oldConfiguration != null) { UpdateStatus status = oldConfiguration.getStatus(); String groupId = oldConfiguration.getEndpointGroupId(); if (schemaId != null && groupId != null) { configurationDao.deactivateOldConfiguration(schemaId, groupId, activatedUsername); } else { throw new DatabaseProcessingException( "Incorrect old configuration. Configuration schema or endpoint group id is empty."); ConfigurationDto configurationDto = getDto(configurationDao.activate( id, activatedUsername)); HistoryDto historyDto = addHistory(configurationDto, ChangeType.ADD_CONF);
configurationSchemaDto = findConfSchemaById(schemaId); if (configurationSchemaDto != null) { Configuration oldInactiveConfiguration = configurationDao.findInactiveBySchemaIdAndGroupId( schemaId, groupId); oldActiveConfiguration = configurationDao.findLatestActiveBySchemaIdAndGroupId( schemaId, groupId); if (oldInactiveConfiguration != null) { return getDto(configurationDao.save(new Configuration(configurationDto)));
@Test public void deactivateTest() { List<Configuration> configs = generateConfiguration(null, null, 1, UpdateStatus.ACTIVE); Assert.assertEquals(1, configs.size()); Configuration first = configs.get(0); Assert.assertEquals(UpdateStatus.ACTIVE, first.getStatus()); Configuration deactivated = configurationDao.deactivate(first.getId().toString(), "Test user"); Configuration found = configurationDao.findById(first.getId().toString()); Assert.assertEquals(UpdateStatus.DEPRECATED, deactivated.getStatus()); Assert.assertEquals(deactivated, found); }
@Test public void activateTest() { List<Configuration> configs = generateConfiguration(null, null, 1, null); Assert.assertEquals(1, configs.size()); Configuration first = configs.get(0); Configuration activated = configurationDao.activate(first.getId().toString(), "Test user"); Configuration found = configurationDao.findById(first.getId().toString()); Assert.assertEquals(UpdateStatus.ACTIVE, activated.getStatus()); Assert.assertEquals(activated, found); }
@Override public ConfigurationRecordDto findConfigurationRecordBySchemaIdAndEndpointGroupId( String schemaId, String endpointGroupId) { ConfigurationRecordDto record = new ConfigurationRecordDto(); Collection<ConfigurationDto> configurations = convertDtoList( configurationDao.findActualBySchemaIdAndGroupId(schemaId, endpointGroupId)); if (configurations != null) { for (ConfigurationDto configuration : configurations) { if (configuration.getStatus() == UpdateStatus.ACTIVE) { record.setActiveStructureDto(configuration); } else if (configuration.getStatus() == UpdateStatus.INACTIVE) { record.setInactiveStructureDto(configuration); } } } if (!record.hasActive()) { ConfigurationDto deprecatedConfiguration = getDto( configurationDao.findLatestDeprecated(schemaId, endpointGroupId)); if (deprecatedConfiguration != null) { record.setActiveStructureDto(deprecatedConfiguration); } } if (record.isEmpty()) { LOG.debug("Can't find related Configuration record."); throw new NotFoundException("Configuration record not found, schemaId: " + schemaId + ", endpointGroupId: " + endpointGroupId); // NOSONAR } return record; }
@Test public void deactivateOldConfigurationTest() { List<Configuration> configs = generateConfiguration(null, null, 1, UpdateStatus.ACTIVE); Assert.assertEquals(1, configs.size()); Configuration first = configs.get(0); ConfigurationSchema schema = first.getConfigurationSchema(); EndpointGroup group = first.getEndpointGroup(); Assert.assertEquals(UpdateStatus.ACTIVE, first.getStatus()); Configuration deactivated = configurationDao.deactivateOldConfiguration(schema.getId().toString(), group.getId().toString(), "Test user"); Configuration found = configurationDao.findById(first.getId().toString()); Assert.assertEquals(UpdateStatus.DEPRECATED, deactivated.getStatus()); Assert.assertEquals(deactivated, found); } }
@Test public void removeByEndpointGroupIdTest() { List<Configuration> configs = generateConfiguration(null, null, 3, UpdateStatus.ACTIVE); Assert.assertEquals(3, configs.size()); Long id = configs.get(0).getId(); EndpointGroup group = configs.get(0).getEndpointGroup(); configurationDao.removeByEndpointGroupId(group.getId().toString()); Configuration found = configurationDao.findById(id.toString()); Assert.assertNull(found); }
@Test public void removeByConfigurationSchemaIdTest() { List<Configuration> configs = generateConfiguration(null, null, 3, UpdateStatus.ACTIVE); Assert.assertEquals(3, configs.size()); Long id = configs.get(0).getId(); ConfigurationSchema schema = configs.get(0).getConfigurationSchema(); configurationDao.removeByConfigurationSchemaId(schema.getId().toString()); Configuration found = configurationDao.findById(id.toString()); Assert.assertNull(found); }
@Override public ConfigurationDto findConfigurationByEndpointGroupIdAndVersion(String endpointGroupId, int version) { validateId(endpointGroupId, "Endpoint group id is incorrect. " + "Can't find configuration by endpoint group id " + endpointGroupId + " and version " + version); return getDto(configurationDao.findConfigurationByEndpointGroupIdAndVersion( endpointGroupId, version)); }
@Override @Deprecated public ConfigurationDto findConfigurationByAppIdAndVersion(String applicationId, int version) { validateSqlId(applicationId, "Application id is incorrect. " + "Can't find configuration by application id " + applicationId + " and version " + version); return getDto(configurationDao.findConfigurationByAppIdAndVersion(applicationId, version)); }
@Override public List<VersionDto> findVacantSchemasByEndpointGroupId(String endpointGroupId) { validateId(endpointGroupId, "Can't find vacant schemas. Invalid endpoint group id: " + endpointGroupId); EndpointGroup group = endpointGroupDao.findById(endpointGroupId); List<Configuration> configurations = configurationDao.findActualByEndpointGroupId( endpointGroupId); List<String> usedSchemaIds = new ArrayList<>(); for (Configuration configuration : configurations) { ConfigurationSchema schema = configuration.getConfigurationSchema(); if (schema != null) { usedSchemaIds.add(idToString(schema.getId())); } } List<ConfigurationSchema> schemas = configurationSchemaDao.findVacantSchemas( group.getApplicationId(), usedSchemaIds); List<VersionDto> schemaDtoList = new ArrayList<>(); for (ConfigurationSchema schema : schemas) { schemaDtoList.add(schema.toVersionDto()); } return schemaDtoList; }
@Override public ConfigurationDto findConfigurationById(String id) { validateSqlId(id, "Configuration id is incorrect. Can't find configuration by id " + id); return getDto(configurationDao.findById(id)); }
@Test public void findInactiveBySchemaIdAndGroupIdTest() { List<Configuration> configs = generateConfiguration(null, null, 1, UpdateStatus.ACTIVE); Assert.assertEquals(1, configs.size()); Configuration first = configs.get(0); EndpointGroup group = first.getEndpointGroup(); ConfigurationSchema schema = first.getConfigurationSchema(); List<Configuration> inactiveConfigs = generateConfiguration(schema, group, 1, UpdateStatus.INACTIVE); generateConfiguration(schema, group, 3, UpdateStatus.DEPRECATED); Configuration found = configurationDao.findInactiveBySchemaIdAndGroupId(schema.getId().toString(), group.getId().toString()); Assert.assertEquals(inactiveConfigs.get(0), found); }
@Test public void findActualBySchemaIdAndGroupIdTest() { List<Configuration> configs = generateConfiguration(null, null, 4, UpdateStatus.DEPRECATED); Configuration first = configs.get(0); EndpointGroup group = first.getEndpointGroup(); ConfigurationSchema schema = first.getConfigurationSchema(); List<Configuration> active = generateConfiguration(schema, group, 1, UpdateStatus.ACTIVE); generateConfiguration(null, group, 1, UpdateStatus.ACTIVE); List<Configuration> inactive = generateConfiguration(schema, group, 1, UpdateStatus.INACTIVE); List<Configuration> actual = new ArrayList<>(); actual.addAll(active); actual.addAll(inactive); List<Configuration> found = configurationDao.findActualBySchemaIdAndGroupId(schema.getId().toString(), group.getId().toString()); Assert.assertEquals(actual.size(), found.size()); Assert.assertEquals(actual, found); }
@Override public ChangeConfigurationNotification deactivateConfiguration( String id, String deactivatedUsername) { ChangeConfigurationNotification configurationNotification; validateSqlId(id, "Incorrect configuration id. Can't deactivate configuration with id " + id); Configuration oldConfiguration = configurationDao.findById(id); if (oldConfiguration != null) { UpdateStatus status = oldConfiguration.getStatus(); if (status != null && status == ACTIVE) { ConfigurationDto configurationDto = getDto(configurationDao.deactivate( id, deactivatedUsername)); HistoryDto historyDto = addHistory(configurationDto, ChangeType.REMOVE_CONF); ChangeNotificationDto changeNotificationDto = createNotification( configurationDto, historyDto); configurationNotification = new ChangeConfigurationNotification(); configurationNotification.setConfigurationDto(configurationDto); configurationNotification.setChangeNotificationDto(changeNotificationDto); } else { throw new UpdateStatusConflictException("Incorrect status for activating configuration " + status); } } else { throw new IncorrectParameterException("Can't find configuration with id " + id); } return configurationNotification; }
@Override public ConfigurationDto findDefaultConfigurationBySchemaId(String schemaId) { validateId(schemaId, "Schema id is incorrect. Can't find default configuration by schema id " + schemaId); ConfigurationDto configuration = null; ConfigurationSchema configurationSchema = configurationSchemaDao.findById(schemaId); if (configurationSchema != null) { String appId = configurationSchema.getApplicationId(); EndpointGroup endpointGroup = endpointGroupDao.findByAppIdAndWeight(appId, 0); if (endpointGroup != null) { String endpointGroupId = String.valueOf(endpointGroup.getId()); configuration = getDto(configurationDao.findConfigurationByEndpointGroupIdAndVersion( endpointGroupId, configurationSchema.getVersion())); } else { LOG.warn("Can't find default group for application [{}]", appId); } } else { LOG.warn("Can't find configuration schema for id [{}]", schemaId); } return configuration; }
@Test public void findConfigurationByAppIdAndVersionTest() { List<Configuration> configs = generateConfiguration(null, null, 1, UpdateStatus.ACTIVE); Assert.assertEquals(1, configs.size()); Configuration first = configs.get(0); Application app = first.getApplication(); Configuration found = configurationDao.findConfigurationByAppIdAndVersion(app.getId().toString(), first.getSchemaVersion()); Assert.assertEquals(first, found); }