001    /**
002     * Copyright (c) 2000-2012 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.TransactionDefinition;
018    import com.liferay.portal.kernel.transaction.Transactional;
019    import com.liferay.portal.util.PropsValues;
020    
021    import java.util.ArrayList;
022    import java.util.List;
023    
024    import org.springframework.transaction.interceptor.NoRollbackRuleAttribute;
025    import org.springframework.transaction.interceptor.RollbackRuleAttribute;
026    import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
027    import org.springframework.transaction.interceptor.TransactionAttribute;
028    
029    /**
030     * @author Shuyang Zhou
031     * @author Brian Wing Shun Chan
032     */
033    public class TransactionAttributeBuilder {
034    
035            public static TransactionAttribute build(Transactional transactional) {
036                    if (transactional == null) {
037                            return null;
038                    }
039    
040                    return _build(
041                            transactional.enabled(), transactional.isolation().value(),
042                            transactional.propagation().value(), transactional.readOnly(),
043                            transactional.timeout(), transactional.rollbackFor(),
044                            transactional.rollbackForClassName(), transactional.noRollbackFor(),
045                            transactional.noRollbackForClassName());
046            }
047    
048            private static TransactionAttribute _build(
049                    boolean enabled, int isolationLevel, int propagationBehavior,
050                    boolean readOnly, int timeout, Class<?>[] rollbackFor,
051                    String[] rollbackForClassName, Class<?>[] noRollbackFor,
052                    String[] noRollbackForClassName) {
053    
054                    if (!enabled) {
055                            return null;
056                    }
057    
058                    RuleBasedTransactionAttribute ruleBasedTransactionAttribute =
059                            new RuleBasedTransactionAttribute();
060    
061                    if (isolationLevel == TransactionDefinition.ISOLATION_COUNTER) {
062                            ruleBasedTransactionAttribute.setIsolationLevel(
063                                    PropsValues.TRANSACTION_ISOLATION_COUNTER);
064                    }
065                    else if (isolationLevel == TransactionDefinition.ISOLATION_PORTAL) {
066                            ruleBasedTransactionAttribute.setIsolationLevel(
067                                    PropsValues.TRANSACTION_ISOLATION_PORTAL);
068                    }
069                    else {
070                            ruleBasedTransactionAttribute.setIsolationLevel(isolationLevel);
071                    }
072    
073                    ruleBasedTransactionAttribute.setPropagationBehavior(
074                            propagationBehavior);
075                    ruleBasedTransactionAttribute.setReadOnly(readOnly);
076                    ruleBasedTransactionAttribute.setTimeout(timeout);
077    
078                    List<RollbackRuleAttribute> rollbackRuleAttributes =
079                            new ArrayList<RollbackRuleAttribute>();
080    
081                    for (int i = 0; i < rollbackFor.length; i++) {
082                            RollbackRuleAttribute rollbackRuleAttribute =
083                                    new RollbackRuleAttribute(rollbackFor[i]);
084    
085                            rollbackRuleAttributes.add(rollbackRuleAttribute);
086                    }
087    
088                    for (int i = 0; i < rollbackForClassName.length; i++) {
089                            RollbackRuleAttribute rollbackRuleAttribute =
090                                    new RollbackRuleAttribute(rollbackForClassName[i]);
091    
092                            rollbackRuleAttributes.add(rollbackRuleAttribute);
093                    }
094    
095                    for (int i = 0; i < noRollbackFor.length; ++i) {
096                            NoRollbackRuleAttribute noRollbackRuleAttribute =
097                                    new NoRollbackRuleAttribute(noRollbackFor[i]);
098    
099                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
100                    }
101    
102                    for (int i = 0; i < noRollbackForClassName.length; ++i) {
103                            NoRollbackRuleAttribute noRollbackRuleAttribute =
104                                    new NoRollbackRuleAttribute(noRollbackForClassName[i]);
105    
106                            rollbackRuleAttributes.add(noRollbackRuleAttribute);
107                    }
108    
109                    List<RollbackRuleAttribute> ruleBasedRollbackRuleAttributes =
110                            ruleBasedTransactionAttribute.getRollbackRules();
111    
112                    ruleBasedRollbackRuleAttributes.addAll(rollbackRuleAttributes);
113    
114                    return ruleBasedTransactionAttribute;
115            }
116    
117    }