001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 package org.apache.camel.language.simple; 019 020 import java.text.SimpleDateFormat; 021 import java.util.Date; 022 023 import org.apache.camel.Exchange; 024 import org.apache.camel.Expression; 025 import org.apache.camel.builder.ExpressionBuilder; 026 import org.apache.camel.language.IllegalSyntaxException; 027 import org.apache.camel.language.constant.ConstantLanguage; 028 029 /** 030 * A helper class for working with <a href="http://activemq.apache.org/camel/expression.html">expressions</a> based 031 * on files. 032 * <p/> 033 * This expression expects the headers from the {@link FileLanguage} on the <b>IN</b> message. 034 * 035 * @see org.apache.camel.language.simple.FileLanguage 036 */ 037 public final class FileExpressionBuilder { 038 039 private FileExpressionBuilder() { 040 // Helper class 041 } 042 043 public static <E extends Exchange> Expression<E> fileNameExpression() { 044 return new Expression<E>() { 045 public Object evaluate(E exchange) { 046 return exchange.getIn().getHeader("CamelFileName", String.class); 047 } 048 049 @Override 050 public String toString() { 051 return "file:name"; 052 } 053 }; 054 } 055 056 public static <E extends Exchange> Expression<E> fileNameNoExtensionExpression() { 057 return new Expression<E>() { 058 public Object evaluate(E exchange) { 059 String name = exchange.getIn().getHeader("CamelFileName", String.class); 060 if (name.lastIndexOf(".") != -1) { 061 return name.substring(0, name.lastIndexOf('.')); 062 } else { 063 // name does not have extension 064 return name; 065 } 066 } 067 068 @Override 069 public String toString() { 070 return "file:name.noext"; 071 } 072 }; 073 } 074 075 public static <E extends Exchange> Expression<E> fileExtensionExpression() { 076 return new Expression<E>() { 077 public Object evaluate(E exchange) { 078 String name = exchange.getIn().getHeader("CamelFileName", String.class); 079 if (name != null) { 080 return name.substring(name.lastIndexOf('.') + 1); 081 } else { 082 return null; 083 } 084 } 085 086 @Override 087 public String toString() { 088 return "file:ext"; 089 } 090 }; 091 } 092 093 public static <E extends Exchange> Expression<E> fileParentExpression() { 094 return new Expression<E>() { 095 public Object evaluate(E exchange) { 096 return exchange.getIn().getHeader("CamelFileParent", String.class); 097 } 098 099 @Override 100 public String toString() { 101 return "file:parent"; 102 } 103 }; 104 } 105 106 public static <E extends Exchange> Expression<E> filePathExpression() { 107 return new Expression<E>() { 108 public Object evaluate(E exchange) { 109 return exchange.getIn().getHeader("CamelFilePath", String.class); 110 } 111 112 @Override 113 public String toString() { 114 return "file:path"; 115 } 116 }; 117 } 118 119 public static <E extends Exchange> Expression<E> fileAbsolutePathExpression() { 120 return new Expression<E>() { 121 public Object evaluate(E exchange) { 122 return exchange.getIn().getHeader("CamelFileAbsolutePath", String.class); 123 } 124 125 @Override 126 public String toString() { 127 return "file:absolute.path"; 128 } 129 }; 130 } 131 132 public static <E extends Exchange> Expression<E> fileCanoicalPathExpression() { 133 return new Expression<E>() { 134 public Object evaluate(E exchange) { 135 return exchange.getIn().getHeader("CamelFileCanonicalPath", String.class); 136 } 137 138 @Override 139 public String toString() { 140 return "file:canonical.path"; 141 } 142 }; 143 } 144 145 public static <E extends Exchange> Expression<E> fileSizeExpression() { 146 return new Expression<E>() { 147 public Object evaluate(E exchange) { 148 return exchange.getIn().getHeader("CamelFileLength", Long.class); 149 } 150 151 @Override 152 public String toString() { 153 return "file:length"; 154 } 155 }; 156 } 157 158 public static <E extends Exchange> Expression<E> dateExpression(final String command, final String pattern) { 159 return new Expression<E>() { 160 public Object evaluate(E exchange) { 161 if ("file".equals(command)) { 162 Date date = exchange.getIn().getHeader("CamelFileLastModified", Date.class); 163 if (date != null) { 164 SimpleDateFormat df = new SimpleDateFormat(pattern); 165 return df.format(date); 166 } else { 167 return null; 168 } 169 } 170 // must call evaluate to return the nested language evaluate when evaluating 171 // stacked expressions 172 return ExpressionBuilder.dateExpression(command, pattern).evaluate(exchange); 173 } 174 175 @Override 176 public String toString() { 177 return "date(" + command + ":" + pattern + ")"; 178 } 179 }; 180 } 181 182 public static <E extends Exchange> Expression<E> simpleExpression(final String simple) { 183 return new Expression<E>() { 184 public Object evaluate(E exchange) { 185 // must call evaluate to return the nested language evaluate when evaluating 186 // stacked expressions 187 try { 188 return SimpleLanguage.simple(simple).evaluate(exchange); 189 } catch (IllegalSyntaxException e) { 190 // fallback to constant so end users can enter a fixed filename 191 return ConstantLanguage.constant(simple).evaluate(exchange); 192 } 193 } 194 195 @Override 196 public String toString() { 197 return "simple(" + simple + ")"; 198 } 199 }; 200 } 201 202 }