How to use

EventClassFamilyDao

in

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

@Override
public EventClassFamilyDto findEventClassFamilyByEcfvId(String id) {
 validateSqlId(id, "Event class family version id is incorrect. Can't find event class family "
          + "by ECF version id " + id);
 return getDto(eventClassFamilyDao.findByEcfvId(id));
}

@Override
public EventClassFamilyDto findEventClassFamilyById(String id) {
 validateSqlId(id, "Event class family id is incorrect. Can't find event class family by id "
          + id);
 return getDto(eventClassFamilyDao.findById(id));
}

@Override
public List<EventClassFamilyDto> findEventClassFamiliesByTenantId(
  String tenantId) {
 List<EventClassFamilyDto> eventClassFamilies;
 if (isValidSqlId(tenantId)) {
  LOG.debug("Find event class families by tenant id [{}]", tenantId);
  eventClassFamilies = convertDtoList(eventClassFamilyDao.findByTenantId(tenantId));
 } else {
  throw new IncorrectParameterException("Incorrect tenant id: " + tenantId);
 }
 return eventClassFamilies;
}

EventClassFamilyDto savedEventClassFamilyDto = null;
if (isValidSqlObject(eventClassFamilyDto)) {
 if (eventClassFamilyDao.validateName(eventClassFamilyDto.getTenantId(),
     eventClassFamilyDto.getId(), eventClassFamilyDto.getName())) {
  if (StringUtils.isBlank(eventClassFamilyDto.getId())) {
   if (NamesValidator.validateNamespace(eventClassFamilyDto.getNamespace())) {
    if (NamesValidator.validateClassName(eventClassFamilyDto.getClassName())) {
     if (eventClassFamilyDao.validateClassName(eventClassFamilyDto.getTenantId(),
         eventClassFamilyDto.getId(), eventClassFamilyDto.getClassName())) {
      eventClassFamilyDto.setCreatedTime(System.currentTimeMillis());
  savedEventClassFamilyDto = getDto(eventClassFamilyDao.save(new EventClassFamily(
      eventClassFamilyDto)));
 } else {

@Test
public void findByTenantIdAndNameTest() {
 List<EventClassFamily> eventClassFamilies = generateEventClassFamily(null, 2);
 EventClassFamily dto = eventClassFamilyDao.findById(eventClassFamilies.get(0).getStringId());
 Assert.assertNotNull(dto);
 EventClassFamily eventClassFamily = eventClassFamilyDao.findByTenantIdAndName(dto.getTenant().getStringId(), dto.getName());
 Assert.assertNotNull(eventClassFamily);
 Assert.assertEquals(dto, eventClassFamily);
}

 @Test
 public void findByEcfvIdTest() {
  List<EventClassFamily> eventClassFamilies = generateEventClassFamily(null, 1);
  EventClassFamily ecf = eventClassFamilies.get(0);
  List<EventClassFamilyVersion> ecfvList = generateEventClassFamilyVersion(ecf, 1, 1);
  ecf.setSchemas(ecfvList);
  ecf = eventClassFamilyDao.save(ecf);

  EventClassFamilyVersion ecfv = ecfvList.get(0);
  EventClassFamily ecfByEcfv = eventClassFamilyDao.findByEcfvId(ecfv.getStringId());
  Assert.assertNotNull(ecfByEcfv);
  Assert.assertEquals(ecf, ecfByEcfv);
  Assert.assertEquals(ecfByEcfv.getSchemas().size(), 1);
  if (ecfByEcfv.getSchemas().size() == 1) {
   Assert.assertEquals(ecfByEcfv.getSchemas().get(0).getRecords().size(), 1);
  } else {
   throw new AssertionError("There should be 1 ecfv in fetched ecf, but got: " + ecfByEcfv.getSchemas().size());
  }
 }
}

@Test
public void findByTenantIdTest() {
 List<EventClassFamily> eventClassFamilies = generateEventClassFamily(null, 2);
 EventClassFamily dto = eventClassFamilyDao.findById(eventClassFamilies.get(0).getStringId());
 Assert.assertNotNull(dto);
 List<EventClassFamily> eventClassFamilyList = eventClassFamilyDao.findByTenantId(dto.getTenant().getStringId());
 EventClassFamily eventClassFamily = null;
 for (EventClassFamily found : eventClassFamilyList) {
  if (dto.getId().equals(found.getId())) {
   eventClassFamily = found;
  }
 }
 Assert.assertNotNull(eventClassFamily);
 Assert.assertEquals(dto, eventClassFamily);
}

@Test
public void removeById() {
 List<EventClassFamily> eventClassFamilies = generateEventClassFamily(null, 2);
 EventClassFamily eventClassFamily = eventClassFamilies.get(0);
 EventClassFamily dto = eventClassFamilyDao.findById(eventClassFamily.getStringId());
 Assert.assertNotNull(dto);
 eventClassFamilyDao.removeById(eventClassFamily.getStringId());
 dto = eventClassFamilyDao.findById(eventClassFamily.getStringId());
 Assert.assertNull(dto);
}

@Test
public void removeByTenantId() {
 List<EventClassFamily> eventClassFamilies = generateEventClassFamily(null, 2);
 EventClassFamily eventClassFamily = eventClassFamilies.get(0);
 EventClassFamily dto = eventClassFamilyDao.findById(eventClassFamily.getStringId());
 Assert.assertNotNull(dto);
 Assert.assertNotNull(dto.getTenant());
 eventClassFamilyDao.removeByTenantId(dto.getTenant().getStringId());
 dto = eventClassFamilyDao.findById(eventClassFamily.getStringId());
 Assert.assertNull(dto);
}

 EventClassFamily ecf = new EventClassFamily(eventClassFamily);
 ecf.setSchemas(schemas);
 eventClassFamilyDao.save(ecf);
} else {
 LOG.debug("Can't process event class family schema.");

@Override
public EventClassFamilyDto findEventClassFamilyByTenantIdAndName(String tenantId, String name) {
 if (isValidSqlId(tenantId)) {
  LOG.debug("Find event class family by tenant id [{}] and name {}", tenantId, name);
  return eventClassFamilyDao.findByTenantIdAndName(tenantId, name).toDto();
 } else {
  throw new IncorrectParameterException("Incorrect tenant id: " + tenantId);
 }
}

protected List<EventClass> generateEventClass(Tenant tenant, EventClassFamily eventClassFamily, int count) {
 if (tenant == null) {
  tenant = generateTenant();
 }
 if (eventClassFamily == null) {
  eventClassFamily = generateEventClassFamily(tenant, 1).get(0);
 }
 List<EventClassFamilyVersion> ecfvList = generateEventClassFamilyVersion(eventClassFamily, 1, count);
 eventClassFamily.setSchemas(ecfvList);
 eventClassFamily = eventClassFamilyDao.save(eventClassFamily);
 List<EventClass> storedECs = eventClassFamily.getSchemas().get(0).getRecords();
 return storedECs;
}

 @Override
 public Set<String> getFqnSetForEcf(String ecfId) {
  if (isValidSqlId(ecfId)) {
   LOG.debug("Get fqn list for event class family by id [{}] ", ecfId);
   Set<String> storedFqns = new HashSet<>();
   EventClassFamily ecf = eventClassFamilyDao.findById(ecfId);
   ecf.getSchemas().forEach(ecfv -> ecfv.getRecords()
       .forEach(ec -> storedFqns.add(ec.getFqn())));
   return storedFqns;
  } else {
   throw new IncorrectParameterException("Incorrect event class family id: " + ecfId);
  }
 }
}

protected List<EventClassFamily> generateEventClassFamily(Tenant tenant, int count) {
 if (tenant == null) {
  tenant = generateTenant();
 }
 EventClassFamily eventClassFamily;
 List<EventClassFamily> eventClassFamilies = new ArrayList<>(count);
 for (int i = 0; i < count; i++) {
  eventClassFamily = new EventClassFamily();
  eventClassFamily.setTenant(tenant);
  eventClassFamily.setClassName("Test ClassName" + RANDOM.nextInt());
  eventClassFamily.setCreatedTime(new Date().getTime());
  eventClassFamily.setCreatedUsername("Test Username");
  eventClassFamily.setDescription("Test Description");
  eventClassFamily.setName("Test Name" + RANDOM.nextInt());
  eventClassFamily.setNamespace("Test Namespace");
  eventClassFamily = eventClassFamilyDao.save(eventClassFamily);
  Assert.assertNotNull(eventClassFamily);
  eventClassFamilies.add(eventClassFamily);
 }
 return eventClassFamilies;
}

if (application != null) {
 String tenantId = application.getTenantId();
 List<EventClassFamily> eventClassFamilies = eventClassFamilyDao.findByTenantId(tenantId);
 List<AefMapInfoDto> aefMaps = findEventClassFamiliesByApplicationId(applicationId);
 List<EcfInfoDto> occupiedEcfs = new ArrayList<>();

@Override
public boolean isValidEcfListInSdkProfile(List<AefMapInfoDto> aefList) {
 Set<EventClass> ecList = new HashSet<>();
 for (AefMapInfoDto aef : aefList) {
  EventClassFamily ecf = eventClassFamilyDao.findById(aef.getEcfId());
  Optional<EventClassFamilyVersion> optEcfv = ecf.getSchemas().stream()
    .filter(ecfv -> ecfv.getVersion() == aef.getVersion())
    .findFirst();
  if (optEcfv.isPresent()) {
   for (EventClass ec : optEcfv.get().getRecords()) {
    if (!ecList.add(ec)) {
     return false;
    }
   }
  }
 }
 return true;
}

@Override
public List<EventClassFamilyVersionDto> findEventClassFamilyVersionsByEcfId(String ecfId) {
 validateSqlId(ecfId, "Event class family id is incorrect. Can't find event class family by id "
            + ecfId);
 EventClassFamily ecf = eventClassFamilyDao.findById(ecfId);
 return convertDtoList(ecf.getSchemas());
}

@Override
public List<EventClassDto> findEventClassesByFamilyIdVersionAndType(String ecfId, int version,
                                  EventClassType type) {
 List<EventClassDto> eventClasses = new ArrayList<>();
 if (isValidSqlId(ecfId)) {
  LOG.debug("Find event classes by family id [{}] version [{}] and type [{}]",
      ecfId, version, type);
  EventClassFamily ecf = eventClassFamilyDao.findById(ecfId);
  Optional<EventClassFamilyVersion> ecfv = ecf.getSchemas().stream()
      .filter(s -> s.getVersion() == version).findFirst();
  if (type == null) {
   ecfv.ifPresent(
     e -> eventClasses.addAll(convertDtoList(e.getRecords())));
  } else {
   ecfv.ifPresent(
     e -> eventClasses.addAll(convertDtoList(e.getRecords().stream()
       .filter(ec -> ec.getType() == type)
       .collect(Collectors.toList()))));
  }
 } else {
  throw new IncorrectParameterException("Incorrect event class family id: " + ecfId);
 }
 return eventClasses;
}