How to use

ConfigurationDao

in

org.kaaproject.kaa.server.common.dao.impl

@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);
}