Example #1
0
  @Test
  public void delete() {
    PlainSchema firstname = plainSchemaDAO.find("firstname");

    plainSchemaDAO.delete(firstname.getKey());

    PlainSchema actual = plainSchemaDAO.find("firstname");
    assertNull("delete did not work", actual);
  }
Example #2
0
  @Test
  public void issueSYNCOPE418() {
    PlainSchema schema = entityFactory.newEntity(PlainSchema.class);
    schema.setKey("http://schemas.examples.org/security/authorization/organizationUnit");

    try {
      plainSchemaDAO.save(schema);
      fail();
    } catch (InvalidEntityException e) {
      assertTrue(e.hasViolation(EntityViolationType.InvalidName));
    }
  }
Example #3
0
  @Override
  public A findByAttrUniqueValue(final String schemaKey, final PlainAttrValue attrUniqueValue) {
    PlainSchema schema = plainSchemaDAO.find(schemaKey);
    if (schema == null) {
      LOG.error("Invalid schema name '{}'", schemaKey);
      return null;
    }
    if (!schema.isUniqueConstraint()) {
      LOG.error("This schema has not unique constraint: '{}'", schemaKey);
      return null;
    }

    List<A> result = findByAttrValue(schemaKey, attrUniqueValue);
    return result.isEmpty() ? null : result.iterator().next();
  }
Example #4
0
  @Override
  @SuppressWarnings("unchecked")
  public List<A> findByAttrValue(final String schemaKey, final PlainAttrValue attrValue) {
    PlainSchema schema = plainSchemaDAO.find(schemaKey);
    if (schema == null) {
      LOG.error("Invalid schema name '{}'", schemaKey);
      return Collections.<A>emptyList();
    }

    String entityName =
        schema.isUniqueConstraint()
            ? getAnyUtils().plainAttrUniqueValueClass().getName()
            : getAnyUtils().plainAttrValueClass().getName();
    Query query = findByAttrValueQuery(entityName);
    query.setParameter("schemaKey", schemaKey);
    query.setParameter("stringValue", attrValue.getStringValue());
    query.setParameter(
        "booleanValue",
        attrValue.getBooleanValue() == null
            ? null
            : ((AbstractPlainAttrValue) attrValue)
                .getBooleanAsInteger(attrValue.getBooleanValue()));
    if (attrValue.getDateValue() == null) {
      query.setParameter("dateValue", null);
    } else {
      query.setParameter("dateValue", attrValue.getDateValue(), TemporalType.TIMESTAMP);
    }
    query.setParameter("longValue", attrValue.getLongValue());
    query.setParameter("doubleValue", attrValue.getDoubleValue());

    List<A> result = new ArrayList<>();
    for (PlainAttrValue value : (List<PlainAttrValue>) query.getResultList()) {
      A any = (A) value.getAttr().getOwner();
      if (!result.contains(any)) {
        result.add(any);
      }
    }

    return result;
  }
Example #5
0
  @Test(expected = InvalidEntityException.class)
  public void saveNonValid() {
    PlainSchema schema = entityFactory.newEntity(PlainSchema.class);
    schema.setKey("secondaryEmail");
    schema.setType(AttrSchemaType.String);
    schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator");
    schema.setMandatoryCondition("false");
    schema.setMultivalue(true);
    schema.setUniqueConstraint(true);

    plainSchemaDAO.save(schema);
  }
Example #6
0
  @Test
  public void checkForEnumType() {
    PlainSchema schema = entityFactory.newEntity(PlainSchema.class);
    schema.setType(AttrSchemaType.Enum);
    schema.setKey("color");

    try {
      plainSchemaDAO.save(schema);
      fail();
    } catch (Exception e) {
      assertNotNull(e);
    }

    schema.setEnumerationValues("red" + SyncopeConstants.ENUM_VALUES_SEPARATOR + "yellow");
    schema.setEnumerationKeys("1" + SyncopeConstants.ENUM_VALUES_SEPARATOR + "2");

    plainSchemaDAO.save(schema);

    PlainSchema actual = plainSchemaDAO.find(schema.getKey());
    assertNotNull(actual);
    assertNotNull(actual.getEnumerationKeys());
    assertFalse(actual.getEnumerationKeys().isEmpty());
  }
