• Home
• org.openmdx
• openmdx-base
• 2.17.1
• source code
• Swagger.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.openmdx.application.rest.http.servlet.Swagger Maven / Gradle / Ivy

/*
 * ====================================================================
 * Project:     openMDX/Core, http://www.openmdx.org/
 * Description: Swagger
 * Owner:       OMEX AG, Switzerland, http://www.omex.ch
 * ====================================================================
 *
 * This software is published under the BSD license
 * as listed below.
 * 
 * Copyright (c) 2014-2016, OMEX AG, Switzerland
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 * 
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 * 
 * * Neither the name of the openMDX team nor the names of its
 *   contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * ------------------
 * 
 * This product includes software developed by other organizations as
 * listed in the NOTICE file.
 */

package org.openmdx.application.rest.http.servlet;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.servlet.http.HttpServletResponse;

import org.omg.mof.spi.Identifier;
import org.openmdx.base.exception.ServiceException;
import org.openmdx.base.json.stream.JSONArray;
import org.openmdx.base.json.stream.JSONException;
import org.openmdx.base.json.stream.JSONObject;
import org.openmdx.base.mof.cci.ModelElement_1_0;
import org.openmdx.base.mof.cci.ModelHelper;
import org.openmdx.base.mof.cci.Model_1_0;
import org.openmdx.base.mof.cci.Multiplicity;
import org.openmdx.base.mof.cci.PrimitiveTypes;
import org.openmdx.base.mof.spi.Model_1Factory;

/**
 * Swagger
 *
 */
public class Swagger {

    /**
     * Constructor 
     *
     * @param typeDef
     */
    public Swagger(
        ModelElement_1_0 typeDef
    ) {
        this.typeDef = typeDef;
    }

