Examples with DepthParam org.opendaylight.restconf.nb.rfc8040.DepthParam used on opensource projects

Example 1 with DepthParam

use of org.opendaylight.restconf.nb.rfc8040.DepthParam in project netconf by opendaylight.

the class JsonNormalizedNodeBodyWriter method writeNormalizedNode.

private static void writeNormalizedNode(final JsonWriter jsonWriter, final SchemaPath path, final InstanceIdentifierContext<SchemaNode> context, final NormalizedNode data, final DepthParam depth, final List<Set<QName>> fields) throws IOException {
    final RestconfNormalizedNodeWriter nnWriter;
    if (context.getSchemaNode() instanceof RpcDefinition) {
        /*
             *  RpcDefinition is not supported as initial codec in JSONStreamWriter,
             *  so we need to emit initial output declaration..
             */
        final RpcDefinition rpc = (RpcDefinition) context.getSchemaNode();
        final SchemaPath rpcPath = SchemaPath.of(Absolute.of(rpc.getQName(), rpc.getOutput().getQName()));
        nnWriter = createNormalizedNodeWriter(context, rpcPath, jsonWriter, depth, fields);
        final Module module = context.getSchemaContext().findModule(data.getIdentifier().getNodeType().getModule()).get();
        jsonWriter.name(module.getName() + ":output");
        jsonWriter.beginObject();
        writeChildren(nnWriter, (ContainerNode) data);
        jsonWriter.endObject();
    } else if (context.getSchemaNode() instanceof ActionDefinition) {
        /*
             *  ActionDefinition is not supported as initial codec in JSONStreamWriter,
             *  so we need to emit initial output declaration..
             */
        final ActionDefinition actDef = (ActionDefinition) context.getSchemaNode();
        final List<QName> qNames = context.getInstanceIdentifier().getPathArguments().stream().filter(arg -> !(arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates)).filter(arg -> !(arg instanceof YangInstanceIdentifier.AugmentationIdentifier)).map(PathArgument::getNodeType).collect(Collectors.toList());
        qNames.add(actDef.getQName());
        qNames.add(actDef.getOutput().getQName());
        final SchemaPath actPath = SchemaPath.of(Absolute.of(qNames));
        nnWriter = createNormalizedNodeWriter(context, actPath, jsonWriter, depth, fields);
        final Module module = context.getSchemaContext().findModule(data.getIdentifier().getNodeType().getModule()).get();
        jsonWriter.name(module.getName() + ":output");
        jsonWriter.beginObject();
        writeChildren(nnWriter, (ContainerNode) data);
        jsonWriter.endObject();
    } else {
        if (SchemaPath.ROOT.equals(path)) {
            nnWriter = createNormalizedNodeWriter(context, path, jsonWriter, depth, fields);
        } else {
            nnWriter = createNormalizedNodeWriter(context, path.getParent(), jsonWriter, depth, fields);
        }
        if (data instanceof MapEntryNode) {
            // Restconf allows returning one list item. We need to wrap it
            // in map node in order to serialize it properly
            nnWriter.write(ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType()).withChild((MapEntryNode) data).build());
        } else {
            nnWriter.write(data);
        }
    }
    nnWriter.flush();
}

Example 2 with DepthParam

use of org.opendaylight.restconf.nb.rfc8040.DepthParam in project netconf by opendaylight.

the class QueryParamsTest method parseUriParametersUserDefinedTest.

/**
 * Test of parsing user defined parameters from URI request.
 */
@Test
public void parseUriParametersUserDefinedTest() {
    final QName containerChild = QName.create("ns", "container-child");
    final var parameters = new MultivaluedHashMap<String, String>();
    parameters.putSingle("content", "config");
    parameters.putSingle("depth", "10");
    parameters.putSingle("fields", "container-child");
    final var params = assertParams(QueryParams::newReadDataParams, parameters);
    // content
    assertEquals(ContentParam.CONFIG, params.content());
    // depth
    final DepthParam depth = params.depth();
    assertNotNull(depth);
    assertEquals(10, depth.value());
    // fields
    assertNotNull(params.fields());
    // fields for write filtering
    final var containerSchema = mock(ContainerSchemaNode.class);
    doReturn(QName.create(containerChild, "container")).when(containerSchema).getQName();
    final var containerChildSchema = mock(LeafSchemaNode.class);
    doReturn(containerChild).when(containerChildSchema).getQName();
    doReturn(containerChildSchema).when(containerSchema).dataChildByName(containerChild);
    final var context = mock(InstanceIdentifierContext.class);
    final var modelContext = mock(EffectiveModelContext.class);
    doReturn(modelContext).when(context).getSchemaContext();
    doReturn(containerSchema).when(context).getSchemaNode();
    final QueryParameters queryParameters = QueryParams.newQueryParameters(params, context);
    final List<Set<QName>> fields = queryParameters.fields();
    assertNotNull(fields);
    assertEquals(1, fields.size());
    assertEquals(Set.of(containerChild), fields.get(0));
}

Example 3 with DepthParam

use of org.opendaylight.restconf.nb.rfc8040.DepthParam in project netconf by opendaylight.

the class XmlNormalizedNodeBodyWriter method writeNormalizedNode.

