Java OProperty类代码示例

import org.odata4j.core.OProperty; //导入依赖的package包/类
/**
 * If there is an item of NTKP in Properties, link information is set.
 * @param properties OEntity key properties
 * @param esNtkp NavigationTargetKeyProperty
 * @param oedh Document handler for registration data
 * @throws NTKPNotFoundException The resource specified by NTKP does not exist
 */
protected void setLinksForOedh(Set<OProperty<?>> properties, EsNavigationTargetKeyProperty esNtkp,
        EntitySetDocHandler oedh)  throws NTKPNotFoundException {
    esNtkp.setProperties(properties);
    Map.Entry<String, String> link = esNtkp.getLinkEntry();

    // NTKPの情報をOEDHから削除する
    for (OProperty<?> property : properties) {
        HashMap<String, String> ntkp = AbstractODataResource.convertNTKP(property.getName());
        if (ntkp != null) {
            oedh.getStaticFields().remove(property.getName());
        }
    }

    // リンク情報が設定されていない場合はリンク情報を空にする
    if (link == null) {
        oedh.setManyToOnelinkId(new HashMap<String, Object>());
        return;
    }
    // 存在していれば、登録Entityにリンク情報を追加する
    // 例）AssociationEndの登録の場合 "l":{"EntityType":"EntityTypeのUUID"}
    Map<String, Object> links = oedh.getManyToOnelinkId();
    links.put(link.getKey(), link.getValue());
    oedh.setManyToOnelinkId(links);
}
 

import org.odata4j.core.OProperty; //导入依赖的package包/类
/**
 * プロパティー情報を解析する.
 */
private void analyzeProperties() {
    for (OProperty<?> property : properties) {
        HashMap<String, String> ntkp = AbstractODataResource.convertNTKP(property.getName());
        if (ntkp == null) {
            // staticフィールドの検索条件
            statics.put(property.getName(), (String) property.getValue());
        } else {
            // linksフィールドの検索条件
            if (shiftNtkp == null) {
                shiftNtkp = new EsNavigationTargetKeyProperty(cellId, boxId, nodeId, ntkp.get("entityType"),
                        odataProducer);
            }
            // OPropertyを組み立てて、追加する
            OProperty<?> newProperty = OProperties.string(ntkp.get("propName"), (String) property.getValue());
            shiftNtkp.properties.add(newProperty);
        }
    }
    if (shiftNtkp != null) {
        links = shiftNtkp.recursiveSearch();
    }
}
 

import org.odata4j.core.OProperty; //导入依赖的package包/类
@Override
public String roleIdToRoleResourceUrl(String roleId) {
    CellCtlODataProducer ccop = new CellCtlODataProducer(this);
    OEntity oe = ccop.getEntityByInternalId(Role.EDM_TYPE_NAME, roleId);
    if (oe == null) {
        // ロールが存在しない場合、nullを返す。
        return null;
    }

    String boxName = (String) oe.getProperty("_Box.Name").getValue();
    OProperty<?> schemaProp = oe.getProperty("_Box.Schema");
    String schema = null;
    if (schemaProp != null) {
        schema = (String) schemaProp.getValue();
    }
    String roleName = (String) oe.getProperty("Name").getValue();
    Role roleObj = new Role(roleName, boxName, schema, this.getUrl());
    return roleObj.createUrl();
}
 

import org.odata4j.core.OProperty; //导入依赖的package包/类
/**
 * スキーマのプロパティ定義に応じて適切な型に変換したプロパティ値オブジェクトを返す.<br/>
 * ユーザデータの場合はBoolean型のプロパティ値を文字列に変換する.
 * @param prop プロパティオブジェクト
 * @param edmType スキーマのプロパティ定義
 * @return 適切な型に変換したプロパティ値オブジェクト
 */
@Override
@SuppressWarnings("unchecked")
protected Object getSimpleValue(OProperty<?> prop, EdmType edmType) {
    if (edmType.equals(EdmSimpleType.DATETIME)) {
        OProperty<LocalDateTime> propD = (OProperty<LocalDateTime>) prop;
        LocalDateTime ldt = propD.getValue();
        if (ldt != null) {
            return ldt.toDateTime().getMillis();
        }
    }

    // Boolean型/Double型のプロパティ値を文字列に変換する
    if (prop.getValue() != null
            && (edmType.equals(EdmSimpleType.BOOLEAN) || edmType.equals(EdmSimpleType.DOUBLE))) {
        return String.valueOf(prop.getValue());
    }
    return prop.getValue();
}
 

