@Override
  public void revertInstanceFromTrash(Long entityId, Long instanceId) {
    EntityDto entity = getEntity(entityId);
    validateCredentials(entity);
    validateNonEditableProperty(entity);
    MotechDataService service = getServiceForEntity(entity);

    Object trash = service.findTrashInstanceById(instanceId, entityId);
    List<FieldRecord> fieldRecords = new LinkedList<>();

    try {
      for (FieldDto field : entityService.getEntityFields(entity.getId())) {
        if (ID_FIELD_NAME.equalsIgnoreCase(field.getBasic().getDisplayName())) {
          continue;
        }
        Field f =
            FieldUtils.getField(
                trash.getClass(), StringUtils.uncapitalize(field.getBasic().getName()), true);
        FieldRecord record = new FieldRecord(field);
        record.setValue(f.get(trash));
        fieldRecords.add(record);
      }

      Class<?> entityClass = getEntityClass(entity);

      Object newInstance = entityClass.newInstance();
      updateFields(newInstance, fieldRecords, service, null);

      service.revertFromTrash(newInstance, trash);
    } catch (Exception e) {
      throw new RevertFromTrashException(entity.getName(), instanceId, e);
    }
  }
  @Test
  public void shouldUseCorrectClassLoaderWhenCreatingInstances() throws ClassNotFoundException {
    mockSampleFields();
    mockEntity();
    mockDataService();

    Bundle ddeBundle = mock(Bundle.class);
    Bundle entitiesBundle = mock(Bundle.class);
    when(bundleContext.getBundles()).thenReturn(new Bundle[] {ddeBundle, entitiesBundle});

    when(entity.getBundleSymbolicName()).thenReturn("org.motechproject.test");

    when(entitiesBundle.getSymbolicName())
        .thenReturn(Constants.BundleNames.MDS_ENTITIES_SYMBOLIC_NAME);
    when(ddeBundle.getSymbolicName()).thenReturn("org.motechproject.test");

    Class testClass = TestSample.class;
    when(entitiesBundle.loadClass(testClass.getName())).thenReturn(testClass);
    when(ddeBundle.loadClass(testClass.getName())).thenReturn(testClass);

    EntityRecord entityRecord =
        new EntityRecord(null, ENTITY_ID, Collections.<FieldRecord>emptyList());

    when(entity.isDDE()).thenReturn(true);
    instanceService.saveInstance(entityRecord);
    verify(ddeBundle).loadClass(TestSample.class.getName());

    when(entity.isDDE()).thenReturn(false);
    instanceService.saveInstance(entityRecord);
    verify(entitiesBundle).loadClass(TestSample.class.getName());

    verify(motechDataService, times(2)).create(any(TestSample.class));
  }
  private EntityRecord instanceToRecord(
      Object instance, EntityDto entityDto, List<FieldDto> fields, MotechDataService service) {
    if (instance == null) {
      return null;
    }
    try {
      List<FieldRecord> fieldRecords = new ArrayList<>();

      for (FieldDto field : fields) {
        Object value = getProperty(instance, field, service);
        Object displayValue = getDisplayValueForField(field, value);

        value =
            parseValueForDisplay(value, field.getMetadata(Constants.MetadataKeys.RELATED_FIELD));

        FieldRecord fieldRecord = new FieldRecord(field);
        fieldRecord.setValue(value);
        fieldRecord.setDisplayValue(displayValue);
        fieldRecords.add(fieldRecord);
      }

      Number id = (Number) PropertyUtil.safeGetProperty(instance, ID_FIELD_NAME);
      return new EntityRecord(id == null ? null : id.longValue(), entityDto.getId(), fieldRecords);
    } catch (Exception e) {
      throw new ObjectReadException(entityDto.getName(), e);
    }
  }
  @Override
  public long countTrashRecords(Long entityId) {
    EntityDto entity = getEntity(entityId);
    validateCredentialsForReading(entity);

    return trashService.countTrashRecords(entity.getClassName());
  }
  @Override
  @Transactional
  public <T> Records<T> getRelatedFieldValue(
      Long entityId, Long instanceId, String fieldName, QueryParams queryParams) {
    EntityDto entity = getEntity(entityId);
    validateCredentials(entity);
    String entityName = entity.getName();

    MotechDataService service = getServiceForEntity(entity);
    Object instance = service.findById(instanceId);

    if (instance == null) {
      throw new ObjectNotFoundException(entityName, instanceId);
    }

    try {
      Collection<T> relatedAsColl =
          TypeHelper.asCollection(PropertyUtil.getProperty(instance, fieldName));

      List<T> filtered = InMemoryQueryFilter.filter(relatedAsColl, queryParams);

      int recordCount = relatedAsColl.size();
      int rowCount = (int) Math.ceil(recordCount / (double) queryParams.getPageSize());

      return new Records<>(queryParams.getPage(), rowCount, recordCount, filtered);
    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
      throw new ObjectReadException(entityName, e);
    }
  }
  @Test(expected = EntityInstancesNonEditableException.class)
  public void shouldThrowExceptionWhileDeletingInstanceInNonEditableEntity() {
    EntityDto nonEditableEntity = new EntityDto();
    nonEditableEntity.setNonEditable(true);

    when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(nonEditableEntity);

    instanceService.deleteInstance(ANOTHER_ENTITY_ID, INSTANCE_ID);
  }
  @Override
  public void revertPreviousVersion(Long entityId, Long instanceId, Long historyId) {
    validateNonEditableProperty(getEntity(entityId));
    HistoryRecord historyRecord = getHistoryRecord(entityId, instanceId, historyId);
    if (!historyRecord.isRevertable()) {
      EntityDto entity = getEntity(entityId);
      throw new EntitySchemaMismatchException(entity.getName());
    }

    saveInstance(new EntityRecord(instanceId, entityId, historyRecord.getFields()));
  }
  @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 validateCredentials(EntityDto entity) {
   boolean authorized;
   SecurityMode securityMode = entity.getSecurityMode();
   if (securityMode != null) {
     Set<String> securityMembers = entity.getSecurityMembers();
     authorized = entity.hasAccessToEntityFromSecurityMode(securityMode, securityMembers);
     if (!authorized && !securityMode.isInstanceRestriction()) {
       throw new SecurityException();
     }
   }
 }
  @Test(expected = EntityInstancesNonEditableException.class)
  public void shouldThrowExceptionWhileSavingInstanceInNonEditableEntity() {
    EntityDto nonEditableEntity = new EntityDto();
    nonEditableEntity.setNonEditable(true);
    nonEditableEntity.setId(ANOTHER_ENTITY_ID);
    EntityRecord entityRecord =
        new EntityRecord(null, ANOTHER_ENTITY_ID, new ArrayList<FieldRecord>());

    when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(nonEditableEntity);

    instanceService.saveInstance(entityRecord);
  }
  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);
  }
  @Test(expected = SecurityException.class)
  public void shouldThrowExceptionWhileReadingInstanceWithoutAnyPermission() {
    EntityDto entityDto = new EntityDto();
    entityDto.setReadOnlySecurityMode(SecurityMode.NO_ACCESS);
    entityDto.setSecurityMode(SecurityMode.NO_ACCESS);

    EntityRecord entityRecord =
        new EntityRecord(ANOTHER_ENTITY_ID, null, new ArrayList<FieldRecord>());

    when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(entityDto);

    instanceService.getEntityRecords(entityRecord.getId());
  }
  private void validateCredentialsForReading(EntityDto entity) {
    boolean authorized = false;
    SecurityMode securityMode = entity.getSecurityMode();
    SecurityMode readOnlySecurityMode = entity.getReadOnlySecurityMode();

    if (securityMode != null) {
      Set<String> securityMembers = entity.getSecurityMembers();
      authorized = entity.hasAccessToEntityFromSecurityMode(securityMode, securityMembers);
      if (!authorized) {
        if (readOnlySecurityMode != null) {
          Set<String> readOnlySecurityMembers = entity.getReadOnlySecurityMembers();
          authorized =
              entity.hasAccessToEntityFromSecurityMode(
                  readOnlySecurityMode, readOnlySecurityMembers);
          if (isAuthorizedByReadAccessOrIsInstanceRestriction(
              authorized, readOnlySecurityMode, securityMode)) {
            throw new SecurityException();
          }
        }
      }
    }
    if (!authorized && readOnlySecurityMode != null) {
      Set<String> readOnlySecurityMembers = entity.getReadOnlySecurityMembers();
      authorized =
          entity.hasAccessToEntityFromSecurityMode(readOnlySecurityMode, readOnlySecurityMembers);
      if (!authorized && !readOnlySecurityMode.isInstanceRestriction()) {
        throw new SecurityException();
      }
    }
  }
  @Test
  public void shouldLoadBlobField() throws InstanceNotFoundException {
    EntityDto entityDto = new EntityDto();
    entityDto.setReadOnlySecurityMode(null);
    entityDto.setSecurityMode(null);
    entityDto.setClassName(TestSample.class.getName());

    when(entityService.getEntity(ENTITY_ID + 1)).thenReturn(entityDto);
    mockDataService();
    TestSample instance = Mockito.mock(TestSample.class);
    when(motechDataService.findById(ENTITY_ID + 1)).thenReturn(instance);

    instanceService.getInstanceField(12l, ENTITY_ID + 1, "blobField");
    verify(motechDataService).getDetachedField(instance, "blobField");
  }
  @Override
  public EntityRecord getEntityInstance(Long entityId, Long instanceId) {
    EntityDto entity = getEntity(entityId);
    validateCredentialsForReading(entity);
    MotechDataService service = getServiceForEntity(entity);

    Object instance = service.retrieve(ID_FIELD_NAME, instanceId);
    if (instance == null) {
      throw new ObjectNotFoundException(entity.getName(), instanceId);
    }

    List<FieldDto> fields = entityService.getEntityFields(entityId);

    return instanceToRecord(instance, entity, fields, service);
  }
  @Test
  public void shouldAcceptUserWithNoPermissionWhileReadingInstanceWithNoSecurityMode() {
    EntityDto entityDto = new EntityDto();
    entityDto.setReadOnlySecurityMode(null);
    entityDto.setSecurityMode(null);
    entityDto.setClassName(TestSample.class.getName());

    EntityRecord entityRecord = new EntityRecord(ANOTHER_ENTITY_ID, null, new ArrayList<>());

    when(entityService.getEntity(ANOTHER_ENTITY_ID)).thenReturn(entityDto);

    mockDataService();
    instanceService.getEntityRecords(entityRecord.getId());

    verify(entityService).getEntityFieldsForUI(ANOTHER_ENTITY_ID);
  }
  @Override
  @Transactional
  public Object saveInstance(EntityRecord entityRecord, Long deleteValueFieldId) {
    EntityDto entity = getEntity(entityRecord.getEntitySchemaId());
    validateCredentials(entity);
    validateNonEditableProperty(entity);

    List<FieldDto> entityFields = getEntityFields(entityRecord.getEntitySchemaId());

    try {
      MotechDataService service = getServiceForEntity(entity);
      Class<?> entityClass = getEntityClass(entity);

      boolean newObject = entityRecord.getId() == null;

      Object instance;
      if (newObject) {
        instance = entityClass.newInstance();

        for (FieldDto entityField : entityFields) {
          if (entityField.getType().isMap() && entityField.getBasic().getDefaultValue() != null) {
            setInstanceFieldMap(instance, entityField);
          }
        }

      } else {
        instance = service.retrieve(ID_FIELD_NAME, entityRecord.getId());
        if (instance == null) {
          throw new ObjectNotFoundException(entity.getName(), entityRecord.getId());
        }
      }

      updateFields(instance, entityRecord.getFields(), service, deleteValueFieldId, !newObject);

      if (newObject) {
        return service.create(instance);
      } else {
        return service.update(instance);
      }
    } catch (Exception e) {
      if (entityRecord.getId() == null) {
        throw new ObjectCreateException(entity.getName(), e);
      } else {
        throw new ObjectUpdateException(entity.getName(), entityRecord.getId(), e);
      }
    }
  }
  @Test
  public void shouldNotUpdateGridSizeWhenUsernameIsBlank() {
    EntityDto entityDto = new EntityDto();
    entityDto.setReadOnlySecurityMode(null);
    entityDto.setSecurityMode(null);
    entityDto.setClassName(TestSample.class.getName());

    EntityRecord entityRecord = new EntityRecord(ENTITY_ID + 1, null, new ArrayList<FieldRecord>());

    when(entityService.getEntity(ENTITY_ID + 1)).thenReturn(entityDto);

    mockDataService();
    instanceService.getEntityRecords(entityRecord.getId(), new QueryParams(1, 100));

    verify(entityService).getEntityFieldsForUI(ENTITY_ID + 1);
    verify(userPreferencesService, never()).updateGridSize(anyLong(), anyString(), anyInt());
  }
  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());
  }