    /**
     * Set tags for given type.
     * 
     * @param node
     * @param typeDef
     * @param multiplicity
     * @param complexTypeAsPath
     * @param prefix
     * @throws ServiceException
     * @throws JSONException
     */
    private boolean setType(
        JSONObject node,
        ModelElement_1_0 typeDef,
        Multiplicity multiplicity,
        boolean complexTypeAsPath,
        String prefix
   ) throws ServiceException, JSONException {
        boolean isRef = false;
        ModelElement_1_0 dereferencedType = typeDef.getModel().getDereferencedType(typeDef);
        if(dereferencedType.isPrimitiveType()) {
            if(
                PrimitiveTypes.SHORT.equals(dereferencedType.getQualifiedName()) ||
                PrimitiveTypes.INTEGER.equals(dereferencedType.getQualifiedName())
            ) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Integer" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "integer");
                    node.put("format", "int32");
                }
            } else if(PrimitiveTypes.LONG.equals(dereferencedType.getQualifiedName())) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Long" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "integer");                    
                    node.put("format", "int64");
                }
            } else if(PrimitiveTypes.BOOLEAN.equals(dereferencedType.getQualifiedName())) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Boolean" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "boolean");
                }
            } else if(PrimitiveTypes.DATE.equals(dereferencedType.getQualifiedName())) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Date" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "string");
                    node.put("format", "date");
                }
            } else if(PrimitiveTypes.DATETIME.equals(dereferencedType.getQualifiedName())) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "DateTime" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "string");
                    node.put("format", "date-time");
                }
            } else if(PrimitiveTypes.DECIMAL.equals(dereferencedType.getQualifiedName())) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Decimal" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "number");
                }
            } else {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "String" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("type", "string");
                }
            }
        } else {
            if(complexTypeAsPath) {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Path" + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("$ref", (prefix == null ? "" : prefix) + "Path");
                    isRef = true;
                }
            } else {
                if(!multiplicity.isSingleValued()) {
                    node.put("$ref", (prefix == null ? "" : prefix) + dereferencedType.getQualifiedName() + LIST_SUFFIX);
                    isRef = true;
                } else {
                    node.put("$ref", (prefix == null ? "" : prefix) + dereferencedType.getQualifiedName());
                    isRef = true;
                }
            }
        }
        return isRef;
    }

    /**
     * Create new parameters.
     * 
     * @return
     * @throws JSONException
     */
    private JSONArray newQueryParameters(
    ) throws JSONException {
        JSONArray parameters = this.newParameters();
        // queryType
        {
            JSONObject queryType = new JSONObject();
            queryType.put("name", "queryType");
            queryType.put("in", "query");
            queryType.put("required", false);
            JSONObject schema = new JSONObject();
            queryType.put("schema", schema);
            schema.put("type", "string");
            parameters.put(queryType);
        }
        // query
        {
            JSONObject query = new JSONObject();
            query.put("name", "query");
            query.put("in", "query");
            query.put("required", false);
            JSONObject schema = new JSONObject();
            query.put("schema", schema);
            schema.put("type", "string");
            parameters.put(query);
        }
        // position
        {
            JSONObject position = new JSONObject();
            position.put("name", "position");
            position.put("in", "query");
            position.put("required", false);
            JSONObject schema = new JSONObject();
            position.put("schema", schema);
            schema.put("type", "integer");
            parameters.put(position);
        }
        // size
        {
        JSONObject size = new JSONObject();
            size.put("name", "size");
            size.put("in", "query");
            size.put("required", false);
            JSONObject schema = new JSONObject();
            size.put("schema", schema);
            schema.put("type", "integer");
            parameters.put(size);
        }
        // groups
        {
            JSONObject groups = new JSONObject();
            groups.put("name", "groups");
            groups.put("in", "query");
            groups.put("required", false);
            JSONObject schema = new JSONObject();
            groups.put("schema", schema);
            schema.put("type", "string");
            parameters.put(groups);
        }
        return parameters;
    }

    /**
     * Create new path parameter for the given name.
     * 
     * @param name
     * @return
     * @throws JSONException
     */
    private JSONObject newPathParameter(
        String name
    ) throws JSONException {
        JSONObject parameter = new JSONObject();
        parameter.put("name", name);
        parameter.put("in", "path");
        parameter.put("required", true);
        JSONObject schema = new JSONObject();
        parameter.put("schema", schema);
        schema.put("type", "string");
        return parameter;
    }

    /**
     * Create new request body for given name and type.
     * 
     * @param description
     * @param typeDef
     * @return
     * @throws JSONException
     * @throws ServiceException
     */
    private JSONObject newRequestBody(
        String description,
        ModelElement_1_0 typeDef,
        Map collectedTypeDefs
    ) throws JSONException, ServiceException {
        Model_1_0 model = typeDef.getModel();
        List subtypeDefs = new ArrayList();
        for(Object subtype: typeDef.objGetSet("allSubtype")) {
            ModelElement_1_0 subtypeDef = model.getElement(subtype);
            if(!Boolean.TRUE.equals(subtypeDef.isAbstract())) {
                subtypeDefs.add(subtypeDef);
            }
        }
        if(typeDef.isStructureType()) {
            this.collectNestedTypeDefs(
                typeDef,
                collectedTypeDefs
            );
        }
        JSONObject requestBody = new JSONObject();
        requestBody.put("description", description);
        requestBody.put("required", true);
        JSONObject content = new JSONObject();
        requestBody.put("content", content);
        JSONObject schema = new JSONObject();
        if(subtypeDefs.size() == 1) {
            schema.put("$ref", "#/components/schemas/" + typeDef.getQualifiedName() + TYPE_SUFFIX);
        } else {
            JSONArray oneOf = new JSONArray();
            for(ModelElement_1_0 subTypeDef: subtypeDefs) {
                JSONObject type = new JSONObject();
                type.put("$ref", "#/components/schemas/" + subTypeDef.getQualifiedName() + TYPE_SUFFIX);
                oneOf.put(type);
            }
            schema.put("oneOf", oneOf);
        }
        JSONObject applicationJson = new JSONObject();
        applicationJson.put("schema", schema);
        content.put("application/json", applicationJson);
        JSONObject applicationXml = new JSONObject();
        applicationXml.put("schema", schema);
        content.put("application/xml", applicationXml);
        requestBody.put("content", content);
        return requestBody;
    }

    /**
     * Create new operation with given tags.
     * 
     * @param operationId
     * @param description
     * @param tags
     * @param parameters
     * @param responses
     * @return
     * @throws JSONException
     */
    private JSONObject newOperation(
        String operationId,
        String description,
        JSONArray tags,
        JSONArray parameters,
        JSONObject requestBody,
        JSONObject responses
    ) throws JSONException {
        JSONObject operation = new JSONObject();
        operation.put("description", description);
        operation.put("operationId", operationId);
        operation.put("tags", tags);
        if(parameters != null) {
            operation.put("parameters", parameters);
        }
        if(requestBody != null) {
            operation.put("requestBody", requestBody);
        }
        operation.put("responses", responses);             
        return operation;
    }

    /**
     * Collect nested types for given structDef
     * 
     * @param structDef
     * @param collectedTypeDefs
     * @throws ServiceException
     */
    private void collectNestedTypeDefs(
        ModelElement_1_0 structDef,
        Map collectedTypeDefs
    ) throws ServiceException {
        Model_1_0 model = structDef.getModel();
        if(structDef.isStructureType()) {
            for(Object field: structDef.objGetMap("field").values()) {
                ModelElement_1_0 fieldDef = model.getElement(field);
                if(fieldDef.isStructureFieldType()) { 
                    ModelElement_1_0 fieldDefType = model.getDereferencedType(fieldDef.getType());
                    if(!fieldDefType.isPrimitiveType()) {
                        collectedTypeDefs.put(
                            fieldDefType.jdoGetObjectId(),
                            fieldDefType
                        );
                    }
                    if(fieldDefType.isStructureType()) {
                        this.collectNestedTypeDefs(
                            fieldDefType,
                            collectedTypeDefs
                        );
                    }
                }
            }
        }
    }

    /**
     * Create response element for given type.
     * 
     * @param typeDef
     * @param multiplicity
     * @return
     * @throws ServiceException
     * @throws JSONException
     */
    private JSONObject newObjectResponse(
        ModelElement_1_0 typeDef,
        String description,
        Multiplicity multiplicity,
        Map collectedTypeDefs
    ) throws ServiceException, JSONException {
        JSONObject response = new JSONObject();
        JSONObject content = new JSONObject();
        JSONObject applicationJson = new JSONObject();
        JSONObject applicationXml = new JSONObject();
        JSONObject schema = new JSONObject();
        if(multiplicity == Multiplicity.LIST) {
            schema.put("$ref", "#/components/schemas/" + typeDef.getQualifiedName() + LIST_SUFFIX);
        } else {
            List subtypeDefs = new ArrayList();
            Model_1_0 model = typeDef.getModel();
            for(Object subtype: typeDef.objGetSet("allSubtype")) {
                ModelElement_1_0 subtypeDef = model.getElement(subtype);
                if(!Boolean.TRUE.equals(subtypeDef.isAbstract())) {
                    subtypeDefs.add(subtypeDef);
                    collectedTypeDefs.put(subtypeDef.jdoGetObjectId(), subtypeDef);
                }
            }
            if(typeDef.isStructureType()) {
                this.collectNestedTypeDefs(
                    typeDef,
                    collectedTypeDefs
                );
            }
            JSONArray oneOf = new JSONArray();
            for(ModelElement_1_0 subTypeDef: subtypeDefs) {
                JSONObject type = new JSONObject();
                this.setType(
                    type, 
                    subTypeDef, 
                    Multiplicity.SINGLE_VALUE, 
                    false, 
                    "#/components/schemas/"
                );
                oneOf.put(type);
            }
            schema.put("oneOf", oneOf);
            JSONObject discriminator = new JSONObject();
            discriminator.put("propertyName", TYPE_PROPERTY);
            schema.put("discriminator", discriminator);
        }
        applicationJson.put("schema", schema);
        content.put("application/json", applicationJson);
        applicationXml.put("schema", schema);
        content.put("application/xml", applicationXml);
        response.put("content", content);
        response.put("description", description);
        return response;
    }

    /**
     * Create new StackTrace response.
     * 
     * @return
     * @throws ServiceException
     * @throws JSONException
     */
    private JSONObject newErrorResponse(
        String description
    ) throws ServiceException, JSONException {
        JSONObject response = new JSONObject();
        response.put("description", description);
        return response;
    }

    /**
     * Create empty response element.
     * 
     * @return
     * @throws JSONException
     */
    private JSONObject newResponse(
    ) throws JSONException {
        return new JSONObject();
    }

    /**
     * Create empty parameters element.
     * 
     * @return
     * @throws JSONException
     */
    private JSONArray newParameters(
    ) throws JSONException {
        return new JSONArray();
    }

    /**
     * Create empty tags element.
     * 
     * @return
     */
    private JSONArray newTags(
    ) {
        return new JSONArray();
    }

    /**
     * Create the definition for the given type.
     * 
     * @param typeDef
     * @param withDiscriminator
     * @param subTypes
     * @param excludeProperties
     * @return
     * @throws JSONException
     * @throws ServiceException
     */
    private JSONObject newDefinition(
        ModelElement_1_0 typeDef,
        JSONArray subTypes,
        Set excludeProperties
    ) throws JSONException, ServiceException {
        Model_1_0 model = typeDef.getModel();
        JSONObject typeDefinition = new JSONObject();
        JSONObject properties = new JSONObject();
        Collection elements = null;
        if(typeDef.isStructureType()) {
            elements = typeDef.objGetMap("field").values();
        } else {
            elements = new TreeMap(
                model.getStructuralFeatureDefs(
                    typeDef, 
                    true, // includeSubtypes
                    true, // includeDerived
                    false // attributesOnly
                    )
                ).values();
        }
        JSONArray required = new JSONArray();
        for(Object element: elements) {
            ModelElement_1_0 elementDef = model.getElement(element);
            if(
                elementDef.isStructureFieldType() || 
                elementDef.isAttributeType() ||
                elementDef.isReferenceStoredAsAttribute()
            ) {
                JSONObject property = new JSONObject();
                try {
                    ModelElement_1_0 elementTypeDef = model.getDereferencedType(elementDef.getType());
                    boolean isRef = this.setType(
                        property,
                        elementTypeDef,
                        ModelHelper.getMultiplicity(elementDef),
                        !elementTypeDef.isStructureType(),
                        "#/components/schemas/"
                    );
                    boolean isReadOnly = 
                        !elementDef.isStructureFieldType() && 
                        !ModelHelper.isChangeable(elementDef);
                    if(!isRef) {
                        property.put("readOnly", isReadOnly);
                        property.put("description", "«" + ModelHelper.getMultiplicity(elementDef).code()  + "» " + elementTypeDef.getQualifiedName() + "");
                    }
                    if(!excludeProperties.contains(elementDef.getName())) {
                        properties.put(
                            elementDef.getName(), 
                            property
                        );
                        if(
                            ModelHelper.getMultiplicity(elementDef) == Multiplicity.SINGLE_VALUE && 
                            !isReadOnly
                        ) {
                        }
                    }
                } catch(Exception e) {
                    new ServiceException(e).log();
                }
            }
        }
        {
            // @type
            {
                JSONObject property = new JSONObject();
                property.put("type", "string");
                if(subTypes != null && subTypes.length() > 0) {
                    property.put("enum", subTypes);
                }
                if(!excludeProperties.contains(TYPE_PROPERTY)) {
                    properties.put(TYPE_PROPERTY, property);
                }
            }
            // @id
            {
                JSONObject property = new JSONObject();
                property.put("type", "string");
                if(!excludeProperties.contains(ID_PROPERTY)) {
                    properties.put(ID_PROPERTY, property);
                }
            }
            // @href
            {
                JSONObject property = new JSONObject();
                property.put("type", "string");
                if(!excludeProperties.contains(HREF_PROPERTY)) {
                    properties.put(HREF_PROPERTY, property);
                }
            }
            if(!typeDef.isStructureType()) {
                // @version
                {
                    JSONObject property = new JSONObject();
                    property.put("type", "string");
                    if(!excludeProperties.contains(VERSION_PROPERTY)) {
                        properties.put(VERSION_PROPERTY, property);
                    }
                }
            }
        }
        typeDefinition.put("properties", properties);
        if(required.length() > 0) {
            typeDefinition.put("required", required);
        }
        return typeDefinition;
    }

    /**
     * Create all definitions for the given type and its sub-types.
     * 
     * @param typeDef
     * @param withDiscriminator
     * @param definitions
     * @param excludeProperties
     * @throws JSONException
     * @throws ServiceException
     */
    private void putAllDefinitions(
        ModelElement_1_0 typeDef,
        JSONObject definitions,
        Set excludeProperties
    ) throws JSONException, ServiceException {
        Model_1_0 model = typeDef.getModel();
        Set