org.eclipse.wst.sse.sieditor.model/api/org/eclipse/wst/sse/sieditor/command/emf/common/namespace/ImportsUpdaterUtils.java

/*******************************************************************************
 * Copyright (c) 2010 SAP AG.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Emil Simeonov - initial API and implementation.
 *    Dimitar Donchev - initial API and implementation.
 *    Dimitar Tenev - initial API and implementation.
 *    Nevena Manova - initial API and implementation.
 *    Georgi Konstantinov - initial API and implementation.
 *    Stanislav Nichev - initial API and implementation.
 *******************************************************************************/
package org.eclipse.wst.sse.sieditor.command.emf.common.namespace;

import java.util.LinkedList;
import java.util.List;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Import;
import org.eclipse.xsd.XSDImport;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDSchemaContent;

/**
 * This class has methods for updating definition schema imports.
 * 
 * 
 * 
 */
public class ImportsUpdaterUtils {

    private static final ImportsUpdaterUtils INSTANCE = new ImportsUpdaterUtils();

    private ImportsUpdaterUtils() {

    }

    public static ImportsUpdaterUtils instance() {
        return INSTANCE;
    }

    /**
     * Method for updating schema imports namespaces. This method checks all the
     * schemas contained in the given definition and updates there import
     * directives if such update is needed. Schema import directives with the
     * given oldNamespaceValue are updated
     * 
     * @param definition
     *            - the definition to update the schemas from
     * @param oldNamespaceValue
     *            - the old namespace value we are changing
     * @param newNamespaceValue
     *            - the new namespace value we are setting
     */
    @SuppressWarnings("unchecked")
    public void updateSchemaImports(final Definition difinition, final String oldNamespaceValue, final String newNamespaceValue) {

        List<XSDSchema> schemas = new LinkedList<XSDSchema>();
        if (difinition.getETypes() != null && difinition.getETypes().getSchemas() != null) {
            schemas = difinition.getETypes().getSchemas();
        }

        for (final XSDSchema schema : schemas) {
            if (newNamespaceValue != null && newNamespaceValue.equals(schema.getTargetNamespace())) {
                continue;
            }
            final EList<XSDSchemaContent> contents = schema.getContents() != null ? schema.getContents()
                    : new BasicEList<XSDSchemaContent>();

            for (final XSDSchemaContent xsdSchemaContent : contents) {
                if (xsdSchemaContent instanceof XSDImport) {
                    final XSDImport importDirective = (XSDImport) xsdSchemaContent;
                    if (shouldUpdateSchemaImportDirective(oldNamespaceValue, schema, importDirective)) {
                        importDirective.setNamespace(newNamespaceValue);
                    }
                }
            }
        }
    }

    /**
     * Utility method. Checks if the given import directive should be updated.
     * 
     * @param oldNamespaceValue
     * @param schema
     * @param importDirective
     * @return
     */
    private boolean shouldUpdateSchemaImportDirective(final String oldNamespaceValue, final XSDSchema schema,
            final XSDImport importDirective) {
        final boolean isSameSchemaLocation = importDirective.getSchemaLocation() == null
                || (importDirective.getSchemaLocation() != null && importDirective.getSchemaLocation().equals(
                        schema.getSchemaLocation()));
        return isSameSchemaLocation && (oldNamespaceValue != null && oldNamespaceValue.equals(importDirective.getNamespace()));
    }

    /**
     * Utility method. Updates all the inner schemas with the same target
     * namespace as the target namespace of the definition. It also updates the
     * schema imports
     * 
     * @param definition
     * @param oldNamespaceValue
     * @param newNamespaceValue
     */
    @SuppressWarnings("unchecked")
    public void updateContainedSchemas(final Definition definition, final String oldNamespaceValue, final String newNamespaceValue) {

        List<XSDSchema> schemas = new LinkedList<XSDSchema>();
        if (definition.getETypes() != null && definition.getETypes().getSchemas() != null) {
            schemas = definition.getETypes().getSchemas();
        }

        for (final XSDSchema schema : schemas) {
            if ((schema.getTargetNamespace() == null && oldNamespaceValue == null)
                    || (schema.getTargetNamespace() != null && schema.getTargetNamespace().equals(oldNamespaceValue))) {
                schema.setTargetNamespace(newNamespaceValue);
            } else {
                updateSchemaImports(definition, oldNamespaceValue, newNamespaceValue);
            }
        }
    }

    /**
     * Utility method. Updates all definition imports - adds prefix for each
     * imported definition, remaps message parts, operation messages, bindings,
     * etc.
     */
    @SuppressWarnings("unchecked")
    public void updateDefinitionImports(final Definition definition, final String oldNamespaceValue,
            final String newNamespaceValue) {
        final EList<Import> eImports = (definition.getEImports() == null ? new BasicEList<Import>() : definition.getEImports());

        for (final Import wsdlImport : eImports) {
            if (wsdlImport.getNamespaceURI() != null && wsdlImport.getNamespaceURI().equals(oldNamespaceValue)
                    && wsdlImport.getEDefinition() != null) {
                final String prefix = namespaceUtils().addDefinitionNamespaceMapping(definition, oldNamespaceValue);
                remapUtils()
                        .remapOperationsMessagesReferences(definition, wsdlImport.getEDefinition(), oldNamespaceValue, prefix);
                remapUtils().remapBindingsPortTypes(definition, wsdlImport.getEDefinition(), oldNamespaceValue);
                remapUtils().remapServicePortBindings(definition, wsdlImport.getEDefinition(), oldNamespaceValue);
            }
        }
    }

    // =========================================================
    // helpers
    // =========================================================

    private NamespaceMappingsUtils namespaceUtils() {
        return NamespaceMappingsUtils.instance();
    }

    private RemapReferencesUtils remapUtils() {
        return RemapReferencesUtils.instance();
    }

}