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.scheduler;
016    
017    import com.liferay.portal.kernel.audit.AuditMessage;
018    import com.liferay.portal.kernel.audit.AuditRouterUtil;
019    import com.liferay.portal.kernel.cal.DayAndPosition;
020    import com.liferay.portal.kernel.cal.Duration;
021    import com.liferay.portal.kernel.cal.Recurrence;
022    import com.liferay.portal.kernel.cal.RecurrenceSerializer;
023    import com.liferay.portal.kernel.json.JSONFactoryUtil;
024    import com.liferay.portal.kernel.messaging.DestinationNames;
025    import com.liferay.portal.kernel.messaging.Message;
026    import com.liferay.portal.kernel.scheduler.JobState;
027    import com.liferay.portal.kernel.scheduler.SchedulerEngine;
028    import com.liferay.portal.kernel.scheduler.SchedulerEngineHelper;
029    import com.liferay.portal.kernel.scheduler.SchedulerEntry;
030    import com.liferay.portal.kernel.scheduler.SchedulerException;
031    import com.liferay.portal.kernel.scheduler.SchedulerLifecycle;
032    import com.liferay.portal.kernel.scheduler.StorageType;
033    import com.liferay.portal.kernel.scheduler.Trigger;
034    import com.liferay.portal.kernel.scheduler.TriggerState;
035    import com.liferay.portal.kernel.scheduler.messaging.SchedulerResponse;
036    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
037    import com.liferay.portal.kernel.util.CalendarFactoryUtil;
038    import com.liferay.portal.kernel.util.InetAddressUtil;
039    import com.liferay.portal.kernel.util.ObjectValuePair;
040    import com.liferay.portal.kernel.util.ParamUtil;
041    import com.liferay.portal.kernel.util.PortalLifecycle;
042    import com.liferay.portal.kernel.util.StringPool;
043    import com.liferay.portal.model.CompanyConstants;
044    import com.liferay.portal.util.PortalUtil;
045    import com.liferay.portal.util.PropsValues;
046    
047    import java.util.ArrayList;
048    import java.util.Calendar;
049    import java.util.Date;
050    import java.util.List;
051    
052    import javax.portlet.PortletRequest;
053    
054    /**
055     * @author Michael C. Han
056     */
057    @DoPrivileged
058    public class SchedulerEngineHelperImpl implements SchedulerEngineHelper {
059    
060            @Override
061            public void addJob(
062                            Trigger trigger, StorageType storageType, String description,
063                            String destinationName, Message message,
064                            String messageListenerClassName, String portletId,
065                            int exceptionsMaxSize)
066                    throws SchedulerException {
067    
068                    if (message == null) {
069                            message = new Message();
070                    }
071    
072                    message.put(
073                            SchedulerEngine.MESSAGE_LISTENER_CLASS_NAME,
074                            messageListenerClassName);
075                    message.put(SchedulerEngine.PORTLET_ID, portletId);
076    
077                    schedule(
078                            trigger, storageType, description, destinationName, message,
079                            exceptionsMaxSize);
080            }
081    
082            @Override
083            public void addJob(
084                            Trigger trigger, StorageType storageType, String description,
085                            String destinationName, Object payload,
086                            String messageListenerClassName, String portletId,
087                            int exceptionsMaxSize)
088                    throws SchedulerException {
089    
090                    Message message = new Message();
091    
092                    message.setPayload(payload);
093    
094                    addJob(
095                            trigger, storageType, description, destinationName, message,
096                            messageListenerClassName, portletId, exceptionsMaxSize);
097            }
098    
099            @Override
100            public void addScriptingJob(
101                            Trigger trigger, StorageType storageType, String description,
102                            String language, String script, int exceptionsMaxSize)
103                    throws SchedulerException {
104    
105                    Message message = new Message();
106    
107                    message.put(SchedulerEngine.LANGUAGE, language);
108                    message.put(SchedulerEngine.SCRIPT, script);
109    
110                    schedule(
111                            trigger, storageType, description,
112                            DestinationNames.SCHEDULER_SCRIPTING, message, exceptionsMaxSize);
113            }
114    
115            @Override
116            public void auditSchedulerJobs(Message message, TriggerState triggerState)
117                    throws SchedulerException {
118    
119                    if (!PropsValues.AUDIT_MESSAGE_SCHEDULER_JOB) {
120                            return;
121                    }
122    
123                    try {
124                            AuditMessage auditMessage = new AuditMessage(
125                                    SchedulerEngine.SCHEDULER, CompanyConstants.SYSTEM, 0,
126                                    StringPool.BLANK, SchedulerEngine.class.getName(), "0",
127                                    triggerState.toString(), new Date(),
128                                    JSONFactoryUtil.createJSONObject(
129                                            JSONFactoryUtil.serialize(message)));
130    
131                            auditMessage.setServerName(InetAddressUtil.getLocalHostName());
132                            auditMessage.setServerPort(PortalUtil.getPortalLocalPort(false));
133    
134                            AuditRouterUtil.route(auditMessage);
135                    }
136                    catch (Exception e) {
137                            throw new SchedulerException(e);
138                    }
139            }
140    
141            @Override
142            public void delete(SchedulerEntry schedulerEntry, StorageType storageType)
143                    throws SchedulerException {
144    
145                    Trigger trigger = schedulerEntry.getTrigger();
146    
147                    delete(trigger.getJobName(), trigger.getGroupName(), storageType);
148            }
149    
150            @Override
151            public void delete(String groupName, StorageType storageType)
152                    throws SchedulerException {
153    
154                    _schedulerEngine.delete(groupName, storageType);
155            }
156    
157            @Override
158            public void delete(
159                            String jobName, String groupName, StorageType storageType)
160                    throws SchedulerException {
161    
162                    _schedulerEngine.delete(jobName, groupName, storageType);
163            }
164    
165            @Override
166            public String getCronText(Calendar calendar, boolean timeZoneSensitive) {
167                    return getCronText(
168                            null, calendar, timeZoneSensitive, Recurrence.NO_RECURRENCE);
169            }
170    
171            @Override
172            public String getCronText(
173                    PortletRequest portletRequest, Calendar calendar,
174                    boolean timeZoneSensitive, int recurrenceType) {
175    
176                    Calendar recurrenceCalendar = null;
177    
178                    if (timeZoneSensitive) {
179                            recurrenceCalendar = CalendarFactoryUtil.getCalendar();
180    
181                            recurrenceCalendar.setTime(calendar.getTime());
182                    }
183                    else {
184                            recurrenceCalendar = (Calendar)calendar.clone();
185                    }
186    
187                    Recurrence recurrence = new Recurrence(
188                            recurrenceCalendar, new Duration(1, 0, 0, 0), recurrenceType);
189    
190                    recurrence.setWeekStart(Calendar.SUNDAY);
191    
192                    if (recurrenceType == Recurrence.DAILY) {
193                            int dailyType = ParamUtil.getInteger(portletRequest, "dailyType");
194    
195                            if (dailyType == 0) {
196                                    int dailyInterval = ParamUtil.getInteger(
197                                            portletRequest, "dailyInterval", 1);
198    
199                                    recurrence.setInterval(dailyInterval);
200                            }
201                            else {
202                                    DayAndPosition[] dayPos = {
203                                            new DayAndPosition(Calendar.MONDAY, 0),
204                                            new DayAndPosition(Calendar.TUESDAY, 0),
205                                            new DayAndPosition(Calendar.WEDNESDAY, 0),
206                                            new DayAndPosition(Calendar.THURSDAY, 0),
207                                            new DayAndPosition(Calendar.FRIDAY, 0)};
208    
209                                    recurrence.setByDay(dayPos);
210                            }
211                    }
212                    else if (recurrenceType == Recurrence.WEEKLY) {
213                            int weeklyInterval = ParamUtil.getInteger(
214                                    portletRequest, "weeklyInterval", 1);
215    
216                            recurrence.setInterval(weeklyInterval);
217    
218                            List<DayAndPosition> dayPos = new ArrayList<DayAndPosition>();
219    
220                            addWeeklyDayPos(portletRequest, dayPos, Calendar.SUNDAY);
221                            addWeeklyDayPos(portletRequest, dayPos, Calendar.MONDAY);
222                            addWeeklyDayPos(portletRequest, dayPos, Calendar.TUESDAY);
223                            addWeeklyDayPos(portletRequest, dayPos, Calendar.WEDNESDAY);
224                            addWeeklyDayPos(portletRequest, dayPos, Calendar.THURSDAY);
225                            addWeeklyDayPos(portletRequest, dayPos, Calendar.FRIDAY);
226                            addWeeklyDayPos(portletRequest, dayPos, Calendar.SATURDAY);
227    
228                            if (dayPos.isEmpty()) {
229                                    dayPos.add(new DayAndPosition(Calendar.MONDAY, 0));
230                            }
231    
232                            recurrence.setByDay(dayPos.toArray(new DayAndPosition[0]));
233                    }
234                    else if (recurrenceType == Recurrence.MONTHLY) {
235                            int monthlyType = ParamUtil.getInteger(
236                                    portletRequest, "monthlyType");
237    
238                            if (monthlyType == 0) {
239                                    int monthlyDay = ParamUtil.getInteger(
240                                            portletRequest, "monthlyDay0", 1);
241    
242                                    recurrence.setByMonthDay(new int[] {monthlyDay});
243    
244                                    int monthlyInterval = ParamUtil.getInteger(
245                                            portletRequest, "monthlyInterval0", 1);
246    
247                                    recurrence.setInterval(monthlyInterval);
248                            }
249                            else {
250                                    int monthlyPos = ParamUtil.getInteger(
251                                            portletRequest, "monthlyPos");
252                                    int monthlyDay = ParamUtil.getInteger(
253                                            portletRequest, "monthlyDay1");
254    
255                                    DayAndPosition[] dayPos = {
256                                            new DayAndPosition(monthlyDay, monthlyPos)};
257    
258                                    recurrence.setByDay(dayPos);
259    
260                                    int monthlyInterval = ParamUtil.getInteger(
261                                            portletRequest, "monthlyInterval1", 1);
262    
263                                    recurrence.setInterval(monthlyInterval);
264                            }
265                    }
266                    else if (recurrenceType == Recurrence.YEARLY) {
267                            int yearlyType = ParamUtil.getInteger(portletRequest, "yearlyType");
268    
269                            if (yearlyType == 0) {
270                                    int yearlyMonth = ParamUtil.getInteger(
271                                            portletRequest, "yearlyMonth0");
272                                    int yearlyDay = ParamUtil.getInteger(
273                                            portletRequest, "yearlyDay0", 1);
274    
275                                    recurrence.setByMonth(new int[] {yearlyMonth});
276                                    recurrence.setByMonthDay(new int[] {yearlyDay});
277    
278                                    int yearlyInterval = ParamUtil.getInteger(
279                                            portletRequest, "yearlyInterval0", 1);
280    
281                                    recurrence.setInterval(yearlyInterval);
282                            }
283                            else {
284                                    int yearlyPos = ParamUtil.getInteger(
285                                            portletRequest, "yearlyPos");
286                                    int yearlyDay = ParamUtil.getInteger(
287                                            portletRequest, "yearlyDay1");
288                                    int yearlyMonth = ParamUtil.getInteger(
289                                            portletRequest, "yearlyMonth1");
290    
291                                    DayAndPosition[] dayPos = {
292                                            new DayAndPosition(yearlyDay, yearlyPos)};
293    
294                                    recurrence.setByDay(dayPos);
295    
296                                    recurrence.setByMonth(new int[] {yearlyMonth});
297    
298                                    int yearlyInterval = ParamUtil.getInteger(
299                                            portletRequest, "yearlyInterval1", 1);
300    
301                                    recurrence.setInterval(yearlyInterval);
302                            }
303                    }
304    
305                    return RecurrenceSerializer.toCronText(recurrence);
306            }
307    
308            @Override
309            public Date getEndTime(SchedulerResponse schedulerResponse) {
310                    Message message = schedulerResponse.getMessage();
311    
312                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
313    
314                    TriggerState triggerState = jobState.getTriggerState();
315    
316                    if (triggerState.equals(TriggerState.NORMAL) ||
317                            triggerState.equals(TriggerState.PAUSED)) {
318    
319                            return (Date)message.get(SchedulerEngine.END_TIME);
320                    }
321                    else {
322                            return jobState.getTriggerDate(SchedulerEngine.END_TIME);
323                    }
324            }
325    
326            @Override
327            public Date getEndTime(
328                            String jobName, String groupName, StorageType storageType)
329                    throws SchedulerException {
330    
331                    SchedulerResponse schedulerResponse = getScheduledJob(
332                            jobName, groupName, storageType);
333    
334                    if (schedulerResponse != null) {
335                            return getEndTime(schedulerResponse);
336                    }
337    
338                    return null;
339            }
340    
341            @Override
342            public Date getFinalFireTime(SchedulerResponse schedulerResponse) {
343                    Message message = schedulerResponse.getMessage();
344    
345                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
346    
347                    TriggerState triggerState = jobState.getTriggerState();
348    
349                    if (triggerState.equals(TriggerState.NORMAL) ||
350                            triggerState.equals(TriggerState.PAUSED)) {
351    
352                            return (Date)message.get(SchedulerEngine.FINAL_FIRE_TIME);
353                    }
354                    else {
355                            return jobState.getTriggerDate(SchedulerEngine.FINAL_FIRE_TIME);
356                    }
357            }
358    
359            @Override
360            public Date getFinalFireTime(
361                            String jobName, String groupName, StorageType storageType)
362                    throws SchedulerException {
363    
364                    SchedulerResponse schedulerResponse = getScheduledJob(
365                            jobName, groupName, storageType);
366    
367                    if (schedulerResponse != null) {
368                            return getFinalFireTime(schedulerResponse);
369                    }
370    
371                    return null;
372            }
373    
374            @Override
375            public ObjectValuePair<Exception, Date>[] getJobExceptions(
376                    SchedulerResponse schedulerResponse) {
377    
378                    Message message = schedulerResponse.getMessage();
379    
380                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
381    
382                    return jobState.getExceptions();
383            }
384    
385            @Override
386            public ObjectValuePair<Exception, Date>[] getJobExceptions(
387                            String jobName, String groupName, StorageType storageType)
388                    throws SchedulerException {
389    
390                    SchedulerResponse schedulerResponse = getScheduledJob(
391                            jobName, groupName, storageType);
392    
393                    if (schedulerResponse != null) {
394                            return getJobExceptions(schedulerResponse);
395                    }
396    
397                    return null;
398            }
399    
400            @Override
401            public TriggerState getJobState(SchedulerResponse schedulerResponse) {
402                    Message message = schedulerResponse.getMessage();
403    
404                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
405    
406                    return jobState.getTriggerState();
407            }
408    
409            @Override
410            public TriggerState getJobState(
411                            String jobName, String groupName, StorageType storageType)
412                    throws SchedulerException {
413    
414                    SchedulerResponse schedulerResponse = getScheduledJob(
415                            jobName, groupName, storageType);
416    
417                    if (schedulerResponse != null) {
418                            return getJobState(schedulerResponse);
419                    }
420    
421                    return null;
422            }
423    
424            @Override
425            public Date getNextFireTime(SchedulerResponse schedulerResponse) {
426                    Message message = schedulerResponse.getMessage();
427    
428                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
429    
430                    TriggerState triggerState = jobState.getTriggerState();
431    
432                    if (triggerState.equals(TriggerState.NORMAL) ||
433                            triggerState.equals(TriggerState.PAUSED)) {
434    
435                            return (Date)message.get(SchedulerEngine.NEXT_FIRE_TIME);
436                    }
437                    else {
438                            return jobState.getTriggerDate(SchedulerEngine.NEXT_FIRE_TIME);
439                    }
440            }
441    
442            @Override
443            public Date getNextFireTime(
444                            String jobName, String groupName, StorageType storageType)
445                    throws SchedulerException {
446    
447                    SchedulerResponse schedulerResponse = getScheduledJob(
448                            jobName, groupName, storageType);
449    
450                    if (schedulerResponse != null) {
451                            return getNextFireTime(schedulerResponse);
452                    }
453    
454                    return null;
455            }
456    
457            @Override
458            public Date getPreviousFireTime(SchedulerResponse schedulerResponse) {
459                    Message message = schedulerResponse.getMessage();
460    
461                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
462    
463                    TriggerState triggerState = jobState.getTriggerState();
464    
465                    if (triggerState.equals(TriggerState.NORMAL) ||
466                            triggerState.equals(TriggerState.PAUSED)) {
467    
468                            return (Date)message.get(SchedulerEngine.PREVIOUS_FIRE_TIME);
469                    }
470                    else {
471                            return jobState.getTriggerDate(SchedulerEngine.PREVIOUS_FIRE_TIME);
472                    }
473            }
474    
475            @Override
476            public Date getPreviousFireTime(
477                            String jobName, String groupName, StorageType storageType)
478                    throws SchedulerException {
479    
480                    SchedulerResponse schedulerResponse = getScheduledJob(
481                            jobName, groupName, storageType);
482    
483                    if (schedulerResponse != null) {
484                            return getPreviousFireTime(schedulerResponse);
485                    }
486    
487                    return null;
488            }
489    
490            @Override
491            public SchedulerResponse getScheduledJob(
492                            String jobName, String groupName, StorageType storageType)
493                    throws SchedulerException {
494    
495                    return _schedulerEngine.getScheduledJob(
496                            jobName, groupName, storageType);
497            }
498    
499            @Override
500            public List<SchedulerResponse> getScheduledJobs()
501                    throws SchedulerException {
502    
503                    return _schedulerEngine.getScheduledJobs();
504            }
505    
506            @Override
507            public List<SchedulerResponse> getScheduledJobs(StorageType storageType)
508                    throws SchedulerException {
509    
510                    return _schedulerEngine.getScheduledJobs(storageType);
511            }
512    
513            @Override
514            public List<SchedulerResponse> getScheduledJobs(
515                            String groupName, StorageType storageType)
516                    throws SchedulerException {
517    
518                    return _schedulerEngine.getScheduledJobs(groupName, storageType);
519            }
520    
521            @Override
522            public Date getStartTime(SchedulerResponse schedulerResponse) {
523                    Message message = schedulerResponse.getMessage();
524    
525                    JobState jobState = (JobState)message.get(SchedulerEngine.JOB_STATE);
526    
527                    TriggerState triggerState = jobState.getTriggerState();
528    
529                    if (triggerState.equals(TriggerState.NORMAL) ||
530                            triggerState.equals(TriggerState.PAUSED)) {
531    
532                            return (Date)message.get(SchedulerEngine.START_TIME);
533                    }
534                    else {
535                            return jobState.getTriggerDate(SchedulerEngine.START_TIME);
536                    }
537            }
538    
539            @Override
540            public Date getStartTime(
541                            String jobName, String groupName, StorageType storageType)
542                    throws SchedulerException {
543    
544                    SchedulerResponse schedulerResponse = getScheduledJob(
545                            jobName, groupName, storageType);
546    
547                    if (schedulerResponse != null) {
548                            return getStartTime(schedulerResponse);
549                    }
550    
551                    return null;
552            }
553    
554            @Override
555            public void initialize() {
556                    SchedulerLifecycle schedulerLifecycle = new SchedulerLifecycle();
557    
558                    schedulerLifecycle.registerPortalLifecycle(PortalLifecycle.METHOD_INIT);
559            }
560    
561            @Override
562            public void pause(String groupName, StorageType storageType)
563                    throws SchedulerException {
564    
565                    _schedulerEngine.pause(groupName, storageType);
566            }
567    
568            @Override
569            public void pause(String jobName, String groupName, StorageType storageType)
570                    throws SchedulerException {
571    
572                    _schedulerEngine.pause(jobName, groupName, storageType);
573            }
574    
575            @Override
576            public void resume(String groupName, StorageType storageType)
577                    throws SchedulerException {
578    
579                    _schedulerEngine.resume(groupName, storageType);
580            }
581    
582            @Override
583            public void resume(
584                            String jobName, String groupName, StorageType storageType)
585                    throws SchedulerException {
586    
587                    _schedulerEngine.resume(jobName, groupName, storageType);
588            }
589    
590            @Override
591            public void schedule(
592                            SchedulerEntry schedulerEntry, StorageType storageType,
593                            String portletId, int exceptionsMaxSize)
594                    throws SchedulerException {
595    
596                    Message message = new Message();
597    
598                    message.put(
599                            SchedulerEngine.MESSAGE_LISTENER_CLASS_NAME,
600                            schedulerEntry.getEventListenerClass());
601                    message.put(SchedulerEngine.PORTLET_ID, portletId);
602    
603                    schedule(
604                            schedulerEntry.getTrigger(), storageType,
605                            schedulerEntry.getDescription(),
606                            DestinationNames.SCHEDULER_DISPATCH, message, exceptionsMaxSize);
607            }
608    
609            @Override
610            public void schedule(
611                            Trigger trigger, StorageType storageType, String description,
612                            String destinationName, Message message, int exceptionsMaxSize)
613                    throws SchedulerException {
614    
615                    if (message == null) {
616                            message = new Message();
617                    }
618    
619                    message.put(SchedulerEngine.EXCEPTIONS_MAX_SIZE, exceptionsMaxSize);
620    
621                    _schedulerEngine.schedule(
622                            trigger, description, destinationName, message, storageType);
623            }
624    
625            @Override
626            public void schedule(
627                            Trigger trigger, StorageType storageType, String description,
628                            String destinationName, Object payload, int exceptionsMaxSize)
629                    throws SchedulerException {
630    
631                    Message message = new Message();
632    
633                    message.setPayload(payload);
634    
635                    schedule(
636                            trigger, storageType, description, destinationName, message,
637                            exceptionsMaxSize);
638            }
639    
640            public void setSchedulerEngine(SchedulerEngine schedulerEngine) {
641                    _schedulerEngine = schedulerEngine;
642            }
643    
644            @Override
645            public void shutdown() throws SchedulerException {
646                    _schedulerEngine.shutdown();
647            }
648    
649            @Override
650            public void start() throws SchedulerException {
651                    _schedulerEngine.start();
652            }
653    
654            @Override
655            public void suppressError(
656                            String jobName, String groupName, StorageType storageType)
657                    throws SchedulerException {
658    
659                    _schedulerEngine.suppressError(jobName, groupName, storageType);
660            }
661    
662            @Override
663            public void unschedule(
664                            SchedulerEntry schedulerEntry, StorageType storageType)
665                    throws SchedulerException {
666    
667                    Trigger trigger = schedulerEntry.getTrigger();
668    
669                    unschedule(trigger.getJobName(), trigger.getGroupName(), storageType);
670            }
671    
672            @Override
673            public void unschedule(String groupName, StorageType storageType)
674                    throws SchedulerException {
675    
676                    _schedulerEngine.unschedule(groupName, storageType);
677            }
678    
679            @Override
680            public void unschedule(
681                            String jobName, String groupName, StorageType storageType)
682                    throws SchedulerException {
683    
684                    _schedulerEngine.unschedule(jobName, groupName, storageType);
685            }
686    
687            @Override
688            public void update(
689                            String jobName, String groupName, StorageType storageType,
690                            String description, String language, String script,
691                            int exceptionsMaxSize)
692                    throws SchedulerException {
693    
694                    SchedulerResponse schedulerResponse = getScheduledJob(
695                            jobName, groupName, storageType);
696    
697                    if (schedulerResponse == null) {
698                            return;
699                    }
700    
701                    Trigger trigger = schedulerResponse.getTrigger();
702    
703                    if (trigger == null) {
704                            return;
705                    }
706    
707                    Message message = schedulerResponse.getMessage();
708    
709                    if (message == null) {
710                            return;
711                    }
712    
713                    addScriptingJob(
714                            trigger, storageType, description, language, script,
715                            exceptionsMaxSize);
716            }
717    
718            @Override
719            public void update(Trigger trigger, StorageType storageType)
720                    throws SchedulerException {
721    
722                    _schedulerEngine.update(trigger, storageType);
723            }
724    
725            protected void addWeeklyDayPos(
726                    PortletRequest portletRequest, List<DayAndPosition> list, int day) {
727    
728                    if (ParamUtil.getBoolean(portletRequest, "weeklyDayPos" + day)) {
729                            list.add(new DayAndPosition(day, 0));
730                    }
731            }
732    
733            private SchedulerEngine _schedulerEngine;
734    
735    }