Пример #1
0
  protected void performCheck(String statement, String expected) throws RepositoryException {
    QueryManager qm = superuser.getWorkspace().getQueryManager();
    Query query =
        qm.createQuery(
            "/jcr:root[rep:spellcheck('" + statement + "')]/(rep:spellcheck())", Query.XPATH);
    RowIterator rows = query.execute().getRows();
    assertEquals("no results returned", 1, rows.getSize());
    Row r = rows.nextRow();
    Value v = r.getValue("rep:spellcheck()");
    if (statement.equals(expected)) {
      assertNull("must not return a suggestion", v);
    } else {
      assertNotNull("no suggestion returned", v);
      assertEquals("wrong suggestion returned", expected, v.getString());
    }

    query =
        qm.createQuery(
            "select rep:spellcheck() from nt:base where "
                + "jcr:path = '/' and spellcheck('"
                + statement
                + "')",
            Query.SQL);
    rows = query.execute().getRows();
    assertEquals("no results returned", 1, rows.getSize());
    r = rows.nextRow();
    v = r.getValue("rep:spellcheck()");
    if (statement.equals(expected)) {
      assertNull("must not return a suggestion", v);
    } else {
      assertNotNull("no suggestion returned", v);
      assertEquals("wrong suggestion returned", expected, v.getString());
    }
  }
 private Row prepareAnActivityRow(String path) throws RepositoryException {
   Row activityRow = mock(Row.class);
   Value pathValue = mock(Value.class);
   when(pathValue.getString()).thenReturn(path);
   when(activityRow.getValue("jcr:path")).thenReturn(pathValue);
   return activityRow;
 }
Пример #3
0
  @Override
  public ResultSet query(String text, String lang) {
    Session session = (Session) this.getThreadLocalRequest().getSession().getAttribute("session");
    ResultSet rs = new ResultSet();
    try {
      QueryManager qm = session.getWorkspace().getQueryManager();
      Query q = qm.createQuery(text, lang);

      QueryResult qr = q.execute();

      rs.setColumnNames(qr.getColumnNames());
      ArrayList<String[]> rows = new ArrayList();
      RowIterator it = qr.getRows();
      while (it.hasNext()) {
        Row row = it.nextRow();
        String[] list = new String[qr.getColumnNames().length];

        for (int i = 0; i < qr.getColumnNames().length; i++) {
          Value v = row.getValue(qr.getColumnNames()[i]);
          list[i] = v != null ? v.getString() : "null";
        }

        rows.add(list);
      }

      rs.setRows(rows);
    } catch (RepositoryException e) {
      log.log(Level.SEVERE, "Error executing query: " + text, e);
    }
    return rs;
  }
Пример #4
0
  /**
   * Writes the given value to the JSON writer. currently the following conversions are done:
   *
   * <table>
   * <tr>
   * <th>JSR Property Type</th>
   * <th>JSON Value Type</th>
   * </tr>
   * <tr>
   * <td>BINARY</td>
   * <td>always 0 as long</td>
   * </tr>
   * <tr>
   * <td>DATE</td>
   * <td>converted date string as defined by ECMA</td>
   * </tr>
   * <tr>
   * <td>BOOLEAN</td>
   * <td>boolean</td>
   * </tr>
   * <tr>
   * <td>LONG</td>
   * <td>long</td>
   * </tr>
   * <tr>
   * <td>DOUBLE</td>
   * <td>double</td>
   * </tr>
   * <tr>
   * <td><i>all other</li>
   * </td>
   * <td>string</td>
   * </tr>
   * </table>
   *
   * <sup>1</sup> Currently not implemented and uses 0 as default.
   *
   * @param w json writer
   * @param v value to dump
   */
  protected void dumpValue(JSONWriter w, Value v)
      throws ValueFormatException, IllegalStateException, RepositoryException, JSONException {

    switch (v.getType()) {
      case PropertyType.BINARY:
        w.value(0);
        break;

      case PropertyType.DATE:
        w.value(format(v.getDate()));
        break;

      case PropertyType.BOOLEAN:
        w.value(v.getBoolean());
        break;

      case PropertyType.LONG:
        w.value(v.getLong());
        break;

      case PropertyType.DOUBLE:
        w.value(v.getDouble());

        break;
      default:
        w.value(v.getString());
    }
  }
 @Test
 public void testNonSiteNode() throws RepositoryException, JSONException {
   SiteSearchResultProcessor siteSearchResultProcessor = new SiteSearchResultProcessor();
   SiteService siteService = createMock(SiteService.class);
   siteSearchResultProcessor.bindSiteService(siteService);
   Row row = createMock(Row.class);
   Value val = createMock(Value.class);
   expect(val.getString()).andReturn("");
   expect(row.getValue("jcr:path")).andReturn(val);
   expect(siteService.isSite(isA(Item.class))).andReturn(false);
   Node resultNode = createMock(Node.class);
   expect(resultNode.getPath()).andReturn("");
   SlingHttpServletRequest request = createMock(SlingHttpServletRequest.class);
   ResourceResolver resourceResolver = createMock(ResourceResolver.class);
   Session session = createMock(Session.class);
   expect(request.getResourceResolver()).andReturn(resourceResolver);
   expect(resourceResolver.adaptTo(Session.class)).andReturn(session);
   expect(session.getItem("")).andReturn(resultNode);
   replay();
   try {
     siteSearchResultProcessor.writeNode(request, null, null, row);
     fail();
   } catch (JSONException e) {
     assertEquals("Unable to write non-site node result", e.getMessage());
   }
 }
