KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > dotmarketing > portlets > events > factories > RecuranceFactory


1 package com.dotmarketing.portlets.events.factories;
2
3 import java.lang.reflect.InvocationTargetException JavaDoc;
4 import java.util.Calendar JavaDoc;
5 import java.util.GregorianCalendar JavaDoc;
6 import java.util.HashSet JavaDoc;
7 import java.util.Iterator JavaDoc;
8 import java.util.List JavaDoc;
9
10 import net.sf.hibernate.HibernateException;
11
12 import org.apache.commons.beanutils.BeanUtils;
13
14 import com.dotmarketing.beans.Identifier;
15 import com.dotmarketing.beans.Inode;
16 import com.dotmarketing.db.DotHibernate;
17 import com.dotmarketing.factories.InodeFactory;
18 import com.dotmarketing.portlets.categories.model.Category;
19 import com.dotmarketing.portlets.events.model.Event;
20 import com.dotmarketing.portlets.events.model.EventRegistration;
21 import com.dotmarketing.portlets.events.model.Recurance;
22 import com.dotmarketing.portlets.facilities.model.Facility;
23 import com.dotmarketing.portlets.files.model.File;
24
25 /**
26  *
27  * @author will
28  */
29
30 public class RecuranceFactory {
31
32     public static Recurance newInstance() {
33         Recurance r = new Recurance();
34
35         return r;
36     }
37
38     public static void buildRecurringEvents(Recurance r, Event e) throws InvocationTargetException JavaDoc, IllegalAccessException JavaDoc, HibernateException {
39
40         if (r == null || e == null || r.getInode() == 0 || e.getInode() == 0) {
41             return;
42         }
43         List JavaDoc l = InodeFactory.getParentsOfClass(r, Event.class);
44         Iterator JavaDoc i = l.iterator();
45         while (i.hasNext()) {
46             Event evt = (Event) i.next();
47             if (evt.getSetupDate().before(e.getSetupDate())) {
48                 e.setSetupDate(evt.getSetupDate());
49                 e.setBreakDate(evt.getBreakDate());
50             }
51         }
52         
53         int interval = r.getInterval();
54
55         GregorianCalendar JavaDoc startDate = new GregorianCalendar JavaDoc();
56         GregorianCalendar JavaDoc endDate = new GregorianCalendar JavaDoc();
57         GregorianCalendar JavaDoc endTime = new GregorianCalendar JavaDoc();
58
59         GregorianCalendar JavaDoc setupDate = new GregorianCalendar JavaDoc();
60         GregorianCalendar JavaDoc breakDate = new GregorianCalendar JavaDoc();
61         
62         startDate.setTime(r.getStarting());
63         endDate.setTime(r.getEnding());
64         endTime.setTime(r.getEnding());
65
66         setupDate.setTime(e.getSetupDate());
67         breakDate.setTime(e.getBreakDate());
68         
69         endDate.set(Calendar.HOUR_OF_DAY, 23);
70         endDate.set(Calendar.MINUTE, 59);
71         endDate.set(Calendar.SECOND, 59);
72
73         new DotHibernate ().getSession().refresh(e);
74         
75         
76         List JavaDoc parents = InodeFactory.getParentsOfClass(e, Category.class);
77         parents.addAll(InodeFactory.getParentsOfClass(e, Facility.class));
78         
79         
80         List JavaDoc children = InodeFactory.getChildrenClass(e, File.class);
81         children.addAll(InodeFactory.getChildrenClass(e, EventRegistration.class));
82         children.addAll(InodeFactory.getChildrenClass(e, Recurance.class));
83         children.addAll(InodeFactory.getChildrenClass(e, Identifier.class));
84         
85         //wipe old events, except for the original
86 i = l.iterator();
87         while (i.hasNext()) {
88             Event event = (Event) i.next();
89             if (event.getInode() != e.getInode()) {
90                 InodeFactory.deleteInode(event);
91             }
92         }
93
94         while (startDate.getTime().before(endDate.getTime())) {
95
96             //copy our event information
97 Event recEvent = new Event();
98             BeanUtils.copyProperties(recEvent, e);
99             //recEvent.setChildren(null);
100 //recEvent.setParents(null);
101 recEvent.setInode(0);
102
103             if ("day".equals(r.getOccurs())) {
104
105                 //build the start time/date
106 GregorianCalendar JavaDoc cal = new GregorianCalendar JavaDoc();
107                 cal.setTime(startDate.getTime());
108                 cal.set(Calendar.HOUR_OF_DAY, startDate.get(Calendar.HOUR_OF_DAY));
109                 cal.set(Calendar.MINUTE, startDate.get(Calendar.MINUTE));
110                 recEvent.setStartDate(cal.getTime());
111
112                 //build end date/time
113 cal = new GregorianCalendar JavaDoc();
114                 cal.setTime(startDate.getTime());
115                 cal.set(Calendar.HOUR_OF_DAY, endTime.get(Calendar.HOUR_OF_DAY));
116                 cal.set(Calendar.MINUTE, endTime.get(Calendar.MINUTE));
117                 recEvent.setEndDate(cal.getTime());
118
119                 recEvent.setSetupDate(setupDate.getTime());
120                 recEvent.setBreakDate(breakDate.getTime());
121                 
122                 //if this event is after, die
123 if (cal.getTime().after(endDate.getTime()))
124                     break;
125
126                 //save new event
127 InodeFactory.saveInode(recEvent);
128                 recEvent.addChild(r);
129
130                 //add to parents
131 Iterator JavaDoc ii = parents.iterator();
132                 while (ii.hasNext()) {
133                     Inode inode = (Inode) ii.next();
134                     inode.addChild(recEvent);
135                 }
136                 //add to children
137 ii = children.iterator();
138                 while (ii.hasNext()) {
139                     Inode inode = (Inode) ii.next();
140                     recEvent.addChild(inode);
141                 }
142
143                 //add to start date
144 startDate.add(Calendar.DAY_OF_MONTH, interval);
145                 setupDate.add(Calendar.DAY_OF_MONTH, interval);
146                 breakDate.add(Calendar.DAY_OF_MONTH, interval);
147             }
148             //event days of week
149 else if ("week".equals(r.getOccurs())) {
150                 if (r.getDaysOfWeek() == null) {
151                     InodeFactory.deleteInode(r);
152                     return;
153                 }
154                 for (int j = 1; j < 8; j++) {
155                     //System.out.println("days of the week="+r.getDaysOfWeek());
156 String JavaDoc x = Integer.toString(startDate.get(Calendar.DAY_OF_WEEK));
157                     if (r.getDaysOfWeek().indexOf(x) > -1) {
158                         
159                         //recreates the event for this
160 recEvent = new Event();
161                         BeanUtils.copyProperties(recEvent, e);
162                         //recEvent.setChildren(null);
163 //recEvent.setParents(null);
164 recEvent.setInode(0);
165
166                         //build the start time/date
167 GregorianCalendar JavaDoc cal = new GregorianCalendar JavaDoc();
168                         cal.setTime(startDate.getTime());
169                         cal.set(Calendar.HOUR_OF_DAY, startDate.get(Calendar.HOUR_OF_DAY));
170                         cal.set(Calendar.MINUTE, startDate.get(Calendar.MINUTE));
171                         recEvent.setStartDate(cal.getTime());
172
173                         //build end date/time
174 cal = new GregorianCalendar JavaDoc();
175                         cal.setTime(startDate.getTime());
176                         cal.set(Calendar.HOUR_OF_DAY, endTime.get(Calendar.HOUR_OF_DAY));
177                         cal.set(Calendar.MINUTE, endTime.get(Calendar.MINUTE));
178                         recEvent.setEndDate(cal.getTime());
179
180                         recEvent.setSetupDate(setupDate.getTime());
181                         recEvent.setBreakDate(breakDate.getTime());
182                         
183                         //if this event is after, die
184 if (cal.getTime().after(endDate.getTime()))
185                             break;
186
187                         //save new event
188 InodeFactory.saveInode(recEvent);
189                         recEvent.addChild(r);
190
191                         //add to parents
192 Iterator JavaDoc ii = parents.iterator();
193                         while (ii.hasNext()) {
194                             Inode inode = (Inode) ii.next();
195                             inode.addChild(recEvent);
196                         }
197                         //add to children
198 ii = children.iterator();
199                         while (ii.hasNext()) {
200                             Inode inode = (Inode) ii.next();
201                             recEvent.addChild(inode);
202                         }
203
204                     }
205                     startDate.add(Calendar.DAY_OF_MONTH, 1);
206                     setupDate.add(Calendar.DAY_OF_MONTH, 1);
207                     breakDate.add(Calendar.DAY_OF_MONTH, 1);
208                 }
209                 startDate.add(Calendar.WEEK_OF_YEAR, interval - 1);
210                 setupDate.add(Calendar.WEEK_OF_YEAR, interval - 1);
211                 breakDate.add(Calendar.WEEK_OF_YEAR, interval - 1);
212             }
213             else {
214
215                 //build the start time/date
216
217                 if (startDate.get(Calendar.DAY_OF_MONTH) > r.getDayOfMonth()) {
218                     startDate.add(Calendar.MONTH, 1);
219                 }
220                 
221                 GregorianCalendar JavaDoc cal = new GregorianCalendar JavaDoc();
222                 cal.setTime(startDate.getTime());
223                 cal.set(Calendar.HOUR_OF_DAY, startDate.get(Calendar.HOUR_OF_DAY));
224                 cal.set(Calendar.MINUTE, startDate.get(Calendar.MINUTE));
225                 cal.set(Calendar.DAY_OF_MONTH, r.getDayOfMonth());
226                 recEvent.setStartDate(cal.getTime());
227
228                 //build end date/time
229 cal = new GregorianCalendar JavaDoc();
230                 cal.setTime(startDate.getTime());
231                 cal.set(Calendar.HOUR_OF_DAY, endTime.get(Calendar.HOUR_OF_DAY));
232                 cal.set(Calendar.MINUTE, endTime.get(Calendar.MINUTE));
233                 cal.set(Calendar.DAY_OF_MONTH, r.getDayOfMonth());
234                 recEvent.setEndDate(cal.getTime());
235
236                 recEvent.setSetupDate(setupDate.getTime());
237                 recEvent.setBreakDate(breakDate.getTime());
238          
239                 //if this event is after, die
240 if (cal.getTime().after(endDate.getTime()))
241                     break;
242
243                 //save new event
244 InodeFactory.saveInode(recEvent);
245                 recEvent.addChild(r);
246
247                 //add to parents
248 Iterator JavaDoc ii = parents.iterator();
249                 while (ii.hasNext()) {
250                     Inode inode = (Inode) ii.next();
251                     inode.addChild(recEvent);
252                 }
253                 //add to children
254 ii = children.iterator();
255                 while (ii.hasNext()) {
256                     Inode inode = (Inode) ii.next();
257                     recEvent.addChild(inode);
258                 }
259
260                 //add to start date
261 startDate.add(Calendar.MONTH, interval);
262                 setupDate.add(Calendar.MONTH, interval);
263                 breakDate.add(Calendar.MONTH, interval);
264             }
265
266         }
267
268
269         //delete the original event
270 InodeFactory.deleteInode(e);
271
272     }
273
274     public static void deleteRecurringEvents(Recurance r) {
275
276         //wipe old events, except for the one we were passed
277 List JavaDoc l = InodeFactory.getParentsOfClass(r, Event.class);
278         Iterator JavaDoc i = l.iterator();
279         while (i.hasNext()) {
280             Event event = (Event) i.next();
281             InodeFactory.deleteInode(event);
282         }
283         InodeFactory.deleteInode(r);
284
285     }
286     public static void deleteRecurringEvents(String JavaDoc r) {
287
288         deleteRecurringEvents((Recurance) InodeFactory.getInode(r, Recurance.class));
289     }
290
291 }
292
Popular Tags