How to use

PersistenceDescriptorModel

in

org.kie.workbench.common.screens.datamodeller.model.persistence

private PersistenceUnitModel getPersistenceUnitModel() {
  return persistenceDescriptorEditorContent.getDescriptorModel().getPersistenceUnit();
}

private void visitPersistence( Element element ) {
  descriptorModel = new PersistenceDescriptorModel();
  descriptorModel.setVersion( element.getAttribute( PersistenceDescriptorXMLMarshaller.VERSION ) );
  NodeList children = element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.PERSISTENCE_UNIT );
  if ( children != null && children.getLength() > 0 ) {
    for ( int i = 0; i < children.getLength(); i++ ) {
      visitPersistenceUnit( (Element) children.item( i ) );
    }
  }
}

private PersistenceDescriptorModel createModel() {
  PersistenceDescriptorModel descriptorModel = new PersistenceDescriptorModel();
  descriptorModel.setPersistenceUnit(new PersistenceUnitModel());
  return descriptorModel;
}

public Document visit() {
  Element element = document.createElement( PersistenceDescriptorXMLMarshaller.PERSISTENCE );
  element.setAttribute( PersistenceDescriptorXMLMarshaller.VERSION, descriptorModel.getVersion() );
  element.setAttribute( "xmlns", "http://java.sun.com/xml/ns/persistence" );
  element.setAttribute( "xmlns:orm", "http://java.sun.com/xml/ns/persistence/orm" );
  element.setAttribute( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance" );
  element.setAttribute( "xsi:schemaLocation", "http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" );
      document.appendChild( element );
  if ( descriptorModel.getPersistenceUnit() != null ) {
    visitPersistenceUnit( element, descriptorModel.getPersistenceUnit() );
  }
  return document;
}

  private PersistenceDescriptorEditorContent newPersistenceDescriptorEditorContent() {
    final PersistenceDescriptorEditorContent content = new PersistenceDescriptorEditorContent();
    final PersistenceDescriptorModel model = new PersistenceDescriptorModel();
    model.setVersion("2.0");

    final PersistenceUnitModel unitModel = new PersistenceUnitModel();
    model.setPersistenceUnit(unitModel);

    unitModel.setName("UnitName");
    unitModel.setTransactionType(TransactionType.JTA);
    unitModel.setProvider("ProviderClass");
    unitModel.setJtaDataSource("JTADataSource");
    unitModel.setClasses(Arrays.asList(new PersistableDataObject("Class1"),
                      new PersistableDataObject("Class2")));

    content.setDescriptorModel(model);
    content.setOverview(new Overview());

    return content;
  }
}

  private PersistenceDescriptorModel createValidDescriptor() {
    PersistenceDescriptorModel descriptor = new PersistenceDescriptorModel();
    descriptor.setVersion(VERSION);
    PersistenceUnitModel unit = new PersistenceUnitModel();
    descriptor.setPersistenceUnit(unit);
    unit.setJtaDataSource(JTA_DATASOURCE);
    unit.setName(PERSISTENCE_UNIT_NAME);
    unit.setProvider(PERSISTENCE_PROVIDER);
    unit.setTransactionType(TransactionType.JTA);

    List<Property> properties = new ArrayList<>();
    properties.add(new Property("name1",
                  "value1"));
    properties.add(new Property("name2",
                  "value2"));
    unit.setProperties(properties);

    List<PersistableDataObject> classes = new ArrayList<>();
    classes.add(new PersistableDataObject(PersistableClass1.class.getName()));
    classes.add(new PersistableDataObject(PersistableClass2.class.getName()));
    classes.add(new PersistableDataObject(PersistableClass3.class.getName()));
    descriptor.getPersistenceUnit().setClasses(classes);

    return descriptor;
  }
}

