View Javadoc

1   /*
2    * $Id: AtomEntryBuilderTransformer.java 20321 2010-11-24 15:21:24Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  package org.mule.module.atom.transformers;
11  
12  import org.mule.api.MuleEvent;
13  import org.mule.api.MuleMessage;
14  import org.mule.api.transformer.DataType;
15  import org.mule.api.transformer.TransformerException;
16  import org.mule.api.transport.OutputHandler;
17  import org.mule.config.i18n.CoreMessages;
18  import org.mule.expression.transformers.AbstractExpressionTransformer;
19  import org.mule.expression.transformers.ExpressionArgument;
20  import org.mule.transformer.types.DataTypeFactory;
21  import org.mule.util.StringUtils;
22  
23  import java.io.IOException;
24  import java.io.InputStream;
25  import java.io.OutputStream;
26  import java.util.Date;
27  
28  import javax.activation.DataHandler;
29  
30  import org.apache.abdera.Abdera;
31  import org.apache.abdera.factory.Factory;
32  import org.apache.abdera.model.Category;
33  import org.apache.abdera.model.Element;
34  import org.apache.abdera.model.Entry;
35  import org.apache.abdera.model.Link;
36  import org.apache.abdera.model.Person;
37  import org.apache.abdera.parser.stax.FOMWriterOptions;
38  
39  public class AtomEntryBuilderTransformer extends AbstractExpressionTransformer
40  {
41      private static final DataType<Entry> TYPE_ENTRY = DataTypeFactory.create(Entry.class);
42      private static final DataType<OutputHandler> TYPE_OUTPUT_HANDLER = DataTypeFactory.create(OutputHandler.class);
43  
44      public AtomEntryBuilderTransformer()
45      {
46          setReturnDataType(TYPE_OUTPUT_HANDLER);
47      }
48  
49      @Override
50      public Object transformMessage(MuleMessage message, String outputEncoding) throws TransformerException
51      {
52          Factory factory = Abdera.getInstance().getFactory();
53          Entry entry = factory.newEntry();
54  
55          for (ExpressionArgument arg: arguments)
56          {
57              String argName = arg.getName();
58              if (argName.equals("title"))
59              {
60                  entry.setTitle(StringUtils.trimToEmpty((String) arg.evaluate(message)));
61              }
62              else if (argName.equals("id"))
63              {
64                  entry.setId(StringUtils.trimToEmpty((String) arg.evaluate(message)));
65              }
66              else if (argName.equals("summary"))
67              {
68                  entry.setSummary(StringUtils.trimToEmpty((String) arg.evaluate(message)));
69              }
70              else if (argName.equals("content"))
71              {
72                  Object content = arg.evaluate(message);
73                  if (content instanceof DataHandler)
74                  {
75                      entry.setContent((DataHandler) content);
76                  }
77                  if (content instanceof Element)
78                  {
79                      entry.setContent((Element) content);
80                  }
81                  if (content instanceof String)
82                  {
83                      entry.setContent((String) content);
84                  }
85                  if (content instanceof InputStream)
86                  {
87                      entry.setContent((InputStream) content);
88                  }
89              }
90              else if (argName.equals("updated"))
91              {
92                  Object date = arg.evaluate(message);
93                  if (date instanceof Date)
94                  {
95                      entry.setUpdated((Date) date);
96                  }
97                  else
98                  {
99                      entry.setUpdated(date.toString());
100                 }
101             }
102             else if (argName.equals("edited"))
103             {
104                 Object date = arg.evaluate(message);
105                 if (date instanceof Date)
106                 {
107                     entry.setEdited((Date) date);
108                 }
109                 else
110                 {
111                     entry.setEdited(date.toString());
112                 }
113             }
114             else if (argName.equals("published"))
115             {
116                 Object date = arg.evaluate(message);
117                 if (date instanceof Date)
118                 {
119                     entry.setPublished((Date) date);
120                 }
121                 else
122                 {
123                     entry.setPublished(date.toString());
124                 }
125             }
126             else if (argName.equals("rights"))
127             {
128                 entry.setRights((String) arg.evaluate(message));
129             }
130             else if (argName.equals("draft"))
131             {
132                 entry.setDraft((Boolean) arg.evaluate(message));
133             }
134             else if (argName.equals("author"))
135             {
136                 Object author = arg.evaluate(message);
137                 if (author instanceof Person)
138                 {
139                     entry.addAuthor((Person) author);
140                 }
141                 else
142                 {
143                     entry.addAuthor(author.toString());
144                 }
145             }
146             else if (argName.equals("category"))
147             {
148                 Object category = arg.evaluate(message);
149                 if (category instanceof Category)
150                 {
151                     entry.addCategory((Category) category);
152                 }
153                 else
154                 {
155                     entry.addCategory(category.toString());
156                 }
157             }
158             else if (argName.equals("contributor"))
159             {
160                 Object author = arg.evaluate(message);
161                 if (author instanceof Person)
162                 {
163                     entry.addContributor((Person) author);
164                 }
165                 else
166                 {
167                     entry.addContributor(author.toString());
168                 }
169             }
170             else if (argName.equals("link"))
171             {
172                 Object link = arg.evaluate(message);
173                 if (link instanceof Link)
174                 {
175                     entry.addLink((Link) link);
176                 }
177                 else
178                 {
179                     entry.addLink(link.toString());
180                 }
181             }
182             else
183             {
184                 throw new TransformerException(CoreMessages.propertyHasInvalidValue("entry-property.name", argName), this);
185             }
186 
187         }
188 
189         if (TYPE_ENTRY.equals(getReturnDataType()))
190         {
191             return entry;
192         }
193         else if (TYPE_OUTPUT_HANDLER.equals(getReturnDataType()))
194         {
195             final Entry e = entry;
196             return new OutputHandler()
197             {
198                 public void write(MuleEvent event, OutputStream out) throws IOException
199                 {
200                     FOMWriterOptions opts = new FOMWriterOptions();
201                     opts.setCharset(event.getEncoding());
202                     e.writeTo(out, opts);
203                 }
204             };
205         }
206         else
207         {
208             return entry.toString();
209         }
210     }
211 }