org.giavacms.base.common.util.ResourceUtils Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of base Show documentation
GiavaCMS Content Management System: Base Subsystem
The newest version!
/*
 * Copyright 2013 GiavaCms.org.
 *
 * Licensed under the Eclipse Public License version 1.0, available at
 * http://www.eclipse.org/legal/epl-v10.html
 */
package org.giavacms.base.common.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.faces.context.FacesContext;
import javax.imageio.stream.FileImageOutputStream;
import javax.servlet.ServletContext;

import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.AndFileFilter;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.NotFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.giavacms.base.model.enums.ResourceType;
import org.jboss.logging.Logger;

public class ResourceUtils
{

   protected static Logger logger = Logger
            .getLogger(ResourceUtils.class.getName());

   static String beginRegExpr = "/(\\.|\\/)(";
   static String separatorRegExpr = "|";
   static String endRegExpr = ")$/";

   public static String ALL = "ALL";

   public static String getRegExpByTypes(String[] types)
   {
      StringBuffer result = new StringBuffer(separatorRegExpr);
      for (String type : types)
      {
         try
         {
            ResourceType resourceType = ResourceType.valueOf(type);
            switch (resourceType)
            {
            case ALL:
               for (ResourceType anyType : ResourceType.values())
               {
                  for (String extension : anyType.getExtensions())
                  {
                     result.append(separatorRegExpr + extension);
                     result.append(separatorRegExpr + extension.toUpperCase());
                  }
               }
               break;
            default:
               for (String extension : resourceType.getExtensions())
               {
                  result.append(separatorRegExpr + extension);
                  result.append(separatorRegExpr + extension.toUpperCase());
               }
               break;
            }
         }
         catch (Exception e)
         {
            logger.error(e.getMessage(), e);
            continue;
         }
      }
      if (result.length() > separatorRegExpr.length())
      {
         return beginRegExpr
                  + (result.toString().substring(1).concat(endRegExpr));
      }
      logger.info("nessun tipo corrispondente");
      return "";
   }

   public static List getFilesName(String directory,
            List extensions)
   {
      File rootDir = new File(getRealPath() + directory);
      IOFileFilter filesFilter = new SuffixFileFilter(extensions, IOCase.INSENSITIVE);
      IOFileFilter notDirectory = new NotFileFilter(
               DirectoryFileFilter.INSTANCE);
      FilenameFilter fileFilter = new AndFileFilter(filesFilter, notDirectory);
      String[] resultFiles = rootDir.list(fileFilter);
      Arrays.sort(resultFiles);
      if (resultFiles.length > 0)
      {
         return Arrays.asList(resultFiles);
      }
      return new ArrayList();
   }

   public static String getType(String fileName)
   {
      String type = fileName.substring(fileName.lastIndexOf(".") + 1);
      for (ResourceType resourceType : ResourceType.values())
      {
         if (resourceType.getExtensions().contains(type.toLowerCase()))
         {
            return resourceType.name();
         }
      }
      return null;
   }

   public static String getFolder(String fileName)
   {
      String type = fileName.substring(fileName.lastIndexOf(".") + 1);
      for (ResourceType resourceType : ResourceType.values())
      {
         if (resourceType.getExtensions().contains(type.toLowerCase()))
         {
            return resourceType.getFolder();
         }
      }
      return null;
   }

   // pdf, p7m, doc, docx, xls, xlsx
   public static List getPdfFiles()
   {
      return getFilesName(ResourceType.DOCUMENT.getFolder(), ResourceType.DOCUMENT.getExtensions());
   }

   public static List getCssFiles()
   {
      return getFilesName(ResourceType.STYLESHEET.getFolder(), ResourceType.STYLESHEET.getExtensions());
   }

   public static List getJsFiles()
   {
      return getFilesName(ResourceType.JAVASCRIPT.getFolder(), ResourceType.JAVASCRIPT.getExtensions());
   }

   public static List getImgFiles()
   {
      return getFilesName(ResourceType.IMAGE.getFolder(), ResourceType.IMAGE.getExtensions());
   }

   public static List getFlashFiles()
   {
      return getFilesName(ResourceType.FLASH.getFolder(), ResourceType.FLASH.getExtensions());
   }

   public static List getFontFiles()
   {
      return getFilesName(ResourceType.FONT.getFolder(), ResourceType.FONT.getExtensions());
   }

   public static String createImage_(String folder, String imageFileName,
            byte[] data)
   {
      try
      {
         String actualFileName = getUniqueName(getRealPath() + folder,
                  imageFileName);
         FileImageOutputStream imageOutput;
         imageOutput = new FileImageOutputStream(new File(actualFileName));
         imageOutput.write(data, 0, data.length);
         imageOutput.close();
         return actualFileName.substring(actualFileName
                  .lastIndexOf(File.separator) + 1);
      }
      catch (FileNotFoundException e)
      {
         e.printStackTrace();
         return null;
      }
      catch (IOException e)
      {
         e.printStackTrace();
         return null;
      }
   }

   public static String createFile_(String folder, String fileName, byte[] data)
   {
      try
      {
         String actualFileName = getUniqueName(getRealPath() + folder,
                  fileName);
         FileOutputStream fos = new FileOutputStream(
                  new File(actualFileName));
         fos.write(data);
         fos.close();
         return actualFileName.substring(actualFileName
                  .lastIndexOf(File.separator) + 1);
      }
      catch (Exception e)
      {
         e.printStackTrace();
         return null;
      }
   }

   public static String getUniqueName(String folder, String fileName)
   {
      String est = fileName.substring(fileName.indexOf(".") + 1);
      String nome = fileName.substring(0, fileName.indexOf(".")).replaceAll(
               " ", "");
      String finalName = fileName.replaceAll(" ", "");
      boolean trovato = false;
      int i = 0;
      while (!trovato)
      {
         logger.info("finalName: " + finalName);
         File file = new File(folder + File.separator + finalName);
         logger.info("found: " + finalName);
         if (file != null && file.exists())
         {
            i++;
            finalName = nome + "_" + i + "." + est;
         }
         else
         {
            trovato = true;
            return folder + File.separator + finalName;
         }
      }
      return folder + File.separator + finalName;
   }

   public static String getRealPath()
   {
      ServletContext servletContext = (ServletContext) FacesContext
               .getCurrentInstance().getExternalContext().getContext();
      String folder = servletContext.getRealPath("") + File.separator;
      return folder;
   }

   public static String getFileContent(String fileName)
   {
      // TODO Auto-generated method stub
      return null;
   }

   public static void main(String[] args)
   {
      String type = getType("flower.png");
      logger.info(type);
   }
}