Пример #6
0
 /**
  * Gets the spell suggestion.
  *
  * @param checkingWord the checking word
  * @param manageableRepository the manageable repository
  * @return the spell suggestion
  * @throws Exception the exception
  */
 private String getSpellSuggestion(String checkingWord, ManageableRepository manageableRepository)
     throws Exception {
   // Retrieve spell suggestion in special way to avoid access denied exception
   String suggestion = null;
   Session session = null;
   try {
     session =
         manageableRepository.getSystemSession(
             manageableRepository.getConfiguration().getDefaultWorkspaceName());
     QueryManager queryManager = session.getWorkspace().getQueryManager();
     Query query =
         queryManager.createQuery(
             "SELECT rep:spellcheck() FROM nt:base WHERE jcr:path like '/' AND SPELLCHECK('"
                 + checkingWord
                 + "')",
             Query.SQL);
     RowIterator rows = query.execute().getRows();
     Value value = rows.nextRow().getValue("rep:spellcheck()");
     if (value != null) {
       suggestion = value.getString();
     }
   } catch (Exception e) {
     if (LOG.isWarnEnabled()) {
       LOG.warn(e.getMessage());
     }
   } finally {
     if (session != null) session.logout();
   }
   return suggestion;
 }
Пример #7
0
 private Row getRow(String key, String val) throws RepositoryException {
   Row row = createMock(Row.class);
   Value value = createMock(Value.class);
   expect(value.getString()).andReturn(val);
   expect(row.getValue(key)).andReturn(value);
   return row;
 }
Пример #8
0
  @Test
  public void testNextWithURI() throws Exception {
    when(mockValue.getType()).thenReturn(PropertyType.URI);
    when(mockValue.getString()).thenReturn("info:xyz");
    final QuerySolution solution = testObj.next();

    assertEquals("info:xyz", solution.get("a").asResource().getURI());
  }
Пример #9
0
  @Test
  public void testNextWithLiteralBoolean() throws Exception {
    when(mockValue.getType()).thenReturn(PropertyType.BOOLEAN);
    when(mockValue.getString()).thenReturn("true");
    final QuerySolution solution = testObj.next();

    assertEquals("true", solution.get("a").asLiteral().getLexicalForm());
  }