private static void writeNormalizedNode(final XMLStreamWriter xmlWriter, final InstanceIdentifierContext<?> pathContext, final NormalizedNode data, final DepthParam depth, final List<Set<QName>> fields) throws IOException {
    final RestconfNormalizedNodeWriter nnWriter;
    final EffectiveModelContext schemaCtx = pathContext.getSchemaContext();
    if (pathContext.getSchemaNode() instanceof RpcDefinition) {
        /*
             *  RpcDefinition is not supported as initial codec in XMLStreamWriter,
             *  so we need to emit initial output declaration..
             */
        final RpcDefinition rpc = (RpcDefinition) pathContext.getSchemaNode();
        final SchemaPath rpcPath = SchemaPath.of(Absolute.of(rpc.getQName(), rpc.getOutput().getQName()));
        nnWriter = createNormalizedNodeWriter(xmlWriter, schemaCtx, rpcPath, depth, fields);
        writeElements(xmlWriter, nnWriter, (ContainerNode) data);
    } else if (pathContext.getSchemaNode() instanceof ActionDefinition) {
        /*
             *  ActionDefinition is not supported as initial codec in XMLStreamWriter,
             *  so we need to emit initial output declaration..
             */
        final ActionDefinition actDef = (ActionDefinition) pathContext.getSchemaNode();
        final List<QName> qNames = pathContext.getInstanceIdentifier().getPathArguments().stream().filter(arg -> !(arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates)).filter(arg -> !(arg instanceof YangInstanceIdentifier.AugmentationIdentifier)).map(PathArgument::getNodeType).collect(Collectors.toList());
        qNames.add(actDef.getQName());
        qNames.add(actDef.getOutput().getQName());
        final SchemaPath actPath = SchemaPath.of(Absolute.of(qNames));
        nnWriter = createNormalizedNodeWriter(xmlWriter, schemaCtx, actPath, depth, fields);
        writeElements(xmlWriter, nnWriter, (ContainerNode) data);
    } else {
        final boolean isRoot = pathContext.getInstanceIdentifier().isEmpty();
        if (isRoot) {
            nnWriter = createNormalizedNodeWriter(xmlWriter, schemaCtx, SchemaPath.ROOT, depth, fields);
        } else {
            final List<QName> qNames = pathContext.getInstanceIdentifier().getPathArguments().stream().filter(arg -> !(arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates)).filter(arg -> !(arg instanceof YangInstanceIdentifier.AugmentationIdentifier)).map(PathArgument::getNodeType).collect(Collectors.toList());
            final SchemaPath path = SchemaPath.of(Absolute.of(qNames));
            nnWriter = createNormalizedNodeWriter(xmlWriter, schemaCtx, path.getParent(), depth, fields);
        }
        if (data instanceof MapEntryNode) {
            // Restconf allows returning one list item. We need to wrap it
            // in map node in order to serialize it properly
            nnWriter.write(ImmutableNodes.mapNodeBuilder(data.getIdentifier().getNodeType()).addChild((MapEntryNode) data).build());
        } else if (isRoot) {
            if (data instanceof ContainerNode && ((ContainerNode) data).isEmpty()) {
                writeEmptyDataNode(xmlWriter, data);
            } else {
                writeAndWrapInDataNode(xmlWriter, nnWriter, data);
            }
        } else {
            nnWriter.write(data);
        }
    }
    nnWriter.flush();
}

Example 4 with DepthParam

use of org.opendaylight.restconf.nb.rfc8040.DepthParam in project netconf by opendaylight.

the class QueryParams method newReadDataParams.

/**
 * Parse parameters from URI request and check their types and values.
 *
 * @param uriInfo    URI info
 * @return {@link ReadDataParams}
 */
@NonNull
public static ReadDataParams newReadDataParams(final UriInfo uriInfo) {
    ContentParam content = ContentParam.ALL;
    DepthParam depth = null;
    FieldsParam fields = null;
    WithDefaultsParam withDefaults = null;
    PrettyPrintParam prettyPrint = null;
    boolean tagged = false;
    for (Entry<String, List<String>> entry : uriInfo.getQueryParameters().entrySet()) {
        final String paramName = entry.getKey();
        final List<String> paramValues = entry.getValue();
        try {
            switch(paramName) {
                case ContentParam.uriName:
                    content = optionalParam(ContentParam::forUriValue, paramName, paramValues);
                    break;
                case DepthParam.uriName:
                    final String depthStr = optionalParam(paramName, paramValues);
                    try {
                        depth = DepthParam.forUriValue(depthStr);
                    } catch (IllegalArgumentException e) {
                        throw new RestconfDocumentedException(e, new RestconfError(ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, "Invalid depth parameter: " + depthStr, null, "The depth parameter must be an integer between 1 and 65535 or \"unbounded\""));
                    }
                    break;
                case FieldsParam.uriName:
                    fields = optionalParam(FieldsParam::forUriValue, paramName, paramValues);
                    break;
                case WithDefaultsParam.uriName:
                    final var defaultsVal = optionalParam(WithDefaultsParam::forUriValue, paramName, paramValues);
                    if (defaultsVal != null) {
                        switch(defaultsVal) {
                            case REPORT_ALL:
                                withDefaults = null;
                                tagged = false;
                                break;
                            case REPORT_ALL_TAGGED:
                                withDefaults = null;
                                tagged = true;
                                break;
                            default:
                                withDefaults = defaultsVal;
                                tagged = false;
                        }
                    }
                    break;
                case PrettyPrintParam.uriName:
                    prettyPrint = optionalParam(PrettyPrintParam::forUriValue, paramName, paramValues);
                    break;
                default:
                    throw unhandledParam("read", paramName);
            }
        } catch (IllegalArgumentException e) {
            throw new RestconfDocumentedException("Invalid " + paramName + " value: " + e.getMessage(), ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE, e);
        }
    }
    return ReadDataParams.of(content, depth, fields, withDefaults, tagged, prettyPrint);
}