Coverage Report

Coverage Report - org.kuali.rice.krms.impl.repository.AgendaItemBo

Classes in this File

Line Coverage

Branch Coverage

Complexity

AgendaItemBo

0/82

0/18

1.429

 /*
  * Copyright 2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 1.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl1.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.kuali.rice.krms.impl.repository;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import org.apache.commons.lang.StringUtils;
 import org.kuali.rice.krad.bo.PersistableBusinessObjectBase;
 import org.kuali.rice.krms.api.repository.agenda.AgendaItem;
 
 /**
  * Agenda Item business object
  * 
  * @author Kuali Rice Team (rice.collab@kuali.org)
  *
  */
 public class AgendaItemBo extends PersistableBusinessObjectBase {
 
         private String id;
         private String agendaId;
         private String ruleId;
         private String subAgendaId;
         private String whenTrueId;
         private String whenFalseId;
         private String alwaysId;
         
         private RuleBo rule;
         
         private AgendaItemBo whenTrue;
         private AgendaItemBo whenFalse;
         private AgendaItemBo always;
         
         public String getUl(AgendaItemBo firstItem) {
                 return ("<ul>" + getUlHelper(firstItem) + "</ul>");
         }
         
         public String getUlHelper(AgendaItemBo item) {
                 StringBuilder sb = new StringBuilder();
                 sb.append("<li>" + ruleId + "</li>");
                 if (whenTrue != null) {
                         sb.append("<ul><li>when true</li><ul>");
                         sb.append(getUlHelper(whenTrue));
                         sb.append("</ul></ul>");
                 }
                 if (whenFalse != null) {
                         sb.append("<ul><li>when false</li><ul>");
                         sb.append(getUlHelper(whenFalse));
                         sb.append("</ul></ul>");
                 }
                 if (always != null) {
                         sb.append(getUlHelper(always));
                 }
                 return sb.toString();
         }
 
     public String getRuleText() {
         StringBuilder resultBuilder = new StringBuilder();
         if (getRule() != null) {
             if (StringUtils.isBlank(getRule().getName())) {
                 resultBuilder.append("- unnamed rule -");
             } else {
                 resultBuilder.append(getRule().getName());
             }
             if (!StringUtils.isBlank(getRule().getDescription())) {
                 resultBuilder.append(": ");
                 resultBuilder.append(getRule().getDescription());
             }
         } else {
             throw new IllegalStateException();
         }
         return resultBuilder.toString();
     }
 
 //        def List<AgendaItemBo> alwaysList
 //        def List<AgendaItemBo> whenTrueList
 //        def List<AgendaItemBo> whenFalseList
         
         public List<AgendaItemBo> getAlwaysList() {
                 List<AgendaItemBo> results = new ArrayList<AgendaItemBo>();
                 
                 AgendaItemBo currentNode = this;
                 while (currentNode.always != null) {
                         results.add(currentNode.always);
                         currentNode = currentNode.always;
                 }
                 
                 return results;
         }
 
         /**
          * @return the id
          */
         public String getId() {
                 return this.id;
         }
 
         /**
          * @param id the id to set
          */
         public void setId(String id) {
                 this.id = id;
         }
 
         /**
          * @return the agendaId
          */
         public String getAgendaId() {
                 return this.agendaId;
         }
 
         /**
          * @param agendaId the agendaId to set
          */
         public void setAgendaId(String agendaId) {
                 this.agendaId = agendaId;
         }
 
         /**
          * @return the ruleId
          */
         public String getRuleId() {
                 return this.ruleId;
         }
 
         /**
          * @param ruleId the ruleId to set
          */
         public void setRuleId(String ruleId) {
                 this.ruleId = ruleId;
         }
 
         /**
          * @return the subAgendaId
          */
         public String getSubAgendaId() {
                 return this.subAgendaId;
         }
 
         /**
          * @param subAgendaId the subAgendaId to set
          */
         public void setSubAgendaId(String subAgendaId) {
                 this.subAgendaId = subAgendaId;
         }
 
 
         /**
          * @return the whenTrueId
          */
         public String getWhenTrueId() {
                 return this.whenTrueId;
         }
 
         /**
          * @param whenTrueId the whenTrueId to set
          */
         public void setWhenTrueId(String whenTrueId) {
                 this.whenTrueId = whenTrueId;
         }
 
         /**
          * @return the whenFalseId
          */
         public String getWhenFalseId() {
                 return this.whenFalseId;
         }
 
         /**
          * @param whenFalseId the whenFalseId to set
          */
         public void setWhenFalseId(String whenFalseId) {
                 this.whenFalseId = whenFalseId;
         }
 
         /**
          * @return the alwaysId
          */
         public String getAlwaysId() {
                 return this.alwaysId;
         }
 
         /**
          * @param alwaysId the alwaysId to set
          */
         public void setAlwaysId(String alwaysId) {
                 this.alwaysId = alwaysId;
         }
 
         /**
          * @return the whenTrue
          */
         public AgendaItemBo getWhenTrue() {
                 return this.whenTrue;
         }
 
         /**
          * @param whenTrue the whenTrue to set
          */
         public void setWhenTrue(AgendaItemBo whenTrue) {
                 this.whenTrue = whenTrue;
         }
 
         /**
          * @return the whenFalse
          */
         public AgendaItemBo getWhenFalse() {
                 return this.whenFalse;
         }
 
         /**
          * @param whenFalse the whenFalse to set
          */
         public void setWhenFalse(AgendaItemBo whenFalse) {
                 this.whenFalse = whenFalse;
         }
 
         /**
          * @return the always
          */
         public AgendaItemBo getAlways() {
                 return this.always;
         }
 
         /**
          * @param always the always to set
          */
         public void setAlways(AgendaItemBo always) {
                 this.always = always;
         }
         
     /**
      * @return the rule
      */
     public RuleBo getRule() {
         return this.rule;
     }
 
     /**
      * @param rule the rule to set
      */
     public void setRule(RuleBo rule) {
         this.rule = rule;
     }
 
         
     /**
         * Converts a mutable bo to it's immutable counterpart
         * @param bo the mutable business object
         * @return the immutable object
         */
    static AgendaItem to(AgendaItemBo bo) {
            if (bo == null) { return null; }
            org.kuali.rice.krms.api.repository.agenda.AgendaItem.Builder builder = 
                    org.kuali.rice.krms.api.repository.agenda.AgendaItem.Builder.create(bo.getId(), bo.getAgendaId());
            builder.setRuleId(bo.getRuleId());
            builder.setSubAgendaId(bo.getSubAgendaId());
            builder.setWhenTrueId(bo.getWhenTrueId());
            builder.setWhenFalseId(bo.getWhenFalseId());
            builder.setAlwaysId(bo.getAlwaysId());
            
            return builder.build();
    }
 
    /**
         * Converts a immutable object to it's mutable bo counterpart
         * @param im immutable object
         * @return the mutable bo
         */
    static AgendaItemBo from(AgendaItem im) {
            if (im == null) { return null; }
 
            AgendaItemBo bo = new AgendaItemBo();
            bo.id = im.getId();
            bo.agendaId = im.getAgendaId();
            bo.ruleId = im.getRuleId();
            bo.subAgendaId = im.getSubAgendaId();
            bo.whenTrueId = im.getWhenTrueId();
            bo.whenFalseId = im.getWhenFalseId();
            bo.alwaysId = im.getAlwaysId();
            
            return bo;
    }
 } 