private void visitPersistenceUnit( Element element ) {
  PersistenceUnitModel persistenceUnit = new PersistenceUnitModel();
  descriptorModel.setPersistenceUnit( persistenceUnit );
  persistenceUnit.setName( element.getAttribute( PersistenceDescriptorXMLMarshaller.NAME ) );
  String transactionType = element.getAttribute( PersistenceDescriptorXMLMarshaller.TRANSACTION_TYPE );
  persistenceUnit.setTransactionType( parseTransactionType( transactionType ) );
  visitDescription( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.DESCRIPTION ) );
  visitProvider( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.PROVIDER ) );
  visitJTADataSource( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.JTA_DATA_SOURCE ) );
  visitNonJTADataSource( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.NON_JTA_DATA_SOURCE ) );
  visitMappingFile( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.MAPPING_FILE ) );
  visitJarFile( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.JAR_FILE ) );
  visitClass( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.CLASS ) );
  visitExcludeUnlistedClasses( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.EXCLUDE_UNLISTED_CLASSES ) );
  visitSharedCacheMode( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.SHARED_CACHE_MODE ) );
  visitValidationMode( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.VALIDATION_MODE ) );
  visitProperties( persistenceUnit, element.getElementsByTagName( PersistenceDescriptorXMLMarshaller.PROPERTIES ) );
}

PersistenceDescriptorModel descriptorModel = new PersistenceDescriptorModel();
descriptorModel.setVersion("2.0");
descriptorModel.setPersistenceUnit(unitModel);

private void assertEqualsDescriptor( PersistenceDescriptorModel expectedDescriptor, PersistenceDescriptorModel descriptor ) {
  assertEquals( expectedDescriptor.getVersion(), descriptor.getVersion() );
  assertEqualsPersistenceUnit( expectedDescriptor.getPersistenceUnit(), descriptor.getPersistenceUnit() );
}

@Test
public void testValidateMissingPersistenceUnit() {
  descriptor.setPersistenceUnit(null);
  List<ValidationMessage> result = validator.validate(path,
                            descriptor);
  //no more errors are produced since the validation stops if the persistence unit is missing.
  assertEquals(1,
         result.size());
  ValidationMessage expectedMessage = newErrorMessage(PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NOT_FOUND_ID,
                            PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NOT_FOUND);
  assertEquals(expectedMessage,
         result.get(0));
}

public String buildJPAMarshallingStrategyValue(KieModule kieModule) {
  PersistenceDescriptorModel pdModel = pdService.load(kieModule);
  if (pdModel != null) {
    return "new org.drools.persistence.jpa.marshaller.JPAPlaceholderResolverStrategy(\"" + pdModel.getPersistenceUnit().getName() + "\", classLoader)";
  }
  return null;
}

private PersistenceDescriptorModel expectedDescriptor() {
  PersistenceDescriptorModel descriptor = new PersistenceDescriptorModel();
  descriptor.setVersion( "2.1" );
  PersistenceUnitModel persistenceUnit = new PersistenceUnitModel();
  descriptor.setPersistenceUnit( persistenceUnit );
  persistenceUnit.setName( "org.test.persistence-unit" );
  persistenceUnit.setDescription( "org.test.description" );
  persistenceUnit.setProvider( "org.test.Provider" );
  persistenceUnit.setJtaDataSource( "java:jboss/datasources/ExampleDS" );
  persistenceUnit.getMappingFile().add( "META-INF/Mapping1.xml" );
  persistenceUnit.getMappingFile().add( "META-INF/Mapping2.xml" );
  persistenceUnit.getJarFile().add( "file1.jar" );
  persistenceUnit.getJarFile().add( "file2.jar" );
  persistenceUnit.getClasses().add(new PersistableDataObject("org.test.Entity1") );
  persistenceUnit.getClasses().add( new PersistableDataObject("org.test.Entity2") );
  persistenceUnit.setExcludeUnlistedClasses( true );
  persistenceUnit.setSharedCacheMode( CachingType.ALL );
  persistenceUnit.setValidationMode( ValidationMode.AUTO );
  persistenceUnit.setTransactionType( TransactionType.JTA );
  persistenceUnit.addProperty( new Property( "property1", "property1_value" ) );
  persistenceUnit.addProperty( new Property( "property2", "property2_value" ) );
  return descriptor;
}

public String buildJPAMarshallingStrategyValue(KieModule kieModule) {
  PersistenceDescriptorModel pdModel = pdService.load(kieModule);
  if (pdModel != null) {
    return "new org.drools.persistence.jpa.marshaller.JPAPlaceholderResolverStrategy(\"" + pdModel.getPersistenceUnit().getName() + "\", classLoader)";
  }
  return null;
}

