Search in sources :

Example 1 with JsonReferenceType

use of org.structr.schema.json.JsonReferenceType in project structr by structr.

the class SchemaTest method test02SimpleSymmetricReferences.

@Test
public void test02SimpleSymmetricReferences() {
    // we need to wait for the schema service to be initialized here.. :(
    try {
        Thread.sleep(1000);
    } catch (Throwable t) {
    }
    try {
        final JsonSchema sourceSchema = StructrSchema.createFromDatabase(app);
        final JsonObjectType project = sourceSchema.addType("Project");
        final JsonObjectType task = sourceSchema.addType("Task");
        // create relation
        final JsonReferenceType rel = project.relate(task, "has", Cardinality.OneToMany, "project", "tasks");
        rel.setName("ProjectTasks");
        final String schema = sourceSchema.toString();
        System.out.println(schema);
        // test map paths
        final Map<String, Object> map = new GsonBuilder().create().fromJson(schema, Map.class);
        mapPathValue(map, "definitions.Project.type", "object");
        mapPathValue(map, "definitions.Project.properties.tasks.$link", "#/definitions/ProjectTasks");
        mapPathValue(map, "definitions.Project.properties.tasks.items.$ref", "#/definitions/Task");
        mapPathValue(map, "definitions.Project.properties.tasks.type", "array");
        mapPathValue(map, "definitions.ProjectTasks.$source", "#/definitions/Project");
        mapPathValue(map, "definitions.ProjectTasks.$target", "#/definitions/Task");
        mapPathValue(map, "definitions.ProjectTasks.cardinality", "OneToMany");
        mapPathValue(map, "definitions.ProjectTasks.rel", "has");
        mapPathValue(map, "definitions.ProjectTasks.sourceName", "project");
        mapPathValue(map, "definitions.ProjectTasks.targetName", "tasks");
        mapPathValue(map, "definitions.ProjectTasks.type", "object");
        mapPathValue(map, "definitions.Task.type", "object");
        mapPathValue(map, "definitions.Task.properties.project.$link", "#/definitions/ProjectTasks");
        mapPathValue(map, "definitions.Task.properties.project.$ref", "#/definitions/Project");
        mapPathValue(map, "definitions.Task.properties.project.type", "object");
        // test
        compareSchemaRoundtrip(sourceSchema);
    } catch (FrameworkException | InvalidSchemaException | URISyntaxException ex) {
        logger.warn("", ex);
        fail("Unexpected exception.");
    }
}
Also used : JsonReferenceType(org.structr.schema.json.JsonReferenceType) InvalidSchemaException(org.structr.schema.json.InvalidSchemaException) FrameworkException(org.structr.common.error.FrameworkException) GsonBuilder(com.google.gson.GsonBuilder) JsonSchema(org.structr.schema.json.JsonSchema) URISyntaxException(java.net.URISyntaxException) JsonObjectType(org.structr.schema.json.JsonObjectType) StructrTest(org.structr.common.StructrTest) Test(org.junit.Test)

Example 2 with JsonReferenceType

use of org.structr.schema.json.JsonReferenceType in project structr by structr.

the class SchemaTest method test03SchemaBuilder.

