001// Copyright 2011 The Apache Software Foundation
002//
003// Licensed under the Apache License, Version 2.0 (the "License");
004// you may not use this file except in compliance with the License.
005// You may obtain a copy of the License at
006//
007// http://www.apache.org/licenses/LICENSE-2.0
008//
009// Unless required by applicable law or agreed to in writing, software
010// distributed under the License is distributed on an "AS IS" BASIS,
011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012// See the License for the specific language governing permissions and
013// limitations under the License.
014
015package org.apache.tapestry5.internal.jpa;
016
017import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
018import org.apache.tapestry5.jpa.TapestryPersistenceUnitInfo;
019
020import javax.naming.Context;
021import javax.naming.InitialContext;
022import javax.naming.NamingException;
023import javax.persistence.SharedCacheMode;
024import javax.persistence.ValidationMode;
025import javax.persistence.spi.ClassTransformer;
026import javax.persistence.spi.PersistenceUnitTransactionType;
027import javax.sql.DataSource;
028import java.net.MalformedURLException;
029import java.net.URL;
030import java.util.Collections;
031import java.util.List;
032import java.util.Map;
033import java.util.Properties;
034import java.util.Set;
035
036public class PersistenceUnitInfoImpl implements TapestryPersistenceUnitInfo
037{
038    private String persistenceUnitName;
039
040    private String persistenceProviderClassName;
041
042    private String persistenceXMLSchemaVersion;
043
044    private PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
045
046    private DataSource nonJtaDataSource;
047
048    private DataSource jtaDataSource;
049
050    private ValidationMode validationMode;
051
052    private SharedCacheMode sharedCacheMode;
053
054    private boolean excludeUnlistedClasses = true;
055
056    private final Set<String> managedClassNames = CollectionFactory.newSet();
057
058    private final Set<String> mappingFilesNames = CollectionFactory.newSet();
059
060    private final List<URL> jarFileUrls = CollectionFactory.newList();
061
062    private final Properties properties = new Properties();
063
064                private Map entityManagerProperties;
065
066    public PersistenceUnitInfoImpl(String persistenceUnitName)
067    {
068        this.persistenceUnitName = persistenceUnitName;
069    }
070
071    /**
072     * {@inheritDoc}
073     */
074    public String getPersistenceUnitName()
075    {
076        return persistenceUnitName;
077    }
078
079    /**
080     * {@inheritDoc}
081     */
082    public String getPersistenceProviderClassName()
083    {
084        return persistenceProviderClassName;
085    }
086
087    /**
088     * {@inheritDoc}
089     */
090    public TapestryPersistenceUnitInfo persistenceProviderClassName(final String persistenceProviderClassName)
091    {
092        this.persistenceProviderClassName = persistenceProviderClassName;
093
094        return this;
095    }
096
097    /**
098     * {@inheritDoc}
099     */
100    public PersistenceUnitTransactionType getTransactionType()
101    {
102        return transactionType;
103    }
104
105    /**
106     * {@inheritDoc}
107     */
108    public TapestryPersistenceUnitInfo transactionType(final PersistenceUnitTransactionType transactionType)
109    {
110        this.transactionType = transactionType;
111
112        return this;
113    }
114
115    /**
116     * {@inheritDoc}
117     */
118    public DataSource getJtaDataSource()
119    {
120        return jtaDataSource;
121    }
122
123    /**
124     * {@inheritDoc}
125     */
126    public DataSource getNonJtaDataSource()
127    {
128        return nonJtaDataSource;
129    }
130
131    /**
132     * {@inheritDoc}
133     */
134    public TapestryPersistenceUnitInfo nonJtaDataSource(final String nonJtaDataSource)
135    {
136        this.nonJtaDataSource = lookupDataSource(nonJtaDataSource);
137
138        return this;
139    }
140
141    /**
142     * {@inheritDoc}
143     */
144    public TapestryPersistenceUnitInfo jtaDataSource(final String jtaDataSource)
145    {
146        this.jtaDataSource = lookupDataSource(jtaDataSource);
147
148        return this;
149    }
150
151    /**
152     * {@inheritDoc}
153     */
154    public List<String> getMappingFileNames()
155    {
156        List<String> tmp = CollectionFactory.newList(mappingFilesNames);
157        return Collections.unmodifiableList(tmp);
158    }
159
160    /**
161     * {@inheritDoc}
162     */
163    public TapestryPersistenceUnitInfo addMappingFileName(final String fileName)
164    {
165        mappingFilesNames.add(fileName);
166
167        return this;
168
169    }
170
171    /**
172     * {@inheritDoc}
173     */
174    public TapestryPersistenceUnitInfo addJarFileUrl(URL url)
175    {
176        jarFileUrls.add(url);
177
178        return this;
179    }
180
181    /**
182     * {@inheritDoc}
183     */
184    public TapestryPersistenceUnitInfo addJarFileUrl(String url)
185    {
186        try
187        {
188            return addJarFileUrl(new URL(getPersistenceUnitRootUrl(), url));
189        } catch (MalformedURLException e)
190        {
191            throw new RuntimeException(e);
192        }
193    }
194
195
196    /**
197     * {@inheritDoc}
198     */
199    public TapestryPersistenceUnitInfo addProperty(String name, String value)
200    {
201        getProperties().put(name, value);
202
203        return this;
204    }
205
206
207    /**
208     * {@inheritDoc}
209     */
210    public TapestryPersistenceUnitInfo excludeUnlistedClasses(boolean exclude)
211    {
212        this.excludeUnlistedClasses = exclude;
213
214        return this;
215    }
216
217    /**
218     * {@inheritDoc}
219     */
220    public List<URL> getJarFileUrls()
221    {
222        return Collections.unmodifiableList(jarFileUrls);
223    }
224
225    /**
226     * {@inheritDoc}
227     */
228    public URL getPersistenceUnitRootUrl()
229    {
230        return getClass().getResource("/");
231    }
232
233    /**
234     * {@inheritDoc}
235     */
236    public List<String> getManagedClassNames()
237    {
238        List<String> tmp = CollectionFactory.newList(managedClassNames);
239        return Collections.<String>unmodifiableList(tmp);
240    }
241
242    /**
243     * {@inheritDoc}
244     */
245    public TapestryPersistenceUnitInfo addManagedClassName(final String className)
246    {
247        managedClassNames.add(className);
248
249        return this;
250    }
251
252    /**
253     * {@inheritDoc}
254     */
255    public TapestryPersistenceUnitInfo addManagedClass(final Class<?> clazz)
256    {
257        addManagedClassName(clazz.getName());
258
259        return this;
260    }
261
262    /**
263     * {@inheritDoc}
264     */
265    public boolean excludeUnlistedClasses()
266    {
267        return excludeUnlistedClasses;
268    }
269
270    /**
271     * {@inheritDoc}
272     */
273    public SharedCacheMode getSharedCacheMode()
274    {
275        return sharedCacheMode;
276    }
277
278    /**
279     * {@inheritDoc}
280     */
281    public TapestryPersistenceUnitInfo sharedCacheMode(final SharedCacheMode cacheMode)
282    {
283        sharedCacheMode = cacheMode;
284
285        return this;
286    }
287
288    /**
289     * {@inheritDoc}
290     */
291    public ValidationMode getValidationMode()
292    {
293        return validationMode;
294    }
295
296    /**
297     * {@inheritDoc}
298     */
299    public TapestryPersistenceUnitInfo validationMode(final ValidationMode validationMode)
300    {
301        this.validationMode = validationMode;
302
303        return this;
304    }
305
306    /**
307     * {@inheritDoc}
308     */
309    public Properties getProperties()
310    {
311        return properties;
312    }
313
314    /**
315     * {@inheritDoc}
316     */
317    public String getPersistenceXMLSchemaVersion()
318    {
319        return persistenceXMLSchemaVersion;
320    }
321
322    public void setPersistenceXMLSchemaVersion(final String version)
323    {
324        persistenceXMLSchemaVersion = version;
325    }
326
327    /**
328     * {@inheritDoc}
329     */
330    public ClassLoader getClassLoader()
331    {
332        return Thread.currentThread().getContextClassLoader();
333    }
334
335    /**
336     * {@inheritDoc}
337     */
338    public void addTransformer(final ClassTransformer transformer)
339    {
340
341    }
342
343    /**
344     * {@inheritDoc}
345     */
346    public ClassLoader getNewTempClassLoader()
347    {
348        return getClassLoader();
349    }
350
351
352    private DataSource lookupDataSource(final String name)
353    {
354        try
355        {
356            // TODO: Create InitialContext with environment properties?
357            final Context initContext = new InitialContext();
358
359            final Context envContext = (Context) initContext.lookup("java:comp/env");
360
361            return (DataSource) envContext.lookup(name);
362        } catch (final NamingException e)
363        {
364            throw new RuntimeException(e);
365        }
366
367    }
368
369    public TapestryPersistenceUnitInfo setEntityManagerProperties(Map properties) {
370        entityManagerProperties = properties;
371        return this;
372    }
373
374    public Map getEntityManagerProperties() {
375        return entityManagerProperties;
376    }
377
378
379}