Пример #10
0
 protected void assertCanObtainValue(Value value, int expectedType) throws Exception {
   switch (expectedType) {
     case PropertyType.BINARY:
       Binary binary = value.getBinary();
       try {
         InputStream stream = binary.getStream();
         assertThat(stream, is(notNullValue()));
         try {
           stream.read();
         } finally {
           stream.close();
         }
       } finally {
         binary.dispose();
       }
       break;
     case PropertyType.BOOLEAN:
       assertThat(value.getBoolean() || !value.getBoolean(), is(true));
       break;
     case PropertyType.DATE:
       Calendar cal = value.getDate();
       assertThat(cal, is(notNullValue()));
       break;
     case PropertyType.DOUBLE:
       double doubleValue = value.getDouble();
       assertThat(doubleValue < 0.0d || doubleValue >= -1.0d, is(true));
       break;
     case PropertyType.LONG:
       long longValue = value.getLong();
       assertThat(longValue < 0L || longValue >= 0L, is(true));
       break;
     case PropertyType.NAME:
       context.getValueFactories().getNameFactory().create(value.getString());
       break;
     case PropertyType.PATH:
       context.getValueFactories().getPathFactory().create(value.getString());
       break;
     case PropertyType.REFERENCE:
       UUID uuid = context.getValueFactories().getUuidFactory().create(value.getString());
       assertThat(uuid, is(notNullValue()));
       break;
     case PropertyType.STRING:
       value.getString();
       break;
   }
 }
Пример #11
0
  @Test
  public void testNextBinding() throws Exception {
    when(mockValue.getString()).thenReturn("x");
    final Binding binding = testObj.nextBinding();

    assertTrue(binding.contains(Var.alloc("a")));
    final Node a = binding.get(Var.alloc("a"));
    assertEquals("x", a.getLiteralLexicalForm());
  }
Пример #12
0
  @Test
  public void testNextWithLiteral() throws Exception {
    when(mockValue.getString()).thenReturn("x");
    final QuerySolution solution = testObj.next();

    assertTrue(solution.contains("a"));
    assertEquals("x", solution.get("a").asLiteral().getLexicalForm());
    assertEquals(solution.get("a"), solution.getLiteral("a"));
  }
Пример #13
0
 /**
  * This method will check notify type of watcher, userName is equal value of property with
  * notification type
  *
  * @param documentNode specify a node to watch
  * @param userName userName to watch a document
  * @param notification Notification Type
  * @return boolean
  * @throws Exception
  */
 private boolean checkNotifyTypeOfWatcher(
     Node documentNode, String userName, String notificationType) throws Exception {
   if (documentNode.hasProperty(notificationType)) {
     Value[] watchers = documentNode.getProperty(notificationType).getValues();
     for (Value value : watchers) {
       if (userName.equalsIgnoreCase(value.getString())) return true;
     }
   }
   return false;
 }
Пример #14
0
 /** Tests if a calendar is returned and if the conversion to a string has correct format. */
 public void testGetString() throws RepositoryException {
   Value val = PropertyUtil.getValue(prop);
   // correct format:  YYYY-MM-DDThh:mm:ss.sssTZD
   // month(01-12), day(01-31), hours(00-23), minutes(00-59), seconds(00-59),
   // TZD(Z or +hh:mm or -hh:mm)
   // String aDay="2005-01-19T15:34:15.917+01:00";
   String date = val.getString();
   log.println("date str = " + date);
   boolean match = PropertyUtil.isDateFormat(prop.getString());
   assertTrue("Date not in correct String format.", match);
 }
Пример #15
0
  @Test
  public void testNextWithReference() throws Exception {
    when(mockValue.getType()).thenReturn(PropertyType.REFERENCE);
    when(mockValue.getString()).thenReturn("uuid");
    when(mockSession.getNodeByIdentifier("uuid")).thenReturn(mockNode);
    when(mockGraphSubjects.getSubject(mockNode.getPath()))
        .thenReturn(ResourceFactory.createResource("http://localhost:8080/xyz"));
    final QuerySolution solution = testObj.next();

    assertEquals("http://localhost:8080/xyz", solution.get("a").asResource().getURI());
  }
Пример #16
0
  @Test
  public void testNextWithResource() throws Exception {
    when(mockValue.getType()).thenReturn(PropertyType.PATH);
    when(mockValue.getString()).thenReturn("/x");
    when(mockGraphSubjects.getSubject("/x")).thenReturn(ResourceFactory.createResource("info:x"));
    final QuerySolution solution = testObj.next();

    assertTrue(solution.contains("a"));
    assertEquals("info:x", solution.get("a").asResource().getURI());
    assertEquals(solution.get("a"), solution.getResource("a"));
  }
