Subversion Repositories general

package ak.photoalbum.webapp;

import java.util.List;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.StringTokenizer;

import java.io.File;

import java.io.IOException;

import java.io.FileInputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.io.FileNotFoundException;

import java.net.URLEncoder;

import org.apache.log4j.Logger;

import ak.photoalbum.images.Thumbnailer;

import ak.photoalbum.images.ThumbnailPosition;

import ak.photoalbum.util.FileUtils;

import ak.photoalbum.util.FileNameComparator;

import ak.photoalbum.util.ImagesFilter;

public class Logic

{

  protected static final int    DEFAULT_COLUMNS = 4;

  protected static final String URL_ENCODING    = "UTF-8";

  protected Logger       logger;

  protected Thumbnailer  thumbnailer;

  protected File         imagesRoot;

  protected int          columns            = DEFAULT_COLUMNS;

  protected ImagesFilter imagesFilter;

  protected Comparator   fileNameComparator = new FileNameComparator(true);

  protected Logic()

  {

    this.logger = Logger.getLogger(this.getClass());

  }

  public void init(String imagesRoot, String imagesMask,

    String cacheDir, String thumbnailFormat,

    Integer smallWidth, Integer smallHeight,

    Integer mediumWidth, Integer mediumHeight, Integer columns,

    String  dirTemplate, String  dirThumbnailPositions)

  {

    this.imagesRoot   = new File(imagesRoot);

    this.imagesFilter = new ImagesFilter(imagesMask);

    if(columns != null) this.columns = columns.intValue();

    this.thumbnailer = new Thumbnailer();

    this.thumbnailer.setImagesRoot(this.imagesRoot);

    this.thumbnailer.setCacheDir(new File(cacheDir));

    if(thumbnailFormat != null)

      this.thumbnailer.setFormat(thumbnailFormat);

    if(smallWidth != null)

      this.thumbnailer.setSmallWidth(smallWidth.intValue());

    if(smallHeight != null)

      this.thumbnailer.setSmallHeight(smallHeight.intValue());

    if(mediumWidth != null)

      this.thumbnailer.setMediumWidth(mediumWidth.intValue());

    if(mediumHeight != null)

      this.thumbnailer.setMediumHeight(mediumHeight.intValue());

    thumbnailer.setResizer(new ak.photoalbum.images.jiu.JiuResizer());

    thumbnailer.setImagesFilter(this.imagesFilter);

    thumbnailer.setDirTemplate(new File(dirTemplate));

    thumbnailer.setDirThumbnailPositions(

      parseThumbnailPositions(dirThumbnailPositions));

    try {

      thumbnailer.startup();

    }

    catch(Exception ex) {

      logger.error("init thumbnailer", ex);

    }

    logger.info("started");

  }

  public void buildCache()

    throws IOException

  {

    thumbnailer.buildCache();

  }

  public void getEntry(String path, IndexEntry page,

      IndexEntry index, IndexEntry prev, IndexEntry current, IndexEntry next)

    throws IOException, LogicException

  {

    File file = new File(imagesRoot, path);

    securePath(imagesRoot, file);

    if(!file.exists())

      throw new FileNotFoundException(

        "[" + file.getCanonicalPath() + "] not found");

    File   dir      = file.getParentFile();

    File[] children = dir.listFiles(imagesFilter);

    int    pos;

    Arrays.sort(children, fileNameComparator);

    pos = Arrays.binarySearch(children, file, fileNameComparator);

    if(pos < 0)

      throw new FileNotFoundException("[" + file.getCanonicalPath()

        + "] not found in [" + dir.getCanonicalPath() + "]");

    setEntryInfo(page,    file, false);

    setEntryInfo(current, file, true);

    setEntryInfo(index,   dir,  true);

    if(pos > 0)                 setEntryInfo(prev,  children[pos-1], true);

    if(pos < children.length-1) setEntryInfo(next,  children[pos+1], true);

  }

  protected void setEntryInfo(IndexEntry entry, File file, boolean small)

    throws IOException

  {

    String title = file.getName();

    int[]  size;

    String path  = getPath(file);

    if(file.isDirectory()) {

      size = thumbnailer.getDirSize(file);

    }

    else {

       title = FileUtils.extractFileName(title);

      if(small)

        size = thumbnailer.getSmallSize(file);

       else

        size = thumbnailer.getMediumSize(file);

    }

    entry.setFile(file);

    entry.setPath(path == null ? null : URLEncoder.encode(path, URL_ENCODING));

    entry.setTitle(title);

    entry.setIsDir(file.isDirectory());

    entry.setWidth(size[0]);

    entry.setHeight(size[1]);

  }

  public String getThumbnailMime()

  {

    return thumbnailer.getMime();

  }

  public String getOriginMime(String path)

    throws IOException, LogicException

  {

    File file = new File(imagesRoot, path);

    if(!file.exists()) return null;

    securePath(imagesRoot, file);

    return FileUtils.getMime(FileUtils.extractFileExt(path));

  }

  public void writeDir(String path, OutputStream out)

    throws IOException, LogicException

  {

    File file = new File(imagesRoot, path);

    securePath(imagesRoot, file);

    thumbnailer.writeDir(file, out);

  }

