Exemplo n.º 1
0
  @Test
  public void testReadOnlyEntryFromMultidirectory() throws Exception {
    MultiDirectory readonlyMultidir =
        (MultiDirectory) directoryService.getDirectory("readonlymulti");
    MultiDirectorySession readonlyDir = (MultiDirectorySession) readonlyMultidir.getSession();

    // all should be readonly
    assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("1")));
    assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("2")));
    assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("3")));
    assertTrue(BaseSession.isReadOnlyEntry(readonlyDir.getEntry("4")));
  }
 private static void updateSubDirectoryEntry(
     SubDirectoryInfo dirInfo,
     Map<String, Object> fieldMap,
     String id,
     boolean canCreateIfOptional) {
   DocumentModel dirEntry = dirInfo.getSession().getEntry(id);
   if (dirInfo.getSession().isReadOnly() || (dirEntry != null && isReadOnlyEntry(dirEntry))) {
     return;
   }
   if (dirEntry == null && !canCreateIfOptional) {
     // entry to update doesn't belong to this directory
     return;
   }
   Map<String, Object> map = new HashMap<String, Object>();
   map.put(dirInfo.idField, id);
   for (Entry<String, String> e : dirInfo.fromSource.entrySet()) {
     map.put(e.getValue(), fieldMap.get(e.getKey()));
   }
   if (map.size() > 1) {
     if (canCreateIfOptional && dirInfo.isOptional && dirEntry == null) {
       // if entry does not exist, create it
       dirInfo.getSession().createEntry(map);
     } else {
       final DocumentModel entry =
           BaseSession.createEntryModel(null, dirInfo.dirSchemaName, id, null);
       // Do not set dataModel values with constructor to force fields
       // dirty
       entry.getDataModel(dirInfo.dirSchemaName).setMap(map);
       dirInfo.getSession().updateEntry(entry);
     }
   }
 }
Exemplo n.º 3
0
  private static DirectoryEntry getDirectoryEntryFromNode(
      JsonNode propertiesNode, Directory directory) throws DirectoryException, IOException {

    String schema = directory.getSchema();
    String id = propertiesNode.get(directory.getIdField()).getTextValue();

    try (Session session = directory.getSession()) {
      DocumentModel entry = session.getEntry(id);

      if (entry == null) {
        entry = BaseSession.createEntryModel(null, schema, id, new HashMap<>());
      }

      Properties props = new Properties();
      Iterator<Entry<String, JsonNode>> fields = propertiesNode.getFields();
      while (fields.hasNext()) {
        Entry<String, JsonNode> fieldEntry = fields.next();
        props.put(schema + ":" + fieldEntry.getKey(), fieldEntry.getValue().getTextValue());
      }

      DocumentHelper.setProperties(null, entry, props);

      return new DirectoryEntry(directory.getName(), entry);
    }
  }
  @Override
  public DocumentModel getEntry(String id, boolean fetchReferences) throws DirectoryException {
    if (!isCurrentUserAllowed(SecurityConstants.READ)) {
      return null;
    }
    init();
    String entryId = id;
    source_loop:
    for (SourceInfo sourceInfo : sourceInfos) {
      boolean isReadOnlyEntry = true;
      final Map<String, Object> map = new HashMap<String, Object>();

      for (SubDirectoryInfo dirInfo : sourceInfo.subDirectoryInfos) {
        final DocumentModel entry = dirInfo.getSession().getEntry(id, fetchReferences);
        boolean isOptional = dirInfo.isOptional;
        if (entry == null && !isOptional) {
          // not in this source
          continue source_loop;
        }
        if (entry != null && !isReadOnlyEntry(entry)) {
          // set readonly to false if at least one source is writable
          isReadOnlyEntry = false;
        }
        if (entry == null && isOptional && !dirInfo.getSession().isReadOnly()) {
          // set readonly to false if null entry is from optional and writable directory
          isReadOnlyEntry = false;
        }
        if (entry != null && entry.getId() == null) {
          entryId = entry.getId();
        }
        for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
          if (entry != null) {
            try {
              map.put(e.getValue(), entry.getProperty(dirInfo.dirSchemaName, e.getKey()));
            } catch (PropertyException e1) {
              throw new DirectoryException(e1);
            }
          } else {
            // fill with default values for this directory
            if (!map.containsKey(e.getValue())) {
              map.put(e.getValue(), dirInfo.defaultEntry.get(e.getKey()));
            }
          }
        }
      }
      // force the entry in readonly if it's defined on the multidirectory
      if (isReadOnly()) {
        isReadOnlyEntry = true;
      }
      // ok we have the data
      try {
        return BaseSession.createEntryModel(null, schemaName, entryId, map, isReadOnlyEntry);
      } catch (PropertyException e) {
        throw new DirectoryException(e);
      }
    }
    return null;
  }
