8a58df3093
Got rid of all the stuff related to GUNID hex-to-int conversion. Commented out lots of functions that are either not in use or will no longer work. Pypo: made things more generic and pluggable, added documentation. Added the PHP scripts to serve the right info back to pypo.
1285 lines
No EOL
42 KiB
PHP
1285 lines
No EOL
42 KiB
PHP
<?php
|
|
require_once(dirname(__FILE__)."/ui_calendar.class.php");
|
|
require_once(dirname(__FILE__)."/../backend/Schedule.php");
|
|
require_once('Calendar/Month/Weekdays.php');
|
|
require_once('Calendar/Week.php');
|
|
|
|
/**
|
|
* @package Campcaster
|
|
* @subpackage htmlUI
|
|
* @copyright 2010 Sourcefabric O.P.S.
|
|
*/
|
|
class uiScheduler extends uiCalendar {
|
|
/**
|
|
* @var array
|
|
*/
|
|
public $curr;
|
|
|
|
/**
|
|
* For the "schedule at time" value.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $scheduleAtTime;
|
|
|
|
/**
|
|
* For the "snap to previous" value.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $schedulePrev;
|
|
|
|
/**
|
|
* For the "snap to next" value.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $scheduleNext;
|
|
|
|
/**
|
|
* @var SchedulerPhpClient
|
|
*/
|
|
public $spc;
|
|
|
|
/**
|
|
* @var uiBase
|
|
*/
|
|
public $Base;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
public $reloadUrl;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
public $closeUrl;
|
|
|
|
/**
|
|
* Playlists that are available to be scheduled. These are copied
|
|
* from the scratchpad.
|
|
*
|
|
* @var array
|
|
*/
|
|
private $availablePlaylists;
|
|
|
|
public $firstDayOfWeek;
|
|
private $scriptError;
|
|
public $error;
|
|
|
|
|
|
public function __construct(&$uiBase)
|
|
{
|
|
$this->curr =& $_SESSION[UI_CALENDAR_SESSNAME]['current'];
|
|
$this->scheduleAtTime =& $_SESSION[UI_CALENDAR_SESSNAME]['scheduleAtTime'];
|
|
$this->schedulePrev =& $_SESSION[UI_CALENDAR_SESSNAME]['schedulePrev'];
|
|
$this->scheduleNext =& $_SESSION[UI_CALENDAR_SESSNAME]['scheduleNext'];
|
|
#$this->error =& $_SESSION['SCHEDULER']['error'];
|
|
|
|
if (!is_array($this->curr)) {
|
|
$this->curr['view'] = UI_SCHEDULER_DEFAULT_VIEW;
|
|
$this->curr['year'] = strftime("%Y");
|
|
$this->curr['month'] = strftime("%m");
|
|
$this->curr['week'] = strftime("%V");
|
|
$this->curr['day'] = strftime("%d");
|
|
$this->curr['hour'] = strftime("%H");
|
|
$this->curr['dayname'] = strftime("%A");
|
|
$this->curr['monthname'] = strftime("%B");
|
|
$this->curr['isToday'] = TRUE;
|
|
}
|
|
|
|
$this->Base =& $uiBase;
|
|
$this->reloadUrl = UI_BROWSER.'?popup[]=_reload_parent&popup[]=_close';
|
|
$this->closeUrl = UI_BROWSER.'?popup[]=_close';
|
|
parent::__construct();
|
|
$this->initXmlRpc();
|
|
} // constructor
|
|
|
|
|
|
public function setReload()
|
|
{
|
|
$this->Base->redirUrl = $this->reloadUrl;
|
|
} // fn setReload
|
|
|
|
|
|
public function setClose()
|
|
{
|
|
$this->Base->redirUrl = $this->closeUrl;
|
|
} // fn setClose
|
|
|
|
|
|
/**
|
|
* @param array $arr
|
|
* Can have keys:
|
|
* ["view"]
|
|
* ["today"]
|
|
* ["year"]
|
|
* ["month"]
|
|
* ["day"]
|
|
* ["hour"]
|
|
* @return void
|
|
*/
|
|
function set($arr)
|
|
{
|
|
extract($arr);
|
|
|
|
if (isset($view)) {
|
|
$this->curr['view'] = $view;
|
|
}
|
|
if (isset($today)) {
|
|
list($year, $month, $day) = explode("-", strftime("%Y-%m-%d"));
|
|
}
|
|
if (isset($year) && is_numeric($year)) {
|
|
$this->curr['year'] = sprintf('%04d', $year);
|
|
}
|
|
if (isset($month) && is_numeric($month)) {
|
|
$this->curr['month'] = sprintf('%02d', $month);
|
|
}
|
|
if (isset($day) && is_numeric($day)) {
|
|
$this->curr['day'] = sprintf('%02d', $day);
|
|
}
|
|
if (isset($hour) && is_numeric($hour)) {
|
|
$this->curr['hour'] = sprintf('%02d', $hour);
|
|
}
|
|
|
|
$stampNow = self::datetimeToTimestamp($this->curr['year']
|
|
.$this->curr['month']
|
|
.$this->curr['day']
|
|
.'T'.$this->curr['hour'].':00:00');
|
|
$stampTarget = $stampNow;
|
|
|
|
if (isset($month) && ($month==='++')) {
|
|
$stampTarget = strtotime("+1 month", $stampNow);
|
|
}
|
|
if (isset($month) && ($month==='--')) {
|
|
$stampTarget = strtotime("-1 month", $stampNow);
|
|
}
|
|
if (isset($week) && ($week==='++')) {
|
|
$stampTarget = strtotime("+1 week", $stampNow);
|
|
}
|
|
if (isset($week) && ($week==='--')) {
|
|
$stampTarget = strtotime("-1 week", $stampNow);
|
|
}
|
|
if (isset($day) && ($day==='++')) {
|
|
$stampTarget = strtotime("+1 day", $stampNow);
|
|
}
|
|
if (isset($day) && ($day==='--')) {
|
|
$stampTarget = strtotime("-1 day", $stampNow);
|
|
}
|
|
|
|
$this->curr['year'] = strftime("%Y", $stampTarget);
|
|
$this->curr['month'] = strftime("%m", $stampTarget);
|
|
$this->curr['week'] = strftime("%V", $stampTarget);
|
|
$this->curr['day'] = strftime("%d", $stampTarget);
|
|
$this->curr['hour'] = strftime("%H", $stampTarget);
|
|
$this->curr['dayname'] = strftime("%A", $stampTarget);
|
|
$this->curr['monthname'] = strftime("%B", $stampTarget);
|
|
|
|
if ($this->curr['year'] === strftime("%Y") && $this->curr['month'] === strftime("%m") && $this->curr['day'] === strftime("%d")) {
|
|
$this->curr['isToday'] = TRUE;
|
|
} else {
|
|
$this->curr['isToday'] = FALSE;
|
|
}
|
|
} // fn set
|
|
|
|
|
|
/**
|
|
* Set the schedule time given by parameters,
|
|
* calculate previous and next clip to snap with it
|
|
*
|
|
* @param input $arr
|
|
* Can contain keys:
|
|
* ["today"]
|
|
* ["year"]
|
|
* ["month"]
|
|
* ["day"]
|
|
* ["hour"]
|
|
* ["minute"]
|
|
* ["second"]
|
|
*
|
|
* @return void
|
|
*/
|
|
public function setScheduleAtTime($arr)
|
|
{
|
|
// $today = $arr['today'];
|
|
// $year = $arr['year'];
|
|
// $month = $arr['month'];
|
|
// $day = $arr['day'];
|
|
// $hour = $arr['hour'];
|
|
// $minute = $arr['minute'];
|
|
// $second = $arr['second'];
|
|
|
|
extract($arr);
|
|
|
|
if (isset($today)) {
|
|
list($year, $month, $day) = explode("-", strftime("%Y-%m-%d"));
|
|
}
|
|
if (is_numeric($year)) {
|
|
$this->scheduleAtTime['year'] = sprintf('%04d', $year);
|
|
}
|
|
if (is_numeric($month)) {
|
|
$this->scheduleAtTime['month'] = sprintf('%02d', $month);
|
|
}
|
|
if (is_numeric($day)) {
|
|
$this->scheduleAtTime['day'] = sprintf('%02d', $day);
|
|
}
|
|
if (is_numeric($hour)) {
|
|
$this->scheduleAtTime['hour'] = sprintf('%02d', $hour);
|
|
}
|
|
if (is_numeric($minute)) {
|
|
$this->scheduleAtTime['minute'] = sprintf('%02d', $minute);
|
|
}
|
|
if (is_numeric($second)) {
|
|
$this->scheduleAtTime['second'] = sprintf('%02d', $second);
|
|
}
|
|
|
|
$this->schedulePrev['year'] = $this->scheduleAtTime['year'];
|
|
$this->schedulePrev['month'] = $this->scheduleAtTime['month'];
|
|
$this->schedulePrev['day'] = $this->scheduleAtTime['day'];
|
|
$this->schedulePrev['hour'] = 0;
|
|
$this->schedulePrev['minute'] = 0;
|
|
$this->schedulePrev['second'] = 0;
|
|
|
|
$this->scheduleNext['year'] = $this->scheduleAtTime['year'];
|
|
$this->scheduleNext['month'] = $this->scheduleAtTime['month'];
|
|
$this->scheduleNext['day'] = $this->scheduleAtTime['day'];
|
|
$this->scheduleNext['hour'] = 23;
|
|
$this->scheduleNext['minute'] = 59;
|
|
$this->scheduleNext['second'] = 59;
|
|
|
|
$this->scheduleAtTime['stamp'] = self::datetimeToTimestamp(
|
|
$this->scheduleAtTime['year']
|
|
.$this->scheduleAtTime['month']
|
|
.$this->scheduleAtTime['day']
|
|
.'T'.$this->scheduleAtTime['hour']
|
|
.':'.$this->scheduleAtTime['minute']
|
|
.':'.$this->scheduleAtTime['second']);
|
|
|
|
$week = $this->getWeekEntrys();
|
|
if (is_array($week)) {
|
|
// Search for previous entry
|
|
if (count($week[$this->scheduleAtTime['day']]) >= 1) {
|
|
$reversedDays = array_reverse($week[$this->scheduleAtTime['day']]);
|
|
foreach ($reversedDays as $hourly) {
|
|
$reversedHours = array_reverse($hourly);
|
|
foreach ($reversedHours as $entry) {
|
|
if ($entry['end_stamp'] <= $this->scheduleAtTime['stamp']) {
|
|
list ($this->schedulePrev['hour'], $this->schedulePrev['minute'], $this->schedulePrev['second']) =
|
|
explode (':', strftime('%H:%M:%S', strtotime('+'.UI_SCHEDULER_PAUSE_PL2PL, strtotime($entry['end'])))
|
|
);
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reset($week);
|
|
|
|
// Search for next entry
|
|
if (count($week[$this->scheduleAtTime['day']]) >= 1) {
|
|
// Go through each hour
|
|
foreach ($week[$this->scheduleAtTime['day']] as $hourly) {
|
|
// Go through all the entries of the hour
|
|
foreach ($hourly as $entry) {
|
|
if ($entry['start_stamp'] >= $this->scheduleAtTime['stamp']) {
|
|
list ($this->scheduleNext['hour'], $this->scheduleNext['minute'], $this->scheduleNext['second']) =
|
|
explode (':', strftime('%H:%M:%S', strtotime('-'.UI_SCHEDULER_PAUSE_PL2PL, strtotime($entry['start']))));
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // fn setScheduleAtTime
|
|
|
|
|
|
/**
|
|
* Get all items scheduled for the week.
|
|
*
|
|
* @return false|array
|
|
*/
|
|
public function getWeekEntrys()
|
|
{
|
|
// build array within all entrys of current week
|
|
$this->buildWeek();
|
|
$thisWeekStart = strftime("%Y-%m-%d", $this->Week[0]['timestamp']);
|
|
$nextWeekStart = strftime("%Y-%m-%d", $this->Week[6]['timestamp'] + 86400);
|
|
$arr = $this->displayScheduleMethod($thisWeekStart.' 00:00:00', $nextWeekStart.' 00:00:00');
|
|
|
|
if (!is_array($arr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
$items = array();
|
|
foreach ($arr as $key => $val) {
|
|
if ($val["count"] == "1") {
|
|
$track = StoredFile::Recall($val["file_id"]);
|
|
$trackMetadata = $track->getMetadata();
|
|
$title = $trackMetadata["track_title"];
|
|
$creator = $trackMetadata["artist_name"];
|
|
} else {
|
|
$title = $val["name"];
|
|
$creator = $val["creator"];
|
|
}
|
|
|
|
$startDay = strftime('%d', self::datetimeToTimestamp($val['start']));
|
|
$startHour = number_format(strftime('%H', self::datetimeToTimestamp($val['start'])));
|
|
$items[$startDay][$startHour][]= array (
|
|
'id' => $val['playlistId'],
|
|
'scheduleid'=> $val["group_id"],
|
|
'start' => substr($val['start'], strpos($val['start'], ' ')+1),
|
|
'end' => substr($val['end'], strpos($val['end'], ' ')+1),
|
|
'start_stamp' => self::datetimeToTimestamp($val['start']),
|
|
'end_stamp' => self::datetimeToTimestamp($val['end']),
|
|
'title' => $title,
|
|
'creator' => $creator,
|
|
'type' => 'Playlist'
|
|
);
|
|
}
|
|
return $items;
|
|
} // fn getWeekEntrys
|
|
|
|
|
|
/**
|
|
* Get all items scheduled for a given day.
|
|
*
|
|
* @return array|false
|
|
*/
|
|
public function getDayEntrys()
|
|
{
|
|
// build array within all entrys of current day
|
|
$this->buildDay();
|
|
$thisDay = strftime("%Y-%m-%d", $this->Day[0]['timestamp']);
|
|
$nextDay = strftime("%Y-%m-%d", $this->Day[0]['timestamp'] + 86400);
|
|
$arr = $this->displayScheduleMethod($thisDay.' 00:00:00', $nextDay.' 00:00:00');
|
|
if (!is_array($arr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
$items = array();
|
|
foreach ($arr as $key => $val) {
|
|
$start = self::datetimeToTimestamp($val['start']);
|
|
$end = self::datetimeToTimestamp($val['end']);
|
|
$Y = strftime('%Y', $start);
|
|
$m = number_format(strftime('%m', $start));
|
|
$d = number_format(strftime('%d', $start));
|
|
$h = number_format(strftime('%H', $start));
|
|
$M = number_format(strftime('%i', $start));
|
|
|
|
$id = $val['playlistId'];
|
|
$startHour = (int)strftime('%H', $start);
|
|
$endHour = (int)strftime('%H', $end);
|
|
$startTime = substr($val['start'], strpos($val['start'], ' ')+1);
|
|
$endTime = substr($val['end'], strpos($val['end'], ' ') + 1);
|
|
|
|
if ($val["count"] == "1") {
|
|
$track = StoredFile::Recall($val["file_id"]);
|
|
$trackMetadata = $track->getMetadata();
|
|
$title = $trackMetadata["track_title"];
|
|
$creator = $trackMetadata["artist_name"];
|
|
} else {
|
|
$title = $val["name"];
|
|
$creator = $val["creator"];
|
|
}
|
|
// Item starts today
|
|
if (strftime('%Y-%m-%d', $start) === $thisDay) {
|
|
$endsToday = (strftime('%d', $start) === strftime('%d', $end)) ? TRUE : FALSE;
|
|
$endsHere = strftime('%H', $start) === strftime('%H', $end) ? TRUE : FALSE;
|
|
$items[$startHour]['start'][] =
|
|
array('id' => $id,
|
|
'scheduleid' => $val['id'],
|
|
'start' => $startTime,
|
|
'end' => $endTime,
|
|
'title' => $title,
|
|
'creator' => $creator,
|
|
'type' => 'Playlist',
|
|
'endstoday' => $endsToday,
|
|
'endshere' => $endsHere);
|
|
}
|
|
|
|
// Item ends today
|
|
if ( (strftime('%Y-%m-%d', $end) === $thisDay) && ($startHour !== $endHour) ) {
|
|
$startsYesterday = (strftime('%d', $start) === strftime('%d', $end)) ? FALSE : TRUE;
|
|
|
|
$items[$endHour]['end'][] =
|
|
array('id' => $id,
|
|
'scheduleid' => $val['id'],
|
|
'start' => $startTime,
|
|
'end' => $endTime,
|
|
'title' => $title,
|
|
'creator' => $creator,
|
|
'type' => 'Playlist',
|
|
'startsyesterday' => $startsYesterday);
|
|
}
|
|
|
|
$diffHours = floor(($end - $start)/3600);
|
|
// If the item spans three hours or more
|
|
if ( $diffHours > 2 ) {
|
|
// $skip becomes true if we dont actually have to do
|
|
// this section.
|
|
$skip = false;
|
|
if (strftime('%Y-%m-%d', $start) === $thisDay) {
|
|
// For the edge case of starting at the end of
|
|
// today.
|
|
if ($startHour == 23) {
|
|
$skip = true;
|
|
}
|
|
$countStart = $startHour + 1;
|
|
} else {
|
|
$countStart = 0;
|
|
}
|
|
if (strftime('%Y-%m-%d', $end) === $thisDay) {
|
|
// For the edge case of ending at the beginning
|
|
// of today.
|
|
if ($endHour == 0) {
|
|
$skip = true;
|
|
}
|
|
$countEnd = $endHour - 1;
|
|
} else {
|
|
$countEnd = 23;
|
|
}
|
|
if (!$skip) {
|
|
for ($i = $countStart; $i <= $countEnd; $i++) {
|
|
$items[$i]['span'] =
|
|
array('id' => $id,
|
|
'scheduleid' => $val['id'],
|
|
'start' => $startTime,
|
|
'end' => $endTime,
|
|
'title' => $title,
|
|
'creator' => $creator,
|
|
'type' => 'Playlist');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $items;
|
|
} // fn getDayEntrys
|
|
|
|
|
|
private function getDayUsage($year, $month, $day)
|
|
{
|
|
$thisDay = $year.$month.$day;
|
|
$nextDay = strftime("%Y-%m-%d", strtotime('+1 day', strtotime("$year-$month-$day")));
|
|
$arr = $this->displayScheduleMethod($thisDay.' 00:00:00', $nextDay.' 00:00:00');
|
|
|
|
if (!is_array($arr)) {
|
|
return FALSE;
|
|
}
|
|
|
|
foreach ($arr as $key => $val) {
|
|
$pl = Playlist::Recall($val['playlistId']);
|
|
//$id = BasicStor::IdFromGunid($val['playlistId']);
|
|
$arr[$key]['title'] = $pl->getName(); //$this->Base->getMetadataValue($id, UI_MDATA_KEY_TITLE);
|
|
$arr[$key]['creator'] = $pl->getPLMetaData("dc:title");// $this->Base->getMetadataValue($id, UI_MDATA_KEY_CREATOR);
|
|
$arr[$key]['pos'] = self::datetimeToTimestamp($val['start']);
|
|
$arr[$key]['span'] = date('H', self::datetimeToTimestamp($val['end'])) - date('H', self::datetimeToTimestamp($val['start'])) +1;
|
|
}
|
|
return $arr;
|
|
} // fn getDayUsage
|
|
|
|
|
|
/**
|
|
* Return the percentage of the day for which audio has been scheduled.
|
|
*
|
|
* @param int $year
|
|
* @param int $month
|
|
* @param int $day
|
|
* @return int
|
|
*/
|
|
public function getDayUsagePercentage($year, $month, $day)
|
|
{
|
|
if (!$arr = $this->getDayUsage($year, $month, $day)) {
|
|
return false;
|
|
}
|
|
|
|
$duration = 0;
|
|
foreach ($arr as $val) {
|
|
$duration += (self::datetimeToTimestamp($val['end'])-self::datetimeToTimestamp($val['start']))/86400*100;
|
|
}
|
|
return $duration;
|
|
} // fn getDayUsagePercentage
|
|
|
|
|
|
/**
|
|
* Return an array of numbers from 0 to 23.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getDayTimingScale()
|
|
{
|
|
for ($n = 0; $n <= 23; $n++) {
|
|
$scale[] = $n;
|
|
}
|
|
|
|
return $scale;
|
|
} //fn getDayTimingScale
|
|
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getScheduleForm()
|
|
{
|
|
global $ui_fmask;
|
|
foreach ($this->availablePlaylists as $val) {
|
|
$ui_fmask['schedule']['id_duration']['options'][$val['id'].'|'.$val['duration']] = $val['title'];
|
|
}
|
|
|
|
$form = new HTML_QuickForm('schedule', UI_STANDARD_FORM_METHOD, UI_HANDLER);
|
|
uiBase::parseArrayToForm($form, $ui_fmask['schedule']);
|
|
$settime = array('H' => $this->scheduleAtTime['hour'],
|
|
'i' => $this->scheduleAtTime['minute'],
|
|
's' => $this->scheduleAtTime['second']);
|
|
$setdate = array('Y' => $this->scheduleAtTime['year'],
|
|
'm' => $this->scheduleAtTime['month'],
|
|
'd' => $this->scheduleAtTime['day']);
|
|
$form->setDefaults(array('time' => $settime,
|
|
'date' => $setdate));
|
|
|
|
$renderer = new HTML_QuickForm_Renderer_Array(true, true);
|
|
$form->accept($renderer);
|
|
$output = $renderer->toArray();
|
|
return $output;
|
|
} // fn getScheduleForm
|
|
|
|
|
|
public function getPlaylistToSchedule($id)
|
|
{
|
|
if ($id) {
|
|
$this->Base->SCRATCHPAD->addItem($id, 'playlist');
|
|
$this->availablePlaylists[] = $this->Base->getPLMetaInfo($id);
|
|
return TRUE;
|
|
} else {
|
|
return $this->copyPlaylistFromScratchpad();
|
|
}
|
|
} // fn getPlaylistToSchedule
|
|
|
|
|
|
/**
|
|
* Get the currently available playlists in the scratchpad and
|
|
* add them to the internal $this->availablePlaylists array.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
private function copyPlaylistFromScratchpad()
|
|
{
|
|
$scratchpad = $this->Base->SCRATCHPAD->get();
|
|
foreach ($scratchpad as $val) {
|
|
if ($val['type'] === 'playlist'
|
|
&& ($this->Base->gb->playlistIsAvailable($val['id'], $this->Base->sessid) === TRUE)
|
|
&& ($val['id'] != $this->Base->PLAYLIST->activeId) ) {
|
|
$this->availablePlaylists[] = $val;
|
|
}
|
|
}
|
|
if (!count($this->availablePlaylists)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get a scheduled item.
|
|
*
|
|
* Note: just use methods here which work without valid authentification.
|
|
*
|
|
* @param int $p_playlist_nr
|
|
* 0=current pl; 1=next pl ...
|
|
* @return array
|
|
*/
|
|
public function getScheduledPlaylist($p_playlist_nr=0, $p_period=3600)
|
|
{
|
|
$now = time();
|
|
$start = strftime('%Y-%m-%d %H:%M:%S', $now);
|
|
$end = $p_playlist_nr ? strftime('%Y-%m-%d %H:%M:%S', $now + $p_period) : strftime('%Y-%m-%d %H:%M:%S', $now);
|
|
$playlists = $this->displayScheduleMethod($start, $end);
|
|
|
|
if (!is_array($playlists) || !count($playlists)) {
|
|
return FALSE;
|
|
}
|
|
|
|
switch ($p_playlist_nr) {
|
|
case 0:
|
|
if ($playlist = current($playlists)) {
|
|
return $playlist;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
$pos = 0;
|
|
foreach ($playlists as $playlist) {
|
|
if (self::datetimeToTimestamp($playlist['start']) > $now) {
|
|
$pos++;
|
|
if ($pos == $p_playlist_nr) {
|
|
return $playlist;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return false;
|
|
} // fn getScheduledPlaylist
|
|
|
|
|
|
public function getClipFromCurrent($p_playlist, $p_item_nr=0)
|
|
{
|
|
// subtract difference to UTC
|
|
$offset = strftime('%H:%M:%S', time() - self::datetimeToTimestamp($p_playlist['start']) - 3600 * strftime('%H', 0));
|
|
|
|
$clip = $this->Base->gb->displayPlaylistClipAtOffset($this->Base->sessid, $p_playlist['playlistId'], $offset, $p_item_nr, $_SESSION['langid'], UI_DEFAULT_LANGID);
|
|
|
|
if (!$clip['gunid']) {
|
|
return FALSE;
|
|
}
|
|
|
|
$secondsElapsed = Playlist::playlistTimeToSeconds($clip['elapsed']);
|
|
$secondsRemaining = Playlist::playlistTimeToSeconds($clip['remaining']);
|
|
list($duration['h'], $duration['m'], $duration['s']) = explode(':', Playlist::secondsToPlaylistTime($secondsElapsed + $secondsRemaining));
|
|
list($elapsed['h'], $elapsed['m'], $elapsed['s']) = explode(':', $clip['elapsed']);
|
|
list($remaining['h'], $remaining['m'], $remaining['s']) = explode(':', $clip['remaining']);
|
|
$duration = array_map('round', $duration);
|
|
$elapsed = array_map('round', $elapsed);
|
|
$remaining = array_map('round', $remaining);
|
|
$percentage = $secondsElapsed ? (100 * $secondsElapsed / ($secondsElapsed + $secondsRemaining)) : 100;
|
|
|
|
return array('title' => $clip['title'],
|
|
'duration' => $duration,
|
|
'elapsed' => $elapsed,
|
|
'remaining' => $remaining,
|
|
'percentage'=> $percentage,
|
|
'playlist' => $clip['playlist']
|
|
);
|
|
}
|
|
|
|
public function getClipFromPlaylist($p_playlist, $p_position=0)
|
|
{
|
|
$pos = 0;
|
|
$playlist = new uiPlaylist($this->Base);
|
|
$flat = $playlist->getFlat(BasicStor::IdFromGunid($p_playlist['playlistId']));
|
|
|
|
foreach ($flat as $clip) {
|
|
if ($pos == $p_position) {
|
|
$found = true;
|
|
break;
|
|
}
|
|
$pos++;
|
|
}
|
|
if ($found) {
|
|
list($duration['h'], $duration['m'], $duration['s']) = explode(':', $clip['attrs']['clipLength']);
|
|
list($elapsed['h'], $elapsed['m'], $elapsed['s']) = explode(':', '00:00:00');
|
|
$remaining = $duration;
|
|
$duration = array_map('round', $duration);
|
|
$elapsed = array_map('round', $elapsed);
|
|
$remaining = array_map('round', $remaining);
|
|
$percentage = $secondsElapsed ? (100 * $secondsElapsed / ($secondsElapsed + $secondsRemaining)) : 100;
|
|
return array(
|
|
'title' => $clip['title'],
|
|
'duration' => $duration,
|
|
'elapsed' => $elapsed,
|
|
'remaining' => $remaining,
|
|
'percentage'=> $percentage
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function getScheduleInfo_jscom($p_playlist_nr=0)
|
|
{
|
|
// just use methods which work without valid authentification
|
|
$c_pl = self::getScheduledPlaylist();
|
|
$pl = Playlist::Recall($c_pl['playlistId']);
|
|
|
|
$n_clip = null;
|
|
if ($c_clip = $this->getClipFromCurrent($c_pl, 0)) {
|
|
$n_clip = $this->getClipFromCurrent($c_pl, 1);
|
|
}
|
|
$nextClip = StoredFile::Recall($n_clip);
|
|
$u_clip = null;
|
|
$u_pl_start = null;
|
|
if ($u_pl = self::getScheduledPlaylist(2)) {
|
|
$u_clip = $this->getClipFromPlaylist($u_pl);
|
|
$u_pl_start = explode(':', date('H:i:s', self::datetimeToTimestamp($u_pl['start'])));
|
|
}
|
|
$upcomingClip = StoredFile::Recall($u_pl['playlistId']);
|
|
|
|
return array(
|
|
'current' => $c_clip ? 1 : 0,
|
|
'current.title' => addcslashes($c_clip['title'], "'"),
|
|
//'current.pltitle' => addcslashes($this->Base->getMetadataValue(BasicStor::IdFromGunid($c_pl['playlistId']), UI_MDATA_KEY_TITLE), "'"),
|
|
'current.pltitle' => addcslashes($pl->getName(), "'"),
|
|
'current.elapsed.h' => $c_clip['elapsed']['h'],
|
|
'current.elapsed.m' => $c_clip['elapsed']['m'],
|
|
'current.elapsed.s' => $c_clip['elapsed']['s'],
|
|
'current.duration.h' => $c_clip['duration']['h'],
|
|
'current.duration.m' => $c_clip['duration']['m'],
|
|
'current.duration.s' => $c_clip['duration']['s'],
|
|
|
|
'next' => $n_clip ? 1 : 0,
|
|
'next.title' => $n_clip ? addcslashes($n_clip['title'], "'") : "",
|
|
//'next.pltitle' => addcslashes($this->Base->getMetadataValue($n_clip, UI_MDATA_KEY_TITLE), "'"),
|
|
'next.pltitle' => addcslashes($nextClip->getTitle(), "'"),
|
|
'next.duration.h' => $n_clip ? $n_clip['duration']['h'] : 0,
|
|
'next.duration.m' => $n_clip ? $n_clip['duration']['m'] : 0,
|
|
'next.duration.s' => $n_clip ? $n_clip['duration']['s'] : 0,
|
|
|
|
'upcoming' => $u_pl ? 1 : 0,
|
|
'upcoming.title' => addcslashes($u_clip['title'], "'"),
|
|
//'upcoming.pltitle' => addcslashes($this->Base->getMetadataValue(BasicStor::IdFromGunid($u_pl['playlistId']), UI_MDATA_KEY_TITLE), "'"),
|
|
'upcoming.pltitle' => addcslashes($upcomingClip->getName(), "'"),
|
|
'upcoming.duration.h' => $u_clip['duration']['h'],
|
|
'upcoming.duration.m' => $u_clip['duration']['m'],
|
|
'upcoming.duration.s' => $u_clip['duration']['s'],
|
|
'upcoming.plstart.h' => $u_pl_start[0],
|
|
'upcoming.plstart.m' => $u_pl_start[1],
|
|
'upcoming.plstart.s' => $u_pl_start[2],
|
|
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
* Convert a string timestamp to UNIX time value.
|
|
*
|
|
* @param string $i
|
|
* @return int
|
|
*/
|
|
public static function datetimeToTimestamp($i)
|
|
{
|
|
$i = str_replace('-', '', $i);
|
|
$i = str_replace(' ', 'T', $i);
|
|
$i = substr($i, 0, 17);
|
|
return self::strtotime($i);
|
|
} // fn datetimeToTimestamp
|
|
|
|
|
|
/**
|
|
* There is a bug in strtotime() - it does not support
|
|
* datetime-format using "T" character correctly, so we need this
|
|
* function.
|
|
*
|
|
* @param string $input
|
|
* @return string
|
|
*/
|
|
private static function strtotime($input)
|
|
{
|
|
return strtotime(str_replace('T', ' ', $input));
|
|
}
|
|
|
|
|
|
protected function _scheduledDays($period)
|
|
{
|
|
if ($period === 'month') {
|
|
$Period = new Calendar_Month_Weekdays($this->curr['year'], $this->curr['month'], $this->firstDayOfWeek);
|
|
$Period->build();
|
|
} elseif ($period === 'week') {
|
|
$Period = new Calendar_Week($this->curr['year'], $this->curr['month'], $this->curr['day'], $this->firstDayOfWeek);
|
|
$Period->build();
|
|
} else {
|
|
return array();
|
|
}
|
|
$d = $Period->fetch();
|
|
// The next two lines are due to a bug in Calendar_Month_Weekdays
|
|
$corrMonth = ($d->thisMonth() <= 12) ? sprintf('%02d', $d->thisMonth()) : '01';
|
|
$corrYear = ($d->thisMonth() <= 12) ? $d->thisYear() : $d->thisYear()+1;
|
|
$first = array('day' => sprintf('%02d', $d->thisDay()),
|
|
'month' => $corrMonth,
|
|
'year' => $corrYear);
|
|
|
|
while ($l = $Period->fetch()) {
|
|
$d = $l;
|
|
}
|
|
// The next two lines are due to a bug in Calendar_Month_Weekdays
|
|
$corrMonth = ($d->thisMonth() <= 12) ? sprintf('%02d', $d->thisMonth()) : '01';
|
|
$corrYear = ($d->thisMonth() <= 12) ? $d->thisYear() : $d->thisYear()+1;
|
|
$last = array('day' => sprintf('%02d', $d->thisDay()),
|
|
'month' => $corrMonth,
|
|
'year' => $corrYear);
|
|
|
|
$days = $this->_receiveScheduledDays($first['year'].$first['month'].$first['day'], $last['year'].$last['month'].$last['day']);
|
|
foreach ($days as $val) {
|
|
$selections[] = new Calendar_Day($val['year'], $val['month'], $val['day']);
|
|
}
|
|
return $selections;
|
|
} // fn _scheduledDays
|
|
|
|
|
|
private function _receiveScheduledDays($dfrom, $dto)
|
|
{
|
|
$dfrom = $dfrom.' 00:00:00';
|
|
$dto = $dto.' 23:59:59';
|
|
if (($pArr = $this->displayScheduleMethod($dfrom, $dto)) === FALSE) {
|
|
return array(FALSE);
|
|
}
|
|
|
|
$pStampArr = null;
|
|
foreach ($pArr as $val) {
|
|
$pStampArr[] = array('start' => self::datetimeToTimestamp($val['start']),
|
|
'end' => self::datetimeToTimestamp($val['end']));
|
|
}
|
|
if (is_array($pStampArr)) {
|
|
for ($n = self::datetimeToTimestamp($dfrom); $n <= self::datetimeToTimestamp($dto); $n+=86400) {
|
|
foreach ($pStampArr as $val) {
|
|
if ($val['start'] < $n+86400 && $val['end'] >= $n) {
|
|
$days[date('Ymd', $n)] = array('year' => date('Y', $n),
|
|
'month' => date('m', $n),
|
|
'day' => date('d', $n));
|
|
}
|
|
}
|
|
}
|
|
return $days;
|
|
}
|
|
return array(FALSE);
|
|
} // fn _receiveScheduledDays
|
|
|
|
|
|
/**
|
|
* Return true if the argument is an array and has a key index "error"
|
|
* which is an array. If it is an error, set the internal error
|
|
* message, which can be retrieved with getErrorMsg().
|
|
*
|
|
* @param mixed $r
|
|
* @return boolean
|
|
*/
|
|
function _isError($r)
|
|
{
|
|
if (isset($r['error']) && is_array($r['error'])) {
|
|
$this->setErrorMsg(tra('Error: $1', str_replace("\n", "\\n", addslashes($r['error']['message']))));
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
} // fn _isError
|
|
|
|
|
|
function getErrorMsg()
|
|
{
|
|
return $this->error;
|
|
} // fn getErrorMsg
|
|
|
|
|
|
/**
|
|
* Set the internal error message.
|
|
*
|
|
* @param string $msg
|
|
* @return void
|
|
*/
|
|
public function setErrorMsg($msg)
|
|
{
|
|
$this->error = $msg;
|
|
} // fn setErrorMsg
|
|
|
|
|
|
/********************************************************************
|
|
* Scheduler Daemon methods
|
|
********************************************************************/
|
|
|
|
/**
|
|
* Return TRUE if the scheduler startup script has been configured.
|
|
* If not, the internal variable $this->scriptError is set with the
|
|
* error message.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
private function scriptIsConfigured()
|
|
{
|
|
$this->scriptError = null;
|
|
if (!isset($this->Base->STATIONPREFS['schedulerStartupScript'])
|
|
|| empty($this->Base->STATIONPREFS['schedulerStartupScript'])) {
|
|
$this->scriptError = 'Scheduler startup script has not been defined. Please set this value in the "Preferences->Station Settings".';
|
|
return FALSE;
|
|
} elseif (!file_exists($this->Base->STATIONPREFS['schedulerStartupScript'])) {
|
|
$this->scriptError = sprintf('The scheduler startup script you defined does not exist. You can set this value in "Preferences->Station Settings". The current value is "%s"', $this->Base->STATIONPREFS['schedulerStartupScript']);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
public function getScriptError()
|
|
{
|
|
return $this->scriptError;
|
|
}
|
|
|
|
|
|
/**
|
|
* Try to start the scheduler daemon.
|
|
*
|
|
* @param boolean $msg
|
|
* @return boolean
|
|
*/
|
|
public function startDaemon($msg=FALSE)
|
|
{
|
|
if (!$this->scriptIsConfigured()) {
|
|
return FALSE;
|
|
}
|
|
if ($this->daemonIsRunning($msg) === TRUE) {
|
|
return TRUE;
|
|
}
|
|
|
|
$cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} start 1>/tmp/scheduler_startup.log 2>&1";
|
|
exec($cmd);
|
|
flush();
|
|
sleep(2);
|
|
|
|
if ($this->daemonIsRunning($msg)===FALSE) {
|
|
if ($msg) {
|
|
$output = file('/tmp/scheduler_startup.log');
|
|
$message = '';
|
|
foreach ($output as $line) {
|
|
$message .= trim(addslashes($line)).'\n';
|
|
}
|
|
$this->Base->_retMsg('Scheduler did not start. Returned message:\n$1', $message);
|
|
}
|
|
return FALSE;
|
|
}
|
|
} // fn startDaemon
|
|
|
|
|
|
/**
|
|
* Try to stop the scheduler daemon.
|
|
*
|
|
* @param boolean $msg
|
|
* @return boolean
|
|
*/
|
|
public function stopDaemon($msg=FALSE)
|
|
{
|
|
if (!$this->scriptIsConfigured()) {
|
|
return FALSE;
|
|
}
|
|
if ($this->daemonIsRunning($msg) === FALSE) {
|
|
return TRUE;
|
|
}
|
|
|
|
$cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} stop 1>/tmp/scheduler_startup.log 2>&1";
|
|
exec($cmd);
|
|
flush();
|
|
sleep(2);
|
|
|
|
if ($this->daemonIsRunning($msg)===TRUE) {
|
|
if ($msg) {
|
|
$output = file('/tmp/scheduler_startup.log');
|
|
foreach ($output as $line) {
|
|
$message .= trim(addslashes($line)).'\n';
|
|
}
|
|
$this->Base->_retMsg('Scheduler did not stop. Returned message:\n$1', $message);
|
|
}
|
|
return FALSE;
|
|
}
|
|
} // fn stopDaemon
|
|
|
|
|
|
/**
|
|
* Return TRUE if the scheduler daemon is running.
|
|
*
|
|
* @param boolean $msg
|
|
* @return boolean
|
|
*/
|
|
public function daemonIsRunning($msg = FALSE)
|
|
{
|
|
if (!$this->scriptIsConfigured()) {
|
|
return FALSE;
|
|
}
|
|
$cmd = "{$this->Base->STATIONPREFS['schedulerStartupScript']} status";
|
|
exec($cmd, $output);
|
|
|
|
if (empty($output)) {
|
|
$this->scriptError = 'Scheduler startup script does not appear to be valid. Please check the value you have set in "Preferences->Station Settings".';
|
|
return FALSE;
|
|
}
|
|
$message = "";
|
|
foreach ($output as $line) {
|
|
$message .= trim(addslashes($line)).'\n';
|
|
}
|
|
|
|
if (strstr($message, 'is running')) {
|
|
if ($msg) {
|
|
$this->Base->_retMsg('Scheduler is running.');
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
} // fn daemonIsRunning
|
|
|
|
|
|
/********************************************************************
|
|
* XML-RPC wrapper methods
|
|
********************************************************************/
|
|
|
|
/**
|
|
* Create the XMLRPC client.
|
|
*/
|
|
function initXmlRpc()
|
|
{
|
|
// include_once(dirname(__FILE__).'/ui_schedulerPhpClient.class.php');
|
|
// $this->spc =& SchedulerPhpClient::factory($mdefs, FALSE, FALSE);
|
|
} // fn initXmlRpc
|
|
|
|
|
|
/**
|
|
* Add an item to the scheduler.
|
|
*
|
|
* @param array $formdata
|
|
* Must have the following keys set:
|
|
* ['playlist'] -> id of playlist
|
|
* ['date']['Y'] - Year
|
|
* ['date']['m'] - month
|
|
* ['date']['d'] - day
|
|
* ['date']['H'] - hour
|
|
* ['date']['i'] - minute
|
|
* ['date']['s'] - second
|
|
*
|
|
* @return int|PEAR_Error
|
|
*
|
|
*/
|
|
function addItem(&$formdata)
|
|
{
|
|
$playlistId = $formdata['playlist'];
|
|
$datetime = $formdata['date']['Y']
|
|
.'-'
|
|
.sprintf('%02d', $formdata['date']['m'])
|
|
.'-'
|
|
.sprintf('%02d', $formdata['date']['d'])
|
|
.' '.sprintf('%02d', $formdata['time']['H'])
|
|
.':'.sprintf('%02d', $formdata['time']['i'])
|
|
.':'.sprintf('%02d', $formdata['time']['s']);
|
|
|
|
$item = new ScheduleGroup();
|
|
$groupId = $item->add($datetime, null, $playlistId);
|
|
return $groupId;
|
|
}
|
|
|
|
|
|
/**
|
|
* Remove an item from the scheduler.
|
|
*
|
|
* @param string $id
|
|
* groupId of the item
|
|
* @return boolean
|
|
* TRUE on success, FALSE on failure.
|
|
*/
|
|
function removeFromScheduleMethod($p_groupId)
|
|
{
|
|
$item = new ScheduleGroup($p_groupId);
|
|
$success = $item->remove();
|
|
//$r = $this->spc->removeFromScheduleMethod($this->Base->sessid, $id);
|
|
if (!$success) {
|
|
return FALSE;
|
|
}
|
|
if (UI_VERBOSE) {
|
|
$this->Base->_retMsg('Entry with ScheduleId $1 removed.', $id);
|
|
}
|
|
return TRUE;
|
|
} // fn removeFromScheduleMethod
|
|
|
|
|
|
/**
|
|
* Get the scheduled items between the $from and $to dates.
|
|
*
|
|
* @param string $from
|
|
* In the format "YYYY-MM-DD HH:MM:SS.nnnnnn"
|
|
* @param string $to
|
|
* In the format "YYYY-MM-DD HH:MM:SS.nnnnnn"
|
|
* @return array|false
|
|
*/
|
|
function displayScheduleMethod($p_from, $p_to, $p_playlistsOnly = true)
|
|
{
|
|
$items = Schedule::GetItems($p_from, $p_to, $p_playlistsOnly);
|
|
//$_SESSION["debug"] = $items;
|
|
return $items;
|
|
} // fn displayScheduleMethod
|
|
|
|
|
|
/********************************************************************
|
|
* Export Methods
|
|
********************************************************************/
|
|
|
|
/**
|
|
* Get the token for the schedule which is currently being exported.
|
|
* It is stored in the user preferences.
|
|
*
|
|
* @return string
|
|
*/
|
|
function getExportToken()
|
|
{
|
|
$token = $this->Base->gb->loadPref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY);
|
|
|
|
if (PEAR::isError($token) || empty($token)) {
|
|
return false;
|
|
}
|
|
return $token;
|
|
} // fn getExportToken
|
|
|
|
|
|
/**
|
|
* Export a schedule within a certain time range.
|
|
*
|
|
* @param string $from
|
|
* Date-time format
|
|
* @param string $to
|
|
* Date-time format
|
|
* @return boolean
|
|
*/
|
|
function scheduleExportOpen($from, $to)
|
|
{
|
|
$criteria = array('filetype' => UI_FILETYPE_ANY);
|
|
$token = $this->spc->exportOpenMethod($this->Base->sessid, $criteria, $from, $to);
|
|
|
|
if (PEAR::isError($token)) {
|
|
$this->Base->_retMsg('Error initializing scheduler export: $1', $token->getMessage());
|
|
return false;
|
|
}
|
|
|
|
if (isset($token["error"])) {
|
|
$this->Base->_retMsg('Error initializing scheduler export: $1',
|
|
$token["error"]["code"].":".$token["error"]["message"]);
|
|
return false;
|
|
}
|
|
$this->Base->gb->savePref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY, $token['token']);
|
|
//$this->scheduleExportCheck();
|
|
return true;
|
|
} // fn scheduleExportOpen
|
|
|
|
|
|
/**
|
|
* Check the status of a schedule that is being exported.
|
|
*
|
|
* @return string|false
|
|
*/
|
|
function scheduleExportCheck()
|
|
{
|
|
$token = $this->getExportToken();
|
|
|
|
if (empty($token)) {
|
|
$this->Base->_retMsg('Token not available');
|
|
return false;
|
|
}
|
|
|
|
$res = $this->spc->exportCheckMethod($token);
|
|
if (PEAR::isError($res)) {
|
|
$this->Base->_retMsg('Unable to check scheduler export status: $1', $res->getMessage());
|
|
return false;
|
|
}
|
|
return $res;
|
|
} // fn scheduleExportCheck
|
|
|
|
|
|
function scheduleExportClose()
|
|
{
|
|
$token = $this->getExportToken();
|
|
|
|
if (empty($token)) {
|
|
$this->Base->_retMsg('Token not available');
|
|
return false;
|
|
}
|
|
|
|
$status = $this->spc->exportCloseMethod($token);
|
|
|
|
if (PEAR::isError($status)) {
|
|
$this->Base->_retMsg('Error closing scheduler export: $1', $status->getMessage());
|
|
return false;
|
|
}
|
|
|
|
if ($status === true) {
|
|
$this->Base->gb->delPref($this->Base->sessid, UI_SCHEDULER_EXPORTTOKEN_KEY);
|
|
}
|
|
|
|
return $status;
|
|
} // fn scheduleExportClose
|
|
|
|
|
|
/********************************************************************
|
|
* Import Methods
|
|
********************************************************************/
|
|
|
|
|
|
function getImportToken()
|
|
{
|
|
$token = $this->Base->gb->loadPref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY);
|
|
|
|
if (PEAR::isError($token)) {
|
|
return false;
|
|
}
|
|
return $token;
|
|
} // fn getImportToken
|
|
|
|
|
|
function scheduleImportOpen($filename)
|
|
{
|
|
$token = $this->spc->importOpenMethod($this->Base->sessid, $filename);
|
|
|
|
if (PEAR::isError($token)) {
|
|
$this->Base->_retMsg('Error initializing scheduler import: $1', $token->getMessage());
|
|
return false;
|
|
}
|
|
|
|
$this->scheduleImportCheck();
|
|
|
|
$this->Base->gb->savePref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY, $token['token']);
|
|
|
|
return true;
|
|
} // fn scheduleImportOpen
|
|
|
|
|
|
function scheduleImportCheck()
|
|
{
|
|
$token = $this->getImportToken();
|
|
|
|
if ($token === false) {
|
|
return false;
|
|
}
|
|
|
|
$res = $this->spc->importCheckMethod($token);
|
|
//echo '<XMP style="background:yellow;">'; var_dump($res); echo "</XMP>\n";
|
|
if (PEAR::isError($res)) {
|
|
$this->Base->_retMsg('Unable to check scheduler import status: $1', $res->getMessage());
|
|
return false;
|
|
}
|
|
|
|
return $res;
|
|
} // fn scheduleImportCheck
|
|
|
|
|
|
function scheduleImportClose()
|
|
{
|
|
$token = $this->getImportToken();
|
|
|
|
if ($token === false) {
|
|
$this->Base->_retMsg('Token not available');
|
|
return false;
|
|
}
|
|
|
|
$status = $this->spc->importCloseMethod($token);
|
|
|
|
if (PEAR::isError($status)) {
|
|
$this->Base->_retMsg('Error closing scheduler import: $1', $status->getMessage());
|
|
return false;
|
|
}
|
|
|
|
if ($status === true) {
|
|
$this->Base->gb->delPref($this->Base->sessid, UI_SCHEDULER_IMPORTTOKEN_KEY);
|
|
}
|
|
|
|
return $status;
|
|
} // fn scheduleImportClose
|
|
|
|
public function getSchedulerTime()
|
|
{
|
|
return time();
|
|
static $first, $cached;
|
|
if (!$first) {
|
|
$first = time();
|
|
$r = $this->spc->GetSchedulerTimeMethod();
|
|
if ($this->_isError($r)) {
|
|
return false;
|
|
}
|
|
$cached = self::datetimeToTimestamp($r['schedulerTime']);
|
|
}
|
|
$schedulerTime = $cached + time() - $first;
|
|
return $schedulerTime;
|
|
}
|
|
|
|
} // class uiScheduler
|
|
|
|
?>
|