Subversion Repositories XServices

/*
 *   Copyright 2014 Brian Rosenberger (Brutex Network)
 *
 *   Licensed 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 net.brutex.xservices.ws.rs;



import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.nio.file.FileVisitOption;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.configuration2.PropertiesConfiguration;
import org.apache.commons.configuration2.builder.fluent.Configurations;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.commons.jcs.JCS;
import org.apache.commons.jcs.access.CacheAccess;
import org.apache.commons.jcs.access.exception.CacheException;


import net.brutex.xservices.cmtypes.ItemType;
import net.brutex.xservices.cmtypes.ItemTypeList;
import net.brutex.xservices.types.FileInfoType;
import net.brutex.xservices.util.FileWalker;



/*
 * The Serena Dimensions CM Java API is required for these imports.
 * The API is not included in this package due to copyright reasons,
 * please get Dimensions CM from Serena Software Inc., Evaluation versions
 * are available from http://www.serena.com
 * 
 * required Jars:
 * serena.darius-14.1.jar
 * serena.dmclient-14.1.jar
 * serena.dmfile-14.1.jar
 * serena.dmnet-14.1.jar
 * serena.dmtpi-14.1.jar
 * 
 */

import com.serena.dmclient.api.BulkOperator;
import com.serena.dmclient.api.DimensionsConnection;
import com.serena.dmclient.api.DimensionsConnectionDetails;
import com.serena.dmclient.api.DimensionsConnectionManager;
import com.serena.dmclient.api.ItemRevision;
import com.serena.dmclient.api.Project;
import com.serena.dmclient.api.RepositoryFolder;
import com.serena.dmclient.api.SystemAttributes;

/**
 * The Class FileInfoImpl.
 * 
 * @author Brian Rosenberger, bru(at)brutex.de
 */
@Slf4j
public class DIMCMInfoImpl implements DIMCMInfo {


