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