private void processAnnotationScanningResults(
List<EntityProcessorOutput> entityProcessorOutput,
Map<String, List<LookupDto>> lookupProcessingResult) {
Map<String, Long> entityIdMappings = new HashMap<>();
for (EntityProcessorOutput result : entityProcessorOutput) {
EntityDto processedEntity = result.getEntityProcessingResult();
EntityDto entity = entityService.getEntityByClassName(processedEntity.getClassName());
if (entity == null) {
entity = entityService.createEntity(processedEntity);
}
entityIdMappings.put(entity.getClassName(), entity.getId());
entityService.updateRestOptions(entity.getId(), result.getRestProcessingResult());
entityService.updateTracking(entity.getId(), result.getTrackingProcessingResult());
entityService.addFields(entity, result.getFieldProcessingResult());
entityService.addFilterableFields(entity, result.getUiFilterableProcessingResult());
entityService.addDisplayedFields(entity, result.getUiDisplayableProcessingResult());
entityService.updateSecurityOptions(
entity.getId(), processedEntity.getSecurityMode(), processedEntity.getSecurityMembers());
entityService.updateMaxFetchDepth(entity.getId(), processedEntity.getMaxFetchDepth());
entityService.addNonEditableFields(entity, result.getNonEditableProcessingResult());
}
for (Map.Entry<String, List<LookupDto>> entry : lookupProcessingResult.entrySet()) {
entityService.addLookups(entityIdMappings.get(entry.getKey()), entry.getValue());
}
}
@Override
public long countTrashRecords(Long entityId) {
EntityDto entity = getEntity(entityId);
validateCredentialsForReading(entity);
return trashService.countTrashRecords(entity.getClassName());
}
@Override
public List<EntityRecord> getTrashRecords(Long entityId, QueryParams queryParams) {
EntityDto entity = getEntity(entityId);
validateCredentialsForReading(entity);
MotechDataService service = getServiceForEntity(entity);
List<FieldDto> fields = entityService.getEntityFields(entityId);
Collection collection = trashService.getInstancesFromTrash(entity.getClassName(), queryParams);
return instancesToRecords(collection, entity, fields, service);
}
private void mockAnotherEntity() {
EntityDto entityWithRelatedField = mock(EntityDto.class);
when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(entityWithRelatedField);
when(entityWithRelatedField.getClassName()).thenReturn(AnotherSample.class.getName());
when(entityWithRelatedField.getName()).thenReturn(AnotherSample.class.getSimpleName());
ServiceReference serviceReferenceForAnotherSample = mock(ServiceReference.class);
when(bundleContext.getServiceReference(
ClassName.getInterfaceName(AnotherSample.class.getName())))
.thenReturn(serviceReferenceForAnotherSample);
when(bundleContext.getService(serviceReferenceForAnotherSample))
.thenReturn(serviceForAnotherSample);
}
private Class<?> getEntityClass(EntityDto entity) throws ClassNotFoundException {
// get the declaring bundle, for DDE the module bundle, for EUDE the generated entities bundle
Bundle declaringBundle;
if (entity.isDDE()) {
declaringBundle = MdsBundleHelper.searchForBundle(bundleContext, entity);
} else {
declaringBundle =
WebBundleUtil.findBundleBySymbolicName(
bundleContext, Constants.BundleNames.MDS_ENTITIES_SYMBOLIC_NAME);
}
Class<?> clazz;
// if no bundle found, fallback to the MDSClassLoader
if (declaringBundle == null) {
clazz = MDSClassLoader.getInstance().loadClass(entity.getClassName());
} else {
clazz = declaringBundle.loadClass(entity.getClassName());
}
return clazz;
}
private HistoryRecord convertToHistoryRecord(
Object object, EntityDto entity, Long instanceId, MotechDataService service) {
Long entityId = entity.getId();
EntityRecord entityRecord =
instanceToRecord(object, entity, entityService.getEntityFields(entityId), service);
Long historyInstanceSchemaVersion =
(Long)
PropertyUtil.safeGetProperty(
object, HistoryTrashClassHelper.schemaVersion(object.getClass()));
Long currentSchemaVersion = entityService.getCurrentSchemaVersion(entity.getClassName());
return new HistoryRecord(
entityRecord.getId(),
instanceId,
historyInstanceSchemaVersion.equals(currentSchemaVersion),
entityRecord.getFields());
}
private void mockEntity(Class<?> entityClass, long entityId, EntityDto entity) {
when(entityService.getEntity(entityId)).thenReturn(entity);
when(entityService.getEntityByClassName(entityClass.getName())).thenReturn(entity);
when(entity.getClassName()).thenReturn(entityClass.getName());
when(entity.getId()).thenReturn(entityId);
}
private void mockTestClassEntity() {
EntityDto testClassEntity = mock(EntityDto.class);
when(testClassEntity.getClassName()).thenReturn(TestClass.class.getName());
when(testClassEntity.getId()).thenReturn(TEST_CLASS_ID);
mockEntity(TestClass.class, TEST_CLASS_ID, testClassEntity);
}
@Test
public void shouldUpdateRelatedFields() {
TestSample test1 = new TestSample("someString", 4);
TestSample test2 = new TestSample("otherString", 5);
TestSample test3 = new TestSample("sample", 6);
RelationshipsUpdate oneToOneUpdate = new RelationshipsUpdate();
oneToOneUpdate.getAddedIds().add(6L);
RelationshipsUpdate oneToManyUpdate = buildRelationshipUpdate();
List<FieldRecord> fieldRecords =
asList(
FieldTestHelper.fieldRecord("title", String.class.getName(), "String field", "Default"),
FieldTestHelper.fieldRecord(
TypeDto.ONE_TO_MANY_RELATIONSHIP, "testSamples", "Related field", oneToManyUpdate),
FieldTestHelper.fieldRecord(
TypeDto.ONE_TO_ONE_RELATIONSHIP,
"testSample",
"Other Related field",
oneToOneUpdate));
EntityRecord entityRecord = new EntityRecord(null, ANOTHER_ENTITY_ID, fieldRecords);
mockSampleFields();
mockDataService();
mockEntity();
EntityDto entityWithRelatedField = mock(EntityDto.class);
when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(entityWithRelatedField);
when(entityWithRelatedField.getClassName()).thenReturn(AnotherSample.class.getName());
when(entityWithRelatedField.getId()).thenReturn(ENTITY_ID + 1);
ServiceReference serviceReferenceForClassWithRelatedField = mock(ServiceReference.class);
MotechDataService serviceForClassWithRelatedField = mock(MotechDataService.class);
when(bundleContext.getServiceReference(
ClassName.getInterfaceName(AnotherSample.class.getName())))
.thenReturn(serviceReferenceForClassWithRelatedField);
when(bundleContext.getService(serviceReferenceForClassWithRelatedField))
.thenReturn(serviceForClassWithRelatedField);
when(motechDataService.findById(4L)).thenReturn(test1);
when(motechDataService.findById(5L)).thenReturn(test2);
when(motechDataService.findById(6L)).thenReturn(test3);
when(motechDataService.findByIds(oneToManyUpdate.getAddedIds()))
.thenReturn(Arrays.asList(test1, test2));
when(entityService.getEntityFieldsForUI(ANOTHER_ENTITY_ID))
.thenReturn(
asList(
FieldTestHelper.fieldDto(
5L, "title", String.class.getName(), "String field", "Default"),
FieldTestHelper.fieldDto(
6L,
"testSamples",
TypeDto.ONE_TO_MANY_RELATIONSHIP.getTypeClass(),
"Related field",
null)));
ArgumentCaptor<AnotherSample> captor = ArgumentCaptor.forClass(AnotherSample.class);
instanceService.saveInstance(entityRecord, null);
verify(serviceForClassWithRelatedField).create(captor.capture());
AnotherSample capturedValue = captor.getValue();
assertEquals(capturedValue.getTestSample(), test3);
assertEquals(capturedValue.getTestSamples().size(), 3);
assertEquals(capturedValue.getTitle(), "Default");
assertTrue(capturedValue.getTestSamples().contains(test1));
assertFalse(capturedValue.getTestSamples().contains(test3));
assertTrue(capturedValue.getTestSamples().contains(test2));
}
@Before
public void setUp() {
when(entity.getClassName()).thenReturn(TestSample.class.getName());
when(entity.getId()).thenReturn(ENTITY_ID);
when(bundleContext.getBundles()).thenReturn(new Bundle[0]);
}
private MotechDataService getServiceForEntity(EntityDto entity) {
String className = entity.getClassName();
return DataServiceHelper.getDataService(bundleContext, className);
}