        /*
         * (non-Javadoc)
         * 
         * @see
         * net.brutex.xservices.ws.rs.FileInfo#getFiles(javax.ws.rs.core.HttpHeaders
         * , java.lang.String, boolean, boolean, int, java.lang.String, int, int)
         */
        public Response getFiles(HttpHeaders h, UriInfo uriInfo, String projSpec,
                        String directory, boolean recursive, boolean withFiles, int level,
                        String search, int count, int page, boolean useCache) throws CacheException {

                
                /*
                 * try to hit cache first
                 */
                CacheAccess<Object, Object> cache = JCS.getInstance("DIMCM");
                String cachekey = projSpec + directory + String.valueOf(recursive);
                if(useCache) {
                                ItemTypeList cacheresult = (ItemTypeList) cache.get(cachekey);
                                if(cacheresult != null) return Response.ok(cacheresult).build();
                }
                
                //Reject when project has not the form "PRODUCT:PROJECT"
                if(! projSpec.contains(":")) return Response.noContent().build();
                
                Project project = getDIMCMConnection().getObjectFactory().getProject(projSpec);
                RepositoryFolder folder = null;
                
                if (directory == null) {
                        folder = project.getRootFolder();
                } else {
                        while(directory.startsWith("/") || directory.startsWith("\\")) {
                                directory = directory.substring(1);
                        }
                        if(directory.equals("")) {
                                folder = project.getRootFolder();
                        } else {
                                folder = project.findRepositoryFolderByPath(directory);
                        }
                }

                
                ItemTypeList resultlist = new ItemTypeList();
                resultlist.list = getItems(folder, recursive);
                if(cache!=null) cache.put(cachekey, resultlist);
                
                //does this help?
                DimensionsConnectionManager.unregisterThreadConnection();
                
                return Response.ok(resultlist).build();

        }

        
        
        
        List<ItemType> getItems(RepositoryFolder f, boolean recursive) {
                DimensionsConnection conn = getDIMCMConnection();
                List<ItemType> result = new ArrayList<>();

                /* get Items from current folder */
                /* latest revision only */
                List<ItemRevision> revisions = f.getLatestItemRevisions();

                int[] attr = { SystemAttributes.FULL_PATH_NAME,
                                SystemAttributes.ITEMFILE_DIR,
                                SystemAttributes.ITEMFILE_FILENAME,
                                SystemAttributes.ITEMFILE_DIR, SystemAttributes.OBJECT_SPEC,
                                SystemAttributes.OBJECT_ID, SystemAttributes.OBJECT_SPEC_UID,
                                SystemAttributes.OBJECT_UID, SystemAttributes.CREATION_DATE,
                                SystemAttributes.CREATION_USER, SystemAttributes.ITEM_FORMAT,
                                SystemAttributes.LAST_UPDATED_DATE,
                                SystemAttributes.LAST_UPDATED_USER };
                BulkOperator bulk = conn.getObjectFactory().getBulkOperator(revisions);
                bulk.queryAttribute(attr);

                // Copy into JAXB object
                for (ItemRevision r : revisions) {
                        ItemType item = new ItemType();
                        item.setLongFilename((String) r
                                        .getAttribute(SystemAttributes.FULL_PATH_NAME));
                        item.setDirName((String) r
                                        .getAttribute(SystemAttributes.ITEMFILE_DIR));
                        item.setShortFilename((String) r
                                        .getAttribute(SystemAttributes.ITEMFILE_FILENAME));
                        item.setObject_id((String) r
                                        .getAttribute(SystemAttributes.OBJECT_ID));
                        item.setObject_uid((String.valueOf(r
                                        .getAttribute(SystemAttributes.OBJECT_UID))));
                        item.setObject_spec((String) r
                                        .getAttribute(SystemAttributes.OBJECT_SPEC));
                        item.setObject_spec_uid(String.valueOf(r
                                        .getAttribute(SystemAttributes.OBJECT_SPEC_UID)));
                        item.setObject_spec_uid(String.valueOf(r
                                        .getAttribute(SystemAttributes.OBJECT_SPEC_UID)));
                        item.setCreatedDate(String.valueOf(r
                                        .getAttribute(SystemAttributes.CREATION_DATE)));
                        item.setCreatedUser(String.valueOf(r
                                        .getAttribute(SystemAttributes.CREATION_USER)));
                        item.setItemFormat(String.valueOf(r
                                        .getAttribute(SystemAttributes.ITEM_FORMAT)));
                        item.setUpdatedDate(String.valueOf(r
                                        .getAttribute(SystemAttributes.LAST_UPDATED_DATE)));
                        item.setUpdatedUser(String.valueOf(r
                                        .getAttribute(SystemAttributes.LAST_UPDATED_USER)));

                        try {
                                item.setUrl(new URL(getBaseURL()
                                                + "?jsp=api&command=openi&object_id="
                                                + item.getObject_spec() + "&DB_CONN="
                                                + conn.getConnectionDetails().getDbConn() + "&DB_NAME="
                                                + conn.getConnectionDetails().getDbName()));
                        } catch (MalformedURLException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        result.add(item);
                }
                
                /*
                 * for recursive add other folders
                 */
                if(recursive) {
                        List<RepositoryFolder> folders = f.getAllChildFolders();
                        for(RepositoryFolder ff : folders) {
                                result.addAll(getItems(ff, false));
                        }
                }
                
                return result;
        }

        /**
         * Sets the directory.
         * 
         * @param list
         *            the list
         * @param dir
         *            the dir
         * @param withDirectories
         *            the with directories
         * @param withFiles
         *            the with files
         * @param depth
         *            the depth
         * @param search
         *            the search
         */
        private void setDirectory(final URI baseuri, final List<FileInfoType> list,
                        File dir, boolean withDirectories, boolean withFiles,
                        final int depth, String search) {
                if (depth <= 0)
                        return;

                if (search == null || search.equals("")) {
                        search = "*";
                        log.info("No search pattern supplied, using default '*'.");
                }

                FileWalker finder = new FileWalker(search);
                try {
                        Files.walkFileTree(dir.toPath(),
                                        EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);
                        log.info("FileWalker returned '" + finder.getCount()
                                        + "' hits. '" + finder.getTotal()
                                        + "' files have been scanned.");
                        List<Path> result = finder.getResult();
                        for (Path f : result) {
                                if (!withDirectories) {
                                        if (f.toFile().isDirectory())
                                                continue;
                                }
                                if (!withFiles) {
                                        if (f.toFile().isFile())
                                                continue;
                                }
                                list.add(new FileInfoType(f, baseuri));
                        }
                } catch (IOException e2) {
                        log.error(e2.getMessage(), e2);
                        ;
                }
        }

        /**
         * Sets the directory.
         * 
         * @param dir
         *            the dir
         * @param withDirectories
         *            the with directories
         * @param withFiles
         *            the with files
         * @param depth
         *            the depth
         * @param search
         *            the search
         * @return the list
         */
        private List<FileInfoType> setDirectory(URI baseuri, String dir,
                        boolean withDirectories, boolean withFiles, int depth, String search) {
                List<FileInfoType> list = new ArrayList<FileInfoType>();
                setDirectory(baseuri, list, new File(dir), withDirectories, withFiles,
                                depth, search);
                return list;
        }

        private boolean isPermitted(String dir) {
                /*
                 * 
                 * logger.warn(String.format(
                 * "User '%s' does not have permission to access '%s'."
                 * ,SecurityUtils.getSubject().getPrincipal(), dir )); throw new
                 * NotAuthorizedException(new
                 * UnauthorizedException("User does not have permission to access "+
                 * dir)); }
                 */
                return true;
        }

        // http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
        private static String humanReadableByteCount(long bytes, boolean si) {
                int unit = si ? 1000 : 1024;
                if (bytes < unit)
                        return bytes + " B";
                int exp = (int) (Math.log(bytes) / Math.log(unit));
                String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp - 1)
                                + (si ? "" : "i");
                return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
        }

