001    /*
002     * SonarQube, open source software quality management tool.
003     * Copyright (C) 2008-2013 SonarSource
004     * mailto:contact AT sonarsource DOT com
005     *
006     * SonarQube is free software; you can redistribute it and/or
007     * modify it under the terms of the GNU Lesser General Public
008     * License as published by the Free Software Foundation; either
009     * version 3 of the License, or (at your option) any later version.
010     *
011     * SonarQube is distributed in the hope that it will be useful,
012     * but WITHOUT ANY WARRANTY; without even the implied warranty of
013     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014     * Lesser General Public License for more details.
015     *
016     * You should have received a copy of the GNU Lesser General Public License
017     * along with this program; if not, write to the Free Software Foundation,
018     * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
019     */
020    package org.sonar.api.rules;
021    
022    import org.apache.commons.collections.CollectionUtils;
023    import org.apache.commons.collections.Transformer;
024    import org.apache.commons.lang.StringUtils;
025    import org.apache.commons.lang.builder.ToStringBuilder;
026    import org.sonar.api.profiles.RulesProfile;
027    
028    import java.util.ArrayList;
029    import java.util.List;
030    
031    import javax.persistence.*;
032    
033    /**
034     * A class to map an ActiveRule to the hibernate model
035     */
036    @Entity
037    @Table(name = "active_rules")
038    public class ActiveRule implements Cloneable {
039    
040      public static final String INHERITED = "INHERITED";
041      public static final String OVERRIDES = "OVERRIDES";
042    
043      @Id
044      @Column(name = "id")
045      @GeneratedValue
046      private Integer id;
047    
048      @ManyToOne(fetch = FetchType.EAGER)
049      @JoinColumn(name = "rule_id", updatable = true, nullable = false)
050      private Rule rule;
051    
052      @Column(name = "failure_level", updatable = true, nullable = false)
053      @Enumerated(EnumType.ORDINAL)
054      private RulePriority severity;
055    
056      @ManyToOne(fetch = FetchType.EAGER)
057      @JoinColumn(name = "profile_id", updatable = true, nullable = false)
058      private RulesProfile rulesProfile;
059    
060      @OneToMany(mappedBy = "activeRule", fetch = FetchType.LAZY, cascade = { CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REMOVE })
061      private List<ActiveRuleParam> activeRuleParams = new ArrayList<ActiveRuleParam>();
062    
063      @Column(name = "inheritance", updatable = true, nullable = true)
064      private String inheritance;
065    
066      /**
067       * @deprecated visibility should be reduced to protected or package
068       */
069      @Deprecated
070      public ActiveRule() {
071      }
072    
073      /**
074       * @deprecated visibility should be reduced to protected or package
075       */
076      @Deprecated
077      public ActiveRule(RulesProfile profile, Rule rule, RulePriority severity) {
078        this.rule = rule;
079        if (severity == null && rule != null) {
080          this.severity = rule.getSeverity();
081        } else {
082          this.severity = severity;
083        }
084    
085        this.rulesProfile = profile;
086      }
087    
088      public Integer getId() {
089        return id;
090      }
091    
092      /**
093       * For internal use only.
094       * 
095       * @since 2.5
096       */
097      public String getInheritance() {
098        return inheritance;
099      }
100    
101      /**
102       * For internal use only.
103       * 
104       * @since 2.5
105       */
106      public void setInheritance(String s) {
107        this.inheritance = s;
108      }
109    
110      public boolean isInherited() {
111        return StringUtils.equals(INHERITED, inheritance);
112      }
113    
114      public boolean doesOverride() {
115        return StringUtils.equals(OVERRIDES, inheritance);
116      }
117    
118      /**
119       * @deprecated visibility should be decreased to protected or package
120       */
121      @Deprecated
122      public void setId(Integer id) {
123        this.id = id;
124      }
125    
126      public Rule getRule() {
127        return rule;
128      }
129    
130      /**
131       * @deprecated visibility should be reduced to protected or package
132       */
133      @Deprecated
134      public void setRule(Rule rule) {
135        this.rule = rule;
136      }
137    
138      /**
139       * @since 2.5
140       */
141      public RulePriority getSeverity() {
142        return severity;
143      }
144    
145      /**
146       * @since 2.5
147       */
148      public void setSeverity(RulePriority severity) {
149        this.severity = severity;
150      }
151    
152      /**
153       * @deprecated since 2.5 use {@link #getSeverity()} instead. See http://jira.codehaus.org/browse/SONAR-1829
154       */
155      @Deprecated
156      public RulePriority getPriority() {
157        return severity;
158      }
159    
160      /**
161       * @deprecated since 2.5 use {@link #setSeverity(RulePriority)} instead. See http://jira.codehaus.org/browse/SONAR-1829
162       */
163      @Deprecated
164      public void setPriority(RulePriority priority) {
165        this.severity = priority;
166      }
167    
168      public RulesProfile getRulesProfile() {
169        return rulesProfile;
170      }
171    
172      /**
173       * @deprecated visibility should be reduced to protected or package
174       */
175      @Deprecated
176      public void setRulesProfile(RulesProfile rulesProfile) {
177        this.rulesProfile = rulesProfile;
178      }
179    
180      public List<ActiveRuleParam> getActiveRuleParams() {
181        return activeRuleParams;
182      }
183    
184      /**
185       * @deprecated use setParameter()
186       */
187      @Deprecated
188      public void setActiveRuleParams(List<ActiveRuleParam> params) {
189        this.activeRuleParams = params;
190      }
191    
192      public ActiveRule setParameter(String key, String value) {
193        RuleParam ruleParameter = rule.getParam(key);
194        if (ruleParameter != null) {
195          activeRuleParams.add(new ActiveRuleParam(this, ruleParameter, value));
196        }
197        return this;
198      }
199    
200      public String getParameter(String key) {
201        if (activeRuleParams != null) {
202          for (ActiveRuleParam param : activeRuleParams) {
203            if (StringUtils.equals(key, param.getKey())) {
204              return param.getValue();
205            }
206          }
207        }
208        return null;
209      }
210    
211      /**
212       * @deprecated since 2.3 use {@link #getRepositoryKey()} instead
213       */
214      @Deprecated
215      public String getPluginName() {
216        return rule.getRepositoryKey();
217      }
218    
219      public String getRepositoryKey() {
220        return rule.getRepositoryKey();
221      }
222    
223      /**
224       * @return the config key the active rule belongs to
225       */
226      public String getConfigKey() {
227        return rule.getConfigKey();
228      }
229    
230      /**
231       * @return the key of the active rule
232       */
233      public String getRuleKey() {
234        return rule.getKey();
235      }
236    
237      @Override
238      public boolean equals(Object o) {
239        if (this == o) {
240          return true;
241        }
242        if (o == null || getClass() != o.getClass()) {
243          return false;
244        }
245    
246        ActiveRule that = (ActiveRule) o;
247    
248        if (!rule.equals(that.rule)) {
249          return false;
250        }
251        if (rulesProfile != null ? !rulesProfile.equals(that.rulesProfile) : that.rulesProfile != null) {
252          return false;
253        }
254    
255        return true;
256      }
257    
258      @Override
259      public int hashCode() {
260        int result = rule.hashCode();
261        result = 31 * result + (rulesProfile != null ? rulesProfile.hashCode() : 0);
262        return result;
263      }
264    
265      @Override
266      public String toString() {
267        return new ToStringBuilder(this).append("id", getId()).append("rule", rule).append("priority", severity)
268            .append("params", activeRuleParams).toString();
269      }
270    
271      @Override
272      public Object clone() {
273        final ActiveRule clone = new ActiveRule(getRulesProfile(), getRule(), getSeverity());
274        clone.setInheritance(getInheritance());
275        if (CollectionUtils.isNotEmpty(getActiveRuleParams())) {
276          clone.setActiveRuleParams(new ArrayList<ActiveRuleParam>(CollectionUtils.collect(getActiveRuleParams(), new Transformer() {
277            public Object transform(Object input) {
278              ActiveRuleParam activeRuleParamClone = (ActiveRuleParam) ((ActiveRuleParam) input).clone();
279              activeRuleParamClone.setActiveRule(clone);
280              return activeRuleParamClone;
281            }
282          })));
283        }
284        return clone;
285      }
286    
287      /**
288       * @since 2.6
289       */
290      public boolean isEnabled() {
291        return getRule()!=null && getRule().isEnabled();
292      }
293    }