Exemple #20
0
  @Before
  public void setUpEntities() {
    book = new EntityDto("Book");
    author = new EntityDto("Author");

    authorFieldInBook = fieldDto("author", ManyToManyRelationship.class);
    authorFieldInBook.addMetadata(new MetadataDto(RELATED_CLASS, "Author"));

    FieldDto bookFieldInAuthor = fieldDto("book", ManyToManyRelationship.class);
    bookFieldInAuthor.addMetadata(new MetadataDto(RELATED_CLASS, "Book"));

    when(schemaHolder.getFields(book)).thenReturn(singletonList(authorFieldInBook));
    when(schemaHolder.getFields(author)).thenReturn(singletonList(bookFieldInAuthor));

    entity1 = new EntityDto("Entity1");
    entity2 = new EntityDto("Entity2");
    entity3 = new EntityDto("Entity3");

    FieldDto entity1Field = fieldDto("entity1", OneToOneRelationship.class);
    entity1Field.addMetadata(new MetadataDto(RELATED_CLASS, "Entity2"));

    FieldDto entity2Field = fieldDto("entity2", OneToOneRelationship.class);
    entity2Field.addMetadata(new MetadataDto(RELATED_CLASS, "Entity3"));

    when(schemaHolder.getFields(entity1)).thenReturn(singletonList(entity1Field));
    when(schemaHolder.getFields(entity2)).thenReturn(singletonList(entity2Field));

    parentEntity = new EntityDto("Parent");
    childEntity = new EntityDto("Child");
    childEntity.setSuperClass("Parent");

    binaryTree = new EntityDto("Binary tree");
    FieldDto leftChild = fieldDto("leftChild", "Left child", OneToOneRelationship.class);
    leftChild.addMetadata(new MetadataDto(RELATED_CLASS, "Binary tree"));

    FieldDto rightChild = fieldDto("rightChild", "Right child", OneToOneRelationship.class);
    rightChild.addMetadata(new MetadataDto(RELATED_CLASS, "Binary tree"));

    when(schemaHolder.getFields(binaryTree)).thenReturn(asList(leftChild, rightChild));

    entity1.setRecordHistory(true);
    entity2.setRecordHistory(true);
    entity3.setRecordHistory(true);
    book.setRecordHistory(true);
    author.setRecordHistory(true);
    parentEntity.setRecordHistory(true);
    childEntity.setRecordHistory(true);
    binaryTree.setRecordHistory(true);
  }
  @Test
  public void shouldUpdateGridSize() {
    setUpSecurityContext();

    EntityDto entityDto = new EntityDto();
    entityDto.setReadOnlySecurityMode(null);
    entityDto.setSecurityMode(null);
    entityDto.setClassName(TestSample.class.getName());

    EntityRecord entityRecord = new EntityRecord(ENTITY_ID + 1, null, new ArrayList<>());

    when(entityService.getEntity(ENTITY_ID + 1)).thenReturn(entityDto);

    mockDataService();
    instanceService.getEntityRecords(entityRecord.getId(), new QueryParams(1, 100));

    verify(entityService).getEntityFieldsForUI(ENTITY_ID + 1);
    verify(userPreferencesService).updateGridSize(ENTITY_ID + 1, "motech", 100);
  }
  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;
  }
Exemple #23
0
  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());
    }
  }
 private void validateNonEditableProperty(EntityDto entity) {
   if (entity.isNonEditable()) {
     throw new EntityInstancesNonEditableException();
   }
 }
 private MotechDataService getServiceForEntity(EntityDto entity) {
   String className = entity.getClassName();
   return DataServiceHelper.getDataService(bundleContext, className);
 }
 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);
 }
 @Before
 public void setUp() {
   when(entity.getClassName()).thenReturn(TestSample.class.getName());
   when(entity.getId()).thenReturn(ENTITY_ID);
   when(bundleContext.getBundles()).thenReturn(new Bundle[0]);
 }
  @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));
  }
 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);
 }
Exemple #30
0
 @Override
 public List<LookupDto> getAvailableLookups(String entityName) {
   EntityDto entity = getEntityByEntityClassName(entityName);
   AdvancedSettingsDto settingsDto = entityService.getAdvancedSettings(entity.getId(), true);
   return settingsDto.getIndexes();
 }