import org.odata4j.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的package包/类
/**
     * Roleリソースのルート.
     * Boxの一覧を返す。
     * @param authzHeader Authorization ヘッダ
     * @return JAX-RS Response Object
     */
//    @Path("")
    @GET
    public final Response list(
            @HeaderParam(HttpHeaders.AUTHORIZATION) final String authzHeader) {
        // アクセス制御
        this.davRsCmp.checkAccessContext(this.davRsCmp.getAccessContext(), CellPrivilege.AUTH_READ);
        EntitiesResponse er = op.getEntities(Box.EDM_TYPE_NAME, null);
        List<OEntity> loe = er.getEntities();
        List<String> sl = new ArrayList<String>();
        sl.add(BOX_PATH_CELL_LEVEL);
        for (OEntity oe : loe) {
            OProperty<String> nameP = oe.getProperty("Name", String.class);
            sl.add(nameP.getValue());
        }
        StringBuilder sb = new StringBuilder();
        for (String s : sl) {
            sb.append(s + "<br/>");
        }
        return Response.ok().entity(sb.toString()).build();
    }
 

import org.odata4j.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的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.core.OProperty; //导入依赖的package包/类
/**
 * JsonEntryをパースする.
 * @param ees EdmEntitySet
 * @param jsr JsonStreamReader
 * @return JsonEntry
 */
protected JsonEntry parseEntry(EdmEntitySet ees, JsonStreamReader jsr) {
    JsonEntry entry = new JsonEntry(ees);
    entry.properties = new ArrayList<OProperty<?>>();
    entry.links = new ArrayList<OLink>();

    String name = "";
    while (jsr.hasNext()) {
        JsonEvent event = jsr.nextEvent();

        if (event.isStartProperty()) {
            try {
                name = event.asStartProperty().getName();
                ees = addProperty(entry, ees, name, jsr);
            } catch (IllegalArgumentException e) {
                throw PersoniumCoreException.OData.REQUEST_FIELD_FORMAT_ERROR.params(name).reason(e);
            }
        } else if (event.isEndObject()) {
            break;
        }
    }

    entry.oentity = toOEntity(ees, entry.getEntityType(), entry.getEntityKey(), entry.properties, entry.links);
    return entry;
}
 

import org.odata4j.core.OProperty; //导入依赖的package包/类
/**
 * OEntityへ変換する.
 * @param entitySet エンティティセット
 * @param entityType エンティティタイプ
 * @param key キー
 * @param properties プロパティ
 * @param links リンク情報
 * @return OEntity
 */
private OEntity toOEntity(EdmEntitySet entitySet,
        EdmEntityType entityType,
        OEntityKey key,
        List<OProperty<?>> properties,
        List<OLink> links) {

    // key is what we pulled out of the _metadata, use it first.
    if (key != null) {
        return OEntities.create(entitySet, entityType, key, properties, links);
    }

    if (entityKey != null) {
        return OEntities.create(entitySet, entityType, entityKey, properties, links);
    }

    return OEntities.createRequest(entitySet, properties, links);
}
 

import org.odata4j.core.OProperty; //导入依赖的package包/类
/**
 * 不足分のComplexTypePropertyを追加する.
 * @param props 追加対象Propertyリスト
 * @param jsr パース対象文字のJsonStreamReader
 * @return OComplexObject
 */
private OComplexObject eatProps(List<OProperty<?>> props, JsonStreamReader jsr) {

    ensureNext(jsr);
    while (jsr.hasNext()) {
        JsonEvent event = jsr.nextEvent();

        if (event.isStartProperty()) {
            addProperty(props, event.asStartProperty().getName(), jsr);
        } else if (event.isEndProperty()) {
            continue;
        } else if (event.isEndObject()) {
            break;
        } else {
            throw new JsonParseException("unexpected parse event: " + event.toString());
        }
    }
    return OComplexObjects.create(returnType, props);
}