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