Exemplo n.º 5
0
  @Test
  public void testCreateFromModel() throws Exception {
    String schema = "schema3";
    DocumentModel entry = BaseSession.createEntryModel(null, schema, null, null);
    entry.setProperty("schema3", "uid", "yo");

    assertNull(dir.getEntry("yo"));
    dir.createEntry(entry);
    assertNotNull(dir.getEntry("yo"));

    // create one with existing same id, must fail
    entry.setProperty("schema3", "uid", "1");
    try {
      entry = dir.createEntry(entry);
      fail("Should raise an error, entry already exists");
    } catch (DirectoryException e) {
    }
  }
  @Override
  @SuppressWarnings("boxing")
  public DocumentModelList query(
      Map<String, Serializable> filter,
      Set<String> fulltext,
      Map<String, String> orderBy,
      boolean fetchReferences) {
    // list of entries
    final DocumentModelList results = new DocumentModelListImpl();
    if (!isCurrentUserAllowed(SecurityConstants.READ)) {
      return results;
    }
    init();

    // entry ids already seen (mapped to the source name)
    final Map<String, String> seen = new HashMap<String, String>();
    if (fulltext == null) {
      fulltext = Collections.emptySet();
    }
    Set<String> readOnlyEntries = new HashSet<String>();

    for (SourceInfo sourceInfo : sourceInfos) {
      // accumulated map for each entry
      final Map<String, Map<String, Object>> maps = new HashMap<String, Map<String, Object>>();
      // number of dirs seen for each entry
      final Map<String, Integer> counts = new HashMap<String, Integer>();

      // list of optional dirs where filter matches default values
      List<SubDirectoryInfo> optionalDirsMatching = new ArrayList<SubDirectoryInfo>();
      for (SubDirectoryInfo dirInfo : sourceInfo.subDirectoryInfos) {
        // compute filter
        final Map<String, Serializable> dirFilter = new HashMap<String, Serializable>();
        for (Entry<String, Serializable> e : filter.entrySet()) {
          final String fieldName = dirInfo.fromSource.get(e.getKey());
          if (fieldName == null) {
            continue;
          }
          dirFilter.put(fieldName, e.getValue());
        }
        if (dirInfo.isOptional) {
          // check if filter matches directory default values
          boolean matches = true;
          for (Map.Entry<String, Serializable> dirFilterEntry : dirFilter.entrySet()) {
            Object defaultValue = dirInfo.defaultEntry.get(dirFilterEntry.getKey());
            Object filterValue = dirFilterEntry.getValue();
            if (defaultValue == null && filterValue != null) {
              matches = false;
            } else if (defaultValue != null && !defaultValue.equals(filterValue)) {
              matches = false;
            }
          }
          if (matches) {
            optionalDirsMatching.add(dirInfo);
          }
        }
        // compute fulltext
        Set<String> dirFulltext = new HashSet<String>();
        for (String sourceFieldName : fulltext) {
          final String fieldName = dirInfo.fromSource.get(sourceFieldName);
          if (fieldName != null) {
            dirFulltext.add(fieldName);
          }
        }
        // make query to subdirectory
        DocumentModelList l =
            dirInfo.getSession().query(dirFilter, dirFulltext, null, fetchReferences);
        for (DocumentModel entry : l) {
          final String id = entry.getId();
          Map<String, Object> map = maps.get(id);
          if (map == null) {
            map = new HashMap<String, Object>();
            maps.put(id, map);
            counts.put(id, 1);
          } else {
            counts.put(id, counts.get(id) + 1);
          }
          for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
            map.put(e.getValue(), entry.getProperty(dirInfo.dirSchemaName, e.getKey()));
          }
          if (BaseSession.isReadOnlyEntry(entry)) {
            readOnlyEntries.add(id);
          }
        }
      }
      // add default entry values for optional dirs
      for (SubDirectoryInfo dirInfo : optionalDirsMatching) {
        // add entry for every data found in other dirs
        Set<String> existingIds =
            new HashSet<String>(
                dirInfo
                    .getSession()
                    .getProjection(Collections.<String, Serializable>emptyMap(), dirInfo.idField));
        for (Entry<String, Map<String, Object>> result : maps.entrySet()) {
          final String id = result.getKey();
          if (!existingIds.contains(id)) {
            counts.put(id, counts.get(id) + 1);
            final Map<String, Object> map = result.getValue();
            for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
              String value = e.getValue();
              if (!map.containsKey(value)) {
                map.put(value, dirInfo.defaultEntry.get(e.getKey()));
              }
            }
          }
        }
      }
      // intersection, ignore entries not in all subdirectories
      final int numdirs = sourceInfo.subDirectoryInfos.size();
      for (Iterator<String> it = maps.keySet().iterator(); it.hasNext(); ) {
        final String id = it.next();
        if (counts.get(id) != numdirs) {
          it.remove();
        }
      }
      // now create entries
      ((ArrayList<?>) results).ensureCapacity(results.size() + maps.size());
      for (Entry<String, Map<String, Object>> e : maps.entrySet()) {
        final String id = e.getKey();
        if (seen.containsKey(id)) {
          log.warn(
              String.format(
                  "Entry '%s' is present in source '%s' but also in source '%s'. "
                      + "The second one will be ignored.",
                  id, seen.get(id), sourceInfo.source.name));
          continue;
        }
        final Map<String, Object> map = e.getValue();
        seen.put(id, sourceInfo.source.name);
        final DocumentModel entry =
            BaseSession.createEntryModel(null, schemaName, id, map, readOnlyEntries.contains(id));
        results.add(entry);
      }
    }
    if (orderBy != null && !orderBy.isEmpty()) {
      directory.orderEntries(results, orderBy);
    }
    return results;
  }
  @Override
  @SuppressWarnings("boxing")
  public DocumentModelList getEntries() {
    if (!isCurrentUserAllowed(SecurityConstants.READ)) {
      return null;
    }
    init();

    // list of entries
    final DocumentModelList results = new DocumentModelListImpl();
    // entry ids already seen (mapped to the source name)
    final Map<String, String> seen = new HashMap<String, String>();
    Set<String> readOnlyEntries = new HashSet<String>();

    for (SourceInfo sourceInfo : sourceInfos) {
      // accumulated map for each entry
      final Map<String, Map<String, Object>> maps = new HashMap<String, Map<String, Object>>();
      // number of dirs seen for each entry
      final Map<String, Integer> counts = new HashMap<String, Integer>();
      for (SubDirectoryInfo dirInfo : sourceInfo.requiredSubDirectoryInfos) {
        final DocumentModelList entries = dirInfo.getSession().getEntries();
        for (DocumentModel entry : entries) {
          final String id = entry.getId();
          // find or create map for this entry
          Map<String, Object> map = maps.get(id);
          if (map == null) {
            map = new HashMap<String, Object>();
            maps.put(id, map);
            counts.put(id, 1);
          } else {
            counts.put(id, counts.get(id) + 1);
          }
          // put entry data in map
          for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
            map.put(e.getValue(), entry.getProperty(dirInfo.dirSchemaName, e.getKey()));
          }
          if (BaseSession.isReadOnlyEntry(entry)) {
            readOnlyEntries.add(id);
          }
        }
      }
      for (SubDirectoryInfo dirInfo : sourceInfo.optionalSubDirectoryInfos) {
        final DocumentModelList entries = dirInfo.getSession().getEntries();
        Set<String> existingIds = new HashSet<String>();
        for (DocumentModel entry : entries) {
          final String id = entry.getId();
          final Map<String, Object> map = maps.get(id);
          if (map != null) {
            existingIds.add(id);
            // put entry data in map
            for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
              map.put(e.getValue(), entry.getProperty(dirInfo.dirSchemaName, e.getKey()));
            }
          } else {
            log.warn(
                String.format(
                    "Entry '%s' for source '%s' is present in optional directory '%s' "
                        + "but not in any required one. "
                        + "It will be skipped.",
                    id, sourceInfo.source.name, dirInfo.dirName));
          }
        }
        for (Entry<String, Map<String, Object>> mapEntry : maps.entrySet()) {
          if (!existingIds.contains(mapEntry.getKey())) {
            final Map<String, Object> map = mapEntry.getValue();
            // put entry data in map
            for (Entry<String, String> e : dirInfo.toSource.entrySet()) {
              // fill with default values for this directory
              if (!map.containsKey(e.getValue())) {
                map.put(e.getValue(), dirInfo.defaultEntry.get(e.getKey()));
              }
            }
          }
        }
      }
      // now create entries for all full maps
      int numdirs = sourceInfo.requiredSubDirectoryInfos.size();
      ((ArrayList<?>) results).ensureCapacity(results.size() + maps.size());
      for (Entry<String, Map<String, Object>> e : maps.entrySet()) {
        final String id = e.getKey();
        if (seen.containsKey(id)) {
          log.warn(
              String.format(
                  "Entry '%s' is present in source '%s' but also in source '%s'. "
                      + "The second one will be ignored.",
                  id, seen.get(id), sourceInfo.source.name));
          continue;
        }
        final Map<String, Object> map = e.getValue();
        if (counts.get(id) != numdirs) {
          log.warn(
              String.format(
                  "Entry '%s' for source '%s' is not present in all directories. "
                      + "It will be skipped.",
                  id, sourceInfo.source.name));
          continue;
        }
        seen.put(id, sourceInfo.source.name);
        final DocumentModel entry =
            BaseSession.createEntryModel(null, schemaName, id, map, readOnlyEntries.contains(id));
        results.add(entry);
      }
    }
    return results;
  }