Пример #17
0
 @Test
 public void testDefaultExcerptProp() throws RepositoryException {
   Row row = createMock(Row.class);
   Value value = createMock(Value.class);
   expect(value.getString()).andReturn("foo");
   expect(row.getValue("rep:excerpt(jcr:content)")).andReturn(null).once();
   expect(row.getValue("rep:excerpt(.)")).andReturn(value).once();
   replay();
   String result = RowUtils.getDefaultExcerpt(row);
   assertEquals("Excerpt is not the same", "foo", result);
 }
Пример #18
0
 /**
  * Gets the values as string.
  *
  * @param node the node
  * @param propName the prop name
  * @return the values as string
  * @throws Exception the exception
  */
 public static List<String> getValuesAsString(Node node, String propName) throws Exception {
   if (!node.hasProperty(propName)) return new ArrayList<String>();
   List<String> results = new ArrayList<String>();
   try {
     for (Value value : node.getProperty(propName).getValues()) {
       results.add(value.getString());
     }
   } catch (ValueFormatException ex) {
     results.add(node.getProperty(propName).getValue().getString());
   }
   return results;
 }
  /* (non-Javadoc)
   * @see org.exoplatform.services.wcm.link.LiveLinkManagerService#updateLinks(javax.jcr.Node, java.util.List)
   */
  public void updateLinkDataForNode(Node webContent, List<String> newLinks) throws Exception {
    ValueFactory valueFactory = webContent.getSession().getValueFactory();
    if (webContent.canAddMixin("exo:linkable")) {
      webContent.addMixin("exo:linkable");
    }
    // get old link from exo:links property
    List<String> listExtractedLink = new ArrayList<String>();
    if (webContent.hasProperty("exo:links")) {
      Property property = webContent.getProperty("exo:links");
      for (Value value : property.getValues()) {
        listExtractedLink.add(value.getString());
      }
    }
    // compare, remove old link, add new link, create new List
    List<String> listResult = new ArrayList<String>();

    for (String extractedLink : listExtractedLink) {
      for (String newUrl : newLinks) {
        if (LinkBean.parse(extractedLink).getUrl().equals(newUrl)) {
          listResult.add(extractedLink);
        }
      }
    }
    List<String> listTemp = new ArrayList<String>();
    listTemp.addAll(newLinks);

    for (String newUrl : newLinks) {
      for (String extractedLink : listExtractedLink) {
        if (newUrl.equals(LinkBean.parse(extractedLink).getUrl())) {
          listTemp.set(newLinks.indexOf(newUrl), "");
        }
      }
    }

    for (String strTemp : listTemp) {
      if (!strTemp.equals("")) {
        listResult.add(strTemp);
      }
    }

    // Create an array of value to add to exo:links property
    Value[] values = new Value[listResult.size()];
    for (String url : listResult) {
      if (url.indexOf(LinkBean.STATUS) < 0) {
        LinkBean linkBean = new LinkBean(url, LinkBean.STATUS_UNCHECKED);
        values[listResult.indexOf(url)] = valueFactory.createValue(linkBean.toString());
      } else {
        values[listResult.indexOf(url)] = valueFactory.createValue(url);
      }
    }
    webContent.setProperty("exo:links", values);
    webContent.save();
  }
  public VNodeDefinition(Node node) throws RepositoryException {
    name = node.getProperty(JCR_NODETYPENAME).getString();

    // do properties
    properties = new HashMap<String, VPropertyDefinitionI>();
    childSuggestions = new HashMap<String, String>();
    NodeIterator nodeIterator = node.getNodes();
    while (nodeIterator.hasNext()) {
      Node definitionNode = nodeIterator.nextNode();
      String nodeType = definitionNode.getProperty(AbstractProperty.JCR_PRIMARYTYPE).getString();

      // do a property
      if (NT_PROPERTYDEFINITION.equals(nodeType)) {
        String propertyName = "*"; // default to wildcard name
        if (definitionNode.hasProperty(JCR_NAME)) {

          // only add non-autogenerated properties
          if (!definitionNode.getProperty(JCR_AUTOCREATED).getBoolean()) {
            propertyName = definitionNode.getProperty(JCR_NAME).getString();
            properties.put(propertyName, new VPropertyDefinition(definitionNode));
          }
        } else {
          // property with no name means this node can accept custom properties
          canAddProperties = true;
        }
      }

      // do a child suggestion
      if (NT_CHILDNODEDEFINITION.equals(nodeType)) {
        String childName = "*";
        // only do well-defined childnodedefinitions with the following 2 jcr properties
        if (definitionNode.hasProperty(JCR_NAME)
            && definitionNode.hasProperty(JCR_DEFAULTPRIMARYTYPE)) {
          childSuggestions.put(
              definitionNode.getProperty(JCR_NAME).getString(),
              definitionNode.getProperty(JCR_DEFAULTPRIMARYTYPE).getString());
        }
      }
    }

    // do supertypes
    supertypes = new HashSet<String>();
    if (node.hasProperty(JCR_SUPERTYPES)) {
      for (Value value : node.getProperty(JCR_SUPERTYPES).getValues()) {
        supertypes.add(value.getString());
      }
    }

    // set mixin status
    isMixin = node.hasProperty(JCR_ISMIXIN) && node.getProperty(JCR_ISMIXIN).getBoolean();
  }
