001    /**
002     * Copyright (c) 2000-present 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 = new ArrayList<>();
068    
069                    for (int i = 0; i < rollbackForClasses.length; i++) {
070                            RollbackRuleAttribute rollbackRuleAttribute =
071                                    new RollbackRuleAttribute(rollbackForClasses[i]);
072    
073                            rollbackRuleAttributes.add(rollbackRuleAttribute);
074                    }
075    
076                    for (int i = 0; i < rollbackForClassNames.length; i++) {
077                            RollbackRuleAttribute rollbackRuleAttribute =
078                                    new RollbackRuleAttribute(rollbackForClassNames[i]);
079    
080                            rollbackRuleAttributes.add(rollbackRuleAttribute);
081                    }
082    
083                    for (int i = 0; i < noRollbackForClasses.length; ++i) {
084                            NoRollbackRuleAttribute noRollbackRuleAttribute =
085                                    new NoRollbackRuleAttribute(noRollbackForClasses[i]);
086    
087                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
088                    }
089    
090                    for (int i = 0; i < noRollbackForClassNames.length; ++i) {
091                            NoRollbackRuleAttribute noRollbackRuleAttribute =
092                                    new NoRollbackRuleAttribute(noRollbackForClassNames[i]);
093    
094                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
095                    }
096    
097                    List<RollbackRuleAttribute> ruleBasedRollbackRuleAttributes =
098                            ruleBasedTransactionAttribute.getRollbackRules();
099    
100                    ruleBasedRollbackRuleAttributes.addAll(rollbackRuleAttributes);
101    
102                    return ruleBasedTransactionAttribute;
103            }
104    
105            public static TransactionAttribute build(
106                    Propagation propagation, Class<?>[] rollbackForClasses,
107                    Class<?>... noRollbackForClasses) {
108    
109                    return build(
110                            true, Isolation.PORTAL, propagation, false, -1, rollbackForClasses,
111                            new String[0], noRollbackForClasses, new String[0]);
112            }
113    
114            public static TransactionAttribute build(Transactional transactional) {
115                    if (transactional == null) {
116                            return null;
117                    }
118    
119                    return build(
120                            transactional.enabled(), transactional.isolation(),
121                            transactional.propagation(), transactional.readOnly(),
122                            transactional.timeout(), transactional.rollbackFor(),
123                            transactional.rollbackForClassName(), transactional.noRollbackFor(),
124                            transactional.noRollbackForClassName());
125            }
126    
127    }