1		/*
2		* Copyright 2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 1.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl1.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.krms.impl.repository;
17
18		import java.util.ArrayList;
19		import java.util.List;
20
21		import org.apache.commons.lang.StringUtils;
22		import org.kuali.rice.krad.bo.PersistableBusinessObjectBase;
23		import org.kuali.rice.krms.api.repository.agenda.AgendaItem;
24
25		/**
26		* Agenda Item business object
27		*
28		* @author Kuali Rice Team (rice.collab@kuali.org)
29		*
30		*/
31	0	public class AgendaItemBo extends PersistableBusinessObjectBase {
32
33		private String id;
34		private String agendaId;
35		private String ruleId;
36		private String subAgendaId;
37		private String whenTrueId;
38		private String whenFalseId;
39		private String alwaysId;
40
41		private RuleBo rule;
42
43		private AgendaItemBo whenTrue;
44		private AgendaItemBo whenFalse;
45		private AgendaItemBo always;
46
47		public String getUl(AgendaItemBo firstItem) {
48	0	return ("<ul>" + getUlHelper(firstItem) + "</ul>");
49		}
50
51		public String getUlHelper(AgendaItemBo item) {
52	0	StringBuilder sb = new StringBuilder();
53	0	sb.append("<li>" + ruleId + "</li>");
54	0	if (whenTrue != null) {
55	0	sb.append("<ul><li>when true</li><ul>");
56	0	sb.append(getUlHelper(whenTrue));
57	0	sb.append("</ul></ul>");
58		}
59	0	if (whenFalse != null) {
60	0	sb.append("<ul><li>when false</li><ul>");
61	0	sb.append(getUlHelper(whenFalse));
62	0	sb.append("</ul></ul>");
63		}
64	0	if (always != null) {
65	0	sb.append(getUlHelper(always));
66		}
67	0	return sb.toString();
68		}
69
70		public String getRuleText() {
71	0	StringBuilder resultBuilder = new StringBuilder();
72	0	if (getRule() != null) {
73	0	if (StringUtils.isBlank(getRule().getName())) {
74	0	resultBuilder.append("- unnamed rule -");
75		} else {
76	0	resultBuilder.append(getRule().getName());
77		}
78	0	if (!StringUtils.isBlank(getRule().getDescription())) {
79	0	resultBuilder.append(": ");
80	0	resultBuilder.append(getRule().getDescription());
81		}
82		} else {
83	0	throw new IllegalStateException();
84		}
85	0	return resultBuilder.toString();
86		}
87
88		// def List<AgendaItemBo> alwaysList
89		// def List<AgendaItemBo> whenTrueList
90		// def List<AgendaItemBo> whenFalseList
91
92		public List<AgendaItemBo> getAlwaysList() {
93	0	List<AgendaItemBo> results = new ArrayList<AgendaItemBo>();
94
95	0	AgendaItemBo currentNode = this;
96	0	while (currentNode.always != null) {
97	0	results.add(currentNode.always);
98	0	currentNode = currentNode.always;
99		}
100
101	0	return results;
102		}
103
104		/**
105		* @return the id
106		*/
107		public String getId() {
108	0	return this.id;
109		}
110
111		/**
112		* @param id the id to set
113		*/
114		public void setId(String id) {
115	0	this.id = id;
116	0	}
117
118		/**
119		* @return the agendaId
120		*/
121		public String getAgendaId() {
122	0	return this.agendaId;
123		}
124
125		/**
126		* @param agendaId the agendaId to set
127		*/
128		public void setAgendaId(String agendaId) {
129	0	this.agendaId = agendaId;
130	0	}
131
132		/**
133		* @return the ruleId
134		*/
135		public String getRuleId() {
136	0	return this.ruleId;
137		}
138
139		/**
140		* @param ruleId the ruleId to set
141		*/
142		public void setRuleId(String ruleId) {
143	0	this.ruleId = ruleId;
144	0	}
145
146		/**
147		* @return the subAgendaId
148		*/
149		public String getSubAgendaId() {
150	0	return this.subAgendaId;
151		}
152
153		/**
154		* @param subAgendaId the subAgendaId to set
155		*/
156		public void setSubAgendaId(String subAgendaId) {
157	0	this.subAgendaId = subAgendaId;
158	0	}
159
160
161		/**
162		* @return the whenTrueId
163		*/
164		public String getWhenTrueId() {
165	0	return this.whenTrueId;
166		}
167
168		/**
169		* @param whenTrueId the whenTrueId to set
170		*/
171		public void setWhenTrueId(String whenTrueId) {
172	0	this.whenTrueId = whenTrueId;
173	0	}
174
175		/**
176		* @return the whenFalseId
177		*/
178		public String getWhenFalseId() {
179	0	return this.whenFalseId;
180		}
181
182		/**
183		* @param whenFalseId the whenFalseId to set
184		*/
185		public void setWhenFalseId(String whenFalseId) {
186	0	this.whenFalseId = whenFalseId;
187	0	}
188
189		/**
190		* @return the alwaysId
191		*/
192		public String getAlwaysId() {
193	0	return this.alwaysId;
194		}
195
196		/**
197		* @param alwaysId the alwaysId to set
198		*/
199		public void setAlwaysId(String alwaysId) {
200	0	this.alwaysId = alwaysId;
201	0	}
202
203		/**
204		* @return the whenTrue
205		*/
206		public AgendaItemBo getWhenTrue() {
207	0	return this.whenTrue;
208		}
209
210		/**
211		* @param whenTrue the whenTrue to set
212		*/
213		public void setWhenTrue(AgendaItemBo whenTrue) {
214	0	this.whenTrue = whenTrue;
215	0	}
216
217		/**
218		* @return the whenFalse
219		*/
220		public AgendaItemBo getWhenFalse() {
221	0	return this.whenFalse;
222		}
223
224		/**
225		* @param whenFalse the whenFalse to set
226		*/
227		public void setWhenFalse(AgendaItemBo whenFalse) {
228	0	this.whenFalse = whenFalse;
229	0	}
230
231		/**
232		* @return the always
233		*/
234		public AgendaItemBo getAlways() {
235	0	return this.always;
236		}
237
238		/**
239		* @param always the always to set
240		*/
241		public void setAlways(AgendaItemBo always) {
242	0	this.always = always;
243	0	}
244
245		/**
246		* @return the rule
247		*/
248		public RuleBo getRule() {
249	0	return this.rule;
250		}
251
252		/**
253		* @param rule the rule to set
254		*/
255		public void setRule(RuleBo rule) {
256	0	this.rule = rule;
257	0	}
258
259
260		/**
261		* Converts a mutable bo to it's immutable counterpart
262		* @param bo the mutable business object
263		* @return the immutable object
264		*/
265		static AgendaItem to(AgendaItemBo bo) {
266	0	if (bo == null) { return null; }
267	0	org.kuali.rice.krms.api.repository.agenda.AgendaItem.Builder builder =
268		org.kuali.rice.krms.api.repository.agenda.AgendaItem.Builder.create(bo.getId(), bo.getAgendaId());
269	0	builder.setRuleId(bo.getRuleId());
270	0	builder.setSubAgendaId(bo.getSubAgendaId());
271	0	builder.setWhenTrueId(bo.getWhenTrueId());
272	0	builder.setWhenFalseId(bo.getWhenFalseId());
273	0	builder.setAlwaysId(bo.getAlwaysId());
274
275	0	return builder.build();
276		}
277
278		/**
279		* Converts a immutable object to it's mutable bo counterpart
280		* @param im immutable object
281		* @return the mutable bo
282		*/
283		static AgendaItemBo from(AgendaItem im) {
284	0	if (im == null) { return null; }
285
286	0	AgendaItemBo bo = new AgendaItemBo();
287	0	bo.id = im.getId();
288	0	bo.agendaId = im.getAgendaId();
289	0	bo.ruleId = im.getRuleId();
290	0	bo.subAgendaId = im.getSubAgendaId();
291	0	bo.whenTrueId = im.getWhenTrueId();
292	0	bo.whenFalseId = im.getWhenFalseId();
293	0	bo.alwaysId = im.getAlwaysId();
294
295	0	return bo;
296		}
297		}