  public void writeSmall(String path, OutputStream out)

    throws IOException, LogicException

  {

    File file = new File(imagesRoot, path);

    securePath(imagesRoot, file);

    thumbnailer.writeSmall(file, out);

  }

  public void writeMedium(String path, OutputStream out)

    throws IOException, LogicException

  {

    File file = new File(imagesRoot, path);

    securePath(imagesRoot, file);

    thumbnailer.writeMedium(file, out);

  }

  public void writeOrigin(String path, OutputStream out)

    throws IOException, LogicException

  {

    FileInputStream in   = null;

    File            file = new File(imagesRoot, path);

    securePath(imagesRoot, file);

    try {

      in  = new FileInputStream(file);

      FileUtils.copyStreams(in, out);

    }

    finally {

      if(in != null) in.close();

    }

  }

  public List listDirectory(String dirName)

    throws UnsupportedEncodingException, IOException, LogicException

  {

    File dir = new File(imagesRoot, dirName);

    securePath(imagesRoot, dir);

    if(!dir.exists()) return null;

    File[] children = dir.listFiles(imagesFilter);

    List   rows     = new ArrayList();

    int    pos      = 0;

    Arrays.sort(children, fileNameComparator);

    while(pos < children.length) {

      List row    = new ArrayList();

      int  rowPos = 0;

      rows.add(row);

      while(rowPos < columns && pos < children.length) {

        String path  = getPath(children[pos]);

        String title = children[pos].getName();

        int[]  size;

        if(children[pos].isDirectory()) {

          size  = thumbnailer.getDirSize(children[pos]);

        }

        else {

          size  = thumbnailer.getSmallSize(children[pos]);

          title = FileUtils.extractFileName(title);

        }

        row.add(new IndexEntry(children[pos],

          URLEncoder.encode(path, URL_ENCODING),

          title, children[pos].isDirectory(), size[0], size[1]));

        rowPos++;

        pos++;

      }

      while(rowPos < columns) {

        row.add(null);

        rowPos++;

      }

    }

    return rows;

  }

  protected String getPath(File file)

    throws IOException

  {

    String path     = file.getCanonicalPath();

    String rootPath = imagesRoot.getCanonicalPath();

    if(path.equals(rootPath)) return "";

    if(!rootPath.endsWith(File.separator)) rootPath += File.separator;

    if(!path.startsWith(rootPath))

      return null;

    return path.substring(rootPath.length());

  }

  protected ThumbnailPosition[] parseThumbnailPositions(String str)

  {

    List            list      = new ArrayList();

    StringTokenizer tokenizer = new StringTokenizer(str, ";");

    while(tokenizer.hasMoreTokens()) {

      StringTokenizer tokenParser

        = new StringTokenizer(tokenizer.nextToken(), ",");

      int    x            = Integer.parseInt(tokenParser.nextToken().trim());

      int    y            = Integer.parseInt(tokenParser.nextToken().trim());

      int    width        = Integer.parseInt(tokenParser.nextToken().trim());

      int    height       = Integer.parseInt(tokenParser.nextToken().trim());

      String horAlignStr  = tokenParser.nextToken().trim().toLowerCase();

      String vertAlignStr = tokenParser.nextToken().trim().toLowerCase();

      int    horAlign;

      int    vertAlign;

      if("l".equals(horAlignStr))

        horAlign = ThumbnailPosition.ALIGN_HOR_LEFT;

      else if("r".equals(horAlignStr))

        horAlign = ThumbnailPosition.ALIGN_HOR_RIGHT;

      else if("c".equals(horAlignStr))

        horAlign = ThumbnailPosition.ALIGN_HOR_CENTER;

      else

        throw new RuntimeException(

          "Cannot parse " + horAlignStr + " as horizontal alignment");

      if("t".equals(vertAlignStr))

        vertAlign = ThumbnailPosition.ALIGN_VERT_TOP;

      else if("b".equals(vertAlignStr))

        vertAlign = ThumbnailPosition.ALIGN_VERT_BOTTOM;

      else if("c".equals(vertAlignStr))

        vertAlign = ThumbnailPosition.ALIGN_VERT_CENTER;

      else

        throw new RuntimeException(

          "Cannot parse " + vertAlignStr + " as vertical alignment");

      list.add(new ThumbnailPosition(x, y, width, height, horAlign, vertAlign));

    }

    ThumbnailPosition[] res = new ThumbnailPosition[list.size()];

    for(int i = 0; i < res.length; i++)

      res[i] = (ThumbnailPosition)list.get(i);

    return res;

  }

  protected static final Logic instance = new Logic();

  public static Logic getLogic()

  {

    return instance;

  }

  /**

   * checks if given file is really under the parent directory

   */

  protected void securePath(File parentDir, File file)

    throws IOException, LogicException

  {

    if(parentDir == null || file == null) return;

    File partFile = file.getCanonicalFile();

    parentDir = parentDir.getCanonicalFile();

    while(partFile != null) {

      if(partFile.equals(parentDir)) return;

      partFile = partFile.getParentFile();

    }

    throw new LogicSecurityException(

      "[" + file.getCanonicalPath() + "] is outside of directory ["

      + parentDir.getCanonicalPath() + "]");

  }

}