org.apache.chemistry.opencmis.server.impl.CallContextImpl Maven / Gradle / Ivy

Go to download
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.chemistry.opencmis.server.impl;

import java.io.File;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.chemistry.opencmis.commons.enums.CmisVersion;
import org.apache.chemistry.opencmis.commons.server.CallContext;
import org.apache.chemistry.opencmis.commons.server.CmisServiceFactory;
import org.apache.chemistry.opencmis.commons.server.MutableCallContext;
import org.apache.chemistry.opencmis.server.shared.TempStoreOutputStreamFactory;

/**
 * Implementation of the {@link CallContext} interface.
 */
public class CallContextImpl implements MutableCallContext, Serializable {

    private static final long serialVersionUID = 1L;

    private final String binding;
    private final boolean objectInfoRequired;
    private final Map parameter = new HashMap();

    public CallContextImpl(String binding, CmisVersion cmisVersion, String repositoryId, ServletContext servletContext,
            HttpServletRequest request, HttpServletResponse response, CmisServiceFactory factory,
            TempStoreOutputStreamFactory streamFactory) {
        this.binding = binding;
        this.objectInfoRequired = BINDING_ATOMPUB.equals(binding);
        put(REPOSITORY_ID, repositoryId);

        // CMIS version
        if (cmisVersion == null) {
            throw new IllegalArgumentException("CMIS version must be set!");
        }
        put(CallContext.CMIS_VERSION, cmisVersion);

        // servlet context and HTTP servlet request and response
        put(CallContext.SERVLET_CONTEXT, servletContext);
        put(CallContext.HTTP_SERVLET_REQUEST, request);
        put(CallContext.HTTP_SERVLET_RESPONSE, response);

        if (factory != null) {
            put(TEMP_DIR, factory.getTempDirectory());
            put(MEMORY_THRESHOLD, factory.getMemoryThreshold());
            put(MAX_CONTENT_SIZE, factory.getMaxContentSize());
            put(ENCRYPT_TEMP_FILE, factory.encryptTempFiles());
            put(STREAM_FACTORY, streamFactory);
        }
    }

    public void setRange(String rangeHeader) {
        if (rangeHeader == null) {
            return;
        }

        remove(OFFSET);
        remove(LENGTH);

        rangeHeader = rangeHeader.replaceAll("\\s", "").toLowerCase(Locale.ENGLISH);

        if (rangeHeader.length() > 6 && rangeHeader.startsWith("bytes=") && rangeHeader.indexOf(',') == -1
                && rangeHeader.charAt(6) != '-') {
            BigInteger offset = null;
            BigInteger length = null;

            int ds = rangeHeader.indexOf('-');
            if (ds > 6) {
                try {
                    String firstBytePosStr = rangeHeader.substring(6, ds);
                    if (firstBytePosStr.length() > 0) {
                        offset = new BigInteger(firstBytePosStr);
                    }

                    if (!rangeHeader.endsWith("-")) {
                        String lastBytePosStr = rangeHeader.substring(ds + 1);
                        if (offset == null) {
                            length = (new BigInteger(lastBytePosStr)).add(BigInteger.ONE);
                        } else {
                            length = (new BigInteger(lastBytePosStr)).subtract(offset).add(BigInteger.ONE);
                        }
                    }

                    if (offset != null) {
                        put(OFFSET, offset);
                    }
                    if (length != null) {
                        put(LENGTH, length);
                    }
                } catch (NumberFormatException e) {
                    // invalid Range header must be ignored
                }
            }
        }
    }

    public void setAcceptLanguage(String acceptLanguageHeader) {
        if (acceptLanguageHeader == null) {
            return;
        }

        remove(LOCALE_ISO639_LANGUAGE);
        remove(LOCALE_ISO3166_COUNTRY);
        remove(LOCALE);

        double lastQ = 0;
        String language = null;
        String country = null;

        String[] languageHeader = acceptLanguageHeader.split(",");
        for (String languageRange : languageHeader) {
            String langRange = languageRange.trim();
            double currentQ = 0;

            int x = langRange.indexOf(';');
            if (x > -1) {
                String qStr = langRange.substring(x + 1).replaceAll("\\s", "").toLowerCase(Locale.ENGLISH);
                if (!qStr.startsWith("q=") && qStr.length() < 3) {
                    continue;
                }
                currentQ = Double.parseDouble(qStr.substring(2));
                langRange = langRange.substring(0, x);
            } else {
                currentQ = 1;
            }

            if (currentQ <= lastQ) {
                continue;
            } else {
                lastQ = currentQ;
            }

            String[] locale = langRange.split("-");
            String locale0 = locale[0].trim();

            language = null;
            country = null;

            if (!locale0.equals("*")) {
                language = locale0;
                if (locale.length > 1) {
                    String locale1 = locale[1].trim();
                    if (!locale1.equals("*")) {
                        country = locale1;
                    }
                }
            }

            if (currentQ >= 1) {
                break;
            }
        }

        if (language != null) {
            put(LOCALE_ISO639_LANGUAGE, language);
            put(LOCALE, language);
        }

        if (country != null) {
            put(LOCALE_ISO3166_COUNTRY, country);
            put(LOCALE, language + "-" + country);
        }
    }

    @Override
    public String getBinding() {
        return binding;
    }

    @Override
    public boolean isObjectInfoRequired() {
        return objectInfoRequired;
    }

    @Override
    public Object get(String key) {
        return parameter.get(key);
    }

    @Override
    public CmisVersion getCmisVersion() {
        return (CmisVersion) get(CMIS_VERSION);
    }

    @Override
    public String getRepositoryId() {
        return (String) get(REPOSITORY_ID);
    }

    @Override
    public String getUsername() {
        return (String) get(USERNAME);
    }

    @Override
    public String getPassword() {
        return (String) get(PASSWORD);
    }

    @Override
    public String getLocale() {
        return (String) get(LOCALE);
    }

    @Override
    public BigInteger getOffset() {
        return (BigInteger) get(OFFSET);
    }

    @Override
    public BigInteger getLength() {
        return (BigInteger) get(LENGTH);
    }

    @Override
    public File getTempDirectory() {
        return (File) get(TEMP_DIR);
    }

    @Override
    public boolean encryptTempFiles() {
        return Boolean.TRUE.equals(get(ENCRYPT_TEMP_FILE));
    }

    @Override
    public int getMemoryThreshold() {
        return (Integer) get(MEMORY_THRESHOLD);
    }

    @Override
    public long getMaxContentSize() {
        return (Long) get(MAX_CONTENT_SIZE);
    }

    @Override
    public final void put(String key, Object value) {
        parameter.put(key, value);
    }

    @Override
    public final Object remove(String key) {
        return parameter.remove(key);
    }
}