@Test
public void test03SchemaBuilder() {
    // we need to wait for the schema service to be initialized here.. :(
    try {
        Thread.sleep(1000);
    } catch (Throwable t) {
    }
    try {
        final JsonSchema sourceSchema = StructrSchema.createFromDatabase(app);
        final String instanceId = app.getInstanceId();
        final JsonObjectType task = sourceSchema.addType("Task");
        final JsonProperty title = task.addStringProperty("title", "public", "ui").setRequired(true);
        final JsonProperty desc = task.addStringProperty("description", "public", "ui").setRequired(true);
        task.addDateProperty("description", "public", "ui").setDatePattern("dd.MM.yyyy").setRequired(true);
        // test function property
        task.addFunctionProperty("displayName", "public", "ui").setReadFunction("this.name");
        task.addFunctionProperty("javascript", "public", "ui").setReadFunction("{ var x = 'test'; return x; }").setContentType("application/x-structr-javascript");
        // a project
        final JsonObjectType project = sourceSchema.addType("Project");
        project.addStringProperty("name", "public", "ui").setRequired(true);
        final JsonReferenceType projectTasks = project.relate(task, "HAS", Cardinality.OneToMany, "project", "tasks");
        projectTasks.setCascadingCreate(Cascade.targetToSource);
        project.getViewPropertyNames("public").add("tasks");
        task.getViewPropertyNames("public").add("project");
        // test enums
        project.addEnumProperty("status", "ui").setEnums("active", "planned", "finished");
        // a worker
        final JsonObjectType worker = sourceSchema.addType("Worker");
        final JsonReferenceType workerTasks = worker.relate(task, "HAS", Cardinality.OneToMany, "worker", "tasks");
        workerTasks.setCascadingDelete(Cascade.sourceToTarget);
        // reference Worker -> Task
        final JsonReferenceProperty workerProperty = workerTasks.getSourceProperty();
        final JsonReferenceProperty tasksProperty = workerTasks.getTargetProperty();
        tasksProperty.setName("renamedTasks");
        worker.addReferenceProperty("taskNames", tasksProperty, "public", "ui").setProperties("name");
        worker.addReferenceProperty("taskInfos", tasksProperty, "public", "ui").setProperties("id", "name");
        worker.addReferenceProperty("taskErrors", tasksProperty, "public", "ui").setProperties("id");
        task.addReferenceProperty("workerName", workerProperty, "public", "ui").setProperties("name");
        task.addReferenceProperty("workerNotion", workerProperty, "public", "ui").setProperties("id");
        // test date properties..
        project.addDateProperty("startDate", "public", "ui");
        // methods
        project.addMethod("onCreate", "set(this, 'name', 'wurst')", "comment for wurst");
        // test URIs
        assertEquals("Invalid schema URI", "https://structr.org/schema/" + instanceId + "/#", sourceSchema.getId().toString());
        assertEquals("Invalid schema URI", "https://structr.org/schema/" + instanceId + "/definitions/Task", task.getId().toString());
        assertEquals("Invalid schema URI", "https://structr.org/schema/" + instanceId + "/definitions/Task/properties/title", title.getId().toString());
        assertEquals("Invalid schema URI", "https://structr.org/schema/" + instanceId + "/definitions/Task/properties/description", desc.getId().toString());
        assertEquals("Invalid schema URI", "https://structr.org/schema/" + instanceId + "/definitions/Worker/properties/renamedTasks", tasksProperty.getId().toString());
        compareSchemaRoundtrip(sourceSchema);
    } catch (Exception ex) {
        ex.printStackTrace();
        logger.warn("", ex);
        fail("Unexpected exception.");
    }
}
Also used : JsonReferenceType(org.structr.schema.json.JsonReferenceType) JsonProperty(org.structr.schema.json.JsonProperty) JsonSchema(org.structr.schema.json.JsonSchema) JsonReferenceProperty(org.structr.schema.json.JsonReferenceProperty) JsonObjectType(org.structr.schema.json.JsonObjectType) URISyntaxException(java.net.URISyntaxException) FrameworkException(org.structr.common.error.FrameworkException) InvalidSchemaException(org.structr.schema.json.InvalidSchemaException) StructrTest(org.structr.common.StructrTest) Test(org.junit.Test)

Example 3 with JsonReferenceType

use of org.structr.schema.json.JsonReferenceType in project structr by structr.

the class OWLParserv2 method parse.

