use of nl.knaw.huygens.timbuctoo.util.Tuple in project timbuctoo by HuygensING.
the class RootQuery method rebuildSchema.
public synchronized GraphQLSchema rebuildSchema() {
final TypeDefinitionRegistry staticQuery = schemaParser.parse(this.staticQuery);
if (archetypes != null && !archetypes.isEmpty()) {
staticQuery.merge(schemaParser.parse(archetypes + "extend type DataSetMetadata {\n" + " archetypes: Archetypes! @passThrough\n" + "}\n" + "\n"));
}
TypeDefinitionRegistry registry = new TypeDefinitionRegistry();
registry.merge(staticQuery);
final RuntimeWiring.Builder wiring = RuntimeWiring.newRuntimeWiring();
wiring.type("Query", builder -> builder.dataFetcher("promotedDataSets", env -> dataSetRepository.getPromotedDataSets().stream().map(DataSetWithDatabase::new).collect(Collectors.toList())).dataFetcher("allDataSets", env -> dataSetRepository.getDataSets().stream().map(DataSetWithDatabase::new).filter(x -> {
if (x.isPublished()) {
return true;
} else {
ContextData contextData = env.getContext();
UserPermissionCheck userPermissionCheck = contextData.getUserPermissionCheck();
return userPermissionCheck.getPermissions(x.getDataSet().getMetadata()).contains(Permission.READ);
}
}).collect(Collectors.toList())).dataFetcher("dataSetMetadata", env -> {
final String dataSetId = env.getArgument("dataSetId");
ContextData context = env.getContext();
final User user = context.getUser().orElse(null);
Tuple<String, String> splitCombinedId = DataSetMetaData.splitCombinedId(dataSetId);
return dataSetRepository.getDataSet(user, splitCombinedId.getLeft(), splitCombinedId.getRight()).map(DataSetWithDatabase::new);
}).dataFetcher("dataSetMetadataList", env -> {
Stream<DataSetWithDatabase> dataSets = dataSetRepository.getDataSets().stream().map(DataSetWithDatabase::new);
if (env.getArgument("promotedOnly")) {
dataSets = dataSets.filter(DataSetWithDatabase::isPromoted);
}
if (env.getArgument("publishedOnly")) {
dataSets = dataSets.filter(DataSetWithDatabase::isPublished);
}
return dataSets.filter(x -> {
ContextData contextData = env.getContext();
UserPermissionCheck userPermissionCheck = contextData.getUserPermissionCheck();
return userPermissionCheck.getPermissions(x.getDataSet().getMetadata()).contains(Permission.READ);
}).collect(Collectors.toList());
}).dataFetcher("aboutMe", env -> ((RootData) env.getRoot()).getCurrentUser().orElse(null)).dataFetcher("availableExportMimetypes", env -> supportedFormats.getSupportedMimeTypes().stream().map(MimeTypeDescription::create).collect(Collectors.toList())));
wiring.type("DataSetMetadata", builder -> builder.dataFetcher("currentImportStatus", env -> {
DataSetMetaData input = env.getSource();
Optional<User> currentUser = ((RootData) env.getRoot()).getCurrentUser();
if (!currentUser.isPresent()) {
throw new RuntimeException("User is not provided");
}
return dataSetRepository.getDataSet(currentUser.get(), input.getOwnerId(), input.getDataSetId()).map(dataSet -> dataSet.getImportManager().getImportStatus());
}).dataFetcher("dataSetImportStatus", env -> {
Optional<User> currentUser = ((RootData) env.getRoot()).getCurrentUser();
if (!currentUser.isPresent()) {
throw new RuntimeException("User is not provided");
}
DataSetMetaData input = env.getSource();
return dataSetRepository.getDataSet(currentUser.get(), input.getOwnerId(), input.getDataSetId()).map(dataSet -> dataSet.getImportManager().getDataSetImportStatus());
}).dataFetcher("collectionList", env -> getCollections(env.getSource(), ((ContextData) env.getContext()).getUser())).dataFetcher("collection", env -> {
String collectionId = (String) env.getArguments().get("collectionId");
if (collectionId != null && collectionId.endsWith("List")) {
collectionId = collectionId.substring(0, collectionId.length() - "List".length());
}
DataSetMetaData input = env.getSource();
ContextData context = env.getContext();
final User user = context.getUser().orElse(null);
final DataSet dataSet = dataSetRepository.getDataSet(user, input.getOwnerId(), input.getDataSetId()).get();
final TypeNameStore typeNameStore = dataSet.getTypeNameStore();
String collectionUri = typeNameStore.makeUri(collectionId);
if (dataSet.getSchemaStore().getStableTypes() == null || dataSet.getSchemaStore().getStableTypes().get(collectionUri) == null) {
return null;
} else {
return getCollection(dataSet, typeNameStore, dataSet.getSchemaStore().getStableTypes().get(collectionUri));
}
}).dataFetcher("dataSetId", env -> ((DataSetMetaData) env.getSource()).getCombinedId()).dataFetcher("dataSetName", env -> ((DataSetMetaData) env.getSource()).getDataSetId()).dataFetcher("ownerId", env -> ((DataSetMetaData) env.getSource()).getOwnerId()));
wiring.type("CurrentImportStatus", builder -> builder.dataFetcher("elapsedTime", env -> {
final String timeUnit = env.getArgument("unit");
return ((ImportStatus) env.getSource()).getElapsedTime(timeUnit);
}));
wiring.type("DataSetImportStatus", builder -> builder.dataFetcher("lastImportDuration", env -> {
final String timeUnit = env.getArgument("unit");
return ((DataSetImportStatus) env.getSource()).getLastImportDuration(timeUnit);
}));
wiring.type("EntryImportStatus", builder -> builder.dataFetcher("elapsedTime", env -> {
final String timeUnit = env.getArgument("unit");
return ((EntryImportStatus) env.getSource()).getElapsedTime(timeUnit);
}));
wiring.type("CollectionMetadata", builder -> builder.dataFetcher("indexConfig", env -> {
SubjectReference source = env.getSource();
final QuadStore qs = source.getDataSet().getQuadStore();
try (Stream<CursorQuad> quads = qs.getQuads(source.getSubjectUri(), TIM_HASINDEXERCONFIG, Direction.OUT, "")) {
final Map result = quads.findFirst().map(q -> {
try {
return objectMapper.readValue(q.getObject(), Map.class);
} catch (IOException e) {
LOG.error("Value not a Map", e);
return new HashMap<>();
}
}).orElse(new HashMap());
if (!result.containsKey("facet") || !(result.get("facet") instanceof List)) {
result.put("facet", new ArrayList<>());
}
if (!result.containsKey("fullText") || !(result.get("fullText") instanceof List)) {
result.put("fullText", new ArrayList<>());
}
return result;
}
}).dataFetcher("viewConfig", new ViewConfigFetcher(objectMapper)));
wiring.type("AboutMe", builder -> builder.dataFetcher("dataSets", env -> (Iterable) () -> dataSetRepository.getDataSetsWithWriteAccess(env.getSource()).stream().map(DataSetWithDatabase::new).iterator()).dataFetcher("dataSetMetadataList", env -> (Iterable) () -> {
Stream<DataSetWithDatabase> dataSets = dataSetRepository.getDataSets().stream().map(DataSetWithDatabase::new);
if (env.getArgument("ownOnly")) {
String userId = ((ContextData) env.getContext()).getUser().map(u -> "u" + u.getPersistentId()).orElse(null);
dataSets = dataSets.filter(d -> d.getOwnerId().equals(userId));
}
Permission permission = Permission.valueOf(env.getArgument("permission"));
if (permission != Permission.READ) {
// Read is implied
UserPermissionCheck check = ((ContextData) env.getContext()).getUserPermissionCheck();
dataSets = dataSets.filter(d -> check.getPermissions(d).contains(permission));
}
return dataSets.iterator();
}).dataFetcher("id", env -> ((User) env.getSource()).getPersistentId()).dataFetcher("name", env -> ((User) env.getSource()).getDisplayName()).dataFetcher("personalInfo", env -> "http://example.com").dataFetcher("canCreateDataSet", env -> true));
wiring.type("Mutation", builder -> builder.dataFetcher("setViewConfig", new ViewConfigMutation(dataSetRepository)).dataFetcher("setSummaryProperties", new SummaryPropsMutation(dataSetRepository)).dataFetcher("setIndexConfig", new IndexConfigMutation(dataSetRepository)).dataFetcher("createDataSet", new CreateDataSetMutation(dataSetRepository)).dataFetcher("deleteDataSet", new DeleteDataSetMutation(dataSetRepository)).dataFetcher("publish", new MakePublicMutation(dataSetRepository)).dataFetcher("extendSchema", new ExtendSchemaMutation(dataSetRepository)).dataFetcher("setDataSetMetadata", new DataSetMetadataMutation(dataSetRepository)).dataFetcher("setCollectionMetadata", new CollectionMetadataMutation(dataSetRepository)));
wiring.wiringFactory(wiringFactory);
StringBuilder root = new StringBuilder("type DataSets {\n sillyWorkaroundWhenNoDataSetsAreVisible: Boolean\n");
boolean[] dataSetAvailable = new boolean[] { false };
dataSetRepository.getDataSets().forEach(dataSet -> {
final DataSetMetaData dataSetMetaData = dataSet.getMetadata();
final String name = dataSetMetaData.getCombinedId();
Map<String, Type> types = dataSet.getSchemaStore().getStableTypes();
Map<String, List<ExplicitField>> customSchema = dataSet.getCustomSchema();
final Map<String, Type> customTypes = new HashMap<>();
for (Map.Entry<String, List<ExplicitField>> entry : customSchema.entrySet()) {
ExplicitType explicitType = new ExplicitType(entry.getKey(), entry.getValue());
customTypes.put(entry.getKey(), explicitType.convertToType());
}
Map<String, Type> mergedTypes;
MergeSchemas mergeSchemas = new MergeSchemas();
mergedTypes = mergeSchemas.mergeSchema(types, customTypes);
types = mergedTypes;
if (types != null) {
dataSetAvailable[0] = true;
root.append(" ").append(name).append(":").append(name).append(" @dataSet(userId:\"").append(dataSetMetaData.getOwnerId()).append("\", dataSetId:\"").append(dataSetMetaData.getDataSetId()).append("\")\n");
wiring.type(name, c -> c.dataFetcher("metadata", env -> new DataSetWithDatabase(dataSet)));
final String schema = typeGenerator.makeGraphQlTypes(name, types, dataSet.getTypeNameStore());
staticQuery.merge(schemaParser.parse(schema));
}
});
root.append("}\n\nextend type Query {\n #The actual dataSets\n dataSets: DataSets @passThrough\n}\n\n");
if (dataSetAvailable[0]) {
staticQuery.merge(schemaParser.parse(root.toString()));
}
SchemaGenerator schemaGenerator = new SchemaGenerator();
return schemaGenerator.makeExecutableSchema(staticQuery, wiring.build());
}
use of nl.knaw.huygens.timbuctoo.util.Tuple in project timbuctoo by HuygensING.
the class RrTriplesMap method getItems.
Stream<Quad> getItems(ErrorHandler defaultErrorHandler) {
final int[] numberOfItemsProcessed = new int[1];
Stream<Quad> quadStream = dataSource.getRows(defaultErrorHandler).peek(e -> {
numberOfItemsProcessed[0]++;
if (numberOfItemsProcessed[0] == 1) {
LoggerFactory.getLogger(RrTriplesMap.class).info("collection '{}' has at least one item", uri);
}
}).flatMap(row -> {
Optional<RdfUri> subjectOpt = subjectMap.generateValue(row);
if (subjectOpt.isPresent()) {
RdfUri subject = subjectOpt.get();
for (Tuple<RrRefObjectMap, String> subscription : subscriptions) {
subscription.getLeft().onNewSubject(row.getRawValue(subscription.getRight()), subject);
}
return predicateObjectMaps.stream().flatMap(predicateObjectMap -> predicateObjectMap.generateValue(subject, row));
} else {
defaultErrorHandler.subjectGenerationFailed(uri, row);
return Stream.empty();
}
});
return quadStream;
}
use of nl.knaw.huygens.timbuctoo.util.Tuple in project timbuctoo by HuygensING.
the class TinkerPopOperations method replaceEntity.
@Override
public int replaceEntity(Collection collection, UpdateEntity updateEntity) throws NotFoundException, AlreadyUpdatedException, IOException {
requireCommit = true;
GraphTraversal<Vertex, Vertex> entityTraversal = entityFetcher.getEntity(this.traversal, updateEntity.getId(), null, collection.getCollectionName());
if (!entityTraversal.hasNext()) {
throw new NotFoundException();
}
Vertex entityVertex = entityTraversal.next();
int curRev = getProp(entityVertex, "rev", Integer.class).orElse(1);
if (curRev != updateEntity.getRev()) {
throw new AlreadyUpdatedException();
}
int newRev = updateEntity.getRev() + 1;
entityVertex.property("rev", newRev);
// update properties
TinkerPopPropertyConverter tinkerPopPropertyConverter = new TinkerPopPropertyConverter(collection);
for (TimProperty<?> property : updateEntity.getProperties()) {
try {
Tuple<String, Object> nameValue = property.convert(tinkerPopPropertyConverter);
collection.getWriteableProperties().get(nameValue.getLeft()).setValue(entityVertex, nameValue.getRight());
} catch (IOException e) {
throw new IOException(property.getName() + " could not be saved. " + e.getMessage(), e);
}
}
// Set removed values to null.
Set<String> propertyNames = updateEntity.getProperties().stream().map(prop -> prop.getName()).collect(Collectors.toSet());
for (String name : Sets.difference(collection.getWriteableProperties().keySet(), propertyNames)) {
collection.getWriteableProperties().get(name).setJson(entityVertex, null);
}
String entityTypesStr = getProp(entityVertex, "types", String.class).orElse("[]");
boolean wasAddedToCollection = false;
if (!entityTypesStr.contains("\"" + collection.getEntityTypeName() + "\"")) {
try {
ArrayNode entityTypes = arrayToEncodedArray.tinkerpopToJson(entityTypesStr);
entityTypes.add(collection.getEntityTypeName());
entityVertex.property("types", entityTypes.toString());
wasAddedToCollection = true;
} catch (IOException e) {
// FIXME potential bug?
LOG.error(Logmarkers.databaseInvariant, "property 'types' was not parseable: " + entityTypesStr);
}
}
setModified(entityVertex, updateEntity.getModified());
entityVertex.property("pid").remove();
Vertex duplicate = duplicateVertex(traversal, entityVertex, indexHandler);
listener.onPropertyUpdate(collection, Optional.of(entityVertex), duplicate);
if (wasAddedToCollection) {
listener.onAddToCollection(collection, Optional.of(entityVertex), duplicate);
}
return newRev;
}
use of nl.knaw.huygens.timbuctoo.util.Tuple in project timbuctoo by HuygensING.
the class EntityToJsonMapper method mapEntity.
public ObjectNode mapEntity(Collection collection, ReadEntity entity, boolean withRelations, ExtraEntityMappingOptions extraEntityMappingOptions, ExtraRelationMappingOptions relationMappingOptions) {
final ObjectNode mappedEntity = JsonNodeFactory.instance.objectNode();
String id = entity.getId().toString();
mappedEntity.set("@type", jsn(collection.getEntityTypeName()));
mappedEntity.set("_id", jsn(id));
mappedEntity.set("^rev", jsn(entity.getRev()));
mappedEntity.set("^deleted", jsn(entity.getDeleted()));
mappedEntity.set("^pid", jsn(entity.getPid()));
if (entity.getRdfUri() != null) {
mappedEntity.set("^rdfUri", jsn(entity.getRdfUri().toString()));
}
mappedEntity.set("^rdfAlternatives", jsnA(entity.getRdfAlternatives().stream().map(JsonBuilder::jsn)));
JsonNode variationRefs = jsnA(entity.getTypes().stream().map(type -> {
ObjectNode variationRef = jsnO();
variationRef.set("id", jsn(id));
variationRef.set("type", jsn(type));
return variationRef;
}));
mappedEntity.set("@variationRefs", variationRefs);
Change modified = entity.getModified();
mappedEntity.set("^modified", mapChange(modified));
Change created = entity.getCreated();
mappedEntity.set("^created", mapChange(created));
// translate TimProperties to Json
JsonPropertyConverter jsonPropertyConverter = new JsonPropertyConverter(collection);
entity.getProperties().forEach(prop -> {
try {
Tuple<String, JsonNode> convertedProperty = prop.convert(jsonPropertyConverter);
mappedEntity.set(convertedProperty.getLeft(), convertedProperty.getRight());
} catch (IOException e) {
LOG.error(databaseInvariant, propConversionErrorMessage(id, prop));
LOG.error("Exception message: {}", e.getMessage());
LOG.debug("Stack trace", e);
}
});
if (!Strings.isNullOrEmpty(entity.getDisplayName())) {
mappedEntity.set("@displayName", jsn(entity.getDisplayName()));
}
extraEntityMappingOptions.execute(entity, mappedEntity);
if (withRelations) {
mappedEntity.set("@relationCount", jsn(entity.getRelations().size()));
mappedEntity.set("@relations", mapRelations(entity.getRelations(), relationMappingOptions));
}
return mappedEntity;
}
use of nl.knaw.huygens.timbuctoo.util.Tuple in project timbuctoo by HuygensING.
the class RdfUpload method upload.
@Consumes(MediaType.MULTIPART_FORM_DATA)
@POST
public Response upload(@FormDataParam("file") final InputStream rdfInputStream, @FormDataParam("file") final FormDataBodyPart body, @FormDataParam("fileMimeTypeOverride") final MediaType mimeTypeOverride, @FormDataParam("encoding") final String encoding, @FormDataParam("baseUri") final URI baseUri, @FormDataParam("defaultGraph") final URI defaultGraph, @HeaderParam("authorization") final String authHeader, @PathParam("userId") final String userId, @PathParam("dataSet") final String dataSetId, @QueryParam("forceCreation") boolean forceCreation, @QueryParam("async") final boolean async) throws ExecutionException, InterruptedException, LogStorageFailedException, DataStoreCreationException {
final Either<Response, Response> result = authCheck.getOrCreate(authHeader, userId, dataSetId, forceCreation).flatMap(userAndDs -> authCheck.hasAdminAccess(userAndDs.getLeft(), userAndDs.getRight())).map((Tuple<User, DataSet> userDataSetTuple) -> {
final MediaType mediaType = mimeTypeOverride == null ? body.getMediaType() : mimeTypeOverride;
final DataSet dataSet = userDataSetTuple.getRight();
ImportManager importManager = dataSet.getImportManager();
if (mediaType == null || !importManager.isRdfTypeSupported(mediaType)) {
return Response.status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON_TYPE).entity("{\"error\": \"We do not support the mediatype '" + mediaType + "'. Make sure to add the correct " + "mediatype to the file parameter. In curl you'd use `-F \"file=@<filename>;type=<mediatype>\"`. In a " + "webbrowser you probably have no way of setting the correct mimetype. So you can use a special " + "parameter " + "to override it: `formData.append(\"fileMimeTypeOverride\", \"<mimetype>\");`\"}").build();
}
if (StringUtils.isBlank(encoding)) {
return Response.status(Response.Status.BAD_REQUEST).entity("Please provide an 'encoding' parameter").build();
}
if (StringUtils.isBlank(body.getContentDisposition().getFileName())) {
return Response.status(400).entity("filename cannot be empty.").build();
}
Future<ImportStatus> promise = null;
try {
promise = importManager.addLog(baseUri == null ? dataSet.getMetadata().getBaseUri() : baseUri.toString(), defaultGraph == null ? dataSet.getMetadata().getBaseUri() : defaultGraph.toString(), body.getContentDisposition().getFileName(), rdfInputStream, Optional.of(Charset.forName(encoding)), mediaType);
} catch (LogStorageFailedException e) {
return Response.serverError().build();
}
if (!async) {
return handleImportManagerResult(promise);
}
return Response.accepted().build();
});
if (result.isLeft()) {
return result.getLeft();
} else {
return result.get();
}
}
Aggregations