        private DimensionsConnection getDIMCMConnection() {
                /*
                 * Do we have a registered connection already?
                 */
                DimensionsConnection conn = null;
                
                try {
                        conn = DimensionsConnectionManager.getThreadConnection();
                        if (conn != null)
                                return conn;
                } catch (Exception e) {
                        log.error(e.getMessage());
                }

                /*
                 * Create a new connection from property file
                 */
                PropertiesConfiguration props;
                try {
                        
                        props = new Configurations().properties(this.getClass()
                                        .getClassLoader().getResource("/../dimcm.properties"));
                } catch (ConfigurationException e) {
                        e.printStackTrace();
                        return null;
                }

                DimensionsConnectionDetails details = new DimensionsConnectionDetails();
                details.setUsername(props.getString("user"));
                details.setPassword(props.getString("password"));
                details.setDbName(props.getString("dbname"));
                details.setDbConn(props.getString("dbconn"));
                details.setServer(props.getString("server"));
                conn = DimensionsConnectionManager.getConnection(details);
                DimensionsConnectionManager.registerThreadConnection(conn);
                return conn;
        }

        private String getBaseURL() {
                final String CACHE_BASEURL = "DIMCM.conf.baseurl";
        try {
                CacheAccess<Object, Object> cache = JCS.getInstance("DIMCM");
                String baseurl = (String) cache.get(CACHE_BASEURL);
                if(baseurl != null) return baseurl;
                
                Configurations configs = new Configurations();
                
                PropertiesConfiguration props = configs.properties((this.getClass().getClassLoader().getResource("/../dimcm.properties")));
                baseurl = props.getString("baseurl");
                cache.put(CACHE_BASEURL, baseurl);
                return baseurl;
                
        } catch (CacheException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
                return null;
        } catch (ConfigurationException e) {
                e.printStackTrace();
                return null;
                
        }
}
}