001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.spring.transaction;
016    
017    import com.liferay.portal.kernel.transaction.Isolation;
018    import com.liferay.portal.kernel.transaction.Propagation;
019    import com.liferay.portal.kernel.transaction.TransactionDefinition;
020    import com.liferay.portal.kernel.transaction.Transactional;
021    import com.liferay.portal.util.PropsValues;
022    
023    import java.util.ArrayList;
024    import java.util.List;
025    
026    import org.springframework.transaction.interceptor.NoRollbackRuleAttribute;
027    import org.springframework.transaction.interceptor.RollbackRuleAttribute;
028    import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
029    import org.springframework.transaction.interceptor.TransactionAttribute;
030    
031    /**
032     * @author Shuyang Zhou
033     * @author Brian Wing Shun Chan
034     */
035    public class TransactionAttributeBuilder {
036    
037            public static TransactionAttribute build(
038                    boolean enabled, Isolation isolation, Propagation propagation,
039                    boolean readOnly, int timeout, Class<?>[] rollbackForClasses,
040                    String[] rollbackForClassNames, Class<?>[] noRollbackForClasses,
041                    String[] noRollbackForClassNames) {
042    
043                    if (!enabled) {
044                            return null;
045                    }
046    
047                    RuleBasedTransactionAttribute ruleBasedTransactionAttribute =
048                            new RuleBasedTransactionAttribute();
049    
050                    if (isolation.value() == TransactionDefinition.ISOLATION_COUNTER) {
051                            ruleBasedTransactionAttribute.setIsolationLevel(
052                                    PropsValues.TRANSACTION_ISOLATION_COUNTER);
053                    }
054                    else if (isolation.value() == TransactionDefinition.ISOLATION_PORTAL) {
055                            ruleBasedTransactionAttribute.setIsolationLevel(
056                                    PropsValues.TRANSACTION_ISOLATION_PORTAL);
057                    }
058                    else {
059                            ruleBasedTransactionAttribute.setIsolationLevel(isolation.value());
060                    }
061    
062                    ruleBasedTransactionAttribute.setPropagationBehavior(
063                            propagation.value());
064                    ruleBasedTransactionAttribute.setReadOnly(readOnly);
065                    ruleBasedTransactionAttribute.setTimeout(timeout);
066    
067                    List<RollbackRuleAttribute> rollbackRuleAttributes =
068                            new ArrayList<RollbackRuleAttribute>();
069    
070                    for (int i = 0; i < rollbackForClasses.length; i++) {
071                            RollbackRuleAttribute rollbackRuleAttribute =
072                                    new RollbackRuleAttribute(rollbackForClasses[i]);
073    
074                            rollbackRuleAttributes.add(rollbackRuleAttribute);
075                    }
076    
077                    for (int i = 0; i < rollbackForClassNames.length; i++) {
078                            RollbackRuleAttribute rollbackRuleAttribute =
079                                    new RollbackRuleAttribute(rollbackForClassNames[i]);
080    
081                            rollbackRuleAttributes.add(rollbackRuleAttribute);
082                    }
083    
084                    for (int i = 0; i < noRollbackForClasses.length; ++i) {
085                            NoRollbackRuleAttribute noRollbackRuleAttribute =
086                                    new NoRollbackRuleAttribute(noRollbackForClasses[i]);
087    
088                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
089                    }
090    
091                    for (int i = 0; i < noRollbackForClassNames.length; ++i) {
092                            NoRollbackRuleAttribute noRollbackRuleAttribute =
093                                    new NoRollbackRuleAttribute(noRollbackForClassNames[i]);
094    
095                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
096                    }
097    
098                    List<RollbackRuleAttribute> ruleBasedRollbackRuleAttributes =
099                            ruleBasedTransactionAttribute.getRollbackRules();
100    
101                    ruleBasedRollbackRuleAttributes.addAll(rollbackRuleAttributes);
102    
103                    return ruleBasedTransactionAttribute;
104            }
105    
106            public static TransactionAttribute build(
107                    Propagation propagation, Class<?>[] rollbackForClasses,
108                    Class<?>... noRollbackForClasses) {
109    
110                    return build(
111                            true, Isolation.PORTAL, propagation, false, -1, rollbackForClasses,
112                            new String[0], noRollbackForClasses, new String[0]);
113            }
114    
115            public static TransactionAttribute build(Transactional transactional) {
116                    if (transactional == null) {
117                            return null;
118                    }
119    
120                    return build(
121                            transactional.enabled(), transactional.isolation(),
122                            transactional.propagation(), transactional.readOnly(),
123                            transactional.timeout(), transactional.rollbackFor(),
124                            transactional.rollbackForClassName(), transactional.noRollbackFor(),
125                            transactional.noRollbackForClassName());
126            }
127    
128    }