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