Examples with IComplexTypeAffectation com.twinsoft.convertigo.beans.core.IComplexTypeAffectation used on opensource projects

Example 1 with IComplexTypeAffectation

use of com.twinsoft.convertigo.beans.core.IComplexTypeAffectation in project convertigo by convertigo.

the class XmlSchemaBuilder method midBuildSchema.

private void midBuildSchema(final int nb) throws EngineException {
    // System.out.println("buildSchema for "+ getTargetNamespace());
    boolean fullSchema = isFull;
    try {
        new WalkHelper() {

            @Override
            protected void walk(DatabaseObject databaseObject) throws Exception {
                if (databaseObject instanceof ISchemaGenerator) {
                    // generate itself and add to the caller list
                    if (databaseObject instanceof ISchemaImportGenerator) {
                        // Import case
                        if (databaseObject instanceof ProjectSchemaReference) {
                            ProjectSchemaReference ref = (ProjectSchemaReference) databaseObject;
                            String targetProjectName = ref.getParser().getProjectName();
                            String tns = Project.getProjectTargetNamespace(targetProjectName);
                            if (collection.schemaForNamespace(tns) == null) {
                                if (SchemaMeta.getXmlSchemaObject(schema, databaseObject) == null) {
                                    XmlSchemaImport schemaImport = new XmlSchemaImport();
                                    schemaImport.setNamespace(tns);
                                    SchemaMeta.setXmlSchemaObject(schema, databaseObject, schemaImport);
                                    XmlSchemaUtils.add(schema, schemaImport);
                                } else {
                                    XmlSchemaBuilder builder = builderExecutor.getBuilderByTargetNamespace(tns);
                                    if (builder != null) {
                                        XmlSchemaUtils.remove(schema, SchemaMeta.getXmlSchemaObject(schema, databaseObject));
                                        XmlSchema xmlSchema = collection.read(builder.schema.getSchemaDocument(), null);
                                        XmlSchemaImport schemaImport = new XmlSchemaImport();
                                        schemaImport.setNamespace(tns);
                                        schemaImport.setSchema(xmlSchema);
                                        SchemaMeta.setXmlSchemaObject(schema, databaseObject, schemaImport);
                                        XmlSchemaUtils.add(schema, schemaImport);
                                    }
                                }
                            }
                        }
                    }
                } else {
                    // doesn't generate schema, just deep walk
                    super.walk(databaseObject);
                }
            }

            @Override
            protected boolean before(DatabaseObject databaseObject, Class<? extends DatabaseObject> dboClass) {
                // just walk references
                return Reference.class.isAssignableFrom(dboClass);
            }
        }.init(project);
        // add missing references import
        if (nb == 1) {
            if (this.equals(builderExecutor.getMainBuilder())) {
                List<String> refs = new ArrayList<String>();
                SchemaManager.getProjectReferences(refs, projectName);
                List<String> missing = new ArrayList<String>();
                missing.addAll(refs);
                missing.remove(projectName);
                for (String pname : refs) {
                    XmlSchemaObjectCollection col = schema.getIncludes();
                    for (int i = 0; i < col.getCount(); i++) {
                        XmlSchemaObject ob = col.getItem(i);
                        if (ob instanceof XmlSchemaImport) {
                            XmlSchemaImport xmlSchemaImport = (XmlSchemaImport) ob;
                            String tns = Project.getProjectTargetNamespace(pname);
                            if (xmlSchemaImport.getNamespace().equals(tns)) {
                                missing.remove(pname);
                            }
                        }
                    }
                }
                for (String pname : missing) {
                    String tns = Project.getProjectTargetNamespace(pname);
                    XmlSchemaBuilder builder = builderExecutor.getBuilderByTargetNamespace(tns);
                    if (builder != null) {
                        XmlSchema xmlSchema = collection.read(builder.schema.getSchemaDocument(), null);
                        XmlSchemaImport schemaImport = new XmlSchemaImport();
                        schemaImport.setNamespace(tns);
                        schemaImport.setSchema(xmlSchema);
                        XmlSchemaUtils.add(schema, schemaImport);
                    }
                }
            }
        }
        new WalkHelper() {

            List<XmlSchemaParticle> particleChildren;

            List<XmlSchemaAttribute> attributeChildren;

            @Override
            protected void walk(DatabaseObject databaseObject) throws Exception {
                // Transaction case
                if (databaseObject instanceof Transaction) {
                    Transaction transaction = (Transaction) databaseObject;
                    String ns = schema.getTargetNamespace();
                    List<QName> partElementQNames = new ArrayList<QName>();
                    partElementQNames.add(new QName(ns, transaction.getXsdRequestElementName()));
                    partElementQNames.add(new QName(ns, transaction.getXsdResponseElementName()));
                    LinkedHashMap<QName, XmlSchemaObject> map = new LinkedHashMap<QName, XmlSchemaObject>();
                    XmlSchemaWalker dw = XmlSchemaWalker.newDependencyWalker(map, true, true);
                    for (QName qname : partElementQNames) {
                        dw.walkByElementRef(schema, qname);
                    }
                    for (QName qname : map.keySet()) {
                        String nsURI = qname.getNamespaceURI();
                        if (nsURI.equals(ns))
                            continue;
                        if (nsURI.equals(Constants.URI_2001_SCHEMA_XSD))
                            continue;
                        SchemaManager.addXmlSchemaImport(collection, schema, nsURI);
                    }
                    map.clear();
                    // add the 'statistics' element
                    if (transaction.getAddStatistics()) {
                        XmlSchemaComplexType xmlSchemaComplexType = (XmlSchemaComplexType) schema.getTypeByName(transaction.getXsdResponseTypeName());
                        XmlSchemaGroupBase xmlSchemaGroupBase = (XmlSchemaGroupBase) xmlSchemaComplexType.getParticle();
                        XmlSchemaType statisticsType = schema.getTypeByName("ConvertigoStatsType");
                        XmlSchemaElement eStatistics = XmlSchemaUtils.makeDynamicReadOnly(databaseObject, new XmlSchemaElement());
                        eStatistics.setName("statistics");
                        eStatistics.setMinOccurs(0);
                        eStatistics.setMaxOccurs(1);
                        eStatistics.setSchemaTypeName(statisticsType.getQName());
                        xmlSchemaGroupBase.getItems().add(eStatistics);
                        SchemaMeta.getReferencedDatabaseObjects(statisticsType).add(transaction);
                    }
                } else // Sequence case
                if (databaseObject instanceof Sequence) {
                    Sequence sequence = (Sequence) databaseObject;
                    // System.out.println("--sequence:"+ sequence.toString());
                    particleChildren = new LinkedList<XmlSchemaParticle>();
                    attributeChildren = new LinkedList<XmlSchemaAttribute>();
                    super.walk(databaseObject);
                    // check for an 'error' element if needed
                    boolean errorFound = false;
                    XmlSchemaType errorType = schema.getTypeByName("ConvertigoError");
                    if (errorType != null) {
                        Set<DatabaseObject> dbos = SchemaMeta.getReferencedDatabaseObjects(errorType);
                        for (DatabaseObject dbo : dbos) {
                            if (dbo instanceof Step) {
                                Step errorStep = (Step) dbo;
                                if (errorStep.getSequence().equals(sequence) && (errorStep instanceof XMLCopyStep || errorStep.getStepNodeName().equals("error"))) {
                                    errorFound = true;
                                    break;
                                }
                            }
                        }
                    }
                    // set particle : choice or sequence
                    XmlSchemaComplexType cType = (XmlSchemaComplexType) schema.getTypeByName(sequence.getComplexTypeAffectation().getLocalPart());
                    XmlSchemaSequence xmlSeq = new XmlSchemaSequence();
                    XmlSchemaChoice xmlChoice = new XmlSchemaChoice();
                    cType.setParticle(errorFound ? xmlSeq : xmlChoice);
                    if (!errorFound) {
                        XmlSchemaElement eError = XmlSchemaUtils.makeDynamicReadOnly(databaseObject, new XmlSchemaElement());
                        eError.setName("error");
                        eError.setMinOccurs(0);
                        eError.setMaxOccurs(1);
                        eError.setSchemaTypeName(errorType.getQName());
                        SchemaMeta.getReferencedDatabaseObjects(errorType).add(sequence);
                        xmlChoice.getItems().add(xmlSeq);
                        xmlChoice.getItems().add(eError);
                    }
                    // add child particles
                    if (!particleChildren.isEmpty()) {
                        for (XmlSchemaParticle child : particleChildren) {
                            xmlSeq.getItems().add(child);
                        }
                    }
                    particleChildren.clear();
                    // add child attributes
                    for (XmlSchemaAttribute attribute : attributeChildren) {
                        cType.getAttributes().add(attribute);
                    }
                    attributeChildren.clear();
                    // add the 'statistics' element
                    if (sequence.getAddStatistics()) {
                        XmlSchemaType statisticsType = schema.getTypeByName("ConvertigoStatsType");
                        XmlSchemaElement eStatistics = XmlSchemaUtils.makeDynamicReadOnly(databaseObject, new XmlSchemaElement());
                        eStatistics.setName("statistics");
                        eStatistics.setMinOccurs(0);
                        eStatistics.setMaxOccurs(1);
                        eStatistics.setSchemaTypeName(statisticsType.getQName());
                        xmlSeq.getItems().add(eStatistics);
                        SchemaMeta.getReferencedDatabaseObjects(statisticsType).add(sequence);
                    }
                // --------------------------- For Further Use -------------------------------------------------//
                // Modify schema to avoid 'cosamb' (same tagname&type in different groupBase at same level)
                // TODO : IfThenElse steps must be modified for xsd:sequence instead of xsd:choice
                // TODO : Then/Else steps must be modified to add minOccurs=0 on xsd:sequence
                // TODO : review/improve cosnoamb(XmlSchema, XmlSchemaGroupBase, XmlSchemaGroupBase) method
                // ---------------------------------------------------------------------------------------------//
                } else // Step case
                if (databaseObject instanceof Step) {
                    Step step = (Step) databaseObject;
                    if (!step.isEnabled()) {
                        // stop walking for disabled steps
                        return;
                    }
                    List<XmlSchemaParticle> parentParticleChildren = particleChildren;
                    List<XmlSchemaAttribute> parentAttributeChildren = attributeChildren;
                    // System.out.println("step:"+ step.toString());
                    if (step instanceof TransactionStep) {
                    // System.out.println("SCHEMA TARGET STEP "+ step.toString() + "(" + step.hashCode() + ")");
                    }
                    if (step.isGenerateSchema() || (fullSchema && step.isXmlOrOutput())) {
                        // System.out.println("-> generate schema...");
                        List<XmlSchemaParticle> myParticleChildren = null;
                        List<XmlSchemaAttribute> myAttributeChildren = null;
                        // is base affected ?
                        @SuppressWarnings("unused") XmlSchemaType base = null;
                        QName baseQName = step instanceof ISimpleTypeAffectation ? ((ISimpleTypeAffectation) step).getSimpleTypeAffectation() : null;
                        if (baseQName != null && baseQName.getLocalPart().length() > 0) {
                            // base = baseQName.getNamespaceURI().length() == 0 ? schema.getTypeByName(baseQName.getLocalPart()) : collection.getTypeByQName(baseQName);
                            base = XmlSchemaBuilder.this.resolveTypeByQName(baseQName);
                        }
                        // is type affected ?
                        XmlSchemaType type = null;
                        QName typeQName = step instanceof IComplexTypeAffectation ? ((IComplexTypeAffectation) step).getComplexTypeAffectation() : null;
                        if (typeQName != null && typeQName.getLocalPart().length() > 0) {
                            // type = typeQName.getNamespaceURI().length() == 0 ? schema.getTypeByName(typeQName.getLocalPart()) : collection.getTypeByQName(typeQName);
                            type = XmlSchemaBuilder.this.resolveTypeByQName(typeQName);
                        }
                        // is element affected ?
                        XmlSchemaElement ref = null;
                        QName refQName = step instanceof IElementRefAffectation ? ((IElementRefAffectation) step).getElementRefAffectation() : null;
                        if (refQName != null && refQName.getLocalPart().length() > 0) {
                            // ref = refQName.getNamespaceURI().length() == 0 ? schema.getElementByName(refQName.getLocalPart()) : collection.getElementByQName(refQName);
                            ref = XmlSchemaBuilder.this.resolveElementByQName(refQName);
                            typeQName = new QName(schema.getTargetNamespace(), refQName.getLocalPart() + "Type");
                            if (ref == null && refQName.getNamespaceURI().equals(schema.getTargetNamespace())) {
                                ref = XmlSchemaUtils.makeDynamic(step, new XmlSchemaElement());
                                ref.setQName(refQName);
                                ref.setName(refQName.getLocalPart());
                                ref.setSchemaTypeName(baseQName);
                                XmlSchemaUtils.add(schema, ref);
                            } else if (ref != null) {
                                ref.setSchemaTypeName(baseQName);
                                // type = typeQName.getNamespaceURI().length() == 0 ? schema.getTypeByName(typeQName.getLocalPart()) : collection.getTypeByQName(typeQName);
                                type = XmlSchemaBuilder.this.resolveTypeByQName(typeQName);
                            }
                        }
                        if (type == null || !SchemaMeta.isReadOnly(type)) {
                            // prepare to receive children
                            if (step instanceof ISchemaParticleGenerator) {
                                myParticleChildren = particleChildren = new LinkedList<XmlSchemaParticle>();
                                if (fullSchema || ((ISchemaParticleGenerator) step).isGenerateElement()) {
                                    myAttributeChildren = attributeChildren = new LinkedList<XmlSchemaAttribute>();
                                }
                            }
                            // deep walk
                            super.walk(step);
                            // generate itself and add to the caller list
                            if (step instanceof ISchemaAttributeGenerator) {
                                // Attribute case
                                XmlSchemaAttribute attribute = ((ISchemaAttributeGenerator) step).getXmlSchemaObject(collection, schema);
                                SchemaMeta.setXmlSchemaObject(schema, step, attribute);
                                parentAttributeChildren.add(attribute);
                            } else if (step instanceof ISchemaParticleGenerator) {
                                if (step instanceof RequestableStep) {
                                    RequestableStep requestableStep = (RequestableStep) step;
                                    String targetProjectName = requestableStep.getProjectName();
                                    Project targetProject = requestableStep.getSequence().getLoadedProject(targetProjectName);
                                    if (targetProject == null) {
                                        Engine.logEngine.warn("(XmlSchemaBuilder) Not complete schema because: Missing required or not loaded project \"" + targetProjectName + "\"");
                                    } else if (step instanceof SequenceStep) {
                                        // SequenceStep case : walk target sequence first
                                        try {
                                            Sequence targetSequence = ((SequenceStep) step).getTargetSequence();
                                            targetProjectName = targetSequence.getProject().getName();
                                            String targetSequenceName = targetSequence.getName();
                                            String stepSequenceName = step.getSequence().getName();
                                            if (projectName.equals(targetProjectName)) {
                                                boolean isAfter = targetSequenceName.compareToIgnoreCase(stepSequenceName) > 0;
                                                if (isAfter) {
                                                    walk(targetSequence);
                                                }
                                            }
                                        } catch (EngineException e) {
                                            if (!e.getMessage().startsWith("There is no ")) {
                                                throw e;
                                            } else {
                                                Engine.logEngine.warn("(XmlSchemaBuilder) Not complete schema because: " + e.getMessage());
                                            }
                                        }
                                    }
                                }
                                // Particle case
                                XmlSchemaParticle particle = ((ISchemaParticleGenerator) step).getXmlSchemaObject(collection, schema);
                                SchemaMeta.setXmlSchemaObject(schema, step, particle);
                                parentParticleChildren.add(particle);
                                // retrieve the xsd:element to add children
                                XmlSchemaElement element = SchemaMeta.getContainerXmlSchemaElement(ref == null ? particle : ref);
                                // retrieve the group to add children if any
                                XmlSchemaGroupBase group = SchemaMeta.getContainerXmlSchemaGroupBase(element != null ? element : particle);
                                // new complexType to enhance the element
                                XmlSchemaComplexType cType = element != null ? (XmlSchemaComplexType) element.getSchemaType() : null;
                                // do something only on case of child
                                if (!myParticleChildren.isEmpty() || (myAttributeChildren != null && !myAttributeChildren.isEmpty())) {
                                    if (cType == null) {
                                        cType = XmlSchemaUtils.makeDynamic(step, new XmlSchemaComplexType(schema));
                                    }
                                    // prepare element children in the group
                                    if (!myParticleChildren.isEmpty()) {
                                        if (group == null) {
                                            group = XmlSchemaUtils.makeDynamic(step, new XmlSchemaSequence());
                                        }
                                        for (XmlSchemaParticle child : myParticleChildren) {
                                            group.getItems().add(child);
                                        }
                                    }
                                    if (element != null) {
                                        XmlSchemaSimpleContentExtension sContentExt = SchemaManager.makeSimpleContentExtension(step, element, cType);
                                        if (sContentExt != null) {
                                            // add attributes
                                            for (XmlSchemaAttribute attribute : myAttributeChildren) {
                                                sContentExt.getAttributes().add(attribute);
                                            }
                                        } else {
                                            // add attributes
                                            for (XmlSchemaAttribute attribute : myAttributeChildren) {
                                                cType.getAttributes().add(attribute);
                                            }
                                            // add elements
                                            if (SchemaMeta.isDynamic(cType) && group != null) {
                                                cType.setParticle(group);
                                            }
                                        }
                                    }
                                }
                                if (element != null) {
                                    // check if the type is named
                                    if (typeQName != null && typeQName.getLocalPart().length() > 0) {
                                        if (cType == null) {
                                            cType = XmlSchemaUtils.makeDynamic(step, new XmlSchemaComplexType(schema));
                                            SchemaManager.makeSimpleContentExtension(step, element, cType);
                                        }
                                        if (type == null) {
                                            // the type doesn't exist, declare it
                                            cType.setName(typeQName.getLocalPart());
                                            schema.addType(cType);
                                            schema.getItems().add(cType);
                                        } else {
                                            // the type already exists, merge it
                                            XmlSchemaComplexType currentCType = (XmlSchemaComplexType) type;
                                            SchemaManager.merge(schema, currentCType, cType);
                                            cType = currentCType;
                                        }
                                        // reference the type in the current element
                                        element.setSchemaTypeName(cType.getQName());
                                        element.setSchemaType(null);
                                    } else if (cType != null && SchemaMeta.isDynamic(cType) && element.getSchemaTypeName() == null) {
                                        // the element contains an anonymous type
                                        element.setSchemaType(cType);
                                    }
                                }
                            } else {
                                XmlSchemaObject object;
                                XmlSchema xmlSchema = null;
                                if (step instanceof XMLCopyStep && !fullSchema) {
                                    final XmlSchemaBuilder fullBuilder = builderExecutor.getBuilder(projectName, true);
                                    if (fullBuilder != null) {
                                        xmlSchema = fullBuilder.getXmlSchema();
                                        XmlSchemaCollection xmlCollection = SchemaMeta.getCollection(xmlSchema);
                                        object = step.getXmlSchemaObject(xmlCollection, xmlSchema);
                                    } else {
                                        xmlSchema = schema;
                                        object = step.getXmlSchemaObject(collection, schema);
                                        SchemaMeta.setXmlSchemaObject(schema, step, object);
                                    }
                                } else {
                                    xmlSchema = schema;
                                    object = step.getXmlSchemaObject(collection, schema);
                                    SchemaMeta.setXmlSchemaObject(schema, step, object);
                                }
                                if (step instanceof XMLCopyStep) {
                                    if (object instanceof XmlSchemaElement) {
                                        XmlSchemaElement xmlSchemaElement = (XmlSchemaElement) object;
                                        QName qname = xmlSchemaElement.getSchemaTypeName();
                                        if (qname != null) {
                                            XmlSchemaType xmlSchemaType = xmlSchema.getTypeByName(qname);
                                            if (xmlSchemaType != null) {
                                                SchemaMeta.getReferencedDatabaseObjects(xmlSchemaType).add(step);
                                            }
                                        }
                                    }
                                }
                                if (object instanceof XmlSchemaParticle) {
                                    particleChildren.add((XmlSchemaParticle) object);
                                } else if (object instanceof XmlSchemaAttribute) {
                                    attributeChildren.add((XmlSchemaAttribute) object);
                                }
                            }
                        } else {
                            // re-use read only type
                            XmlSchemaElement elt = XmlSchemaUtils.makeDynamic(step, new XmlSchemaElement());
                            SchemaMeta.getReferencedDatabaseObjects(type).add(step);
                            SchemaMeta.setXmlSchemaObject(schema, step, elt);
                            elt.setName(step.getStepNodeName());
                            elt.setSchemaTypeName(typeQName);
                            particleChildren.add(elt);
                        }
                    } else // Other case
                    {
                        // doesn't generate schema, just deep walk
                        // System.out.println("-> do not generate schema (deep walk)");
                        super.walk(step);
                    }
                    // restore lists for siblings
                    particleChildren = parentParticleChildren;
                    attributeChildren = parentAttributeChildren;
                } else {
                    // just deep walk
                    super.walk(databaseObject);
                }
            }

            @Override
            protected boolean before(DatabaseObject databaseObject, Class<? extends DatabaseObject> dboClass) {
                // just walk ISchemaGenerator DBO
                return Step.class.isAssignableFrom(dboClass) || Sequence.class.isAssignableFrom(dboClass) || Transaction.class.isAssignableFrom(dboClass) || Connector.class.isAssignableFrom(dboClass);
            }
        }.init(project);
    } catch (Exception e) {
        throw new EngineException("midBuildSchema failed", e);
    }
}