public void parse(final String fileName, final String blobsDirectory) {
    boolean success = true;
    try (final App app = StructrApp.getInstance()) {
        final Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new java.io.File(fileName));
        System.out.println("Parsing XML document..");
        logger.println("Parsing XML document..");
        // parse XML document
        parseDocument(doc.getDocumentElement(), 0);
        System.out.println("Filtering unwanted classes..");
        logger.println("Filtering unwanted classes..");
        // filter unwanted objects by their IDs
        filter(owlClassesByURI.values());
        filter(owlPropertiesByURI.values());
        if (importSchema) {
            // initialize class hierarchies
            System.out.println("Resolving " + owlClassesByURI.size() + " OWL superclasses..");
            logger.println("Resolving " + owlClassesByURI.size() + " OWL superclasses..");
            for (final OWLClass owlClass : owlClassesByURI.values()) {
                owlClass.resolveSuperclasses(owlClassesByURI);
            }
            for (final OWLClass owlClass : owlClassesByURI.values()) {
                owlClass.resolveRelatedTypes(owlClassesByURI);
            }
            for (final OWLClass owlClass : owlClassesByURI.values()) {
                owlClass.resolveRelationshipTypes(owlClassesByURI);
            }
            // initialize classes with datatype properties
            System.out.println("Resolving " + owlPropertiesByURI.size() + " datatype properties..");
            logger.println("Resolving " + owlPropertiesByURI.size() + " datatype properties..");
            for (final OWLProperty owlProperty : owlPropertiesByURI.values()) {
                owlProperty.resolveSuperclasses(owlPropertiesByURI);
                owlProperty.resolveClassProperties(owlClassesByURI);
            }
            final JsonSchema schema = StructrSchema.newInstance(URI.create("http://localhost/test/#"));
            // create common base class
            final JsonType baseType = schema.addType("BaseNode");
            final JsonType nameType = schema.addType("LocalizedName");
            nameType.addStringProperty("locale").setIndexed(true);
            nameType.addStringProperty("name").setIndexed(true);
            baseType.addStringProperty("originId").setIndexed(true);
            baseType.addDateProperty("createdAt").setIndexed(true);
            baseType.addDateProperty("modifiedAt").setIndexed(true);
            baseType.addFunctionProperty("isFallbackLang", "ui").setContentType("application/x-structr-script").setReadFunction("(empty(get_or_null(first(filter(this.names, equal(data.locale, substring(locale, 0, 2)))), 'name')))").setIndexed(true);
            baseType.addFunctionProperty("localizedName", "ui").setContentType("application/x-structr-script").setReadFunction("(if (equal('zh', substring(locale, 0, 2)),(if (empty(first(filter(this.names, equal(data.locale, 'zh')))),if (empty(first(filter(this.names, equal(data.locale, 'en')))),get_or_null(first(filter(this.names, equal(data.locale, 'de'))), 'name'),get(first(filter(this.names, equal(data.locale, 'en'))), 'name')),get(first(filter(this.names, equal(data.locale, 'zh'))), 'name'))),if (equal('de', substring(locale, 0, 2)),(if (empty(first(filter(this.names, equal(data.locale, 'de')))),if (empty(first(filter(this.names, equal(data.locale, 'en')))),get_or_null(first(filter(this.names, equal(data.locale, 'zh'))), 'name'),get(first(filter(this.names, equal(data.locale, 'en'))), 'name')),get(first(filter(this.names, equal(data.locale, 'de'))), 'name'))),(if (empty(first(filter(this.names, equal(data.locale, 'en')))),if (empty(first(filter(this.names, equal(data.locale, 'de')))),get_or_null(first(filter(this.names, equal(data.locale, 'zh'))), 'name'),get(first(filter(this.names, equal(data.locale, 'de'))), 'name')),get(first(filter(this.names, equal(data.locale, 'en'))), 'name'))))))").setIndexed(true);
            baseType.addFunctionProperty("nameDE", "ui").setContentType("application/x-structr-script").setReadFunction("get_or_null(first(filter(this.names, equal(data.locale, 'de'))), 'name')").setWriteFunction("(store('node', first(filter(this.names, equal(data.locale, 'de')))),if (empty(retrieve('node')),set(this, 'names', merge(this.names, create('LocalizedName', 'locale', 'de', 'name', value))),(if (empty(value),delete(retrieve('node')),set(retrieve('node'), 'name', value)))))").setIndexed(true);
            baseType.addFunctionProperty("nameEN", "ui").setContentType("application/x-structr-script").setReadFunction("get_or_null(first(filter(this.names, equal(data.locale, 'en'))), 'name')").setWriteFunction("(store('node', first(filter(this.names, equal(data.locale, 'en')))),if (empty(retrieve('node')),set(this, 'names', merge(this.names, create('LocalizedName', 'locale', 'en', 'name', value))),(if (empty(value),delete(retrieve('node')),set(retrieve('node'), 'name', value)))))").setIndexed(true);
            baseType.addFunctionProperty("nameZH", "ui").setContentType("application/x-structr-script").setReadFunction("get_or_null(first(filter(this.names, equal(data.locale, 'zh'))), 'name')").setWriteFunction("(store('node', first(filter(this.names, equal(data.locale, 'zh')))),if (empty(retrieve('node')),set(this, 'names', merge(this.names, create('LocalizedName', 'locale', 'zh', 'name', value))),(if (empty(value),delete(retrieve('node')),set(retrieve('node'), 'name', value)))))").setIndexed(true);
            final JsonReferenceType names = ((JsonObjectType) baseType).relate((JsonObjectType) nameType, "HasName", Cardinality.OneToMany);
            names.setSourcePropertyName("isNameOf");
            names.setTargetPropertyName("names");
            final JsonReferenceType extensions = ((JsonObjectType) baseType).relate((JsonObjectType) baseType, "ExtendedBy", Cardinality.ManyToMany);
            extensions.setSourcePropertyName("extends");
            extensions.setTargetPropertyName("extendedBy");
            baseType.addStringProperty("name").setIndexed(true);
            System.out.println("Creating schema..");
            logger.println("Creating schema..");
            try (final Tx tx = StructrApp.getInstance().tx()) {
                for (final OWLClass owlClass : owlClassesByURI.values()) {
                    final String name = owlClass.getStructrName(true);
                    if (name != null && schema.getType(name) == null && owlClass.isPrimary()) {
                        logger.println("Creating type " + name + "..");
                        schema.addType(name);
                    }
                }
                StructrSchema.replaceDatabaseSchema(app, schema);
                tx.success();
            } catch (FrameworkException fex) {
                System.out.println(fex.getErrorBuffer().getErrorTokens());
            }
            // resolve inheritance
            System.out.println("Resolving class inheritance..");
            logger.println("Resolving class inheritance..");
            try (final Tx tx = StructrApp.getInstance().tx()) {
                for (final OWLClass owlClass : owlClassesByURI.values()) {
                    final String name = owlClass.getStructrName(true);
                    final JsonType type = schema.getType(name);
                    final OWLClass superclass = owlClass.getSuperclass();
                    // type can be null if it is inverseOf another type
                    if (type != null) {
                        if (superclass != null) {
                            final JsonType superType = schema.getType(superclass.getStructrName(true));
                            if (superType != null) {
                                type.setExtends(superType);
                            } else {
                                type.setExtends(baseType);
                            }
                        } else {
                            type.setExtends(baseType);
                        }
                        for (final Name localizedName : owlClass.getNames()) {
                            app.create(Localization.class, new NodeAttribute(StructrApp.key(Localization.class, "name"), name), new NodeAttribute(StructrApp.key(Localization.class, "localizedName"), localizedName.name), new NodeAttribute(StructrApp.key(Localization.class, "locale"), localizedName.lang));
                        }
                    }
                }
                StructrSchema.replaceDatabaseSchema(app, schema);
                tx.success();
            } catch (FrameworkException fex) {
                System.out.println(fex.getErrorBuffer().getErrorTokens());
            }
            // resolve relationship types
            System.out.println("Resolving relationship types..");
            logger.println("Resolving relationship types..");
            try (final Tx tx = StructrApp.getInstance().tx()) {
                for (final OWLClass possibleOutgoingRelationshipType : owlClassesByURI.values()) {
                    final OWLClass possibleIncomingRelationshipType = possibleOutgoingRelationshipType.getInverse();
                    if (possibleOutgoingRelationshipType.isPrimary() && possibleIncomingRelationshipType != null) {
                        // this is a relationship
                        final List<OWLClass> sourceTypes = possibleOutgoingRelationshipType.getActualSourceTypes();
                        final List<OWLClass> targetTypes = possibleOutgoingRelationshipType.getActualTargetTypes();
                        for (final OWLClass sourceType : sourceTypes) {
                            for (final OWLClass targetType : targetTypes) {
                                final String sourceName = possibleOutgoingRelationshipType.getStructrName(false);
                                final String targetName = possibleIncomingRelationshipType.getStructrName(false);
                                final String sourceTypeName = sourceType.getStructrName(true);
                                final String targetTypeName = targetType.getStructrName(true);
                                final JsonType sourceJsonType = schema.getType(sourceTypeName);
                                final JsonType targetJsonType = schema.getType(targetTypeName);
                                if (sourceJsonType != null && targetJsonType != null) {
                                    final String relationshipTypeName = possibleOutgoingRelationshipType.getStructrName(true);
                                    final JsonObjectType relType = schema.addType(relationshipTypeName);
                                    final JsonObjectType srcType = (JsonObjectType) sourceJsonType;
                                    final JsonObjectType tgtType = (JsonObjectType) targetJsonType;
                                    srcType.relate(relType, sourceName, Cardinality.OneToMany, sourceType.getStructrName(false), sourceName);
                                    relType.relate(tgtType, targetName, Cardinality.ManyToOne, targetName, targetType.getStructrName(false));
                                    possibleOutgoingRelationshipType.setIsRelationship(true);
                                }
                            }
                        }
                    }
                }
                StructrSchema.replaceDatabaseSchema(app, schema);
                tx.success();
            } catch (FrameworkException fex) {
                System.out.println(fex.getErrorBuffer().getErrorTokens());
            }
            System.out.println("Adding properties to types");
            logger.println("Adding properties to types");
            try (final Tx tx = StructrApp.getInstance().tx()) {
                for (final OWLClass owlClass : owlClassesByURI.values()) {
                    final String typeName = owlClass.getStructrName(true);
                    JsonType type = schema.getType(typeName);
                    // type not found, try to set property on inverse type
                    if (type == null) {
                        final OWLClass inverse = owlClass.getInverse();
                        if (inverse != null) {
                            type = schema.getType(inverse.getStructrName(true));
                        }
                    }
                    if (type != null) {
                        for (final OWLProperty prop : owlClass.getAllProperties()) {
                            addProperty(type, prop, prop.getStructrName(false));
                        }
                    } else {
                        System.out.println("Class: no type found for " + owlClass.getId());
                    }
                }
                StructrSchema.replaceDatabaseSchema(app, schema);
                tx.success();
            }
            System.out.println("Adding metdata to node types");
            logger.println("Adding metdata to node types");
            try (final Tx tx = StructrApp.getInstance().tx()) {
                for (final OWLClass owlClass : owlClassesByURI.values()) {
                    final String name = owlClass.getStructrName(true);
                    final SchemaNode schemaNode = app.nodeQuery(SchemaNode.class).andName(name).getFirst();
                    String icon = owlClass.getIcon();
                    if (schemaNode != null) {
                        // part after the second dash
                        if (icon != null && icon.contains("-")) {
                            // start with
                            final int pos = icon.indexOf("-", 7);
                            if (pos > -1) {
                                icon = icon.substring(pos + 1);
                            }
                        }
                        schemaNode.setProperty(SchemaNode.icon, icon);
                    }
                }
                tx.success();
            } catch (FrameworkException fex) {
                System.out.println(fex.getErrorBuffer().getErrorTokens());
            }
            // create instances
            System.out.println("Resolving instances..");
            logger.println("Resolving instances..");
            final Iterator<OWLInstance> instancesIterator = owlInstances.values().iterator();
            final List<OWLInstance> newInstances = new LinkedList<>();
            int count = 0;
            while (instancesIterator.hasNext()) {
                try (final Tx tx = StructrApp.getInstance().tx()) {
                    while (instancesIterator.hasNext()) {
                        final OWLInstance instance = instancesIterator.next();
                        final OWLClass owlType = instance.getType();
                        if (owlType != null) {
                            instance.createDatabaseNode(app);
                            instance.resolveProperties();
                            instance.resolveExtensions(app, owlClassesByFragment, owlInstances, newInstances);
                        }
                        if (++count == 100) {
                            count = 0;
                            break;
                        }
                    }
                    tx.success();
                }
            }
            // add newly created extension instances to global map
            for (final OWLInstance newInstance : newInstances) {
                owlInstances.put(newInstance.getId(), newInstance);
            }
            System.out.println("Resolving instance relationships..");
            logger.println("Resolving instance relationships..");
            final Iterator<OWLInstance> relationshipsIterator = owlInstances.values().iterator();
            count = 0;
            while (relationshipsIterator.hasNext()) {
                try (final Tx tx = StructrApp.getInstance().tx()) {
                    while (relationshipsIterator.hasNext()) {
                        final OWLInstance instance = relationshipsIterator.next();
                        final OWLClass owlType = instance.getType();
                        if (owlType != null) {
                            instance.resolveRelationships(schema, owlClassesByFragment, owlInstances, rdfDescriptions, owlPropertiesByName);
                        }
                        if (++count == 100) {
                            count = 0;
                            break;
                        }
                    }
                    tx.success();
                }
            }
        }
        final java.io.File blobs = new java.io.File(blobsDirectory);
        if (blobs.exists()) {
            final ConfigurationProvider config = StructrApp.getConfiguration();
            final List<Tuple<Class, PropertyKey>> mapping = createPropertyKeyMapping(config);
            final Set<Path> files = new LinkedHashSet<>();
            int count = 0;
            // collect all files
            Files.walkFileTree(blobs.toPath(), new Visitor(files));
            if (createFileRelationships) {
                System.out.println("Resolving file relationships..");
                logger.println("Resolving file relationships..");
                // iterate over files to identify relationships and extend schema
                final Iterator<Path> pathIteratorForSchemaExtension = files.iterator();
                try (final Tx tx = StructrApp.getInstance().tx()) {
                    while (pathIteratorForSchemaExtension.hasNext()) {
                        final Path file = pathIteratorForSchemaExtension.next();
                        final String name = file.getFileName().toString();
                        final int pos = name.indexOf(".", 7);
                        final String idPart = name.substring(6, pos == -1 ? name.length() : pos);
                        if (name.startsWith("KBlob-") && name.length() > 23) {
                            for (final Tuple<Class, PropertyKey> entry : mapping) {
                                final Class type = entry.getKey();
                                final PropertyKey key = entry.getValue();
                                Object value = idPart;
                                if (key instanceof ArrayProperty) {
                                    value = new String[] { idPart };
                                }
                                final Query<NodeInterface> query = app.nodeQuery().andType(type).and(key, value, false);
                                final List<NodeInterface> nodes = query.getAsList();
                                if (nodes.size() == 1) {
                                    System.out.println("                ##########: " + nodes.size() + " results..");
                                    // create schema relationship from schema type to file (once)
                                    // import file
                                    // link file
                                    final SchemaNode schemaNode = app.nodeQuery(SchemaNode.class).andName(type.getSimpleName()).getFirst();
                                    if (schemaNode != null) {
                                        System.out.println("                ##########: found SchemaNode " + schemaNode.getUuid() + " (" + schemaNode.getName() + ")");
                                        final SchemaNode fileSchemaNode = app.nodeQuery(SchemaNode.class).andName(File.class.getSimpleName()).getFirst();
                                        if (fileSchemaNode != null) {
                                            final String capitalJsonName = StringUtils.capitalize(key.jsonName());
                                            final String targetJsonName = "has" + capitalJsonName;
                                            final String sourceJsonName = "is" + capitalJsonName + "Of" + type.getSimpleName();
                                            final SchemaRelationshipNode link = app.nodeQuery(SchemaRelationshipNode.class).and(SchemaRelationshipNode.sourceNode, schemaNode).and(SchemaRelationshipNode.targetNode, fileSchemaNode).and(SchemaRelationshipNode.relationshipType, key.jsonName()).getFirst();
                                            if (link == null) {
                                                System.out.println("Creating link from " + schemaNode + " to " + fileSchemaNode + ", " + sourceJsonName + ", " + targetJsonName);
                                                app.create(SchemaRelationshipNode.class, new NodeAttribute(SchemaRelationshipNode.sourceNode, schemaNode), new NodeAttribute(SchemaRelationshipNode.targetNode, fileSchemaNode), new NodeAttribute(SchemaRelationshipNode.relationshipType, key.jsonName()), new NodeAttribute(SchemaRelationshipNode.sourceMultiplicity, "1"), new NodeAttribute(SchemaRelationshipNode.targetMultiplicity, key instanceof ArrayProperty ? "*" : "1"), new NodeAttribute(SchemaRelationshipNode.sourceJsonName, sourceJsonName), new NodeAttribute(SchemaRelationshipNode.targetJsonName, targetJsonName));
                                            } else {
                                                System.out.println("Link relationship already exists: " + link);
                                            }
                                        } else {
                                            System.out.println("NO SchemaNode found for type File!");
                                        }
                                    } else {
                                        System.out.println("NO SchemaNode found for type " + type.getSimpleName() + "!");
                                    }
                                // no need to search further
                                // break;
                                }
                            }
                        }
                    }
                    tx.success();
                }
            }
            if (importFiles) {
                System.out.println("Importing files..");
                logger.println("Importing files..");
                final SecurityContext superUserSecurityContext = SecurityContext.getSuperUserInstance();
                final Iterator<Path> pathIteratorForRelationshipCreation = files.iterator();
                while (pathIteratorForRelationshipCreation.hasNext()) {
                    try (final Tx tx = StructrApp.getInstance().tx()) {
                        while (pathIteratorForRelationshipCreation.hasNext()) {
                            final Path file = pathIteratorForRelationshipCreation.next();
                            final String name = file.getFileName().toString();
                            final int pos = name.indexOf(".", 7);
                            final String idPart = name.substring(6, pos == -1 ? name.length() : pos);
                            boolean found = false;
                            if (name.startsWith("KBlob-") && name.length() > 23) {
                                for (final Tuple<Class, PropertyKey> entry : mapping) {
                                    final Class type = entry.getKey();
                                    final PropertyKey key = entry.getValue();
                                    final boolean isMultiple = (key instanceof ArrayProperty);
                                    Object value = idPart;
                                    if (isMultiple) {
                                        value = new String[] { idPart };
                                    }
                                    final Query<NodeInterface> query = app.nodeQuery().andType(type).and(key, value, false);
                                    final List<NodeInterface> nodes = query.getAsList();
                                    if (nodes.size() == 1) {
                                        final String capitalJsonName = StringUtils.capitalize(key.jsonName());
                                        final String targetJsonName = "has" + capitalJsonName;
                                        final NodeInterface node = nodes.get(0);
                                        final PropertyKey fileRelationshipKey = StructrApp.key(type, targetJsonName);
                                        if (fileRelationshipKey != null) {
                                            try (final InputStream is = new FileInputStream(file.toFile())) {
                                                // import file..
                                                final Class fileType = ImageHelper.isImageType(name) ? Image.class : File.class;
                                                if (isMultiple) {
                                                    final String[] possibleNames = (String[]) node.getProperty(key);
                                                    String actualName = name;
                                                    for (final String possibleName : possibleNames) {
                                                        if (possibleName.startsWith(name)) {
                                                            actualName = possibleName.substring(name.length() + 1);
                                                            break;
                                                        }
                                                    }
                                                    logger.println("        Importing " + name + " => " + actualName);
                                                    final File importedFile = FileHelper.createFile(superUserSecurityContext, is, null, fileType, actualName);
                                                    final List<File> fileList = (List<File>) node.getProperty(fileRelationshipKey);
                                                    fileList.add(importedFile);
                                                    node.setProperty(fileRelationshipKey, fileList);
                                                } else {
                                                    final String possibleName = (String) node.getProperty(key);
                                                    String actualName = name;
                                                    if (possibleName != null) {
                                                        actualName = possibleName.substring(name.length() + 1);
                                                    }
                                                    logger.println("        Importing " + name + " => " + actualName);
                                                    final File importedFile = FileHelper.createFile(superUserSecurityContext, is, null, fileType, actualName);
                                                    node.setProperty(fileRelationshipKey, importedFile);
                                                }
                                            } catch (Throwable t) {
                                                t.printStackTrace();
                                            }
                                        } else {
                                            System.out.println("############################# INVALID KEY " + type.getSimpleName() + "." + targetJsonName + ", not found??!");
                                            logger.println("############################# INVALID KEY " + type.getSimpleName() + "." + targetJsonName + ", not found??!");
                                        }
                                        found = true;
                                        // no need to search further
                                        break;
                                    }
                                }
                            }
                            if (!found) {
                                System.out.println("Found NO document for file " + name + ", importing without association");
                                logger.println("Found NO document for file " + name + ", importing without association");
                                try (final InputStream is = new FileInputStream(file.toFile())) {
                                    // import file..
                                    final Class fileType = ImageHelper.isImageType(name) ? Image.class : File.class;
                                    FileHelper.createFile(superUserSecurityContext, is, null, fileType, name);
                                } catch (Throwable t) {
                                    t.printStackTrace();
                                }
                            }
                            if (++count == 100) {
                                count = 0;
                                break;
                            }
                        }
                        tx.success();
                    }
                }
            }
        }
    } catch (Throwable t) {
        t.printStackTrace();
        success = false;
    }
    if (success) {
        System.out.println("Import successful");
        logger.println("Import successful");
    }
    logger.flush();
    logger.close();
}
Also used : App(org.structr.core.app.App) StructrApp(org.structr.core.app.StructrApp) LinkedHashSet(java.util.LinkedHashSet) JsonSchema(org.structr.schema.json.JsonSchema) Document(org.w3c.dom.Document) SchemaRelationshipNode(org.structr.core.entity.SchemaRelationshipNode) List(java.util.List) LinkedList(java.util.LinkedList) NodeInterface(org.structr.core.graph.NodeInterface) ArrayProperty(org.structr.core.property.ArrayProperty) Tx(org.structr.core.graph.Tx) LinkedList(java.util.LinkedList) FileInputStream(java.io.FileInputStream) File(org.structr.web.entity.File) JsonType(org.structr.schema.json.JsonType) FileVisitor(java.nio.file.FileVisitor) ConfigurationProvider(org.structr.schema.ConfigurationProvider) Path(java.nio.file.Path) JsonReferenceType(org.structr.schema.json.JsonReferenceType) NodeAttribute(org.structr.core.graph.NodeAttribute) FrameworkException(org.structr.common.error.FrameworkException) FileInputStream(java.io.FileInputStream) InputStream(java.io.InputStream) JsonObjectType(org.structr.schema.json.JsonObjectType) SchemaNode(org.structr.core.entity.SchemaNode) SecurityContext(org.structr.common.SecurityContext) PropertyKey(org.structr.core.property.PropertyKey)