public void onDataObjectDeleted(@Observes DataObjectDeletedEvent event) {
  Path descriptorPath;
  PersistenceDescriptorModel persistenceDescriptor;
  descriptorPath = descriptorService.calculatePersistenceDescriptorPath(event.getCurrentModule());
  persistenceDescriptor = safeLoad(descriptorPath);
  if (persistenceDescriptor != null &&
      containsClass(persistenceDescriptor.getPersistenceUnit(), event.getCurrentDataObject().getClassName())) {
    persistenceDescriptor.getPersistenceUnit().getClasses().remove(new PersistableDataObject(event.getCurrentDataObject().getClassName()));
    descriptorService.save(descriptorPath,
                persistenceDescriptor,
                null,
                "Entity removed from persistence descriptor");
  }
}

@Test
public void onNonPersistableDataObjectCreatedTest() {
  descriptorModel.getPersistenceUnit().getClasses().add(new PersistableDataObject("package1.PersistableObject"));
  DataObjectCreatedEvent createdEvent = new DataObjectCreatedEvent(module, dataObject);
  eventObserver.onDataObjectCreated(createdEvent);
  verify(descriptorService, times(0)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString());
  assertEquals(1, descriptorModel.getPersistenceUnit().getClasses().size());
}

if (model.getPersistenceUnit() == null) {
  messages.add(newErrorMessage(PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NOT_FOUND_ID,
                 PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NOT_FOUND));
final PersistenceUnitModel unitModel = model.getPersistenceUnit();
if (unitModel.getName() == null || unitModel.getName().trim().isEmpty()) {
  messages.add(newErrorMessage(PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NAME_EMPTY_ID,

public void onDataObjectCreated(@Observes DataObjectCreatedEvent event) {
  Path descriptorPath;
  PersistenceDescriptorModel persistenceDescriptor;
  if (isPersistable(event.getCurrentDataObject())) {
    descriptorPath = descriptorService.calculatePersistenceDescriptorPath(event.getCurrentModule());
    persistenceDescriptor = safeLoad(descriptorPath);
    if (persistenceDescriptor != null &&
        !containsClass(persistenceDescriptor.getPersistenceUnit(), event.getCurrentDataObject().getClassName())) {
      persistenceDescriptor.getPersistenceUnit().getClasses().add(new PersistableDataObject(event.getCurrentDataObject().getClassName()));
      descriptorService.save(descriptorPath,
                  persistenceDescriptor,
                  null,
                  "Entity added to persistence descriptor");
    }
  }
}

@Test
public void testValidateNonPersistableClass() {
  //add a non persistable class
  descriptor.getPersistenceUnit().getClasses().add(new PersistableDataObject(NonPersistableClass1.class.getName()));
  List<ValidationMessage> result = validator.validate(path,
                            descriptor);
  ValidationMessage expectedMessage;
  //validation for the non persistable class should fail.
  expectedMessage = newErrorMessage(PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE_ID,
                   MessageFormat.format(PersistenceDescriptorValidationMessages.CLASS_NOT_PERSISTABLE,
                              NonPersistableClass1.class.getName()),
                   NonPersistableClass1.class.getName());
  assertTrue(result.contains(expectedMessage));
}

@Test
public void onNonPersistableDataObjectDeletedTest() {
  DataObject dataObject = new DataObjectImpl("package1", "NonPersistableObject");
  DataObjectCreatedEvent createdEvent = new DataObjectCreatedEvent(module, dataObject);
  eventObserver.onDataObjectCreated(createdEvent);
  descriptorModel.getPersistenceUnit().getClasses().add(new PersistableDataObject(createdEvent.getCurrentDataObject().getClassName()));
  verify(descriptorService, times(0)).save(eq(descriptorPath), eq(descriptorModel), any(Metadata.class), anyString());
  assertEquals(1, descriptorModel.getPersistenceUnit().getClasses().size());
}

@Test
public void testValidateMissingNonJtaDataSource() {
  descriptor.getPersistenceUnit().setTransactionType(TransactionType.RESOURCE_LOCAL);
  descriptor.getPersistenceUnit().setNonJtaDataSource(null);
  List<ValidationMessage> result = validator.validate(path,
                            descriptor);
  ValidationMessage expectedMessage;
  //jta datasource validation should fail
  expectedMessage = newErrorMessage(PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NON_JTA_DATASOURCE_EMPTY_ID,
                   PersistenceDescriptorValidationMessages.PERSISTENCE_UNIT_NON_JTA_DATASOURCE_EMPTY);
  assertTrue(result.contains(expectedMessage));
}