1961 lines
71 KiB
PHP
1961 lines
71 KiB
PHP
<?php
|
|
|
|
define('MAX_REBROADCAST_DATES', 10);
|
|
define('NO_REPEAT', -1);
|
|
define('REPEAT_WEEKLY', 0);
|
|
define('REPEAT_BI_WEEKLY', 1);
|
|
define('REPEAT_MONTHLY_MONTHLY', 2);
|
|
define('REPEAT_MONTHLY_WEEKLY', 3);
|
|
define('REPEAT_TRI_WEEKLY', 4);
|
|
define('REPEAT_QUAD_WEEKLY', 5);
|
|
|
|
class Application_Service_ShowService
|
|
{
|
|
private $ccShow;
|
|
private $isRecorded;
|
|
private $isRebroadcast;
|
|
private $repeatType;
|
|
private $isUpdate;
|
|
private $oldShowTimezone;
|
|
private $localShowStartHour;
|
|
private $localShowStartMin;
|
|
private $origCcShowDay;
|
|
private $origShowRepeatStatus;
|
|
private $instanceIdsForScheduleUpdates;
|
|
|
|
// keeps track of which show instances are new from either adding a new show
|
|
// day or changing the repeat type day during a show edit, or when a user moves
|
|
// forward in the calendar
|
|
private $newInstanceIdsCreated;
|
|
|
|
public function __construct($showId = null, $showData = null, $isUpdate = false)
|
|
{
|
|
if (!is_null($showId)) {
|
|
$this->ccShow = CcShowQuery::create()->findPk($showId);
|
|
}
|
|
|
|
if (isset($showData['add_show_repeats']) && $showData['add_show_repeats']) {
|
|
$this->repeatType = $showData['add_show_repeat_type'];
|
|
if ($showData['add_show_repeat_type'] == 2) {
|
|
$this->repeatType = $showData['add_show_monthly_repeat_type'];
|
|
}
|
|
} else {
|
|
$this->repeatType = -1;
|
|
}
|
|
|
|
$this->isRecorded = (isset($showData['add_show_record']) && $showData['add_show_record']) ? 1 : 0;
|
|
$this->isRebroadcast = (isset($showData['add_show_rebroadcast']) && $showData['add_show_rebroadcast']) ? 1 : 0;
|
|
$this->isUpdate = $isUpdate;
|
|
$this->instanceIdsForScheduleUpdates = [];
|
|
$this->newInstanceIdsCreated = [];
|
|
}
|
|
|
|
public function editRepeatingShowInstance($showData)
|
|
{
|
|
$service_user = new Application_Service_UserService();
|
|
$currentUser = $service_user->getCurrentUser();
|
|
|
|
$showData['add_show_duration'] = $this->formatShowDuration(
|
|
$showData['add_show_duration']
|
|
);
|
|
|
|
$con = Propel::getConnection();
|
|
$con->beginTransaction();
|
|
|
|
try {
|
|
if (!$currentUser->isAdminOrPM()) {
|
|
throw new Exception('Permission denied');
|
|
}
|
|
|
|
$showId = $showData['add_show_id'];
|
|
|
|
// UPDATE SCHEDULE START TIME
|
|
// get the ccShow object to which this instance belongs
|
|
// so we can get the original start date and time
|
|
$this->ccShow = CcShowQuery::create()
|
|
->findPk($showId);
|
|
|
|
// DateTime in shows's local time
|
|
$newStartDateTime = new DateTime(
|
|
$showData['add_show_start_date'] . ' ' .
|
|
$showData['add_show_start_time'],
|
|
new DateTimeZone($showData['add_show_timezone'])
|
|
);
|
|
|
|
$ccShowInstanceOrig = CcShowInstancesQuery::create()
|
|
->findPk($showData['add_show_instance_id']);
|
|
|
|
// convert original start time into the show's local timezone
|
|
$origLocalStartDateTime = $ccShowInstanceOrig->getLocalStartDateTime();
|
|
|
|
$diff = $this->calculateShowStartDiff(
|
|
$newStartDateTime,
|
|
$origLocalStartDateTime
|
|
);
|
|
|
|
if ($diff != 0) {
|
|
Application_Service_SchedulerService::updateScheduleStartTime(
|
|
[$showData['add_show_instance_id']],
|
|
$diff
|
|
);
|
|
}
|
|
// UPDATE SCHEDULE START TIME ENDS
|
|
|
|
/*
|
|
* In the case where an instance is being edited for a second
|
|
* (or third, fourth, etc.) time we need to delete the old
|
|
* cc_show_day record
|
|
*
|
|
* Since we don't store the cc_show_day ids we need to use the
|
|
* original start time from cc_show_instances, convert it to the show's
|
|
* local timezone, and find the record in cc_show_days
|
|
*
|
|
* *** There is a flaw here: We have to assume the show timezone has
|
|
* *** not changed (make timezone readonly??)
|
|
*/
|
|
$origCcShowDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbRepeatType(-1)
|
|
->filterByDbFirstShow($origLocalStartDateTime->format('Y-m-d'))
|
|
->filterByDbStartTime($origLocalStartDateTime->format('H:i:s'))
|
|
->delete();
|
|
|
|
/*
|
|
* Set the new cc_show_day record
|
|
* Associates it with the current show_id and sets it to non-repeating
|
|
*/
|
|
$this->setCcShowDays($showData);
|
|
|
|
/*
|
|
* We need to find the new show day rule we just created by passing
|
|
* in the first show and start time in case multiple single
|
|
* instances have been edited out of the repeating sequence.
|
|
*/
|
|
$showDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbRepeatType(-1)
|
|
->filterByDbFirstShow($showData['add_show_start_date'])
|
|
->filterByDbStartTime($showData['add_show_start_time'] . ':00')
|
|
->findOne();
|
|
|
|
$ccShowInstance = $this->createNonRepeatingInstance(
|
|
$showDay,
|
|
$this->getPopulateShowUntilDateTIme()
|
|
);
|
|
|
|
// update cc_schedule with the new instance id
|
|
$con = Propel::getConnection(CcShowInstancesPeer::DATABASE_NAME);
|
|
$selectCriteria = new Criteria();
|
|
$selectCriteria->add(CcSchedulePeer::INSTANCE_ID, $showData['add_show_instance_id']);
|
|
$updateCriteria = new Criteria();
|
|
$updateCriteria->add(CcSchedulePeer::INSTANCE_ID, $ccShowInstance->getDbId());
|
|
BasePeer::doUpdate($selectCriteria, $updateCriteria, $con);
|
|
|
|
$ccShowInstance->updateDbTimeFilled($con);
|
|
$ccShowInstance->updateScheduleStatus($con);
|
|
$ccShowInstance
|
|
->setDbDescription($showData['add_show_instance_description'])
|
|
->save();
|
|
|
|
// delete the edited instance from the repeating sequence
|
|
$ccShowInstanceOrig
|
|
->setDbModifiedInstance(true)
|
|
->setDbDescription($showData['add_show_instance_description'])
|
|
->save();
|
|
|
|
$con->commit();
|
|
Application_Model_RabbitMq::PushSchedule();
|
|
} catch (Exception $e) {
|
|
$con->rollback();
|
|
Logging::info('EXCEPTION: Show update failed.');
|
|
Logging::info($e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If a user is editing a show we need to store the original timezone and
|
|
* start time in case the show's timezone is changed and we are crossing
|
|
* over DST.
|
|
*/
|
|
private function storeOrigLocalShowInfo()
|
|
{
|
|
if ($this->ccShow->isRepeating()) {
|
|
$this->origCcShowDay = clone $this->ccShow->getFirstRepeatingCcShowDay();
|
|
$this->origShowRepeatStatus = true;
|
|
} else {
|
|
$this->origCcShowDay = clone $this->ccShow->getFirstCcShowDay();
|
|
$this->origShowRepeatStatus = false;
|
|
}
|
|
|
|
$this->oldShowTimezone = $this->origCcShowDay->getDbTimezone();
|
|
|
|
$origStartTime = explode(':', $this->origCcShowDay->getDbStartTime());
|
|
$this->localShowStartHour = $origStartTime[0];
|
|
$this->localShowStartMin = $origStartTime[1];
|
|
}
|
|
|
|
public function addUpdateShow($showData)
|
|
{
|
|
$service_user = new Application_Service_UserService();
|
|
$currentUser = $service_user->getCurrentUser();
|
|
|
|
$showData['add_show_duration'] = $this->formatShowDuration(
|
|
$showData['add_show_duration']
|
|
);
|
|
|
|
$con = Propel::getConnection();
|
|
$con->beginTransaction();
|
|
|
|
try {
|
|
if (!$currentUser->isAdminOrPM()) {
|
|
throw new Exception('Permission denied');
|
|
}
|
|
|
|
// update ccShow
|
|
$this->setCcShow($showData);
|
|
|
|
$daysAdded = [];
|
|
|
|
if ($this->isUpdate) {
|
|
$showId = $this->ccShow->getDbId();
|
|
|
|
// Only delete the previous logo if a new one is being uploaded
|
|
if (array_key_exists('add_show_logo_name', $showData) && $showData['add_show_logo_name'] !== '') {
|
|
if (!Rest_ShowImageController::deleteShowImagesFromStor($showId)) {
|
|
throw new Exception('Error deleting show images');
|
|
}
|
|
}
|
|
|
|
if (!$this->ccShow->getCcShowDayss()->isEmpty()) {
|
|
$this->storeOrigLocalShowInfo();
|
|
}
|
|
|
|
$daysAdded = $this->delegateInstanceCleanup($showData);
|
|
|
|
$this->deleteRebroadcastInstances();
|
|
|
|
$this->deleteCcShowHosts();
|
|
|
|
if ($this->isRebroadcast) {
|
|
// delete entry in cc_show_rebroadcast
|
|
$this->deleteCcShowRebroadcasts();
|
|
}
|
|
|
|
$this->storeInstanceIds();
|
|
}
|
|
|
|
// update ccShowDays
|
|
$this->setCcShowDays($showData);
|
|
|
|
// update ccShowRebroadcasts
|
|
$this->setCcShowRebroadcasts($showData);
|
|
|
|
// update ccShowHosts
|
|
$this->setCcShowHosts($showData);
|
|
|
|
// create new ccShowInstances
|
|
$this->delegateInstanceCreation($daysAdded);
|
|
|
|
if ($this->isUpdate) {
|
|
/* If the show is repeating and the start date changes we need
|
|
* to ignore that difference when re-calculating schedule start times.
|
|
* Otherwise it might calculate a difference of a week, for example.
|
|
*/
|
|
if (
|
|
$this->ccShow->isRepeating()
|
|
&& $this->origCcShowDay->getLocalStartDateAndTime()->format('Y-m-d') != $showData['add_show_start_date']
|
|
) {
|
|
$showData['add_show_start_date'] = $this->origCcShowDay->getLocalStartDateAndTime()->format('Y-m-d');
|
|
}
|
|
|
|
$this->adjustSchedule($showData);
|
|
}
|
|
|
|
$con->commit();
|
|
Application_Model_RabbitMq::PushSchedule();
|
|
} catch (Exception $e) {
|
|
$con->rollback();
|
|
$this->isUpdate ? $action = 'update' : $action = 'creation';
|
|
Logging::info('EXCEPTION: Show ' . $action . ' failed.');
|
|
Logging::info($e->getMessage());
|
|
}
|
|
|
|
// Added to pass along to the RESTful ShowImageController
|
|
return $this->ccShow->getDbId();
|
|
}
|
|
|
|
/**
|
|
* Returns an array of instance ids that already exist
|
|
* We need this if a show is being updated so we can separate the
|
|
* instances that already exist and any new instances that
|
|
* get created (by adding a new repeat show day).
|
|
*/
|
|
private function storeInstanceIds()
|
|
{
|
|
$instances = $this->ccShow->getFutureCcShowInstancess();
|
|
foreach ($instances as $instance) {
|
|
$this->instanceIdsForScheduleUpdates[] = $instance->getDbId();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adjusts the items in cc_schedule to reflect the
|
|
* new (if one) start and end time of the show getting updated.
|
|
*
|
|
* @param mixed $showData
|
|
*/
|
|
private function adjustSchedule($showData)
|
|
{
|
|
$con = Propel::getConnection(CcSchedulePeer::DATABASE_NAME);
|
|
|
|
$this->updateScheduleStartEndTimes($showData);
|
|
|
|
$ccShowInstances = $this->ccShow->getFutureCcShowInstancess();
|
|
foreach ($ccShowInstances as $instance) {
|
|
$instance->updateScheduleStatus($con);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Receives a cc_show id and determines whether to create a
|
|
* single show instance or repeating show instances.
|
|
*
|
|
* @param null|mixed $daysAdded
|
|
* @param null|mixed $end
|
|
* @param mixed $fillInstances
|
|
*/
|
|
public function delegateInstanceCreation($daysAdded = null, $end = null, $fillInstances = false)
|
|
{
|
|
$populateUntil = $this->getPopulateShowUntilDateTIme();
|
|
|
|
if (is_null($this->ccShow)) {
|
|
$ccShowDays = $this->getShowDaysInRange($populateUntil, $end);
|
|
} else {
|
|
if ($this->ccShow->isRepeating()) {
|
|
$ccShowDays = $this->ccShow->getRepeatingCcShowDays();
|
|
} else {
|
|
// $ccShowDays = $this->ccShow->getCcShowDayss();
|
|
|
|
/* Cannot use the above statement to get the cc_show_days
|
|
* object because it's getting the old object before the
|
|
* show was edited. clearInstancePool() didn't work.
|
|
*/
|
|
$ccShowDays = CcShowDaysQuery::create()
|
|
->filterByDbShowId($this->ccShow->getDbId())
|
|
->find();
|
|
}
|
|
}
|
|
|
|
if (!is_null($end)) {
|
|
$populateUntil = $end;
|
|
}
|
|
|
|
/* In case the user is moving forward in the calendar and there are
|
|
* linked shows in the schedule we need to keep track of each cc_show
|
|
* so we know which shows need to be filled with content
|
|
*/
|
|
$ccShows = [];
|
|
|
|
foreach ($ccShowDays as $day) {
|
|
$this->ccShow = $day->getCcShow();
|
|
$this->isRecorded = $this->ccShow->isRecorded();
|
|
$this->isRebroadcast = $this->ccShow->isRebroadcast();
|
|
|
|
$show_id = $day->getDbShowId();
|
|
if (!isset($ccShows[$show_id])) {
|
|
$ccShows[$show_id] = $day->getccShow();
|
|
}
|
|
|
|
// keep track of the new show instances getting created
|
|
// so we can fill their schedule after
|
|
if (!isset($this->newInstanceIdsCreated[$show_id])) {
|
|
$this->newInstanceIdsCreated[$show_id] = [];
|
|
}
|
|
|
|
switch ($day->getDbRepeatType()) {
|
|
case NO_REPEAT:
|
|
$this->createNonRepeatingInstance($day, $populateUntil);
|
|
|
|
break;
|
|
|
|
case REPEAT_WEEKLY:
|
|
$this->createWeeklyRepeatInstances(
|
|
$day,
|
|
$populateUntil,
|
|
REPEAT_WEEKLY,
|
|
new DateInterval('P7D'),
|
|
$daysAdded
|
|
);
|
|
|
|
break;
|
|
|
|
case REPEAT_BI_WEEKLY:
|
|
$this->createWeeklyRepeatInstances(
|
|
$day,
|
|
$populateUntil,
|
|
REPEAT_BI_WEEKLY,
|
|
new DateInterval('P14D'),
|
|
$daysAdded
|
|
);
|
|
|
|
break;
|
|
|
|
case REPEAT_TRI_WEEKLY:
|
|
$this->createWeeklyRepeatInstances(
|
|
$day,
|
|
$populateUntil,
|
|
REPEAT_TRI_WEEKLY,
|
|
new DateInterval('P21D'),
|
|
$daysAdded
|
|
);
|
|
|
|
break;
|
|
|
|
case REPEAT_QUAD_WEEKLY:
|
|
$this->createWeeklyRepeatInstances(
|
|
$day,
|
|
$populateUntil,
|
|
REPEAT_QUAD_WEEKLY,
|
|
new DateInterval('P28D'),
|
|
$daysAdded
|
|
);
|
|
|
|
break;
|
|
|
|
case REPEAT_MONTHLY_MONTHLY:
|
|
$this->createMonthlyRepeatInstances($day, $populateUntil);
|
|
|
|
break;
|
|
|
|
case REPEAT_MONTHLY_WEEKLY:
|
|
$this->createMonthlyRepeatInstances($day, $populateUntil);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
foreach ($ccShows as $ccShow) {
|
|
if (($this->isUpdate || $fillInstances) && $ccShow->isLinked()) {
|
|
Application_Service_SchedulerService::fillLinkedInstances(
|
|
$ccShow,
|
|
$this->newInstanceIdsCreated[$ccShow->getDbId()]
|
|
);
|
|
}
|
|
}
|
|
|
|
/*if (isset($this->linkedShowContent)) {
|
|
Application_Service_SchedulerService::fillPreservedLinkedShowContent(
|
|
$this->ccShow, $this->linkedShowContent);
|
|
}*/
|
|
|
|
return $this->ccShow;
|
|
}
|
|
|
|
private function getShowDaysInRange($start, $end)
|
|
{
|
|
$endTimeString = $end->format(DEFAULT_TIMESTAMP_FORMAT);
|
|
if (!is_null($start)) {
|
|
$startTimeString = $start->format(DEFAULT_TIMESTAMP_FORMAT);
|
|
} else {
|
|
$today_timestamp = new DateTime('now', new DateTimeZone('UTC'));
|
|
$startTimeString = $today_timestamp->format(DEFAULT_TIMESTAMP_FORMAT);
|
|
}
|
|
|
|
$c = new Criteria();
|
|
$c->add(CcShowDaysPeer::FIRST_SHOW, $endTimeString, Criteria::LESS_THAN);
|
|
$c->addAnd(CcShowDaysPeer::LAST_SHOW, $startTimeString, Criteria::GREATER_THAN);
|
|
$c->addAnd(CcShowDaysPeer::REPEAT_TYPE, -1, Criteria::NOT_EQUAL);
|
|
$c->addOr(CcShowDaysPeer::LAST_SHOW, null, Criteria::ISNULL);
|
|
|
|
return CcShowDaysPeer::doSelect($c);
|
|
}
|
|
|
|
public static function formatShowDuration($duration)
|
|
{
|
|
$hPos = strpos($duration, 'h');
|
|
$mPos = strpos($duration, 'm');
|
|
|
|
$hValue = 0;
|
|
$mValue = 0;
|
|
|
|
if ($hPos !== false) {
|
|
$hValue = trim(substr($duration, 0, $hPos));
|
|
}
|
|
if ($mPos !== false) {
|
|
$hPos = $hPos === false ? 0 : $hPos + 1;
|
|
$mValue = trim(substr($duration, $hPos, -1));
|
|
}
|
|
|
|
return $hValue . ':' . $mValue;
|
|
}
|
|
|
|
/**
|
|
* Deletes all the cc_show_days entries for a specific show
|
|
* that is currently being edited. They will get recreated with
|
|
* the new show day specs.
|
|
*/
|
|
private function deleteCcShowDays()
|
|
{
|
|
CcShowDaysQuery::create()->filterByDbShowId($this->ccShow->getDbId())->delete();
|
|
}
|
|
|
|
private function deleteRebroadcastInstances()
|
|
{
|
|
$sql = <<<'SQL'
|
|
DELETE FROM cc_show_instances
|
|
WHERE starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
AND rebroadcast = 1;
|
|
SQL;
|
|
Application_Common_Database::prepareAndExecute($sql, [
|
|
':showId' => $this->ccShow->getDbId(),
|
|
':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
], 'execute');
|
|
}
|
|
|
|
private function deleteAllShowDays($showId)
|
|
{
|
|
CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->delete();
|
|
}
|
|
|
|
/**
|
|
* TODO: This function is messy. Needs refactoring.
|
|
*
|
|
* When editing a show we may need to perform some actions to reflect the new specs:
|
|
* - Delete some show instances
|
|
* - Update duration
|
|
* - Update start and end time
|
|
*
|
|
* @param $showData edit show form values in raw form
|
|
*/
|
|
private function delegateInstanceCleanup($showData)
|
|
{
|
|
$showId = $this->ccShow->getDbId();
|
|
|
|
$daysAdded = [];
|
|
|
|
// CcShowDay object
|
|
if ($this->ccShow->isRepeating()) {
|
|
$currentShowDay = $this->ccShow->getFirstRepeatingCcShowDay();
|
|
|
|
// all cc_show_days
|
|
$ccShowDays = $this->ccShow->getRepeatingCcShowDays();
|
|
} else {
|
|
$currentShowDay = $this->ccShow->getFirstCcShowDay();
|
|
|
|
// all cc_show_days
|
|
$ccShowDays = $this->ccShow->getCcShowDayss();
|
|
}
|
|
|
|
// new end date in the show's timezone (from the select box)
|
|
$endDateTime = $this->calculateEndDate($showData);
|
|
|
|
// repeat option was toggled
|
|
if ($showData['add_show_repeats'] != $currentShowDay->isRepeating()) {
|
|
$this->deleteAllRepeatInstances($currentShowDay, $showId);
|
|
|
|
if (!$showData['add_show_repeats']) {
|
|
$this->deleteAllShowDays($showId);
|
|
}
|
|
|
|
// if repeat option was checked we need to treat the current show day
|
|
// as a new show day so the repeat instances get created properly
|
|
// in createWeeklyRepeatInstances()
|
|
if ($showData['add_show_repeats']) {
|
|
array_push($daysAdded, $currentShowDay->getDbDay());
|
|
}
|
|
}
|
|
|
|
if ($showData['add_show_repeats']) {
|
|
$localShowStart = $currentShowDay->getLocalStartDateAndTime();
|
|
|
|
// if the start date changes, these are the repeat types
|
|
// that require show instance deletion
|
|
$deleteRepeatTypes = [
|
|
REPEAT_BI_WEEKLY, REPEAT_TRI_WEEKLY, REPEAT_QUAD_WEEKLY, REPEAT_MONTHLY_MONTHLY,
|
|
REPEAT_MONTHLY_WEEKLY,
|
|
];
|
|
|
|
if (
|
|
in_array($this->repeatType, $deleteRepeatTypes)
|
|
&& $showData['add_show_start_date'] != $localShowStart->format('Y-m-d')
|
|
) {
|
|
// Start date has changed when repeat type is bi-weekly or monthly.
|
|
// This screws up the repeating positions of show instances, so
|
|
// we need to delete them (CC-2351)
|
|
$this->deleteAllInstances($showId);
|
|
}
|
|
|
|
$currentRepeatType = $currentShowDay->getDbRepeatType();
|
|
// only delete instances if the show being edited was already repeating
|
|
// and the repeat type changed
|
|
if ($currentRepeatType != -1 && $this->repeatType != $currentRepeatType) {
|
|
$this->deleteAllInstances($showId);
|
|
$this->deleteAllShowDays($showId);
|
|
|
|
// when repeating by day of the month (1st, 2nd, etc.) we do not store the repeat week days
|
|
} elseif ($currentRepeatType != 2) {
|
|
// repeat type is the same, check if the days of the week are the same
|
|
$repeatingDaysChanged = false;
|
|
|
|
$showDays = [];
|
|
foreach ($ccShowDays as $day) {
|
|
$showDays[] = $day->getDbDay();
|
|
}
|
|
|
|
if (count($showData['add_show_day_check']) == count($showDays)) {
|
|
// same number of days checked, lets see if they are the same numbers
|
|
$intersect = array_intersect($showData['add_show_day_check'], $showDays);
|
|
if (count($intersect) != count($showData['add_show_day_check'])) {
|
|
$repeatingDaysChanged = true;
|
|
}
|
|
} else {
|
|
$repeatingDaysChanged = true;
|
|
}
|
|
|
|
if ($repeatingDaysChanged) {
|
|
$daysRemoved = array_diff($showDays, $showData['add_show_day_check']);
|
|
$newDays = array_diff($showData['add_show_day_check'], $showDays);
|
|
foreach ($newDays as $newDay) {
|
|
array_push($daysAdded, $newDay);
|
|
}
|
|
|
|
if (count($daysRemoved) > 0) {
|
|
// delete repeating show instances for the repeating
|
|
// days that were removed
|
|
/*if ($this->ccShow->isLinked()) {
|
|
$this->preserveLinkedShowContent();
|
|
}*/
|
|
$this->deleteRemovedShowDayInstances(
|
|
$daysRemoved,
|
|
$ccShowDays,
|
|
$showId
|
|
);
|
|
}
|
|
}
|
|
|
|
if (
|
|
$showData['add_show_start_date'] != $localShowStart->format('Y-m-d')
|
|
|| $showData['add_show_start_time'] != $localShowStart->format('H:i')
|
|
) {
|
|
// start date has been pushed forward so we need to delete
|
|
// any instances of this show scheduled before the new start date
|
|
if ($showData['add_show_start_date'] > $localShowStart->format('Y-m-d')) {
|
|
$this->deleteInstancesBeforeDate($showData['add_show_start_date'], $showId);
|
|
}
|
|
}
|
|
}
|
|
|
|
// get the endate from the past for this show.
|
|
// check if this is null if "no end"
|
|
$currentShowEndDateTime = $this->getRepeatingEndDate();
|
|
|
|
if ($endDateTime && $currentShowEndDateTime != $endDateTime) {
|
|
$endDate = clone $endDateTime;
|
|
$endDate->setTimezone(new DateTimeZone('UTC'));
|
|
|
|
// show's "No End" option was toggled
|
|
// or the end date comes earlier
|
|
if (is_null($currentShowEndDateTime) || ($endDateTime < $currentShowEndDateTime)) {
|
|
// "No End" option was unchecked so we need to delete the
|
|
// repeat instances that are scheduled after the new end date
|
|
// OR
|
|
// end date was pushed back so we have to delete any
|
|
// instances of this show scheduled after the new end date
|
|
$this->deleteInstancesFromDate($endDate->format('Y-m-d'), $showId);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $daysAdded;
|
|
}
|
|
|
|
/*private function preserveLinkedShowContent()
|
|
{
|
|
// Get show content from any future linked instance. It doesn't
|
|
// matter which instance since content is the same in all.
|
|
//
|
|
$ccShowInstance = $this->ccShow->getFutureCcShowInstancess()->getFirst();
|
|
|
|
if (!$ccShowInstance) {
|
|
return;
|
|
}
|
|
$ccSchedules = CcScheduleQuery::create()
|
|
->filterByDbInstanceId($ccShowInstance->getDbId())
|
|
->find();
|
|
|
|
if (!$ccSchedules->isEmpty()) {
|
|
$this->linkedShowContent = $ccSchedules;
|
|
}
|
|
}*/
|
|
|
|
// returns a DateTime of the current show end date set to the timezone of the show.
|
|
public function getRepeatingEndDate()
|
|
{
|
|
$sql = <<<'SQL'
|
|
SELECT last_show, timezone
|
|
FROM cc_show_days
|
|
WHERE show_id = :showId
|
|
ORDER BY last_show DESC
|
|
LIMIT 1
|
|
SQL;
|
|
|
|
$query = Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
['showId' => $this->ccShow->getDbId()],
|
|
'single'
|
|
);
|
|
|
|
$date = null;
|
|
|
|
if ($query !== false && isset($query['last_show'])) {
|
|
$date = new DateTime(
|
|
$query['last_show'],
|
|
new DateTimeZone($query['timezone'])
|
|
);
|
|
}
|
|
|
|
return $date;
|
|
}
|
|
|
|
private function deleteInstancesFromDate($endDate, $showId)
|
|
{
|
|
$sql = <<<'SQL'
|
|
DELETE FROM cc_show_instances
|
|
WHERE date(starts) >= :endDate::DATE
|
|
AND starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
SQL;
|
|
Application_Common_Database::prepareAndExecute($sql, [
|
|
':endDate' => $endDate, ':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
':showId' => $showId,
|
|
], 'execute');
|
|
}
|
|
|
|
private function deleteInstancesBeforeDate($newStartDate, $showId)
|
|
{
|
|
$sql = <<<'SQL'
|
|
DELETE
|
|
FROM cc_show_instances
|
|
WHERE date(starts) < :newStartDate::DATE
|
|
AND starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
SQL;
|
|
|
|
Application_Common_Database::prepareAndExecute($sql, [
|
|
':newStartDate' => $newStartDate, ':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
':showId' => $showId,
|
|
], 'execute');
|
|
}
|
|
|
|
/**
|
|
* Enter description here ...
|
|
*
|
|
* @param $daysRemoved array of days (days of the week) removed
|
|
* (days of the week are represented numerically
|
|
* 0=>sunday, 1=>monday, 2=>tuesday, etc.)
|
|
* @param $showDays array of ccShowDays objects
|
|
* @param mixed $showId
|
|
*/
|
|
private function deleteRemovedShowDayInstances($daysRemoved, $showDays, $showId)
|
|
{
|
|
$daysRemovedUTC = [];
|
|
|
|
// convert the start day of the week to UTC
|
|
foreach ($showDays as $showDay) {
|
|
if (in_array($showDay->getDbDay(), $daysRemoved)) {
|
|
$showDay->reload();
|
|
$startDay = $showDay->getUTCStartDateAndTime();
|
|
$daysRemovedUTC[] = $startDay->format('w');
|
|
}
|
|
}
|
|
|
|
foreach ($daysRemoved as $day) {
|
|
// delete the cc_show_day entries as well
|
|
CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbDay($day)
|
|
->delete();
|
|
}
|
|
|
|
$uncheckedDays = pg_escape_string(implode(',', $daysRemovedUTC));
|
|
|
|
$sql = <<<SQL
|
|
DELETE
|
|
FROM cc_show_instances
|
|
WHERE EXTRACT(DOW FROM starts) IN ({$uncheckedDays})
|
|
AND starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
SQL;
|
|
|
|
Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
[
|
|
':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT), ':showId' => $showId,
|
|
],
|
|
'execute'
|
|
);
|
|
}
|
|
|
|
public function deleteShow($instanceId, $singleInstance = false)
|
|
{
|
|
$service_user = new Application_Service_UserService();
|
|
$currentUser = $service_user->getCurrentUser();
|
|
|
|
$con = Propel::getConnection();
|
|
$con->beginTransaction();
|
|
|
|
try {
|
|
if (!$currentUser->isAdminOrPM()) {
|
|
throw new Exception('Permission denied');
|
|
}
|
|
|
|
$ccShowInstance = CcShowInstancesQuery::create()
|
|
->findPk($instanceId);
|
|
if (!$ccShowInstance) {
|
|
throw new Exception('Could not find show instance');
|
|
}
|
|
|
|
// Delete show images
|
|
$showId = $ccShowInstance->getDbShowId();
|
|
if (!$singleInstance && !Rest_ShowImageController::deleteShowImagesFromStor($showId)) {
|
|
throw new Exception('Error deleting show images');
|
|
}
|
|
|
|
if ($singleInstance) {
|
|
$ccShowInstances = [$ccShowInstance];
|
|
} else {
|
|
$ccShowInstances = CcShowInstancesQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbStarts($ccShowInstance->getDbStarts(), Criteria::GREATER_EQUAL)
|
|
->find();
|
|
}
|
|
|
|
if (gmdate(DEFAULT_TIMESTAMP_FORMAT) <= $ccShowInstance->getDbEnds()) {
|
|
$this->deleteShowInstances($ccShowInstances, $showId);
|
|
} else {
|
|
throw new Exception('Cannot delete a show instance in the past');
|
|
}
|
|
|
|
Application_Model_StoredFile::updatePastFilesIsScheduled();
|
|
|
|
Application_Model_RabbitMq::PushSchedule();
|
|
|
|
$con->commit();
|
|
|
|
return $showId;
|
|
} catch (Exception $e) {
|
|
$con->rollback();
|
|
Logging::info('Delete show instance failed');
|
|
Logging::info($e->getMessage());
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public function deleteShowInstances($ccShowInstances, $showId)
|
|
{
|
|
foreach ($ccShowInstances as $ccShowInstance) {
|
|
$instanceId = $ccShowInstance->getDbId();
|
|
|
|
$ccShowInstance
|
|
->setDbModifiedInstance(true)
|
|
->save();
|
|
|
|
// delete the rebroadcasts of the removed recorded show
|
|
if ($ccShowInstance->isRecorded()) {
|
|
CcShowInstancesQuery::create()
|
|
->filterByDbOriginalShow($instanceId)
|
|
->delete();
|
|
}
|
|
|
|
// delete all files scheduled in cc_schedules table
|
|
CcScheduleQuery::create()
|
|
->filterByDbInstanceId($instanceId)
|
|
->delete();
|
|
}
|
|
|
|
if ($this->checkToDeleteCcShow($showId)) {
|
|
CcShowQuery::create()
|
|
->filterByDbId($showId)
|
|
->delete();
|
|
// There is only one cc_show_instance if the user selects 'Delete This Instance'
|
|
// There is more than one cc_show_instance if the user selects 'Delete This
|
|
// Instance and All Following'. We only need to set the last_show value
|
|
// when 'Delete This Instance and All Following' has been selected
|
|
} elseif (count($ccShowInstances) > 1) {
|
|
$this->setLastRepeatingShowDate($showId);
|
|
}
|
|
}
|
|
|
|
private function setLastRepeatingShowDate($showId)
|
|
{
|
|
$ccShowInstances = CcShowInstancesQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbModifiedInstance(false)
|
|
->filterByDbRebroadcast(0)
|
|
->orderByDbStarts()
|
|
->find();
|
|
|
|
/* We need to update the last_show in cc_show_days so the instances
|
|
* don't get recreated as the user moves forward in the calendar
|
|
*/
|
|
$lastShowDays = [];
|
|
|
|
// get the show's timezone
|
|
$ccShow = CcShowQuery::create()->findPk($showId);
|
|
if ($ccShow->isRepeating()) {
|
|
$showTimezone = $ccShow->getFirstRepeatingCcShowDay()->getDbTimezone();
|
|
} else {
|
|
$showTimezone = $ccShow->getFirstCcShowDay()->getDbTimezone();
|
|
}
|
|
|
|
/* Creates an array where the key is the day of the week (monday,
|
|
* tuesday, etc.) and the value is the last show date for each
|
|
* day of the week. We will use this array to update the last_show
|
|
* for each cc_show_days entry of a cc_show
|
|
*/
|
|
foreach ($ccShowInstances as $instance) {
|
|
$instanceStartDT = $instance->getDbStarts(null);
|
|
$instanceStartDT->setTimezone(new DateTimeZone($showTimezone));
|
|
$lastShowDays[$instanceStartDT->format('w')] = $instanceStartDT;
|
|
}
|
|
|
|
foreach ($lastShowDays as $dayOfWeek => $lastShowStartDT) {
|
|
$ccShowDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbDay($dayOfWeek)
|
|
->filterByDbRepeatType(-1, Criteria::NOT_EQUAL)
|
|
->findOne();
|
|
|
|
if (isset($ccShowDay)) {
|
|
$lastShowStartDT->setTimeZone(new DateTimeZone(
|
|
$ccShowDay->getDbTimezone()
|
|
));
|
|
$lastShowEndDT = Application_Service_CalendarService::addDeltas(
|
|
$lastShowStartDT,
|
|
1,
|
|
0
|
|
);
|
|
|
|
$ccShowDay
|
|
->setDbLastShow($lastShowEndDT->format('Y-m-d'))
|
|
->save();
|
|
}
|
|
}
|
|
|
|
// NOTE: Some cc_show_day records may not get updated because there may not be an instance
|
|
// left on one of the repeating days so we have to find the entries where the last_show is
|
|
// still null
|
|
$showDays = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbRepeatType(0, Criteria::GREATER_EQUAL)
|
|
->filterByDbLastShow(null)
|
|
->find();
|
|
foreach ($showDays as $showDay) {
|
|
$showDay->setDbLastShow($showDay->getDbFirstShow())->save();
|
|
}
|
|
}
|
|
|
|
private function checkToDeleteCcShow($showId)
|
|
{
|
|
// check if there are any non deleted show instances remaining.
|
|
$ccShowInstances = CcShowInstancesQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbModifiedInstance(false)
|
|
->filterByDbRebroadcast(0)
|
|
->orderByDbStarts()
|
|
->find();
|
|
|
|
if ($ccShowInstances->isEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function deleteAllInstances($showId)
|
|
{
|
|
$sql = <<<'SQL'
|
|
DELETE
|
|
FROM cc_show_instances
|
|
WHERE starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
SQL;
|
|
Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
[
|
|
':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
':showId' => $showId,
|
|
],
|
|
'execute'
|
|
);
|
|
}
|
|
|
|
private function deleteAllRepeatInstances($currentShowDay, $showId)
|
|
{
|
|
$firstShow = $currentShowDay->getUTCStartDateAndTime();
|
|
|
|
$sql = <<<'SQL'
|
|
DELETE
|
|
FROM cc_show_instances
|
|
WHERE starts > :timestamp::TIMESTAMP
|
|
AND show_id = :showId
|
|
AND starts != :firstShow
|
|
SQL;
|
|
Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
[
|
|
':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
':showId' => $showId,
|
|
':firstShow' => $firstShow->format(DEFAULT_TIMESTAMP_FORMAT),
|
|
],
|
|
'execute'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Determines what the show end date should be based on
|
|
* the form data.
|
|
*
|
|
* @param $showData add/edit show form data
|
|
*
|
|
* @return DateTime object in user's local timezone
|
|
*/
|
|
private function calculateEndDate($showData)
|
|
{
|
|
// if no end return null
|
|
if ($showData['add_show_no_end']) {
|
|
$endDate = null;
|
|
}
|
|
// if the show is repeating & ends, then return the end date
|
|
elseif ($showData['add_show_repeats']) {
|
|
$endDate = new DateTime(
|
|
$showData['add_show_end_date'],
|
|
new DateTimeZone($showData['add_show_timezone'])
|
|
);
|
|
$endDate->add(new DateInterval('P1D'));
|
|
}
|
|
// the show doesn't repeat, so add one day to the start date.
|
|
else {
|
|
$endDate = new DateTime(
|
|
$showData['add_show_start_date'],
|
|
new DateTimeZone($showData['add_show_timezone'])
|
|
);
|
|
$endDate->add(new DateInterval('P1D'));
|
|
}
|
|
|
|
return $endDate;
|
|
}
|
|
|
|
private function updateScheduleStartEndTimes($showData)
|
|
{
|
|
$showId = $this->ccShow->getDbId();
|
|
// DateTime in show's local time
|
|
$newStartDateTime = new DateTime(
|
|
$showData['add_show_start_date'] . ' ' .
|
|
$showData['add_show_start_time'],
|
|
new DateTimeZone($showData['add_show_timezone'])
|
|
);
|
|
|
|
$diff = $this->calculateShowStartDiff(
|
|
$newStartDateTime,
|
|
$this->origCcShowDay->getLocalStartDateAndTime()
|
|
);
|
|
|
|
Application_Service_SchedulerService::updateScheduleStartTime(
|
|
$this->instanceIdsForScheduleUpdates,
|
|
$diff
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns the difference in seconds between a show's new and
|
|
* old start time.
|
|
*
|
|
* @param $newStartDateTime DateTime object
|
|
* @param $oldStartDateTime DateTime object
|
|
*/
|
|
private function calculateShowStartDiff($newStartDateTime, $oldStartDateTime)
|
|
{
|
|
return $newStartDateTime->getTimestamp() - $oldStartDateTime->getTimestamp();
|
|
}
|
|
|
|
/**
|
|
* Updates the start and end time for cc_show_instances.
|
|
*
|
|
* @param mixed $diff
|
|
*/
|
|
private function updateInstanceStartEndTime($diff)
|
|
{
|
|
$sql = <<<'SQL'
|
|
UPDATE cc_show_instances
|
|
SET starts = starts + :diff1::INTERVAL,
|
|
ends = ends + :diff2::INTERVAL
|
|
WHERE show_id = :showId
|
|
AND starts > :timestamp::TIMESTAMP
|
|
SQL;
|
|
|
|
Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
[
|
|
':diff1' => $diff, ':diff2' => $diff,
|
|
':showId' => $this->ccShow->getDbId(), ':timestamp' => gmdate(DEFAULT_TIMESTAMP_FORMAT),
|
|
],
|
|
'execute'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Enter description here ...
|
|
*
|
|
* @param ccShowDays $showDay
|
|
* @param DateTime $showStartDate user's local time
|
|
* @param mixed $instanceId
|
|
*/
|
|
private function createRebroadcastInstances($showDay, $showStartDate, $instanceId)
|
|
{
|
|
$currentUtcTimestamp = gmdate(DEFAULT_TIMESTAMP_FORMAT);
|
|
$showId = $this->ccShow->getDbId();
|
|
|
|
$sql = 'SELECT * FROM cc_show_rebroadcast WHERE show_id=:show_id';
|
|
$rebroadcasts = Application_Common_Database::prepareAndExecute(
|
|
$sql,
|
|
[':show_id' => $showId],
|
|
'all'
|
|
);
|
|
|
|
foreach ($rebroadcasts as $rebroadcast) {
|
|
$days = explode(' ', $rebroadcast['day_offset']);
|
|
$time = explode(':', $rebroadcast['start_time']);
|
|
$offset = ['days' => $days[0], 'hours' => $time[0], 'mins' => $time[1]];
|
|
|
|
[$utcStartDateTime, $utcEndDateTime] = $this->createUTCStartEndDateTime(
|
|
$showStartDate,
|
|
$showDay->getDbDuration(),
|
|
$offset
|
|
);
|
|
|
|
if ($utcStartDateTime->format(DEFAULT_TIMESTAMP_FORMAT) > $currentUtcTimestamp) {
|
|
$ccShowInstance = new CcShowInstances();
|
|
$ccShowInstance->setDbShowId($showId);
|
|
$ccShowInstance->setDbStarts($utcStartDateTime);
|
|
$ccShowInstance->setDbEnds($utcEndDateTime);
|
|
$ccShowInstance->setDbRecord(0);
|
|
$ccShowInstance->setDbRebroadcast(1);
|
|
$ccShowInstance->setDbOriginalShow($instanceId);
|
|
$ccShowInstance->save();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets a single cc_show_instance table row.
|
|
*
|
|
* @param mixed $showDay
|
|
* @param mixed $populateUntil
|
|
*/
|
|
private function createNonRepeatingInstance($showDay, $populateUntil)
|
|
{
|
|
// DateTime object
|
|
$start = $showDay->getLocalStartDateAndTime();
|
|
|
|
[$utcStartDateTime, $utcEndDateTime] = $this->createUTCStartEndDateTime(
|
|
$start,
|
|
$showDay->getDbDuration()
|
|
);
|
|
|
|
if ($utcStartDateTime->getTimestamp() < $populateUntil->getTimestamp()) {
|
|
$ccShowInstance = new CcShowInstances();
|
|
if ($this->isUpdate) {
|
|
// use original cc_show_day object to get the current cc_show_instance
|
|
$origStartDateTime = new DateTime(
|
|
$this->origCcShowDay->getDbFirstShow() . ' ' . $this->origCcShowDay->getDbStartTime(),
|
|
new DateTimeZone($this->origCcShowDay->getDbTimezone())
|
|
);
|
|
$origStartDateTime->setTimezone(new DateTimeZone('UTC'));
|
|
$ccShowInstance = $this->getInstance($origStartDateTime);
|
|
if (!$ccShowInstance) {
|
|
throw new Exception('Could not find show instance with start time: ' . $origStartDateTime->format(DEFAULT_TIMESTAMP_FORMAT));
|
|
}
|
|
}
|
|
|
|
$ccShowInstance->setDbShowId($this->ccShow->getDbId());
|
|
$ccShowInstance->setDbStarts($utcStartDateTime);
|
|
$ccShowInstance->setDbEnds($utcEndDateTime);
|
|
$ccShowInstance->setDbRecord($showDay->getDbRecord());
|
|
$ccShowInstance->save();
|
|
|
|
if ($this->isRebroadcast) {
|
|
$this->createRebroadcastInstances($showDay, $start, $ccShowInstance->getDbId());
|
|
}
|
|
}
|
|
|
|
return $ccShowInstance;
|
|
}
|
|
|
|
/**
|
|
* Sets multiple cc_show_instances table rows.
|
|
*
|
|
* @param unknown_type $showDay
|
|
* @param unknown_type $populateUntil
|
|
* @param unknown_type $repeatInterval
|
|
* @param mixed $repeatType
|
|
* @param null|mixed $daysAdded
|
|
*/
|
|
private function createWeeklyRepeatInstances(
|
|
$showDay,
|
|
$populateUntil,
|
|
$repeatType,
|
|
$repeatInterval,
|
|
$daysAdded = null
|
|
) {
|
|
$show_id = $showDay->getDbShowId();
|
|
$first_show = $showDay->getDbFirstShow(); // non-UTC
|
|
$last_show = $showDay->getDbLastShow(); // non-UTC
|
|
$duration = $showDay->getDbDuration();
|
|
$day = $showDay->getDbDay();
|
|
$record = $showDay->getDbRecord();
|
|
$timezone = $showDay->getDbTimezone();
|
|
|
|
// DateTime local
|
|
$start = $this->getNextRepeatingPopulateStartDateTime($showDay);
|
|
|
|
if (is_null($repeatInterval) && $repeatType == REPEAT_MONTHLY_WEEKLY) {
|
|
$repeatInterval = self::getMonthlyWeeklyRepeatInterval($start, $timezone);
|
|
}
|
|
|
|
// DatePeriod in user's local time
|
|
$datePeriod = $this->getDatePeriod(
|
|
$start,
|
|
$timezone,
|
|
$last_show,
|
|
$repeatInterval,
|
|
$populateUntil
|
|
);
|
|
|
|
if ($last_show) {
|
|
$utcLastShowDateTime = new DateTime($last_show, new DateTimeZone($timezone));
|
|
$utcLastShowDateTime->setTimezone(new DateTimeZone('UTC'));
|
|
} else {
|
|
$utcLastShowDateTime = null;
|
|
}
|
|
|
|
$previousDate = clone $start;
|
|
|
|
foreach ($datePeriod as $date) {
|
|
[$utcStartDateTime, $utcEndDateTime] = $this->createUTCStartEndDateTime(
|
|
$date,
|
|
$duration
|
|
);
|
|
/*
|
|
* Make sure start date is less than populate until date AND
|
|
* last show date is null OR start date is less than last show date
|
|
*/
|
|
if (
|
|
$utcStartDateTime <= $populateUntil
|
|
&& (is_null($utcLastShowDateTime) || $utcStartDateTime < $utcLastShowDateTime)
|
|
) {
|
|
$lastCreatedShow = clone $utcStartDateTime;
|
|
/* There may not always be an instance when editing a show
|
|
* This will be the case when we are adding a new show day to
|
|
* a repeating show
|
|
*/
|
|
if ($this->isUpdate) {
|
|
if ($this->hasInstance($utcStartDateTime)) {
|
|
$ccShowInstance = $this->getInstance($utcStartDateTime);
|
|
$newInstance = false;
|
|
} else {
|
|
$newInstance = true;
|
|
$ccShowInstance = new CcShowInstances();
|
|
}
|
|
} else {
|
|
$newInstance = true;
|
|
$ccShowInstance = new CcShowInstances();
|
|
}
|
|
|
|
/* When editing the start/end time of a repeating show, we don't want to
|
|
* change shows that are in the past so we check the end time.
|
|
*/
|
|
if ($newInstance || $ccShowInstance->getDbEnds() > gmdate(DEFAULT_TIMESTAMP_FORMAT)) {
|
|
$ccShowInstance->setDbShowId($show_id);
|
|
$ccShowInstance->setDbStarts($utcStartDateTime);
|
|
$ccShowInstance->setDbEnds($utcEndDateTime);
|
|
$ccShowInstance->setDbRecord($record);
|
|
$ccShowInstance->save();
|
|
}
|
|
|
|
if ($newInstance) {
|
|
array_push($this->newInstanceIdsCreated[$show_id], $ccShowInstance->getDbId());
|
|
}
|
|
|
|
if ($this->isRebroadcast) {
|
|
$this->createRebroadcastInstances($showDay, $date, $ccShowInstance->getDbId());
|
|
}
|
|
}
|
|
$previousDate = clone $date;
|
|
}
|
|
|
|
/* We need to set the next populate date for repeat shows so when a user
|
|
* moves forward in the calendar we know when to start generating new
|
|
* show instances.
|
|
* If $utcStartDateTime is not set then we know zero new shows were
|
|
* created and we shouldn't update the next populate date.
|
|
*/
|
|
if (isset($lastCreatedShow)) {
|
|
/* Set UTC to local time before setting the next repeat date. If we don't
|
|
* the next repeat date might be scheduled for the following day
|
|
* THIS MUST BE IN THE TIMEZONE THE SHOW WAS CREATED IN */
|
|
$lastCreatedShow->setTimezone(new DateTimeZone($timezone));
|
|
$nextDate = $lastCreatedShow->add($repeatInterval);
|
|
$this->setNextRepeatingShowDate($nextDate->format('Y-m-d'), $day, $show_id);
|
|
}
|
|
}
|
|
|
|
private function createMonthlyRepeatInstances($showDay, $populateUntil)
|
|
{
|
|
$show_id = $showDay->getDbShowId();
|
|
$first_show = $showDay->getDbFirstShow(); // non-UTC
|
|
$last_show = $showDay->getDbLastShow(); // non-UTC
|
|
$duration = $showDay->getDbDuration();
|
|
$day = $showDay->getDbDay();
|
|
$record = $showDay->getDbRecord();
|
|
$timezone = $showDay->getDbTimezone();
|
|
|
|
// DateTime local
|
|
$start = $this->getNextRepeatingPopulateStartDateTime($showDay);
|
|
if (isset($last_show)) {
|
|
$end = new DateTime($last_show, new DateTimeZone($timezone));
|
|
} else {
|
|
$end = $populateUntil;
|
|
}
|
|
|
|
// We will only need this if the repeat type is MONTHLY_WEEKLY
|
|
[$weekNumberOfMonth, $dayOfWeek] =
|
|
self::getMonthlyWeeklyRepeatInterval(
|
|
new DateTime($first_show, new DateTimeZone($timezone))
|
|
);
|
|
|
|
$this->repeatType = $showDay->getDbRepeatType();
|
|
|
|
if ($last_show) {
|
|
$utcLastShowDateTime = new DateTime($last_show, new DateTimeZone($timezone));
|
|
$utcLastShowDateTime->setTimezone(new DateTimeZone('UTC'));
|
|
} else {
|
|
$utcLastShowDateTime = null;
|
|
}
|
|
|
|
while ($start->getTimestamp() < $end->getTimestamp()) {
|
|
[$utcStartDateTime, $utcEndDateTime] = $this->createUTCStartEndDateTime(
|
|
$start,
|
|
$duration
|
|
);
|
|
/*
|
|
* Make sure start date is less than populate until date AND
|
|
* last show date is null OR start date is less than last show date
|
|
*/
|
|
if (
|
|
$utcStartDateTime->getTimestamp() <= $populateUntil->getTimestamp()
|
|
&& (is_null($utcLastShowDateTime)
|
|
|| $utcStartDateTime->getTimestamp() < $utcLastShowDateTime->getTimestamp())
|
|
) {
|
|
$lastCreatedShow = clone $utcStartDateTime;
|
|
/* There may not always be an instance when editing a show
|
|
* This will be the case when we are adding a new show day to
|
|
* a repeating show
|
|
*/
|
|
if ($this->isUpdate && $this->hasInstance($utcStartDateTime)) {
|
|
$ccShowInstance = $this->getInstance($utcStartDateTime);
|
|
$newInstance = false;
|
|
} else {
|
|
$newInstance = true;
|
|
$ccShowInstance = new CcShowInstances();
|
|
}
|
|
|
|
/* When editing the start/end time of a repeating show, we don't want to
|
|
* change shows that started in the past. So check the start time.
|
|
*/
|
|
if ($newInstance || $ccShowInstance->getDbStarts() > gmdate(DEFAULT_TIMESTAMP_FORMAT)) {
|
|
$ccShowInstance->setDbShowId($show_id);
|
|
$ccShowInstance->setDbStarts($utcStartDateTime);
|
|
$ccShowInstance->setDbEnds($utcEndDateTime);
|
|
$ccShowInstance->setDbRecord($record);
|
|
$ccShowInstance->save();
|
|
}
|
|
|
|
if ($newInstance) {
|
|
array_push($this->newInstanceIdsCreated[$show_id], $ccShowInstance->getDbId());
|
|
}
|
|
|
|
if ($this->isRebroadcast) {
|
|
$this->createRebroadcastInstances($showDay, $start, $ccShowInstance->getDbId());
|
|
}
|
|
}
|
|
if ($this->repeatType == REPEAT_MONTHLY_WEEKLY) {
|
|
$monthlyWeeklyStart = new DateTime(
|
|
$utcStartDateTime->format('Y-m'),
|
|
new DateTimeZone('UTC')
|
|
);
|
|
$monthlyWeeklyStart->add(new DateInterval('P1M'));
|
|
$start = self::getNextMonthlyWeeklyRepeatDate(
|
|
$monthlyWeeklyStart,
|
|
$timezone,
|
|
$showDay->getDbStartTime(),
|
|
$weekNumberOfMonth,
|
|
$dayOfWeek
|
|
);
|
|
} else {
|
|
$start = $this->getNextMonthlyMonthlyRepeatDate(
|
|
$start,
|
|
$timezone,
|
|
$showDay->getDbStartTime()
|
|
);
|
|
}
|
|
}
|
|
$this->setNextRepeatingShowDate($start->format('Y-m-d'), $day, $show_id);
|
|
}
|
|
|
|
/**
|
|
* i.e. last thursday of each month
|
|
* i.e. second monday of each month.
|
|
*
|
|
* @param string $showStart
|
|
*/
|
|
public static function getMonthlyWeeklyRepeatInterval($showStart)
|
|
{
|
|
$start = clone $showStart;
|
|
$dayOfMonth = $start->format('j');
|
|
$dayOfWeek = $start->format('l');
|
|
$yearAndMonth = $start->format('Y-m');
|
|
$firstDayOfWeek = strtotime($dayOfWeek . ' ' . $yearAndMonth);
|
|
// if $dayOfWeek is Friday, what number of the month does
|
|
// the first Friday fall on
|
|
$numberOfFirstDayOfWeek = date('j', $firstDayOfWeek);
|
|
|
|
$weekCount = 0;
|
|
while ($dayOfMonth >= $numberOfFirstDayOfWeek) {
|
|
++$weekCount;
|
|
$dayOfMonth -= 7;
|
|
}
|
|
|
|
switch ($weekCount) {
|
|
case 1:
|
|
$weekNumberOfMonth = 'first';
|
|
|
|
break;
|
|
|
|
case 2:
|
|
$weekNumberOfMonth = 'second';
|
|
|
|
break;
|
|
|
|
case 3:
|
|
$weekNumberOfMonth = 'third';
|
|
|
|
break;
|
|
|
|
case 4:
|
|
$weekNumberOfMonth = 'fourth';
|
|
|
|
break;
|
|
|
|
case 5:
|
|
$weekNumberOfMonth = 'fifth';
|
|
|
|
break;
|
|
}
|
|
|
|
/* return DateInterval::createFromDateString(
|
|
$weekNumberOfMonth." ".$dayOfWeek." of next month"); */
|
|
return [$weekNumberOfMonth, $dayOfWeek];
|
|
}
|
|
|
|
/**
|
|
* Enter description here ...
|
|
*
|
|
* @param $start user's local time
|
|
* @param mixed $timezone
|
|
* @param mixed $startTime
|
|
*/
|
|
private function getNextMonthlyMonthlyRepeatDate($start, $timezone, $startTime)
|
|
{
|
|
$dt = new DateTime($start->format('Y-m'), new DateTimeZone($timezone));
|
|
|
|
do {
|
|
$dt->add(new DateInterval('P1M'));
|
|
} while (!checkdate($dt->format('m'), $start->format('d'), $dt->format('Y')));
|
|
|
|
$dt->setDate($dt->format('Y'), $dt->format('m'), $start->format('d'));
|
|
|
|
$startTime = explode(':', $startTime);
|
|
$hours = isset($startTime[0]) ? $startTime[0] : '00';
|
|
$minutes = isset($startTime[1]) ? $startTime[1] : '00';
|
|
$seconds = isset($startTime[2]) ? $startTime[2] : '00';
|
|
$dt->setTime($hours, $minutes, $seconds);
|
|
|
|
return $dt;
|
|
}
|
|
|
|
/**
|
|
* Returns a DateTime object of when the next repeating show that repeats
|
|
* monthly, by day of the week (i.e. every fourth Tuesday) should be created.
|
|
*
|
|
* @param DateTime $start
|
|
* $start only has the year and month of the next show
|
|
* @param string $timezone
|
|
* @param string (i.e. '14:30' $startTime
|
|
* @param string (i.e. 'first', 'second') $weekNumberOfMonth
|
|
* @param string (i.e. 'Monday') $dayOfWeek
|
|
*/
|
|
public static function getNextMonthlyWeeklyRepeatDate(
|
|
$start,
|
|
$timezone,
|
|
$startTime,
|
|
$weekNumberOfMonth,
|
|
$dayOfWeek
|
|
) {
|
|
$dt = new DateTime($start->format('Y-m'), new DateTimeZone($timezone));
|
|
$tempDT = clone $dt;
|
|
$fifthWeekExists = false;
|
|
do {
|
|
$nextDT = date_create($weekNumberOfMonth . ' ' . $dayOfWeek .
|
|
' of ' . $tempDT->format('F') . ' ' . $tempDT->format('Y'));
|
|
$nextDT->setTimezone(new DateTimeZone($timezone));
|
|
|
|
/* We have to check if the next date is in the same month in case
|
|
* the repeat day is in the fifth week of the month.
|
|
* If it's not in the same month we know that a fifth week of
|
|
* the next month does not exist. So let's skip it.
|
|
*/
|
|
if ($tempDT->format('F') == $nextDT->format('F')) {
|
|
$fifthWeekExists = true;
|
|
}
|
|
$tempDT->add(new DateInterval('P1M'));
|
|
} while (!$fifthWeekExists);
|
|
|
|
$dt = $nextDT;
|
|
|
|
$startTime = explode(':', $startTime);
|
|
$hours = isset($startTime[0]) ? $startTime[0] : '00';
|
|
$minutes = isset($startTime[1]) ? $startTime[1] : '00';
|
|
$seconds = isset($startTime[2]) ? $startTime[2] : '00';
|
|
$dt->setTime($hours, $minutes, $seconds);
|
|
|
|
return $dt;
|
|
}
|
|
|
|
private function getNextRepeatingPopulateStartDateTime($showDay)
|
|
{
|
|
$nextPopDate = $showDay->getDbNextPopDate();
|
|
$startTime = $showDay->getDbStartTime();
|
|
|
|
if (isset($nextPopDate)) {
|
|
return new DateTime($nextPopDate . ' ' . $startTime, new DateTimeZone($showDay->getDbTimezone()));
|
|
}
|
|
|
|
return new DateTime($showDay->getDbFirstShow() . ' ' . $startTime, new DateTimeZone($showDay->getDbTimezone()));
|
|
}
|
|
|
|
/**
|
|
* Create a DatePeriod object in the user's local time
|
|
* It will get converted to UTC before the show instance gets created.
|
|
*
|
|
* @param mixed $start
|
|
* @param mixed $timezone
|
|
* @param mixed $lastShow
|
|
* @param mixed $repeatInterval
|
|
* @param mixed $populateUntil
|
|
*/
|
|
private function getDatePeriod($start, $timezone, $lastShow, $repeatInterval, $populateUntil)
|
|
{
|
|
if (isset($lastShow)) {
|
|
$endDatePeriod = new DateTime($lastShow, new DateTimeZone($timezone));
|
|
} else {
|
|
$endDatePeriod = $populateUntil;
|
|
}
|
|
|
|
return new DatePeriod($start, $repeatInterval, $endDatePeriod);
|
|
}
|
|
|
|
private function hasInstance($starts)
|
|
{
|
|
return $this->getInstance($starts) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Attempts to retrieve the cc_show_instance belonging to a cc_show
|
|
* that starts at $starts. We have to pass in the start
|
|
* time in case the show is repeating.
|
|
*
|
|
* Returns the instance if one was found (one that is not a recording
|
|
* and modified instance is false (has not been deleted))
|
|
*
|
|
* @param mixed $starts
|
|
*/
|
|
private function getInstance($starts)
|
|
{
|
|
$temp = clone $starts;
|
|
$temp->setTimezone(new DateTimeZone($this->oldShowTimezone));
|
|
$temp->setTime($this->localShowStartHour, $this->localShowStartMin);
|
|
|
|
$temp->setTimezone(new DateTimeZone('UTC'));
|
|
|
|
$ccShowInstance = CcShowInstancesQuery::create()
|
|
->filterByDbStarts($temp->format(DEFAULT_TIMESTAMP_FORMAT), Criteria::EQUAL)
|
|
->filterByDbShowId($this->ccShow->getDbId(), Criteria::EQUAL)
|
|
// ->filterByDbModifiedInstance(false, Criteria::EQUAL)
|
|
->filterByDbRebroadcast(0, Criteria::EQUAL)
|
|
->limit(1)
|
|
->find();
|
|
|
|
if ($ccShowInstance->isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
return $ccShowInstance[0];
|
|
}
|
|
|
|
private function hasCcShowDay($repeatType, $day)
|
|
{
|
|
return $this->getCcShowDay($repeatType, $day) ? true : false;
|
|
}
|
|
|
|
private function getCcShowDay($repeatType, $day)
|
|
{
|
|
$ccShowDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($this->ccShow->getDbId())
|
|
->filterByDbDay($day)
|
|
->filterByDbRepeatType($repeatType)
|
|
->limit(1)
|
|
->find();
|
|
|
|
if ($ccShowDay->isEmpty()) {
|
|
return false;
|
|
}
|
|
|
|
return $ccShowDay[0];
|
|
}
|
|
|
|
/**
|
|
* Sets the fields for a cc_show table row.
|
|
*
|
|
* @param mixed $showData
|
|
*/
|
|
public function setCcShow($showData)
|
|
{
|
|
if (!$this->isUpdate) {
|
|
$ccShow = new CcShow();
|
|
} else {
|
|
$ccShow = CcShowQuery::create()->findPk($showData['add_show_id']);
|
|
}
|
|
|
|
$ccShow->setDbName($showData['add_show_name']);
|
|
$ccShow->setDbDescription($showData['add_show_description']);
|
|
$ccShow->setDbUrl($showData['add_show_url']);
|
|
$ccShow->setDbGenre($showData['add_show_genre']);
|
|
$ccShow->setDbColor($showData['add_show_color']);
|
|
$ccShow->setDbBackgroundColor($showData['add_show_background_color']);
|
|
$ccShow->setDbLiveStreamUsingAirtimeAuth($showData['cb_airtime_auth'] == 1);
|
|
$ccShow->setDbLiveStreamUsingCustomAuth($showData['cb_custom_auth'] == 1);
|
|
$ccShow->setDbLiveStreamUser($showData['custom_username']);
|
|
$ccShow->setDbLiveStreamPass($showData['custom_password']);
|
|
$ccShow->setDbHasAutoPlaylist($showData['add_show_has_autoplaylist'] == 1);
|
|
$ccShow->setDbAutoPlaylistRepeat($showData['add_show_autoplaylist_repeat'] == 1);
|
|
// added to prevent errors with insert due to a lack of data
|
|
if ($showData['add_show_autoplaylist_id'] != '') {
|
|
$ccShow->setDbAutoPlaylistId($showData['add_show_autoplaylist_id']);
|
|
}
|
|
|
|
$ccShow->setDbOverrideIntroPlaylist($showData['add_show_intro_playlist_id'] != 0);
|
|
if ($showData['add_show_intro_playlist_id'] != '') {
|
|
$ccShow->setDbIntroPlaylistId($showData['add_show_intro_playlist_id']);
|
|
}
|
|
|
|
$ccShow->setDbOverrideOutroPlaylist($showData['add_show_outro_playlist_id'] != 0);
|
|
if ($showData['add_show_outro_playlist_id'] != '') {
|
|
$ccShow->setDbOutroPlaylistId($showData['add_show_outro_playlist_id']);
|
|
}
|
|
|
|
// Here a user has edited a show and linked it.
|
|
// We need to grab the existing show instances ids and fill their content
|
|
// with the content from the show instance that was clicked on to edit the show.
|
|
// We do this because linked show instances need to have the same content in each.
|
|
if ($this->isUpdate && (!$ccShow->getDbLinked() && $showData['add_show_linked'])) {
|
|
$existingShowInstanceIds = $ccShow->getFutureInstanceIds(new Criteria());
|
|
Application_Service_SchedulerService::fillLinkedInstances($ccShow, $existingShowInstanceIds, $showData['add_show_instance_id']);
|
|
}
|
|
$ccShow->setDbLinked($showData['add_show_linked']);
|
|
|
|
$ccShow->save();
|
|
$this->ccShow = $ccShow;
|
|
}
|
|
|
|
/**
|
|
* Sets the fields for a cc_show_days table row.
|
|
*
|
|
* @param mixed $showData
|
|
*/
|
|
private function setCcShowDays($showData)
|
|
{
|
|
$showId = $this->ccShow->getDbId();
|
|
|
|
$startDateTime = new DateTime(
|
|
$showData['add_show_start_date'] . ' ' . $showData['add_show_start_time'],
|
|
new DateTimeZone($showData['add_show_timezone'])
|
|
);
|
|
|
|
$endDateTime = $this->calculateEndDate($showData);
|
|
if (!is_null($endDateTime)) {
|
|
$endDate = $endDateTime->format('Y-m-d');
|
|
} else {
|
|
$endDate = null;
|
|
}
|
|
|
|
// Our calculated start DOW must be used for non repeating since a day has not been selected.
|
|
// For all repeating shows, only the selected days of the week will be repeated on.
|
|
$startDow = $startDateTime->format('w');
|
|
if (!$showData['add_show_repeats']) {
|
|
$showData['add_show_day_check'] = [$startDow];
|
|
}
|
|
|
|
// Don't set day for monthly repeat type, it's invalid
|
|
if ($showData['add_show_repeats'] && $showData['add_show_repeat_type'] == 2) {
|
|
if ($this->isUpdate) {
|
|
$showDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbRepeatType($this->origCcShowDay->getDbRepeatType())
|
|
->findOne();
|
|
if (!$showDay) {
|
|
// repeat type changed so we have to create a new show_day rule
|
|
$showDay = new CcShowDays();
|
|
}
|
|
} else {
|
|
$showDay = new CcShowDays();
|
|
}
|
|
|
|
$showDay->setDbFirstShow($startDateTime->format('Y-m-d'));
|
|
$showDay->setDbLastShow($endDate);
|
|
$showDay->setDbStartTime($startDateTime->format('H:i:s'));
|
|
$showDay->setDbTimezone($showData['add_show_timezone']);
|
|
$showDay->setDbDuration($showData['add_show_duration']);
|
|
$showDay->setDbRepeatType($this->repeatType);
|
|
$showDay->setDbShowId($showId);
|
|
$showDay->setDbRecord($this->isRecorded);
|
|
// in case we are editing a show we need to set this to the first show
|
|
// so when editing, the date period iterator will start from the beginning
|
|
$showDay->setDbNextPopDate($startDateTime->format('Y-m-d'));
|
|
$showDay->save();
|
|
} else {
|
|
foreach ($showData['add_show_day_check'] as $day) {
|
|
$daysAdd = 0;
|
|
$startDateTimeClone = clone $startDateTime;
|
|
if ($startDow !== $day) {
|
|
if ($startDow > $day) {
|
|
$daysAdd = 6 - $startDow + 1 + $day;
|
|
} else {
|
|
$daysAdd = $day - $startDow;
|
|
}
|
|
|
|
$startDateTimeClone->add(new DateInterval('P' . $daysAdd . 'D'));
|
|
}
|
|
if (is_null($endDate) || $startDateTimeClone->getTimestamp() <= $endDateTime->getTimestamp()) {
|
|
if ($this->isUpdate) {
|
|
if (
|
|
$this->origCcShowDay->getDbRepeatType() == 2
|
|
|| $this->origCcShowDay->getDbRepeatType() == 3
|
|
) {
|
|
$day = null;
|
|
} elseif (!$this->origShowRepeatStatus) {
|
|
// keep current show day to use for updating cc_show_day rule
|
|
$keepDay = $day;
|
|
$day = $this->origCcShowDay->getDbDay();
|
|
}
|
|
|
|
$showDay = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbRepeatType($this->origCcShowDay->getDbRepeatType())
|
|
->filterByDbDay($day)
|
|
->findOne();
|
|
if (!$showDay) {
|
|
// if no show day object was found it is because a new
|
|
// repeating day of the week was added OR the repeat
|
|
// type has changed
|
|
$showDay = new CcShowDays();
|
|
}
|
|
|
|
if (isset($keepDay)) {
|
|
$day = $keepDay;
|
|
}
|
|
} else {
|
|
$showDay = new CcShowDays();
|
|
}
|
|
|
|
$showDay->setDbFirstShow($startDateTimeClone->format('Y-m-d'));
|
|
$showDay->setDbLastShow($endDate);
|
|
$showDay->setDbStartTime($startDateTimeClone->format('H:i'));
|
|
$showDay->setDbTimezone($showData['add_show_timezone']);
|
|
$showDay->setDbDuration($showData['add_show_duration']);
|
|
$showDay->setDbDay($day);
|
|
$showDay->setDbRepeatType($this->repeatType);
|
|
$showDay->setDbShowId($showId);
|
|
$showDay->setDbRecord($this->isRecorded);
|
|
// in case we are editing a show we need to set this to the first show
|
|
// so when editing, the date period iterator will start from the beginning
|
|
$showDay->setDbNextPopDate($startDateTimeClone->format('Y-m-d'));
|
|
$showDay->save();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes all the cc_show_rebroadcast entries for a specific show
|
|
* that is currently being edited. They will get recreated with
|
|
* the new show specs.
|
|
*/
|
|
private function deleteCcShowRebroadcasts()
|
|
{
|
|
CcShowRebroadcastQuery::create()->filterByDbShowId($this->ccShow->getDbId())->delete();
|
|
}
|
|
|
|
/**
|
|
* Sets the fields for a cc_show_rebroadcast table row.
|
|
*
|
|
* @param mixed $showData
|
|
*/
|
|
private function setCcShowRebroadcasts($showData)
|
|
{
|
|
$showId = $this->ccShow->getDbId();
|
|
|
|
if (($this->isRecorded && $showData['add_show_rebroadcast']) && ($this->repeatType != -1)) {
|
|
for ($i = 1; $i <= MAX_REBROADCAST_DATES; ++$i) {
|
|
if ($showData['add_show_rebroadcast_date_' . $i]) {
|
|
$showRebroad = new CcShowRebroadcast();
|
|
$showRebroad->setDbDayOffset($showData['add_show_rebroadcast_date_' . $i]);
|
|
$showRebroad->setDbStartTime($showData['add_show_rebroadcast_time_' . $i]);
|
|
$showRebroad->setDbShowId($showId);
|
|
$showRebroad->save();
|
|
}
|
|
}
|
|
} elseif ($this->isRecorded && $showData['add_show_rebroadcast'] && ($this->repeatType == -1)) {
|
|
for ($i = 1; $i <= MAX_REBROADCAST_DATES; ++$i) {
|
|
if ($showData['add_show_rebroadcast_date_absolute_' . $i]) {
|
|
$rebroadcastDate = new DateTime($showData["add_show_rebroadcast_date_absolute_{$i}"]);
|
|
$startDate = new DateTime($showData['add_show_start_date']);
|
|
$offsetDays = $startDate->diff($rebroadcastDate);
|
|
|
|
$showRebroad = new CcShowRebroadcast();
|
|
$showRebroad->setDbDayOffset($offsetDays->format('%a days'));
|
|
$showRebroad->setDbStartTime($showData['add_show_rebroadcast_time_absolute_' . $i]);
|
|
$showRebroad->setDbShowId($showId);
|
|
$showRebroad->save();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes all the cc_show_hosts entries for a specific show
|
|
* that is currently being edited. They will get recreated with
|
|
* the new show specs.
|
|
*/
|
|
private function deleteCcShowHosts()
|
|
{
|
|
CcShowHostsQuery::create()->filterByDbShow($this->ccShow->getDbId())->delete();
|
|
}
|
|
|
|
/**
|
|
* Sets the fields for a cc_show_hosts table row.
|
|
*
|
|
* @param mixed $showData
|
|
*/
|
|
private function setCcShowHosts($showData)
|
|
{
|
|
if (is_array($showData['add_show_hosts'])) {
|
|
foreach ($showData['add_show_hosts'] as $host) {
|
|
$showHost = new CcShowHosts();
|
|
$showHost->setDbShow($this->ccShow->getDbId());
|
|
$showHost->setDbHost($host);
|
|
$showHost->save();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the date and time shows (particularly repeating shows)
|
|
* can be populated until.
|
|
*
|
|
* @return DateTime object
|
|
*/
|
|
private static function getPopulateShowUntilDateTIme()
|
|
{
|
|
$populateUntil = Application_Model_Preference::GetShowsPopulatedUntil();
|
|
|
|
if (is_null($populateUntil)) {
|
|
$populateUntil = new DateTime('now', new DateTimeZone('UTC'));
|
|
Application_Model_Preference::SetShowsPopulatedUntil($populateUntil);
|
|
}
|
|
|
|
return $populateUntil;
|
|
}
|
|
|
|
/**
|
|
* Enter description here ...
|
|
*
|
|
* @param DateTime $showStart user's local time
|
|
* @param string $duration time interval (h)h:(m)m(:ss)
|
|
* @param array $offset (days, hours, mins) used for rebroadcast shows
|
|
*
|
|
* @return array of 2 DateTime objects, start/end time of the show in UTC
|
|
*/
|
|
private function createUTCStartEndDateTime($showStart, $duration, $offset = null)
|
|
{
|
|
$startDateTime = clone $showStart;
|
|
$timezone = $startDateTime->getTimezone();
|
|
|
|
if (isset($offset)) {
|
|
// $offset["hours"] and $offset["mins"] represents the start time
|
|
// of a rebroadcast show
|
|
$startDateTime = new DateTime($startDateTime->format('Y-m-d') . ' ' .
|
|
$offset['hours'] . ':' . $offset['mins'], $timezone);
|
|
$startDateTime->add(new DateInterval("P{$offset['days']}D"));
|
|
}
|
|
|
|
$endDateTime = clone $startDateTime;
|
|
$duration = explode(':', $duration);
|
|
[$hours, $mins] = array_slice($duration, 0, 2);
|
|
$endDateTime->add(new DateInterval("PT{$hours}H{$mins}M"));
|
|
|
|
$startDateTime->setTimezone(new DateTimeZone('UTC'));
|
|
$endDateTime->setTimezone(new DateTimeZone('UTC'));
|
|
|
|
return [$startDateTime, $endDateTime];
|
|
}
|
|
|
|
/**
|
|
* Show instances for repeating shows only get created up
|
|
* until what is visible on the calendar. We need to set the
|
|
* date for when the next repeating show instance should be created
|
|
* as the user browses the calendar further.
|
|
*
|
|
* @param mixed $nextDate
|
|
* @param mixed $day
|
|
* @param mixed $showId
|
|
*/
|
|
private function setNextRepeatingShowDate($nextDate, $day, $showId)
|
|
{
|
|
$nextInfo = explode(' ', $nextDate);
|
|
|
|
$repeatInfo = CcShowDaysQuery::create()
|
|
->filterByDbShowId($showId)
|
|
->filterByDbDay($day)
|
|
->filterByDbRepeatType(-1, Criteria::NOT_EQUAL)
|
|
->findOne();
|
|
|
|
$repeatInfo->setDbNextPopDate($nextInfo[0])
|
|
->save();
|
|
}
|
|
}
|