Пример #21
0
 /**
  * Reads the list of recipients from the <code>james:recipients</code> property.
  *
  * @param node mail node
  * @return list of recipient, or an empty list if not set
  * @throws MessagingException if a messaging error occurs
  * @throws RepositoryException if a repository error occurs
  */
 @SuppressWarnings("unchecked")
 private Collection<MailAddress> getRecipients(Node node)
     throws MessagingException, RepositoryException {
   try {
     Value[] values = node.getProperty("james:recipients").getValues();
     Collection<MailAddress> recipients = new ArrayList<MailAddress>(values.length);
     for (Value value : values) {
       recipients.add(new MailAddress(value.getString()));
     }
     return recipients;
   } catch (PathNotFoundException e) {
     return Collections.EMPTY_LIST;
   }
 }
  public List<ContentMap> getItems(Node item, String nodeType, String workspace) {
    final List<ContentMap> items = new ArrayList<ContentMap>(0);

    try {
      final Value[] values = item.getProperty(nodeType).getValues();
      if (values != null) {
        for (Value value : values) {
          items.add(templatingFunctions.contentById(value.getString(), workspace));
        }
      }
    } catch (RepositoryException e) {
      log.error("Exception while getting items", e.getMessage());
    }
    return items;
  }
Пример #23
0
 /**
  * Utility method used to convert a JCR {@link Value} object into a valid graph property value.
  *
  * @param value the JCR value; may be null
  * @param jcrProperty the JCR property, used to access the session (if needed)
  * @return the graph representation of the value
  * @throws RepositoryException if there is an error working with the session
  */
 public Object convert(Value value, javax.jcr.Property jcrProperty) throws RepositoryException {
   if (value == null) return null;
   try {
     switch (value.getType()) {
       case javax.jcr.PropertyType.BINARY:
         return factories.getBinaryFactory().create(value.getBinary().getStream(), 0);
       case javax.jcr.PropertyType.BOOLEAN:
         return factories.getBooleanFactory().create(value.getBoolean());
       case javax.jcr.PropertyType.DATE:
         return factories.getDateFactory().create(value.getDate());
       case javax.jcr.PropertyType.DOUBLE:
         return factories.getDoubleFactory().create(value.getDouble());
       case javax.jcr.PropertyType.LONG:
         return factories.getLongFactory().create(value.getLong());
       case javax.jcr.PropertyType.NAME:
         return factories.getNameFactory().create(value.getString());
       case javax.jcr.PropertyType.PATH:
         return factories.getPathFactory().create(value.getString());
       case javax.jcr.PropertyType.REFERENCE:
         return factories.getReferenceFactory().create(value.getString());
       case javax.jcr.PropertyType.STRING:
         return factories.getStringFactory().create(value.getString());
       case javax.jcr.PropertyType.UNDEFINED:
         // We don't know what type of values these are, but we need to convert any value
         // that depends on namespaces (e.g., names and paths) into Graph objects.
         try {
           // So first try a name ...
           return factories.getNameFactory().create(value.getString());
         } catch (ValueFormatException e) {
           // Wasn't a name, so try a path ...
           try {
             return factories.getPathFactory().create(value.getString());
           } catch (ValueFormatException e2) {
             // Wasn't a path, so finally treat as a string ...
             return factories.getStringFactory().create(value.getString());
           }
         }
     }
   } catch (ValueFormatException e) {
     // There was an error converting the JCR value into the appropriate graph value
     String typeName = javax.jcr.PropertyType.nameFromValue(value.getType());
     throw new RepositoryException(
         JcrConnectorI18n.errorConvertingJcrValueOfType.text(value.getString(), typeName));
   }
   return null;
 }