Example #7
0
  @Test
  public void save() {
    PlainSchema schema = entityFactory.newEntity(PlainSchema.class);
    schema.setKey("secondaryEmail");
    schema.setType(AttrSchemaType.String);
    schema.setValidatorClass("org.apache.syncope.core.validation.EmailAddressValidator");
    schema.setMandatoryCondition("false");
    schema.setMultivalue(true);

    plainSchemaDAO.save(schema);

    PlainSchema actual = plainSchemaDAO.find("secondaryEmail");
    assertNotNull("expected save to work", actual);
    assertEquals(schema, actual);
  }
  @Test
  public void issue42() {
    PlainSchema userId = plainSchemaDAO.find("userId");

    Set<MappingItem> beforeUserIdMappings = new HashSet<>();
    for (ExternalResource res : resourceDAO.findAll()) {
      if (res.getProvision(anyTypeDAO.findUser()) != null
          && res.getProvision(anyTypeDAO.findUser()).getMapping() != null) {

        for (MappingItem mapItem :
            res.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
          if (userId.getKey().equals(mapItem.getIntAttrName())) {
            beforeUserIdMappings.add(mapItem);
          }
        }
      }
    }

    ResourceTO resourceTO = new ResourceTO();
    resourceTO.setKey("resource-issue42");
    resourceTO.setConnector(100L);
    resourceTO.setEnforceMandatoryCondition(true);

    ProvisionTO provisionTO = new ProvisionTO();
    provisionTO.setAnyType(AnyTypeKind.USER.name());
    provisionTO.setObjectClass(ObjectClass.ACCOUNT_NAME);
    resourceTO.getProvisions().add(provisionTO);

    MappingTO mapping = new MappingTO();
    provisionTO.setMapping(mapping);

    MappingItemTO item = new MappingItemTO();
    item.setIntAttrName("userId");
    item.setIntMappingType(IntMappingType.UserPlainSchema);
    item.setExtAttrName("campo1");
    item.setConnObjectKey(true);
    item.setMandatoryCondition("false");
    item.setPurpose(MappingPurpose.BOTH);
    mapping.setConnObjectKeyItem(item);

    ExternalResource resource = resourceDataBinder.create(resourceTO);
    resource = resourceDAO.save(resource);
    assertNotNull(resource);
    assertNotNull(resource.getProvision(anyTypeDAO.findUser()).getMapping());
    assertEquals(1, resource.getProvision(anyTypeDAO.findUser()).getMapping().getItems().size());

    resourceDAO.flush();

    ExternalResource actual = resourceDAO.find("resource-issue42");
    assertNotNull(actual);
    assertEquals(resource, actual);

    userId = plainSchemaDAO.find("userId");

    Set<MappingItem> afterUserIdMappings = new HashSet<>();
    for (ExternalResource res : resourceDAO.findAll()) {
      if (res.getProvision(anyTypeDAO.findUser()) != null
          && res.getProvision(anyTypeDAO.findUser()).getMapping() != null) {

        for (MappingItem mapItem :
            res.getProvision(anyTypeDAO.findUser()).getMapping().getItems()) {
          if (userId.getKey().equals(mapItem.getIntAttrName())) {
            afterUserIdMappings.add(mapItem);
          }
        }
      }
    }

    assertEquals(beforeUserIdMappings.size(), afterUserIdMappings.size() - 1);
  }
Example #9
0
  /**
   * Generate one where clause for each different attribute schema into the derived schema
   * expression provided.
   *
   * @param expression derived schema expression
   * @param value derived attribute value
   * @param attrUtils USER / GROUP
   * @return where clauses to use to build the query
   */
  private Set<String> getWhereClause(final String expression, final String value) {
    Parser parser = new Parser(new StringReader(expression));

    // Schema names
    List<String> identifiers = new ArrayList<>();

    // Literals
    List<String> literals = new ArrayList<>();

    // Get schema names and literals
    for (Token token = parser.getNextToken();
        token != null && StringUtils.isNotBlank(token.toString());
        token = parser.getNextToken()) {

      if (token.kind == ParserConstants.STRING_LITERAL) {
        literals.add(token.toString().substring(1, token.toString().length() - 1));
      }

      if (token.kind == ParserConstants.IDENTIFIER) {
        identifiers.add(token.toString());
      }
    }

    // Sort literals in order to process later literals included into others
    Collections.sort(
        literals,
        new Comparator<String>() {

          @Override
          public int compare(final String t, final String t1) {
            if (t == null && t1 == null) {
              return 0;
            } else if (t != null && t1 == null) {
              return -1;
            } else if (t == null && t1 != null) {
              return 1;
            } else if (t.length() == t1.length()) {
              return 0;
            } else if (t.length() > t1.length()) {
              return -1;
            } else {
              return 1;
            }
          }
        });

    // Split value on provided literals
    List<String> attrValues = split(value, literals);

    if (attrValues.size() != identifiers.size()) {
      LOG.error("Ambiguous JEXL expression resolution.");
      throw new IllegalArgumentException("literals and values have different size");
    }

    // clauses to be used with INTERSECTed queries
    Set<String> clauses = new HashSet<>();

    // builder to build the clauses
    StringBuilder bld = new StringBuilder();

    // Contains used identifiers in order to avoid replications
    Set<String> used = new HashSet<>();

    // Create several clauses: one for eanch identifiers
    for (int i = 0; i < identifiers.size(); i++) {
      if (!used.contains(identifiers.get(i))) {

        // verify schema existence and get schema type
        PlainSchema schema = plainSchemaDAO.find(identifiers.get(i));
        if (schema == null) {
          LOG.error("Invalid schema id '{}'", identifiers.get(i));
          throw new IllegalArgumentException("Invalid schema id " + identifiers.get(i));
        }

        // clear builder
        bld.delete(0, bld.length());

        bld.append("(");

        // set schema name
        bld.append("s.id = '").append(identifiers.get(i)).append("'");

        bld.append(" AND ");

        bld.append("s.id = a.schema_id").append(" AND ");

        bld.append("a.id = v.attribute_id");

        bld.append(" AND ");

        // use a value clause different for eanch different schema type
        switch (schema.getType()) {
          case Boolean:
            bld.append("v.booleanValue = '").append(attrValues.get(i)).append("'");
            break;
          case Long:
            bld.append("v.longValue = ").append(attrValues.get(i));
            break;
          case Double:
            bld.append("v.doubleValue = ").append(attrValues.get(i));
            break;
          case Date:
            bld.append("v.dateValue = '").append(attrValues.get(i)).append("'");
            break;
          default:
            bld.append("v.stringValue = '").append(attrValues.get(i)).append("'");
        }

        bld.append(")");

        used.add(identifiers.get(i));

        clauses.add(bld.toString());
      }
    }

    LOG.debug("Generated where clauses {}", clauses);

    return clauses;
  }
Example #10
0
 @Test(expected = InvalidEntityException.class)
 public void saveInvalidSchema() {
   PlainSchema schema = entityFactory.newEntity(PlainSchema.class);
   schema.setKey("username");
   plainSchemaDAO.save(schema);
 }