Java EdmProperty类代码示例

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * constructor.
 * @param metadata UserDataのメタデータ（プロパティ更新前)
 * @param entityTypeName 追加対象のEntityType名
 * @param dynamicPropCount 追加されるDynamicProperty数
 */
public PropertyLimitChecker(final EdmDataServices metadata,
        final String entityTypeName, final int dynamicPropCount) {
    this();
    // 引数で受け取る metadataは更新前のものなので、追加後のメタデータを作成する必要がある。
    Builder builder = EdmDataServices.newBuilder(metadata);

    // 追加対象数分、ダミーでプロパティをスキーマ情報に追加する
    String dummyKey = "dummy" + System.currentTimeMillis();
    for (int i = 0; i < dynamicPropCount; i++) {
        EdmEntityType.Builder entityTypeBuilder = builder
                .findEdmEntityType(UserDataODataProducer.USER_ODATA_NAMESPACE + "." + entityTypeName);
        EdmProperty.Builder propertyBuilder =
                EdmProperty.newBuilder(String.format("%s_%03d", dummyKey, i))
                .setType(EdmSimpleType.getSimple("Edm.String"));
        entityTypeBuilder.addProperties(propertyBuilder);
    }
    // 変更後のメタデータを作成
    this.metadata = builder.build();
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
@Override
public void visit(GeExpression expr) {
    log.debug("visit(GeExpression expr)");

    // $filterに指定された検索条件のプロパティが単純型ではない場合は、パースエラーとする。
    if (!(expr.getLHS() instanceof EntitySimpleProperty)) {
        throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
    }
    EdmProperty edmProperty = getEdmProprety((EntitySimpleProperty) expr.getLHS());

    // $filterに指定されたプロパティの型と検索条件の値として指定されたデータ型の検証
    CommonExpression searchValue = expr.getRHS();
    FilterConditionValidator.validateFilterOpCondition(edmProperty, searchValue);

    // ESの Range filterを設定する
    Map<String, Object> ge = new HashMap<String, Object>();
    Map<String, Object> property = new HashMap<String, Object>();
    ge.put("gte", getSearchValue(expr.getRHS()));
    property.put(getSearchKey(expr.getLHS(), true), ge);
    this.current.put("range", property);
    this.current = stack.pop();
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * $filterクエリの検索条件に指定するプロパティのデータ型と検索条件の値として指定されたデータ型の整合性を検証する.
 * <ul>
 * <li>StringLiteral</li>
 * <li>IntegralLiteral、Int64Literal</li>
 * <li>DoubleLiteral</li>
 * </ul>
 * なお、"1.0f" や "1.0m" などの表記（それぞれSingleLiteral、DecimalLiteral）はパースエラーとする。
 * @param edmProperty $filterの検索条件に指定されたプロパティ
 * @param searchValue $filterの検索条件の値
 */
static void validateFilterOpCondition(EdmProperty edmProperty, CommonExpression searchValue) {
    // 比較演算子（lt/le/ge/gt）共通で許容するデータ： 文字列／整数値／実数値
    // 真偽値やNULLは大小比較ができないため、許容しない。
    if (searchValue instanceof BooleanLiteral
            || searchValue instanceof NullLiteral) {
        throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
    }

    // スキーマ定義されているプロパティのデータ型として検索条件の値が評価できることを検証する。
    // ただし、スキーマ定義されていない場合は、検証できないので除外する。
    if (edmProperty != null) {
        AbstractValidator validator = validatorMap.get(edmProperty.getType());
        if (null == validator) {
            throw PersoniumCoreException.OData.FILTER_PARSE_ERROR;
        }
        validator.validate(searchValue, edmProperty.getName());
    }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * ComplexTypeを型に設定しているEntityTypeを取得する.
 * @param complexTypeList 削除対象のComplexTypePropertyと関連するcomplexTypeのList
 * @return ComplexTypeを型に設定しているEntityTypeの一覧
 */
protected List<String> getEntityTypeNameLinkedComplexType(List<String> complexTypeList) {
    ArrayList<String> entityTypeList = new ArrayList<String>();
    Iterator<EdmEntityType> entityTypeIter = null;
    for (String complexTypeName : complexTypeList) {
        entityTypeIter = userDataProducer.getMetadata().getEntityTypes().iterator();
        while (entityTypeIter.hasNext()) {
            EdmEntityType entityType = entityTypeIter.next();
            for (EdmProperty edmProp : entityType.getProperties()) {
                if (edmProp.getType().getFullyQualifiedTypeName()
                        .equals(UserDataODataProducer.USER_ODATA_NAMESPACE + "." + complexTypeName)
                        && !entityTypeList.contains(entityType.getName())) {
                    entityTypeList.add(entityType.getName());
                }
            }
        }
    }
    return entityTypeList;
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * 指定されたComplexTypeを型に設定しているComplexTypeを設定する.
 * @param complexTypeName ComplexType名
 * @param complexTypeList 削除対象のComplexTypePropertyと関連するcomplexTypeの一覧
 */
protected void addComplexTypeNameLinkedComplexType(String complexTypeName, List<String> complexTypeList) {
    Iterator<EdmComplexType> complexTypeIter = userDataProducer.getMetadata().getComplexTypes().iterator();

    while (complexTypeIter.hasNext()) {
        EdmComplexType complexType = complexTypeIter.next();
        for (EdmProperty edmProp : complexType.getProperties()) {
            if (edmProp.getType().getFullyQualifiedTypeName()
                    .equals(UserDataODataProducer.USER_ODATA_NAMESPACE + "." + complexTypeName)
                    && !complexTypeList.contains(complexType.getName())) {
                complexTypeList.add(complexType.getName());
                addComplexTypeNameLinkedComplexType(complexType.getName(), complexTypeList);
            }
        }
    }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * シンプルタイプの配列要素をプロパティに追加する.
 * @param properties プロパティ一覧
 * @param edmProp 追加プロパティのスキーマ
 * @param propValue 追加プロカティの値
 * @param edmType タイプの型情報
 */
@SuppressWarnings("unchecked")
protected void addSimpleListProperty(List<OProperty<?>> properties,
        EdmProperty edmProp,
        Object propValue,
        EdmType edmType) {
    EdmCollectionType collectionType = new EdmCollectionType(edmProp.getCollectionKind(), edmType);
    OCollection.Builder<OObject> builder = OCollections.<OObject>newBuilder(collectionType.getItemType());
    if (propValue == null) {
        properties.add(OProperties.collection(edmProp.getName(), collectionType, null));
    } else {
        for (Object val : (ArrayList<Object>) propValue) {
            if (null == val) {
                builder.add(OSimpleObjects.parse((EdmSimpleType<?>) collectionType.getItemType(), null));
            } else {
                builder.add(OSimpleObjects.parse((EdmSimpleType<?>) collectionType.getItemType(), val.toString()));
            }
        }
        properties.add(OProperties.collection(edmProp.getName(), collectionType, builder.build()));
    }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * Complexタイプの配列要素をプロパティに追加する.
 * @param metadata スキーマ情報
 * @param properties プロパティ一覧
 * @param edmProp 追加プロパティのスキーマ
 * @param propValue 追加プロカティの値
 * @param edmType タイプの型情報
 */
@SuppressWarnings("unchecked")
protected void addComplexListProperty(EdmDataServices metadata,
        List<OProperty<?>> properties,
        EdmProperty edmProp,
        Object propValue,
        EdmType edmType) {
    EdmCollectionType collectionType = new EdmCollectionType(edmProp.getCollectionKind(), edmType);
    OCollection.Builder<OObject> builder = OCollections.<OObject>newBuilder(collectionType.getItemType());

    // ComplexTypeの型情報を取得する
    EdmComplexType ct = metadata.findEdmComplexType(
            collectionType.getItemType().getFullyQualifiedTypeName());

    if (propValue == null) {
        properties.add(OProperties.collection(edmProp.getName(), collectionType, null));
    } else {
        // ComplexTypeプロパティを配列に追加する
        for (Object val : (ArrayList<Object>) propValue) {
            builder.add(OComplexObjects.create(ct, getComplexTypePropList(metadata, edmProp, val)));
        }

        // ComplexTypeの配列要素をプロパティに追加する
        properties.add(OProperties.collection(edmProp.getName(), collectionType, builder.build()));
    }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * スキーマ定義をもとにOPropertyにデフォルト値を設定. <br />
 * MERGEの場合、キー, updated, published以外の項目にデフォルト値は設定しない
 * @param ep EdmProperty
 * @param propName プロパティ名
 * @param op OProperty
 * @param metadata EdmDataServicesスキーマ定義
 * @return Oproperty
 */
@Override
protected OProperty<?> setDefaultValue(EdmProperty ep, String propName, OProperty<?> op, EdmDataServices metadata) {

    if (metadata != null) {
        // スキーマ情報の取得
        EdmEntitySet edmEntitySet = metadata.findEdmEntitySet(getEntitySetName());
        EdmEntityType edmEntityType = edmEntitySet.getType();
        // スキーマに定義されたキーリストを取得
        List<String> keysDefined = edmEntityType.getKeys();
        String epName = ep.getName();

        // キー, updated, published以外の項目にデフォルト値は設定しない
        if (!keysDefined.contains(epName) && !Common.P_PUBLISHED.getName().equals(epName)
                && !Common.P_UPDATED.getName().equals(epName)) {
            return null;
        }
    }

    return super.setDefaultValue(ep, propName, op, metadata);
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * デフォルト値を設定したComplexプロパティ一覧を取得する.
 * @param ep EdmProperty
 * @param propName プロパティ名
 * @param opList OProperty一覧
 * @param metadata スキーマ情報
 * @return デフォルト値を設定したシンプルプロパティ
 */
protected List<OProperty<?>> getComplexPropertyList(EdmProperty ep, String propName, List<OProperty<?>> opList,
        EdmDataServices metadata) {
    // ComplexTypeのスキーマ情報を取得する
    EdmComplexType edmComplexType =
            metadata.findEdmComplexType(ep.getType().getFullyQualifiedTypeName());
    Map<String, OProperty<?>> complexProperties = new HashMap<String, OProperty<?>>();

    // 不足項目を確認するためにスキーマ情報をベースにループさせるので、OPropertyの一覧をHash形式に変換する
    for (OProperty<?> cp : opList) {
        complexProperties.put(cp.getName(), cp);
    }

    List<OProperty<?>> newComplexProperties = createNewComplexProperties(metadata, edmComplexType,
            complexProperties);

    // デフォルト値を設定したComplexTypeプロパティの一覧を返却する
    return newComplexProperties;
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * ComplexTypeスキーマを参照して、必須チェックとデフォルト値の設定を行う.
 * @param metadata スキーマ情報
 * @param edmComplexType ComplexTypeのスキーマ情報
 * @param complexProperties ComplexTypePropertyのList
 * @return デフォルト値を設定したComplexTypeプロパティの一覧
 */
protected List<OProperty<?>> createNewComplexProperties(EdmDataServices metadata,
        EdmComplexType edmComplexType,
        Map<String, OProperty<?>> complexProperties) {
    List<OProperty<?>> newComplexProperties = new ArrayList<OProperty<?>>();
    for (EdmProperty ctp : edmComplexType.getProperties()) {
        // プロパティ情報を取得する
        String compPropName = ctp.getName();
        OProperty<?> complexProperty = complexProperties.get(compPropName);
        if (ctp.getType().isSimple()) {
            // シンプル型の場合
            complexProperty = getSimpleProperty(ctp, compPropName, complexProperty);
        } else {
            // Complex型の場合
            complexProperty = getComplexProperty(ctp, compPropName, complexProperty, metadata);
        }
        if (complexProperty != null) {
            newComplexProperties.add(complexProperty);
        }
    }
    return newComplexProperties;
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * デフォルト値の設定.
 * @param ep EdmProperty
 * @param propName プロパティ名
 * @param op OProperty
 * @param metadata EdmDataServicesスキーマ定義
 * @return Oproperty
 */
protected OProperty<?> setDefaultValue(EdmProperty ep, String propName, OProperty<?> op, EdmDataServices metadata) {
    // スキーマ上定義されているのに入力の存在しない Property
    // デフォルト値が定義されていればそれをいれる。
    // ComplexTypeそのものの項目、または配列の項目であればデフォルト値は設定しない
    NamespacedAnnotation<?> annotation = ep.findAnnotation(Common.P_NAMESPACE.getUri(),
            Property.P_IS_DECLARED.getName());
    if (annotation != null && !(Boolean.valueOf(annotation.getValue().toString()))) {
        return null;
    }
    if (ep.getType().isSimple() && !ep.getCollectionKind().equals(CollectionKind.List)
            && ep.getDefaultValue() != null) {
        op = generateDefautlProperty(ep);
    } else if (ep.isNullable()) {
        // nullableがtrueであれば。nullの入ったプロパティ
        // TODO これでいいのか？
        op = OProperties.null_(propName, ep.getType().getFullyQualifiedTypeName());
    } else {
        // nullableがfalseであれば。エラーとする
        throw PersoniumCoreException.OData.INPUT_REQUIRED_FIELD_MISSING.params(propName);
    }
    return op;
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
/**
 * プロパティ項目の値をチェックする.
 * @param ep EdmProperty
 * @param propName プロパティ名
 * @param op OProperty
 */
protected void validateProperty(EdmProperty ep, String propName, OProperty<?> op) {
    for (NamespacedAnnotation<?> annotation : ep.getAnnotations()) {
        if (annotation.getName().equals(Common.P_FORMAT)) {
            String pFormat = annotation.getValue().toString();
            // 正規表現チェックの場合
            if (pFormat.startsWith(Common.P_FORMAT_PATTERN_REGEX)) {
                validatePropertyRegEx(propName, op, pFormat);
            } else if (pFormat.equals(Common.P_FORMAT_PATTERN_URI)) {
                validatePropertyUri(propName, op);
            } else if (pFormat.startsWith(Common.P_FORMAT_PATTERN_SCHEMA_URI)) {
                validatePropertySchemaUri(propName, op);
            } else if (pFormat.startsWith(Common.P_FORMAT_PATTERN_CELL_URL)) {
                validatePropertyCellUrl(propName, op);
            } else if (pFormat.startsWith(Common.P_FORMAT_PATTERN_USUSST)) {
                validatePropertyUsusst(propName, op, pFormat);
            } else if (pFormat.startsWith(Common.P_FORMAT_PATTERN_MESSAGE_REQUEST_RELATION)) {
                validatePropertyMessageRequestRelation(propName, op);
            }
        }
    }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
private EdmComplexType.Builder ComplexTypeにcomplex型Propertyを指定数作成(int count, String complexTypeName,
        EdmComplexType.Builder builder) {
    // ComplexTypeを新規に作成
    EdmComplexType.Builder ctBuilder = EdmComplexType.newBuilder();
    ctBuilder.setName(complexTypeName).setNamespace(NS);

    // ComplexTypeに加えるべき プロパティを作成
    List<EdmProperty.Builder> pBuilderList = new ArrayList<EdmProperty.Builder>();
    for (int i = 0; i < count; i++) {
        EdmProperty.Builder pBuilder = EdmProperty.newBuilder(String.format("%s_prop_%03d", complexTypeName, i))
                .setType(ctBuilder);
        pBuilderList.add(pBuilder);

        // 予約語プロパティ用ダミー
        pBuilder = EdmProperty.newBuilder(String.format("_reservedProp_%03d", i))
                .setType(EdmSimpleType.STRING);
        builder.addProperties(pBuilder);
    }

    builder.addProperties(pBuilderList);
    return ctBuilder;
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
protected void addStructuralTypeProperties(Context c, EdmStructuralType st, ExpressionEvaluator ev) {
  for (EdmProperty prop : st.getProperties()) {
    boolean add = true;
    if (ev != null) {
      c.pushResolver(prop);
      add = ev.evaluate(c.queryInfo.filter);
    }
    if (add) {
      c.addEntity(this.getProperty(st, st, prop, c));
    }
    if (ev != null) {
      c.popResolver();
    }
  }

  EdmDataServices ds = dataProducer.getMetadata();
  Iterator<?> candidates = (st instanceof EdmComplexType) ? ds.getComplexTypes().iterator() : ds.getEntityTypes().iterator();
  // down the subtypes hole...
  while (candidates.hasNext()) {
    EdmStructuralType item = (EdmStructuralType) candidates.next();
    if (item.getBaseType() != null && item.getBaseType().equals(st)) {
      addStructuralTypeProperties(c, item, ev);
    }
  }
}
 

import org.odata4j.edm.EdmProperty; //导入依赖的package包/类
private OProperty<?> createPropWithDefaultValue(EdmProperty prop) {
  String defaultValue = prop.getDefaultValue();
  EdmSimpleType<?> type = (EdmSimpleType<?>) prop.getType();

  // Trying to re-use the JsonTypeConverter that will convert string to 
  // corresponding types, the JsonTokenType is a required parameter, just
  // fake it here.
  JsonTokenType jsonTokenType = JsonTokenType.STRING;

  if (type == EdmSimpleType.BOOLEAN) {
    jsonTokenType = JsonTokenType.TRUE;
  }
  // The default value should match the data type, if it is a number, then it should not have () to enclose them.
  if (type != null && type == EdmSimpleType.INT16 || type == EdmSimpleType.INT32 || type == EdmSimpleType.INT64
      || type == EdmSimpleType.SINGLE || type == EdmSimpleType.DOUBLE || type == EdmSimpleType.DECIMAL) {
    if (defaultValue != null && defaultValue.length() > 0) {
      if (defaultValue.startsWith("(") && defaultValue.endsWith(")")) {
        defaultValue = defaultValue.replace("(", "").replace(")", "");
      }
    }
  }
  return JsonTypeConverter.parse(prop.getName(), type, defaultValue, jsonTokenType);
}