Exemplo n.º 8
0
  @Test
  public void testReadOnlyEntryInGetEntriesResults() throws Exception {
    Map<String, String> orderBy = new HashMap<String, String>();
    orderBy.put("schema3:uid", "asc");
    DocumentModelComparator comp = new DocumentModelComparator(orderBy);

    DocumentModelList results = dir.getEntries();
    Collections.sort(results, comp);

    // by default no backing dir is readonly
    assertFalse(BaseSession.isReadOnlyEntry(results.get(0)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(1)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(2)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(3)));

    memdir1.setReadOnly(true);
    memdir2.setReadOnly(false);
    memdir3.setReadOnly(false);
    results = dir.getEntries();
    Collections.sort(results, comp);
    assertTrue(BaseSession.isReadOnlyEntry(results.get(0)));
    assertTrue(BaseSession.isReadOnlyEntry(results.get(1)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(2)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(3)));

    memdir1.setReadOnly(false);
    memdir2.setReadOnly(false);
    memdir3.setReadOnly(true);
    results = dir.getEntries();
    Collections.sort(results, comp);
    assertFalse(BaseSession.isReadOnlyEntry(results.get(0)));
    assertFalse(BaseSession.isReadOnlyEntry(results.get(1)));
    assertTrue(BaseSession.isReadOnlyEntry(results.get(2)));
    assertTrue(BaseSession.isReadOnlyEntry(results.get(3)));
  }
Exemplo n.º 9
0
  @Test
  public void testReadOnlyEntryFromGetEntry() throws Exception {

    // by default no backing dir is readonly
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("1")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("2")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("3")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("4")));

    memdir1.setReadOnly(true);
    memdir2.setReadOnly(false);
    memdir3.setReadOnly(false);
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("1")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("2")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("3")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("4")));

    memdir1.setReadOnly(false);
    memdir2.setReadOnly(true);
    memdir3.setReadOnly(true);
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("1")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("2")));
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("3")));
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("4")));

    memdir1.setReadOnly(false);
    memdir2.setReadOnly(false);
    memdir3.setReadOnly(true);
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("1")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("2")));
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("3")));
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("4")));

    memdir1.setReadOnly(true);
    memdir2.setReadOnly(true);
    memdir3.setReadOnly(false);
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("1")));
    assertTrue(BaseSession.isReadOnlyEntry(dir.getEntry("2")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("3")));
    assertFalse(BaseSession.isReadOnlyEntry(dir.getEntry("4")));
  }