Пример #24
0
  /**
   * Grants the specified permission to the role. Both permission and role nodes have to exist. The
   * {@link Session#save()} is not called by this method; it is the responsibility of the caller.
   *
   * @param permissionPath the path of the permission to be granted
   * @param rolePath the path of the role the permission should be granted to
   * @param session current JCR session
   * @return <code>true</code> if any modification was done; if the role already has that permission
   *     assigned, <code>false</code> is returned.
   * @throws RepositoryException in case of an error
   */
  public static boolean grantPermissionToRole(
      String permissionPath, String rolePath, JCRSessionWrapper session)
      throws RepositoryException {
    if (permissionPath == null || !permissionPath.startsWith("/permissions/")) {
      throw new IllegalArgumentException(
          "Illegal value for the permission path: " + permissionPath);
    }
    if (rolePath == null || rolePath.length() == 0) {
      throw new IllegalArgumentException("Illegal value for the role: " + rolePath);
    }

    boolean modified = true;

    JCRNodeWrapper permission = session.getNode(permissionPath);
    String permissionId = permission.getIdentifier();
    JCRNodeWrapper role = session.getNode(rolePath.contains("/") ? rolePath : "/roles/" + rolePath);

    if (role.hasProperty("j:permissions")) {
      Value[] values = role.getProperty("j:permissions").getValues();
      boolean alreadyPresent = false;
      for (Value value : values) {
        if (permissionId.equals(value.getString())) {
          alreadyPresent = true;
          break;
        }
      }
      if (!alreadyPresent) {
        Value[] newValues = new Value[values.length + 1];
        System.arraycopy(values, 0, newValues, 0, values.length);
        newValues[values.length] = session.getValueFactory().createValue(permission, true);
        role.setProperty("j:permissions", newValues);
        logger.info("Granted permission {} to role {}", permission.getPath(), role.getPath());
      } else {
        if (logger.isDebugEnabled()) {
          logger.debug(
              "Role {} already has permission {} granted", role.getPath(), permission.getPath());
        }
        modified = false;
      }
    } else {
      role.setProperty(
          "j:permissions", new Value[] {session.getValueFactory().createValue(permission, true)});
      logger.info("Granted permission {} to role {}", permission.getPath(), role.getPath());
    }

    return modified;
  }
Пример #25
0
  @Override
  public void delete() {
    try {
      @SuppressWarnings("unchecked")
      final Iterator<Property> references = node.getReferences();
      @SuppressWarnings("unchecked")
      final Iterator<Property> weakReferences = node.getWeakReferences();
      final Iterator<Property> inboundProperties = Iterators.concat(references, weakReferences);

      while (inboundProperties.hasNext()) {
        final Property prop = inboundProperties.next();
        final List<Value> newVals = new ArrayList<>();
        final Iterator<Value> propIt = property2values.apply(prop);
        while (propIt.hasNext()) {
          final Value v = propIt.next();
          if (!node.equals(getSession().getNodeByIdentifier(v.getString()))) {
            newVals.add(v);
            LOGGER.trace("Keeping multivalue reference property when deleting node");
          }
        }
        if (newVals.size() == 0) {
          prop.remove();
        } else {
          prop.setValue(newVals.toArray(new Value[newVals.size()]));
        }
      }

      final Node parent;

      if (getNode().getDepth() > 0) {
        parent = getNode().getParent();
      } else {
        parent = null;
      }
      final String name = getNode().getName();

      node.remove();

      if (parent != null) {
        createTombstone(parent, name);
      }

    } catch (final RepositoryException e) {
      throw new RepositoryRuntimeException(e);
    }
  }