Example 4 with JsonReferenceType

use of org.structr.schema.json.JsonReferenceType in project structr by structr.

the class SchemaSnapshotTest method testSnapshotRoundtripWithPrimitives.

@Test
public void testSnapshotRoundtripWithPrimitives() {
    File file = null;
    String source = null;
    String export = null;
    String imp = null;
    // 1. step: create schema with all possible (primitive) property types
    try {
        // create new instance id
        app.getInstanceId();
        final JsonSchema sourceSchema = StructrSchema.createFromDatabase(app);
        // a customer
        final JsonObjectType customer = sourceSchema.addType("Customer");
        customer.addStringProperty("name", "public", "ui").setRequired(true).setUnique(true);
        customer.addStringProperty("street", "public", "ui");
        customer.addStringProperty("city", "public", "ui");
        customer.addDateProperty("birthday", "public", "ui");
        customer.addEnumProperty("status", "public", "ui").setEnums("active", "retired", "none").setDefaultValue("active");
        customer.addIntegerProperty("count", "public", "ui").setMinimum(1).setMaximum(10, true).setDefaultValue("5");
        customer.addNumberProperty("number", "public", "ui").setMinimum(2.0, true).setMaximum(5.0, true).setDefaultValue("3.0");
        customer.addLongProperty("loong", "public", "ui").setMinimum(20, true).setMaximum(50);
        customer.addBooleanProperty("isCustomer", "public", "ui");
        customer.addFunctionProperty("displayName", "public", "ui").setReadFunction("concat(this.name, '.', this.id)");
        customer.addStringProperty("description", "public", "ui").setContentType("text/plain").setFormat("multi-line");
        customer.addStringArrayProperty("stringArray", "public", "ui");
        customer.addIntegerArrayProperty("intArray", "public", "ui").setMinimum(0, true).setMaximum(100, true);
        customer.addLongArrayProperty("longArray", "public", "ui").setMinimum(1, true).setMaximum(101, true);
        customer.addDoubleArrayProperty("doubleArray", "public", "ui").setMinimum(2.0, true).setMaximum(102.0, true);
        customer.addBooleanArrayProperty("booleanArray", "public", "ui");
        // a project
        final JsonObjectType project = sourceSchema.addType("Project");
        final JsonReferenceType rel = customer.relate(project);
        rel.setCardinality(Relation.Cardinality.OneToMany);
        rel.setCascadingDelete(JsonSchema.Cascade.sourceToTarget);
        rel.setRelationship("hasProject");
        rel.setSourcePropertyName("customer");
        rel.setTargetPropertyName("projects");
        source = sourceSchema.toString();
        try (final FileWriter writer = new FileWriter(createTempFile(1))) {
            writer.append(source);
            writer.flush();
        } catch (IOException ioex) {
            ioex.printStackTrace();
        }
        StructrSchema.replaceDatabaseSchema(app, sourceSchema);
    } catch (Throwable t) {
        fail("Unexpected exception");
    }
    // step 2: export schema
    try {
        app.command(SnapshotCommand.class).execute("export", "test");
    } catch (FrameworkException ex) {
        fail("Unexpected exception");
    }
    // step 3: read schema export file and compare to source
    try {
        file = new File(basePath + "/snapshots").listFiles()[0];
        export = IOUtils.toString(new FileInputStream(file)).trim();
        try (final FileWriter writer = new FileWriter(createTempFile(3))) {
            writer.append(export);
            writer.flush();
        } catch (IOException ioex) {
            ioex.printStackTrace();
        }
        assertEquals("Invalid schema export result, ", source, export);
    } catch (IOException t) {
        t.printStackTrace();
        fail("Unexpected exception");
    }
    // step 4: clear schema
    try {
        StructrSchema.replaceDatabaseSchema(app, StructrSchema.createEmptySchema());
    } catch (FrameworkException | InvalidSchemaException | URISyntaxException ex) {
        fail("Unexpected exception");
    }
    // step 5: import schema from export file
    try {
        app.command(SnapshotCommand.class).execute("restore", file.getName());
    } catch (FrameworkException ex) {
        ex.printStackTrace();
        fail("Unexpected exception");
    }
    // step 6: create string representation of imported schema
    try {
        final JsonSchema sourceSchema = StructrSchema.createFromDatabase(app);
        imp = sourceSchema.toString();
    } catch (Throwable t) {
        fail("Unexpected exception");
    }
    try (final FileWriter writer = new FileWriter(createTempFile(2))) {
        writer.append(imp);
        writer.flush();
    } catch (IOException ioex) {
        ioex.printStackTrace();
    }
    // step 7: compare import result to initial source
    assertEquals("Invalid schema export result, ", source, imp);
}
Also used : JsonReferenceType(org.structr.schema.json.JsonReferenceType) FrameworkException(org.structr.common.error.FrameworkException) JsonSchema(org.structr.schema.json.JsonSchema) FileWriter(java.io.FileWriter) IOException(java.io.IOException) URISyntaxException(java.net.URISyntaxException) JsonObjectType(org.structr.schema.json.JsonObjectType) FileInputStream(java.io.FileInputStream) InvalidSchemaException(org.structr.schema.json.InvalidSchemaException) SnapshotCommand(org.structr.rest.maintenance.SnapshotCommand) File(java.io.File) Test(org.junit.Test) StructrUiTest(org.structr.web.StructrUiTest)

Aggregations

FrameworkException (org.structr.common.error.FrameworkException)4 JsonObjectType (org.structr.schema.json.JsonObjectType)4 JsonReferenceType (org.structr.schema.json.JsonReferenceType)4 JsonSchema (org.structr.schema.json.JsonSchema)4 URISyntaxException (java.net.URISyntaxException)3 Test (org.junit.Test)3 InvalidSchemaException (org.structr.schema.json.InvalidSchemaException)3 FileInputStream (java.io.FileInputStream)2 StructrTest (org.structr.common.StructrTest)2 GsonBuilder (com.google.gson.GsonBuilder)1 File (java.io.File)1 FileWriter (java.io.FileWriter)1 IOException (java.io.IOException)1 InputStream (java.io.InputStream)1 FileVisitor (java.nio.file.FileVisitor)1 Path (java.nio.file.Path)1 LinkedHashSet (java.util.LinkedHashSet)1 LinkedList (java.util.LinkedList)1 List (java.util.List)1 SecurityContext (org.structr.common.SecurityContext)1