@Override public void add(Document document) { requireNonNull(document, "Document is required"); documents.put(document.getName(), document); }
@Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof DefaultDocument)) { return false; } Document that = (Document) o; return Objects.equals(name, that.getName()) && Objects.equals(value, that.getValue()); }
private static void toDocument(Map<String, Object> entityValues, Document document) { Object value = ValueUtil.convert(document.getValue()); if (Document.class.isInstance(value)) { Document subDocument = Document.class.cast(value); entityValues.put(document.getName(), singletonMap(subDocument.getName(), subDocument.get())); } else if (isDocumentIterable(value)) { entityValues.put(document.getName(), getMap(value)); } else if (isSudDocumentList(value)) { entityValues.put(document.getName(), StreamSupport.stream(Iterable.class.cast(value).spliterator(), false) .map(OrientDBConverter::getMap).collect(toList())); } else { entityValues.put(document.getName(), value); } }
private static void appendCondition(StringBuilder aql, Map<String, Object> params, char entity, Document document, String condition) { String nameParam = getNameParam(document.getName(), params); aql.append(SEPARATOR).append(entity).append('.').append(document.getName()) .append(condition).append(PARAM_APPENDER).append(nameParam); if(IN.equals(condition)) { params.put(nameParam, ValueUtil.convertToList(document.getValue())); } else { params.put(nameParam, document.get()); } }
@Override public Map<String, Object> toMap() { Map<String, Object> map = new HashMap<>(); for (Map.Entry<String, Document> entry : documents.entrySet()) { Document value = entry.getValue(); map.put(value.getName(), convert(value.get())); } return Collections.unmodifiableMap(map); }
protected <T> Consumer<String> feedObject(T instance, List<Document> documents, Map<String, FieldRepresentation> fieldsGroupByName) { return k -> { Optional<Document> document = documents.stream().filter(c -> c.getName().equals(k)).findFirst(); FieldRepresentation field = fieldsGroupByName.get(k); DocumentFieldConverter fieldConverter = converterFactory.get(field); fieldConverter.convert(instance, documents, document, field, this); }; }
private Object convert(Object value) { if (value instanceof Document) { Document column = Document.class.cast(value); return singletonMap(column.getName(), convert(column.get())); } else if (value instanceof Iterable) { List<Object> list = new ArrayList<>(); Iterable.class.cast(value).forEach(e -> list.add(convert(e))); return list; } return value; }
private static void inKeys(List<String> keys, String documentCollection, Document document) { if(document.getName().equals(KEY_FIELD)){ keys.addAll(document.get(new TypeReference<List<String>>() { })); } else { List<String> ids = document.get(new TypeReference<List<String>>() {}); ids.stream().map(id -> EntityConverter.getPrefix(documentCollection, id)) .forEach(keys::add); } }
static List<DocumentEntity> convert(N1qlQueryResult result, String database) { return result.allRows().stream() .map(N1qlQueryRow::value) .map(JsonObject::toMap) .map(m -> m.get(database)) .filter(Objects::nonNull) .filter(Map.class::isInstance) .map(m -> (Map<String, Object>) m) .map(map -> { List<Document> documents = toDocuments(map); Optional<Document> keyDocument = documents.stream().filter(d -> KEY_FIELD.equals(d.getName())).findFirst(); String collection = keyDocument.map(d -> d.get(String.class)).orElse(database).split(SPLIT_KEY)[0]; return DocumentEntity.of(collection, documents); }).collect(toList()); }
private static void appendCondition(StringBuilder query, List<Object> params, Document document, String condition, List<ORecordId> ids) { if(OrientDBConverter.RID_FIELD.equals(document.getName())) { ids.add(new ORecordId(document.get(String.class))); return; } query.append(document.getName()) .append(condition).append(PARAM_APPENDER); if(IN.equals(condition)) { params.add(ValueUtil.convertToList(document.getValue())); } else { params.add(document.get()); } }
private static void eqKeys(List<String> keys, String documentCollection, Document document) { if(document.getName().equals(KEY_FIELD)){ keys.add(document.get(String.class)); } else { keys.add(EntityConverter.getPrefix(documentCollection, document.get(String.class))); } }
static BaseDocument getBaseDocument(DocumentEntity entity) { Map<String, Object> map = new HashMap<>(); for (Document document : entity.getDocuments()) { map.put(document.getName(), convert(document.getValue())); } return new BaseDocument(map); }
private static Object convert(Value value) { Object val = ValueUtil.convert(value); if (Document.class.isInstance(val)) { Document document = Document.class.cast(val); return singletonMap(document.getName(), convert(document.getValue())); } if (isSudDocument(val)) { return getMap(val); } if (isSudDocumentList(val)) { return StreamSupport.stream(Iterable.class.cast(val).spliterator(), false) .map(ArangoDBUtil::getMap).collect(toList()); } return val; }
private static Consumer<Document> toJsonObject(JsonObject jsonObject) { return d -> { Object value = ValueUtil.convert(d.getValue()); if (Document.class.isInstance(value)) { convertDocument(jsonObject, d, value); } else if (Iterable.class.isInstance(value)) { convertIterable(jsonObject, d, value); } else { jsonObject.put(d.getName(), value); } }; }
private static void convertIterable(JsonObject jsonObject, Document document, Object value) { JsonObject map = JsonObject.create(); JsonArray array = JsonArray.create(); Iterable.class.cast(value).forEach(element -> { if (Document.class.isInstance(element)) { Document subdocument = Document.class.cast(element); map.put(subdocument.getName(), subdocument.get()); } else if (isSudDocument(element)) { JsonObject subJson = JsonObject.create(); stream(Iterable.class.cast(element).spliterator(), false) .forEach(getSubdocument(subJson)); array.add(subJson); } else { array.add(element); } }); if (array.isEmpty()) { jsonObject.put(document.getName(), map); } else { jsonObject.put(document.getName(), array); } }
params.put(document.getName(), ValueUtil.convertToList(document.getValue())); } else { params.put(document.getName(), ValueUtil.convert(document.getValue())); return x(document.getName()).eq(x(PARAM_PREFIX + document.getName())); case LESSER_THAN: return x(document.getName()).lt(x(PARAM_PREFIX + document.getName())); case LESSER_EQUALS_THAN: return x(document.getName()).lte(x(PARAM_PREFIX + document.getName())); case GREATER_THAN: return x(document.getName()).gt(x(PARAM_PREFIX + document.getName())); case GREATER_EQUALS_THAN: return x(document.getName()).gte(x(PARAM_PREFIX + document.getName())); case LIKE: return x(document.getName()).like(x(PARAM_PREFIX + document.getName())); case IN: return x(document.getName()).in(x(PARAM_PREFIX + document.getName())); case BETWEEN: return x(document.getName()).between(x(PARAM_PREFIX + document.getName())); case AND: return document.get(new TypeReference<List<DocumentCondition>>() {