Пример #26
0
  @Override
  public JcrRepositoryDescriptor repositoryInfo() {
    Session session = (Session) this.getThreadLocalRequest().getSession().getAttribute("session");
    JcrRepositoryDescriptor desc = new JcrRepositoryDescriptor();

    Repository repo = session.getRepository();
    try {
      String keys[] = session.getRepository().getDescriptorKeys();
      for (int i = 0; i < keys.length; i++) {
        Value value = repo.getDescriptorValue(keys[i]);
        desc.add(keys[i], value != null ? value.getString() : "N/A");
      }
    } catch (RepositoryException e) {
      log.log(Level.SEVERE, "Error getting repository information", e);
    }
    return desc;
  }
 /* (non-Javadoc)
  * @see org.exoplatform.services.wcm.link.LiveLinkManagerService#getBrokenLinks(javax.jcr.Node)
  */
 public List<String> getBrokenLinks(Node webContent) throws Exception {
   List<String> listBrokenUrls = (List<String>) brokenLinksCache.get(webContent.getUUID());
   if (listBrokenUrls == null || listBrokenUrls.size() == 0) {
     listBrokenUrls = new ArrayList<String>();
     if (webContent.hasProperty("exo:links")) {
       for (Value value : webContent.getProperty("exo:links").getValues()) {
         String link = value.getString();
         LinkBean linkBean = LinkBean.parse(link);
         if (linkBean.isBroken()) {
           listBrokenUrls.add(linkBean.getUrl());
         }
       }
       brokenLinksCache.put(webContent.getUUID(), listBrokenUrls);
     }
   }
   return listBrokenUrls;
 }
Пример #28
0
 protected void assertProperty(
     AbstractJcrProperty property,
     javax.jcr.Node node,
     String name,
     int propertyType,
     Object... values)
     throws Exception {
   assertThat(property.getName(), is(name));
   assertThat(property.getType(), is(propertyType));
   assertThat(property.getParent(), is(node));
   if (values.length > 1) {
     int i = 0;
     for (Value actual : property.getValues()) {
       String actualString = actual.getString();
       String expectedString = context.getValueFactories().getStringFactory().create(values[i]);
       assertThat(actualString, is(expectedString));
       assertCanObtainValue(actual, propertyType);
       ++i;
     }
     // Getting the single value should result in an error ...
     try {
       property.getValue();
       fail("Should not be able to call Property.getValue() on multi-valued properties");
     } catch (ValueFormatException e) {
       // expected ...
     }
   } else {
     String actualString = property.getValue().getString();
     String expectedString = context.getValueFactories().getStringFactory().create(values[0]);
     assertThat(actualString, is(expectedString));
     assertThat(actualString, is(property.getString()));
     assertCanObtainValue(property.getValue(), propertyType);
     // Getting the multiple values should result in an error ...
     try {
       property.getValues();
       fail("Should not be able to call Property.getValues() on single-valued properties");
     } catch (ValueFormatException e) {
       // expected ...
     }
     // Check resolving the reference ...
     if (propertyType == PropertyType.REFERENCE) {
       javax.jcr.Node referenced = property.getNode();
       assertThat(referenced, is(notNullValue()));
     }
   }
 }
Пример #29
0
 @Test
 public void shouldFindLatestCommitDetailsInMasterBranch() throws Exception {
   Node git = gitNode();
   Node commits = git.getNode("commit");
   Node commit = commits.getNodes().nextNode(); // the first commit ...
   // print = true;
   printDetails(commit);
   assertNodeHasObjectIdProperty(commit);
   assertNodeHasCommittedProperties(commit);
   assertThat(commit.getProperty("git:parents").isMultiple(), is(true));
   for (Value parentValue : commit.getProperty("git:parents").getValues()) {
     String identifier = parentValue.getString();
     Node parent = getSession().getNodeByIdentifier(identifier);
     assertThat(parent, is(notNullValue()));
   }
   assertThat(commit.getProperty("git:diff").getString(), is(notNullValue()));
   assertThat(commit.getProperty("git:tree").getNode().getPath(), is(treePathFor(commit)));
 }
Пример #30
0
 @Override
 public String createData(Node node, Row row) {
   try {
     UserACL userACL = WCMCoreUtils.getService(UserACL.class);
     if (node.hasProperty("gtn:access-permissions")) {
       for (Value v : node.getProperty("gtn:access-permissions").getValues()) {
         if (userACL.hasPermission(v.getString())) {
           return node.getPath();
         }
       }
       return null;
     } else {
       return node.getPath();
     }
   } catch (RepositoryException e) {
     return null;
   }
 }