@Test public void shouldDeserialiseFromFullClassName() throws IOException, ClassNotFoundException { // Given final SimpleClassKeyDeserializer deserialiser = new SimpleClassKeyDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = IsA.class; final String id = expectedClass.getName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); // When final Class<?> clazz = (Class<?>) deserialiser.deserializeKey(id, context); // Then assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); }
@Override public Object deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { ObjectCodec oc = jsonParser.getCodec(); JsonNode node = oc.readTree(jsonParser); if (node instanceof ArrayNode) { ArrayNode arrayNode = (ArrayNode) node; ArrayList<String> ret = new ArrayList<>(); for (int i = 0; i < arrayNode.size(); i++) { ret.add(arrayNode.get(i).textValue()); } return ret.toArray(new String[0]); } else { return new String[]{node.textValue()}; } }
/** Get type for "on" values that are plain URIs by deducing the type from their parent. */ private String getOnType(DeserializationContext ctxt) { // Easiest way: The parser has already constructed an annotation object with a motivation. // This is highly dependendant on the order of keys in the JSON, i.e. if "on" is the first key in the annotation // object, this won't work. Object curVal = ctxt.getParser().getCurrentValue(); boolean isPaintingAnno = (curVal != null && curVal instanceof Annotation && ((Annotation) curVal).getMotivation() != null && ((Annotation) curVal).getMotivation().equals(Motivation.PAINTING)); if (isPaintingAnno) { return "sc:Canvas"; } // More reliable way: Walk up the parsing context until we hit a IIIF resource that we can deduce the type from // Usually this shouldn't be more than two levels up JsonStreamContext parent = ctxt.getParser().getParsingContext().getParent(); while (parent != null && (parent.getCurrentValue() == null || !(parent.getCurrentValue() instanceof Resource))) { parent = parent.getParent(); } if (parent != null) { Resource parentObj = (Resource) parent.getCurrentValue(); return parentObj.getType(); } return null; }
@Override public Object handleUnexpectedToken(DeserializationContext ctxt, Class<?> targetType, JsonToken t, JsonParser p, String failureMsg) throws IOException { if (p.getCurrentName().equals("@type") && t == JsonToken.START_ARRAY) { // Handle multi-valued @types, only current known cases are oa:SvgSelector and oa:CssStyle // in combination with cnt:ContentAsText ObjectMapper mapper = (ObjectMapper) p.getCodec(); String typeName = StreamSupport.stream(((ArrayNode) mapper.readTree(p)).spliterator(), false) .map(JsonNode::textValue) .filter(v -> !v.equals(ContentAsText.TYPE)) .findFirst().orElse(null); if (typeName != null) { return typeName; } } return super.handleUnexpectedToken(ctxt, targetType, t, p, failureMsg); }
@Override public KeyValue deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonNode node = objectMapper.getFactory().setCodec(objectMapper).getCodec().readTree(jp); String key = node.get("key").asText(); String type = node.get("type").asText(); KeyValue keyValue = new KeyValue(); keyValue.setKey(key); keyValue.setValueType(type); if ("string".equalsIgnoreCase(type)) { keyValue.setValueString(node.get("value").asText()); } else if ("boolean".equalsIgnoreCase(type)) { keyValue.setValueBoolean(node.get("value").asBoolean()); } return keyValue; }
@Test public void shouldDeserialiseFromSimpleClassName() throws IOException, ClassNotFoundException { // Given final SimpleClassDeserializer deserialiser = new SimpleClassDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = IsA.class; final String id = expectedClass.getSimpleName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); // When final Class<?> clazz = deserialiser._deserialize(id, context); // Then assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); }
public static <T> List<Extension<T>> readExtensions(JsonParser parser, DeserializationContext context) throws IOException { Objects.requireNonNull(parser); Objects.requireNonNull(context); List<Extension<T>> extensions = new ArrayList<>(); while (parser.nextToken() != JsonToken.END_OBJECT) { String extensionName = parser.getCurrentName(); ExtensionJson extensionJson = ExtensionSupplier.findExtensionJson(extensionName); if (extensionJson != null) { parser.nextToken(); Extension<T> extension = extensionJson.deserialize(parser, context); extensions.add(extension); } else { skip(parser); } } return extensions; }
@Override public Foo deserialize(JsonParser parser, DeserializationContext context) throws IOException { List<Extension<Foo>> extensions = Collections.emptyList(); while (parser.nextToken() != JsonToken.END_OBJECT) { if (parser.getCurrentName().equals("extensions")) { parser.nextToken(); extensions = JsonUtil.readExtensions(parser, context); } } Foo foo = new Foo(); ExtensionSupplier.addExtensions(foo, extensions); return foo; }
@Override public PostContingencyResult deserialize(JsonParser parser, DeserializationContext deserializationContext) throws IOException { Contingency contingency = null; LimitViolationsResult limitViolationsResult = null; while (parser.nextToken() != JsonToken.END_OBJECT) { switch (parser.getCurrentName()) { case "contingency": parser.nextToken(); contingency = parser.readValueAs(Contingency.class); break; case "limitViolationsResult": parser.nextToken(); limitViolationsResult = parser.readValueAs(LimitViolationsResult.class); break; default: throw new AssertionError("Unexpected field: " + parser.getCurrentName()); } } return new PostContingencyResult(contingency, limitViolationsResult); }
@Override public BeakerCodeCellList deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectMapper mapper = (ObjectMapper)jp.getCodec(); JsonNode node = mapper.readTree(jp); List<BeakerCodeCell> l = new ArrayList<BeakerCodeCell>(); if (node.isArray()) { for (JsonNode o : node) { Object obj = objectSerializerProvider.get().deserialize(o, mapper); if (obj instanceof BeakerCodeCell) l.add((BeakerCodeCell) obj); } } BeakerCodeCellList r = new BeakerCodeCellList(); r.theList = l; return r; }
@Override public ZonedDateTime deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss[.SSS]").withZone(ZoneId.of("UTC")); String value = p.getValueAsString(); ZonedDateTime result = null; if(value != null) { int index; if ((index = value.indexOf('.')) > -1) { char[] chars = new char[4 - (value.length() - index)]; Arrays.fill(chars, '0'); value += new String(chars); } result = ZonedDateTime.from(formatter.parse(value)); } return result; }
@Test public void shouldDeserialiseFromSimpleClassName() throws IOException, ClassNotFoundException { // Given final SimpleClassKeyDeserializer deserialiser = new SimpleClassKeyDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = IsA.class; final String id = expectedClass.getSimpleName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); // When final Class<?> clazz = (Class<?>) deserialiser.deserializeKey(id, context); // Then assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); }
private static void initMasterClient() { JacksonJaxbJsonProvider provider = new JacksonJaxbJsonProvider(); ObjectMapper objectMapper = JSONUtil.prettyMapper(); objectMapper.registerModule( new SimpleModule() .addDeserializer(JobDataFragment.class, new JsonDeserializer<JobDataFragment>() { @Override public JobDataFragment deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return jsonParser.readValueAs(DataPOJO.class); } } ) ); provider.setMapper(objectMapper); masterClient = ClientBuilder.newBuilder().register(provider).register(MultiPartFeature.class).build(); WebTarget rootTarget = masterClient.target("http://localhost:" + masterDremioDaemon.getWebServer().getPort()); masterApiV2 = rootTarget.path(API_LOCATION); }
@Test public void shouldDeserialiseFromFullClassNameForUnknownClass() throws IOException, ClassNotFoundException { // Given final SimpleClassDeserializer deserialiser = new SimpleClassDeserializer(); final DeserializationContext context = mock(DeserializationContext.class); final Class expectedClass = UnsignedLong.class; final String id = expectedClass.getName(); given(context.findClass(expectedClass.getName())).willReturn(expectedClass); // When final Class<?> clazz = deserialiser._deserialize(id, context); // Then assertEquals(expectedClass, clazz); verify(context).findClass(expectedClass.getName()); }
@Override public String deserialize(final JsonParser parser, final DeserializationContext ctxt) throws IOException, JsonProcessingException { final boolean hasStringValue = parser.hasToken(JsonToken.VALUE_STRING); if (!hasStringValue) { return null; } final String text = parser.getText(); final String trimmed = text.trim(); if (trimmed.isEmpty()) { return null; } return trimmed; }
@Override public T deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { ObjectCodec objectCodec = jsonParser.getCodec(); JsonNode node = objectCodec.readTree(jsonParser); Class<? extends T> typeClass = null; if (node.isObject() && node.has("type")) { JsonNode type = node.get("type"); if (type != null && type.isTextual()) { typeClass = registry.get(type.textValue()); } } if (typeClass == null) { return null; } StringWriter writer = new StringWriter(); objectMapper.writeValue(writer, node); writer.close(); String json = writer.toString(); return objectMapper.readValue(json, typeClass); }
@Override protected GitterUser deserializeObject(JsonParser jsonParser, DeserializationContext deserializationContext, ObjectCodec objectCodec, JsonNode jsonNode) throws IOException { String userId = nullSafeValue(jsonNode.get("id"), String.class); String userUrl = nullSafeValue(jsonNode.get("url"), String.class); String userName = nullSafeValue(jsonNode.get("username"), String.class); String userDisplayName = nullSafeValue(jsonNode.get("displayName"), String.class); String userAvatar = nullSafeValue(jsonNode.get("avatarUrl"), String.class); String userAvatarMed = nullSafeValue(jsonNode.get("avatarUrlMedium"), String.class); String userAvatarSm = nullSafeValue(jsonNode.get("avatarUrlSmall"), String.class); return new GitterUser(userId, userUrl, userName, userDisplayName, userAvatar, userAvatarMed, userAvatarSm); }
@Override protected GitterMessage deserializeObject(JsonParser jsonParser, DeserializationContext deserializationContext, ObjectCodec objectCodec, JsonNode jsonNode) throws IOException { String id = nullSafeValue(jsonNode.get("id"), String.class); String text = nullSafeValue(jsonNode.get("text"), String.class); String html = nullSafeValue(jsonNode.get("html"), String.class); JsonNode userNode = jsonNode.get("fromUser"); GitterUser user = objectCodec.readValue(userNode.traverse(objectCodec), GitterUser.class); String sent = nullSafeValue(jsonNode.get("sent"), String.class); return new GitterMessage(id, text, html, user, Instant.parse(sent)); }
@Test public void shouldCreateEnumBasedOnValue() throws IOException { final JsonParser parserMock = mock(JsonParser.class); final DeserializationContext contextMock = mock(DeserializationContext.class); when(parserMock.getValueAsString()).thenReturn("Long term capital gain"); final DividendType result = dividendTypeDeserializer.deserialize(parserMock, contextMock); assertThat(result).isEqualTo(DividendType.LONG_TERM_CAPITAL_GAIN); }
private Object[] parseArray(JsonParser parser, DeserializationContext context) throws IOException, JsonProcessingException { boolean started = false; final List<Object> values = Lists.newArrayList(); while( parser.hasCurrentToken() ) { final JsonToken currentToken = parser.getCurrentToken(); switch( currentToken ) { case START_ARRAY: if( started ) { values.add(parseArray(parser, context)); } started = true; break; case END_ARRAY: if( !started ) { throw context.mappingException("End array encountered without start " + where(parser, context)); } return values.toArray(); case NOT_AVAILABLE: break; default: if( !started ) { throw context.mappingException("Value encountered without array start " + where(parser, context)); } values.add(parse(parser, context)); } parser.nextToken(); } throw context.mappingException("No end array found " + where(parser, context)); }
@Override public SimpleReport deserialize(JsonParser parser, DeserializationContext ctx) throws IOException { JsonNode node = parser.getCodec().readTree(parser); SimpleReport report = new SimpleReport(); if (node.hasNonNull(SimpleReport.KEY_CONFIG_APP)) { final AppConfiguration config = ctx.readValue(node.get(SimpleReport.KEY_CONFIG_APP).traverse(parser.getCodec()), AppConfiguration.class); report.put(SimpleReport.KEY_CONFIG_APP, config); } if (node.hasNonNull(SimpleReport.KEY_CONFIG_CONTROLLER)) { final Controller controller = ctx.readValue(node.get(SimpleReport.KEY_CONFIG_CONTROLLER) .traverse(parser.getCodec()), Controller.class); report.put(SimpleReport.KEY_CONFIG_CONTROLLER, controller); } if (node.hasNonNull(SimpleReport.KEY_ATTACKS)) { List<HttpFloodAttack> httpAttacks = new ArrayList<>(); Iterator<JsonNode> iter = node.get(SimpleReport.KEY_ATTACKS).elements(); while (iter.hasNext()) { JsonNode n = iter.next(); HttpFloodAttack attack = ctx.readValue(n.traverse(parser.getCodec()), HttpFloodAttack.class); httpAttacks.add(attack); } report.put(SimpleReport.KEY_ATTACKS, httpAttacks); } node.fields().forEachRemaining(f -> { if (!f.getKey().equals(SimpleReport.KEY_CONFIG_APP) && !f.getKey().equals(SimpleReport.KEY_CONFIG_CONTROLLER) && !f.getKey().equals(SimpleReport.KEY_ATTACKS)) { report.put(f.getKey(), f.getValue().asText()); } }); return report; }
@Override public Date deserialize(JsonParser jsonParser, DeserializationContext dc) throws JsonProcessingException { Date date = null; try { DateFormat dateFormat = new SimpleDateFormat(pattern); String val = jsonParser.getText(); date = dateFormat.parse(val); } catch (ParseException | IOException pex) { throw new RuntimeException("json转换Date异常,格式:" + pattern); } return date; }
private String getMissingType(DeserializationContext ctxt, String containingField) { switch (containingField) { case "on": return getOnType(ctxt); case "within": return getWithinType(ctxt); case "canvases": return "sc:Canvas"; case "thumbnail": case "logo": return "dctypes:Image"; default: return null; } }
@NotNull @Override public KeyShardSet deserialize(@NotNull final JsonParser jp, final DeserializationContext context) throws IOException { JsonNode node = jp.getCodec().readTree(jp); String version = deserializeVersion(node); switch (version) { case VERSION1_0: return deserialize1_0(node); default: throw new RuntimeException("Value of " + VERSION_NAME + " is \"" + version + "\" but must be \"1.0\""); } }
@Override public Zone deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { Zone zone = new Zone(); jp.nextToken(); while (jp.nextToken() != JsonToken.END_OBJECT) { String name = jp.getCurrentName(); String value = jp.getValueAsString(); if (value != null) { zone.put(name, value.toUpperCase()); } } return zone; }
@Override public JavaType handleMissingTypeId(DeserializationContext ctxt, JavaType baseType, TypeIdResolver idResolver, String failureMsg) throws IOException { if (baseType.getRawClass() == Feature.class) { return idResolver.typeFromId(ctxt, "Feature"); } return super.handleMissingTypeId(ctxt, baseType, idResolver, failureMsg); }
@Override public Object handleWeirdStringValue(DeserializationContext ctxt, Class<?> targetType, String valueToConvert, String failureMsg) throws IOException { if (targetType.isEnum()) { String lowerCased = valueToConvert.toLowerCase(); Optional<?> match = Arrays.stream(targetType.getEnumConstants()) .filter(v -> v.toString().toLowerCase().equals(valueToConvert.toLowerCase())) .findFirst(); if (match.isPresent()) { return match.get(); } } return super.handleWeirdStringValue(ctxt, targetType, valueToConvert, failureMsg); }
@Override public Map<String, Object> deserialize(JsonParser parser, DeserializationContext context) throws IOException, JsonProcessingException { final Map<String, Object> map = Maps.newHashMap(); int times = 0; while( parser.hasCurrentToken() ) { final JsonToken currentToken = parser.getCurrentToken(); switch( currentToken ) { case START_OBJECT: // sure times++; if( times > 1 ) { throw context.mappingException("Object opened twice??"); } break; case END_OBJECT: return map; case FIELD_NAME: parser.nextToken(); map.put(parser.getCurrentName(), parse(parser, context)); break; case NOT_AVAILABLE: parser.nextToken(); break; default: throw context.mappingException("Object can only contain fields " + where(parser, context)); } parser.nextToken(); } throw context.mappingException("No end object encountered " + where(parser, context)); }
@Override public DoubleTimeSeries deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) { List<TimeSeries> timeSeriesList = TimeSeries.parseJson(jsonParser, true); if (timeSeriesList.size() != 1 || !(timeSeriesList.get(0) instanceof DoubleTimeSeries)) { throw new TimeSeriesException("Double time series JSON deserialization error"); } return (DoubleTimeSeries) timeSeriesList.get(0); }
@Test public void shouldThrowOnNullTree() throws Exception { exception.expect(JWTDecodeException.class); exception.expectMessage("Parsing the Header's JSON resulted on a Null map"); JsonDeserializer deserializer = new HeaderDeserializer(); JsonParser parser = mock(JsonParser.class); ObjectCodec codec = mock(ObjectCodec.class); DeserializationContext context = mock(DeserializationContext.class); when(codec.readValue(eq(parser), any(TypeReference.class))).thenReturn(null); when(parser.getCodec()).thenReturn(codec); deserializer.deserialize(parser, context); }
@Override public TriggerDefinition deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonNode root = p.getCodec().readTree(p); JsonNode triggerKey = root.get("triggerKey"); JsonNode description = root.get("description"); JsonNode jobKey = root.get("jobKey"); JsonNode triggerData = root.get("triggerData"); JsonNode misfireInstruction = root.get("misfireInstruction"); JsonNode cron = root.get("cronExpression"); if (triggerKey == null || jobKey == null) { throw new IOException("JSON is missing a triggerKey and jobKey"); } if (cron == null) { return TriggerDefinitionBuilder.immediate() .identifiedAs(mapper.convertValue(triggerKey, NameAndGroup.class)) .forJob(mapper.convertValue(jobKey, NameAndGroup.class)) .withDescription(description != null ? description.textValue() : null) .withData(triggerData != null ? mapper.convertValue(triggerData, Map.class) : emptyMap()) .withMisfireInstruction(misfireInstruction != null ? mapper.convertValue(misfireInstruction, Immediate.MisfireInstruction.class) : null) .build(); } else { return TriggerDefinitionBuilder.cron() .identifiedAs(mapper.convertValue(triggerKey, NameAndGroup.class)) .forJob(mapper.convertValue(jobKey, NameAndGroup.class)) .withCronExpression(cron.textValue()) .withDescription(description != null ? description.textValue() : null) .withData(triggerData != null ? mapper.convertValue(triggerData, Map.class) : emptyMap()) .withMisfireInstruction(misfireInstruction != null ? mapper.convertValue(misfireInstruction, Cron.MisfireInstruction.class) : null) .build(); } }
@Override public ControllerNode deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonNode node = jp.getCodec().readTree(jp); NodeId nodeId = new NodeId(node.get(ID).textValue()); IpAddress ip = IpAddress.valueOf(node.get(IP).textValue()); int port = node.get(PORT).asInt(); return new DefaultControllerNode(nodeId, ip, port); }
@Override public NodeDependency deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { String name = null; NodeInfo nodeInfo = null; JsonToken token; while ((token = jsonParser.nextToken()) != null) { if (token == JsonToken.END_OBJECT) { break; } else if (token == JsonToken.FIELD_NAME) { switch (jsonParser.getCurrentName()) { case "name": jsonParser.nextToken(); name = jsonParser.getValueAsString(); break; case "nodeInfo": nodeInfo = new NodeInfoJsonDeserializer().deserialize(jsonParser, deserializationContext); break; default: throw new AssertionError("Unexpected field: " + jsonParser.getCurrentName()); } } } if (name == null || nodeInfo == null) { throw new IllegalStateException("Inconsistent node dependency json"); } return new NodeDependency(name, nodeInfo); }
protected static void initClient() { ObjectMapper objectMapper = JSONUtil.prettyMapper(); objectMapper.registerModule( new SimpleModule() .addDeserializer(JobDataFragment.class, new JsonDeserializer<JobDataFragment>() { @Override public JobDataFragment deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { return jsonParser.readValueAs(DataPOJO.class); } } ) ); initClient(objectMapper); }
@Override public Boolean deserialize(JsonParser parser, DeserializationContext context) throws IOException, JsonProcessingException { if (parser != null && parser.getText() != null){ return parser.getText().equals(ConstanteUtils.TYP_BOOLEAN_YES)?true:false; } return false; }
@Test public void shouldReturnUnknownTypeIfValueIsNull() throws IOException { final JsonParser parserMock = mock(JsonParser.class); final DeserializationContext contextMock = mock(DeserializationContext.class); when(parserMock.getValueAsString()).thenReturn(null); final TradingStatusType result = tradingStatusTypeDeserializer.deserialize(parserMock, contextMock); assertThat(result).isEqualTo(TradingStatusType.UNKNOWN); }
/** * Deserialize date. * * @param jsonparser * @param context * @return * @throws IOException * @throws JsonProcessingException */ @Override public Date deserialize(JsonParser jsonparser, DeserializationContext context) throws IOException, JsonProcessingException { String date = jsonparser.getText(); try { return formatter.parse(date); } catch (Exception e) { } return null; }
@Override public JSONOptions deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonLocation l = jp.getTokenLocation(); // logger.debug("Reading tree."); TreeNode n = jp.readValueAsTree(); // logger.debug("Tree {}", n); if (n instanceof JsonNode) { return new JSONOptions( (JsonNode) n, l); } else { throw new IllegalArgumentException(String.format("Received something other than a JsonNode %s", n)); } }
@Override public PreContingency deserialize(JsonParser parser, DeserializationContext deserializationContext) throws IOException { float value = Float.NaN; while (parser.nextToken() != JsonToken.END_OBJECT) { if (parser.getCurrentName().equals("value")) { parser.nextToken(); value = parser.readValueAs(Float.class); } else { throw new PowsyblException("Unexpected field: " + parser.getCurrentName()); } } return new PreContingency(value); }
@Override public final Dienstbundel deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException { final ObjectCodec oc = jp.getCodec(); final JsonNode node = oc.readTree(jp); final Leveringsautorisatie leveringsautorisatie = entityManager.getReference(Leveringsautorisatie.class, JsonUtils.getAsInteger(node, DienstbundelModule.LEVERINGSAUTORISATIE)); final Dienstbundel dienstbundel = new Dienstbundel(leveringsautorisatie); dienstbundel.setLeveringsautorisatie(leveringsautorisatie); dienstbundel.setId(JsonUtils.getAsInteger(node, DienstbundelModule.ID)); dienstbundel.setNaam(JsonUtils.getAsString(node, DienstbundelModule.NAAM)); dienstbundel.setDatumIngang(JsonUtils.getAsInteger(node, DienstbundelModule.DATUM_INGANG)); dienstbundel.setDatumEinde(JsonUtils.getAsInteger(node, DienstbundelModule.DATUM_EINDE)); dienstbundel.setNaderePopulatiebeperking(JsonUtils.getAsString(node, DienstbundelModule.NADERE_POPULATIE_BEPERKING)); dienstbundel.setIndicatieNaderePopulatiebeperkingVolledigGeconverteerd( JsonUtils.getAsBoolean( node, DienstbundelModule.INDICATIE_NADERE_POPULATIE_BEPERKING_GECONVERTEERD, DienstbundelModule.WAARDE_NEE, Boolean.FALSE, null)); dienstbundel.setToelichting(JsonUtils.getAsString(node, DienstbundelModule.TOELICHTING)); dienstbundel.setIndicatieGeblokkeerd( JsonUtils.getAsBoolean(node, DienstbundelModule.INDICATIE_GEBLOKKEERD, DienstbundelModule.WAARDE_JA, Boolean.TRUE, null)); return dienstbundel; }