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