DTC::Program* Guide::GetProgramDetails( int nChanId,
const QDateTime &rawStartTime )
{
if (!(nChanId > 0))
throw( "Channel ID is invalid" );
if (!rawStartTime.isValid())
throw( "StartTime is invalid" );
QDateTime dtStartTime = rawStartTime.toUTC();
// ----------------------------------------------------------------------
// -=>TODO: Add support for getting Recorded Program Info
// ----------------------------------------------------------------------
// Build Response
DTC::Program *pProgram = new DTC::Program();
ProgramInfo *pInfo = LoadProgramFromProgram(nChanId, dtStartTime);
FillProgramInfo( pProgram, pInfo, true, true, true );
delete pInfo;
return pProgram;
}
DTC::ProgramList* Dvr::GetConflictList( int nStartIndex,
int nCount,
int nRecordId )
{
RecordingList recordingList; // Auto-delete deque
RecList tmpList; // Standard deque, objects must be deleted
if (nRecordId <= 0)
nRecordId = -1;
// NOTE: Fetching this information directly from the schedule is
// significantly faster than using ProgramInfo::LoadFromScheduler()
Scheduler *scheduler = dynamic_cast<Scheduler*>(gCoreContext->GetScheduler());
if (scheduler)
scheduler->GetAllPending(tmpList, nRecordId);
// Sort the upcoming into only those which are conflicts
RecList::iterator it = tmpList.begin();
for(; it < tmpList.end(); ++it)
{
if (((*it)->GetRecordingStatus() == RecStatus::Conflict) &&
((*it)->GetRecordingStartTime() >= MythDate::current()))
{
recordingList.push_back(new RecordingInfo(**it));
}
delete *it;
*it = NULL;
}
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)recordingList.size() );
nCount = (nCount > 0) ? min( nCount, (int)recordingList.size() ) : recordingList.size();
int nEndIndex = min((nStartIndex + nCount), (int)recordingList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = recordingList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( recordingList.size() );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::ProgramList* Dvr::GetConflictList( int nStartIndex,
int nCount,
int nRecordId )
{
RecordingList recordingList;
RecordingList tmpList;
bool hasConflicts;
if (nRecordId <= 0)
nRecordId = -1;
LoadFromScheduler(tmpList, hasConflicts, "", nRecordId);
// Sort the upcoming into only those which are conflicts
RecordingList::iterator it = tmpList.begin();
for(; it < tmpList.end(); ++it)
{
if (nRecordId > 0 &&
(*it)->GetRecordingRuleID() != static_cast<uint>(nRecordId))
continue;
if (((*it)->GetRecordingStatus() == RecStatus::Conflict) &&
((*it)->GetRecordingStartTime() >= MythDate::current()))
{
recordingList.push_back(new RecordingInfo(**it));
}
}
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)recordingList.size() );
nCount = (nCount > 0) ? min( nCount, (int)recordingList.size() ) : recordingList.size();
int nEndIndex = min((nStartIndex + nCount), (int)recordingList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = recordingList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( recordingList.size() );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::ProgramList* Dvr::GetUpcomingList( int nStartIndex,
int nCount,
bool bShowAll )
{
RecordingList recordingList;
RecordingList tmpList;
bool hasConflicts;
LoadFromScheduler(tmpList, hasConflicts);
// Sort the upcoming into only those which will record
RecordingList::iterator it = tmpList.begin();
for(; it < tmpList.end(); ++it)
{
if (!bShowAll && ((*it)->GetRecordingStatus() <= rsWillRecord) &&
((*it)->GetRecordingStartTime() >=
QDateTime::currentDateTime()))
{
recordingList.push_back(new RecordingInfo(**it));
}
else if (bShowAll && ((*it)->GetRecordingStartTime() >=
QDateTime::currentDateTime()))
{
recordingList.push_back(new RecordingInfo(**it));
}
}
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)recordingList.size() );
nCount = (nCount > 0) ? min( nCount, (int)recordingList.size() ) : recordingList.size();
int nEndIndex = min((nStartIndex + nCount), (int)recordingList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = recordingList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( recordingList.size() );
pPrograms->setAsOf ( QDateTime::currentDateTime() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::EncoderList* Dvr::GetEncoderList()
{
DTC::EncoderList* pList = new DTC::EncoderList();
QMap<int, EncoderLink *>::Iterator iter = tvList.begin();
for (; iter != tvList.end(); ++iter)
{
EncoderLink *elink = *iter;
if (elink != NULL)
{
DTC::Encoder *pEncoder = pList->AddNewEncoder();
pEncoder->setId ( elink->GetCardID() );
pEncoder->setState ( elink->GetState() );
pEncoder->setLocal ( elink->IsLocal() );
pEncoder->setConnected ( elink->IsConnected() );
pEncoder->setSleepStatus ( elink->GetSleepStatus() );
// pEncoder->setLowOnFreeSpace( elink->isLowOnFreeSpace());
if (pEncoder->Local())
pEncoder->setHostName( gCoreContext->GetHostName() );
else
pEncoder->setHostName( elink->GetHostName() );
switch ( pEncoder->State() )
{
case kState_WatchingLiveTV:
case kState_RecordingOnly:
case kState_WatchingRecording:
{
ProgramInfo *pInfo = elink->GetRecording();
if (pInfo)
{
DTC::Program *pProgram = pEncoder->Recording();
FillProgramInfo( pProgram, pInfo, true, true );
delete pInfo;
}
break;
}
default:
break;
}
}
}
return pList;
}
DTC::Program* Dvr::GetRecorded(int chanid, const QDateTime &recstarttsRaw)
{
if (chanid <= 0 || !recstarttsRaw.isValid())
throw QString("Channel ID or StartTime appears invalid.");
ProgramInfo pi(chanid, recstarttsRaw.toUTC());
DTC::Program *pProgram = new DTC::Program();
FillProgramInfo( pProgram, &pi, true );
return pProgram;
}
DTC::Program* Dvr::GetRecorded( int nChanId,
const QDateTime &dStartTime )
{
if (nChanId <= 0 || !dStartTime.isValid())
throw( QString("Channel ID or StartTime appears invalid."));
ProgramInfo *pInfo = new ProgramInfo(nChanId, dStartTime);
DTC::Program *pProgram = new DTC::Program();
FillProgramInfo( pProgram, pInfo, true );
return pProgram;
}
DTC::Program* Guide::GetProgramDetails( int nChanId,
const QDateTime &dtStartTime )
{
if (!dtStartTime.isValid())
throw( "StartTime is invalid" );
// ----------------------------------------------------------------------
// -=>TODO: Add support for getting Recorded Program Info
// ----------------------------------------------------------------------
// Build add'l SQL statement for Program Listing
MSqlBindings bindings;
QString sSQL = "WHERE program.chanid = :ChanId "
"AND program.starttime = :StartTime ";
bindings[":ChanId" ] = nChanId;
bindings[":StartTime"] = dtStartTime;
// Get all Pending Scheduled Programs
ProgramList schedList;
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
ProgramList progList;
LoadFromProgram( progList, sSQL, bindings, schedList, false );
if ( progList.size() == 0)
throw( "Error Reading Program Info" );
// Build Response
DTC::Program *pProgram = new DTC::Program();
ProgramInfo *pInfo = progList[ 0 ];
FillProgramInfo( pProgram, pInfo, true );
return pProgram;
}
DTC::ProgramList* Dvr::GetExpiringList( int nStartIndex,
int nCount )
{
pginfolist_t infoList;
if (expirer)
expirer->GetAllExpiring( infoList );
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)infoList.size() );
nCount = (nCount > 0) ? min( nCount, (int)infoList.size() ) : infoList.size();
int nEndIndex = min((nStartIndex + nCount), (int)infoList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = infoList[ n ];
if (pInfo != NULL)
{
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
delete pInfo;
}
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( infoList.size() );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::Program* Dvr::GetRecorded(int RecordedId,
int chanid, const QDateTime &recstarttsRaw)
{
if ((RecordedId <= 0) &&
(chanid <= 0 || !recstarttsRaw.isValid()))
throw QString("Recorded ID or Channel ID and StartTime appears invalid.");
// TODO Should use RecordingInfo
ProgramInfo pi;
if (RecordedId > 0)
pi = ProgramInfo(RecordedId);
else
pi = ProgramInfo(chanid, recstarttsRaw.toUTC());
DTC::Program *pProgram = new DTC::Program();
FillProgramInfo( pProgram, &pi, true );
return pProgram;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &dtStartTime ,
const QDateTime &dtEndTime ,
int nStartChanId,
int nNumChannels,
bool bDetails )
{
if (!dtStartTime.isValid())
throw( "StartTime is invalid" );
if (!dtEndTime.isValid())
throw( "EndTime is invalid" );
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nNumChannels == 0)
nNumChannels = 1;
if (nNumChannels == -1)
nNumChannels = SHRT_MAX;
// ----------------------------------------------------------------------
// Find the ending channel Id
// ----------------------------------------------------------------------
int nEndChanId = nStartChanId;
MSqlQuery query(MSqlQuery::InitCon());
query.prepare( "SELECT chanid FROM channel WHERE (chanid >= :STARTCHANID )"
" ORDER BY chanid LIMIT :NUMCHAN" );
query.bindValue(":STARTCHANID", nStartChanId );
query.bindValue(":NUMCHAN" , nNumChannels );
if (!query.exec())
MythDB::DBError("Select ChanId", query);
query.first(); nStartChanId = query.value(0).toInt();
query.last(); nEndChanId = query.value(0).toInt();
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
QString sSQL = "WHERE program.chanid >= :StartChanId "
"AND program.chanid <= :EndChanId "
"AND program.endtime >= :StartDate "
"AND program.starttime <= :EndDate "
"GROUP BY program.starttime, channel.channum, "
"channel.callsign, program.title "
"ORDER BY program.chanid ";
bindings[":StartChanId"] = nStartChanId;
bindings[":EndChanId" ] = nEndChanId;
bindings[":StartDate" ] = dtStartTime;
bindings[":EndDate" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
LoadFromProgram( progList, sSQL, bindings, schedList, false );
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
int nChanCount = 0;
uint nCurChanId = 0;
DTC::ChannelInfo *pChannel = NULL;
for( uint n = 0; n < progList.size(); n++)
{
ProgramInfo *pInfo = progList[ n ];
if ( nCurChanId != pInfo->GetChanID() )
{
nChanCount++;
nCurChanId = pInfo->GetChanID();
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, pInfo, bDetails );
}
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, pInfo, false, bDetails );
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setStartChanId ( nStartChanId );
pGuide->setEndChanId ( nEndChanId );
pGuide->setNumOfChannels( nChanCount );
pGuide->setDetails ( bDetails );
pGuide->setCount ( progList.size());
pGuide->setAsOf ( QDateTime::currentDateTime() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &rawStartTime ,
const QDateTime &rawEndTime ,
int nStartChanId,
int nNumChannels,
bool bDetails,
int nChannelGroupId )
{
if (!rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime.toUTC();
QDateTime dtEndTime = rawEndTime.toUTC();
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nNumChannels == 0)
nNumChannels = SHRT_MAX;
// ----------------------------------------------------------------------
// Find the ending channel Id
// ----------------------------------------------------------------------
int nEndChanId = nStartChanId;
MSqlQuery query(MSqlQuery::InitCon());
query.prepare( "SELECT chanid FROM channel WHERE (chanid >= :STARTCHANID )"
" ORDER BY chanid LIMIT :NUMCHAN" );
query.bindValue(":STARTCHANID", nStartChanId );
query.bindValue(":NUMCHAN" , nNumChannels );
if (!query.exec())
MythDB::DBError("Select ChanId", query);
query.first(); nStartChanId = query.value(0).toInt();
query.last(); nEndChanId = query.value(0).toInt();
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
// lpad is to allow natural sorting of numbers
QString sSQL;
if (nChannelGroupId > 0)
{
sSQL = "LEFT JOIN channelgroup ON program.chanid = channelgroup.chanid "
"WHERE channelgroup.grpid = :CHANGRPID AND ";
bindings[":CHANGRPID" ] = nChannelGroupId;
}
else
sSQL = "WHERE ";
sSQL += "visible != 0 "
"AND program.chanid >= :StartChanId "
"AND program.chanid <= :EndChanId "
"AND program.endtime >= :StartDate "
"AND program.starttime <= :EndDate "
"AND program.manualid = 0 " // Exclude programmes created purely for 'manual' recording schedules
"ORDER BY LPAD(CAST(channum AS UNSIGNED), 10, 0), "
" LPAD(channum, 10, 0), "
" callsign, "
" LPAD(program.chanid, 10, 0), "
" program.starttime ";
bindings[":StartChanId"] = nStartChanId;
bindings[":EndChanId" ] = nEndChanId;
bindings[":StartDate" ] = dtStartTime;
bindings[":EndDate" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
LoadFromProgram( progList, sSQL, bindings, schedList );
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
int nChanCount = 0;
uint nCurChanId = 0;
DTC::ChannelInfo *pChannel = NULL;
QString sCurCallsign;
uint nSkipChanId = 0;
for( uint n = 0; n < progList.size(); n++)
{
ProgramInfo *pInfo = progList[ n ];
if ( nSkipChanId == pInfo->GetChanID())
continue;
if ( nCurChanId != pInfo->GetChanID() )
{
nChanCount++;
nCurChanId = pInfo->GetChanID();
// Filter out channels with the same callsign, keeping just the
// first seen
if (sCurCallsign == pInfo->GetChannelSchedulingID())
{
nSkipChanId = pInfo->GetChanID();
continue;
}
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, pInfo->GetChanID(), bDetails );
sCurCallsign = pChannel->CallSign();
}
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, pInfo, false, bDetails, false ); // No cast info
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setStartChanId ( nStartChanId );
pGuide->setEndChanId ( nEndChanId );
pGuide->setNumOfChannels( nChanCount );
pGuide->setDetails ( bDetails );
pGuide->setCount ( progList.size());
pGuide->setAsOf ( MythDate::current() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
DTC::ProgramList* Guide::GetProgramList(int nStartIndex,
int nCount,
const QDateTime& rawStartTime,
const QDateTime& rawEndTime,
int nChanId,
const QString& sTitleFilter,
const QString& sCategoryFilter,
const QString& sPersonFilter,
const QString& sKeywordFilter,
bool bOnlyNew,
bool bDetails,
const QString &sSort,
bool bDescending)
{
if (!rawStartTime.isNull() && !rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isNull() && !rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime;
QDateTime dtEndTime = rawEndTime;
if (!rawEndTime.isNull() && dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
MSqlQuery query(MSqlQuery::InitCon());
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
QString sSQL;
if (!sPersonFilter.isEmpty())
{
sSQL = ", people, credits " // LEFT JOIN
"WHERE people.name LIKE :PersonFilter "
"AND credits.person = people.person "
"AND program.chanid = credits.chanid "
"AND program.starttime = credits.starttime AND ";
bindings[":PersonFilter"] = QString("%%1%").arg(sPersonFilter);
}
else
sSQL = "WHERE ";
sSQL += "visible != 0 AND program.manualid = 0 "; // Exclude programmes created purely for 'manual' recording schedules
if (nChanId < 0)
nChanId = 0;
if (nChanId > 0)
{
sSQL += "AND program.chanid = :ChanId ";
bindings[":ChanId"] = nChanId;
}
if (dtStartTime.isNull())
dtStartTime = QDateTime::currentDateTimeUtc();
sSQL += " AND program.endtime >= :StartDate ";
bindings[":StartDate"] = dtStartTime;
if (!dtEndTime.isNull())
{
sSQL += "AND program.starttime <= :EndDate ";
bindings[":EndDate"] = dtEndTime;
}
if (!sTitleFilter.isEmpty())
{
sSQL += "AND program.title LIKE :Title ";
bindings[":Title"] = QString("%%1%").arg(sTitleFilter);
}
if (!sCategoryFilter.isEmpty())
{
sSQL += "AND program.category LIKE :Category ";
bindings[":Category"] = sCategoryFilter;
}
if (!sKeywordFilter.isEmpty())
{
sSQL += "AND (program.title LIKE :Keyword1 "
"OR program.subtitle LIKE :Keyword2 "
"OR program.description LIKE :Keyword3) ";
QString filter = QString("%%1%").arg(sKeywordFilter);
bindings[":Keyword1"] = filter;
bindings[":Keyword2"] = filter;
bindings[":Keyword3"] = filter;
}
if (sSort == "starttime")
sSQL += "ORDER BY program.starttime ";
else if (sSort == "title")
sSQL += "ORDER BY program.title ";
else if (sSort == "channel")
sSQL += "ORDER BY channel.channum ";
else if (sSort == "duration")
sSQL += "ORDER BY (program.endtime - program.starttime) ";
else
sSQL += "ORDER BY program.starttime ";
if (bDescending)
sSQL += "DESC ";
else
sSQL += "ASC ";
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
uint nTotalAvailable = 0;
LoadFromProgram( progList, sSQL, bindings, schedList,
(uint)nStartIndex, (uint)nCount, nTotalAvailable);
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nCount = (int)progList.size();
int nEndIndex = (int)progList.size();
for( int n = 0; n < nEndIndex; n++)
{
ProgramInfo *pInfo = progList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true, bDetails, false ); // No cast info, loading this takes far too long
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( nTotalAvailable );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::ProgramList* Dvr::GetRecordedList( bool bDescending,
int nStartIndex,
int nCount,
const QString &sTitleRegEx,
const QString &sRecGroup,
const QString &sStorageGroup )
{
QMap< QString, ProgramInfo* > recMap;
if (gCoreContext->GetScheduler())
recMap = gCoreContext->GetScheduler()->GetRecording();
QMap< QString, uint32_t > inUseMap = ProgramInfo::QueryInUseMap();
QMap< QString, bool > isJobRunning= ProgramInfo::QueryJobsRunning(JOB_COMMFLAG);
ProgramList progList;
int desc = 1;
if (bDescending)
desc = -1;
LoadFromRecorded( progList, false, inUseMap, isJobRunning, recMap, desc );
QMap< QString, ProgramInfo* >::iterator mit = recMap.begin();
for (; mit != recMap.end(); mit = recMap.erase(mit))
delete *mit;
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
int nAvailable = 0;
int nMax = (nCount > 0) ? nCount : progList.size();
nAvailable = 0;
nCount = 0;
QRegExp rTitleRegEx = QRegExp(sTitleRegEx, Qt::CaseInsensitive);
for( unsigned int n = 0; n < progList.size(); n++)
{
ProgramInfo *pInfo = progList[ n ];
if (pInfo->IsDeletePending() ||
(!sTitleRegEx.isEmpty() && !pInfo->GetTitle().contains(rTitleRegEx)) ||
(!sRecGroup.isEmpty() && sRecGroup != pInfo->GetRecordingGroup()) ||
(!sStorageGroup.isEmpty() && sStorageGroup != pInfo->GetStorageGroup()))
continue;
if ((nAvailable < nStartIndex) ||
(nCount >= nMax))
{
++nAvailable;
continue;
}
++nAvailable;
++nCount;
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( nAvailable );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &rawStartTime ,
const QDateTime &rawEndTime ,
bool bDetails,
int nChannelGroupId,
int nStartIndex,
int nCount)
{
if (!rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime.toUTC();
QDateTime dtEndTime = rawEndTime.toUTC();
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nStartIndex <= 0)
nStartIndex = 0;
if (nCount <= 0)
nCount = 20000;
// ----------------------------------------------------------------------
// Load the channel list
// ----------------------------------------------------------------------
uint nTotalAvailable = 0;
ChannelInfoList chanList = ChannelUtil::LoadChannels(nStartIndex, nCount,
nTotalAvailable, true,
ChannelUtil::kChanOrderByChanNum,
ChannelUtil::kChanGroupByCallsign,
0,
nChannelGroupId);
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList schedList;
MSqlBindings bindings;
QString sWhere = "program.chanid = :CHANID "
"AND program.endtime >= :STARTDATE "
"AND program.starttime < :ENDDATE "
"AND program.starttime >= :STARTDATELIMIT "
"AND program.manualid = 0"; // Omit 'manual' recordings scheds
QString sGroupBy = "program.starttime, channel.channum,"
"channel.callsign, program.title";
QString sOrderBy = "program.starttime";
bindings[":STARTDATE" ] = dtStartTime;
bindings[":STARTDATELIMIT"] = dtStartTime.addDays(-1);
bindings[":ENDDATE" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
// NOTE: Fetching this information directly from the schedule is
// significantly faster than using ProgramInfo::LoadFromScheduler()
Scheduler *scheduler = dynamic_cast<Scheduler*>(gCoreContext->GetScheduler());
if (scheduler)
scheduler->GetAllPending(schedList);
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
ChannelInfoList::iterator chan_it;
for (chan_it = chanList.begin(); chan_it != chanList.end(); ++chan_it)
{
// Create ChannelInfo Object
DTC::ChannelInfo *pChannel = NULL;
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, (*chan_it), bDetails );
// Load the list of programmes for this channel
ProgramList progList;
bindings[":CHANID"] = (*chan_it).chanid;
LoadFromProgram( progList, sWhere, sOrderBy, sOrderBy, bindings,
schedList );
// Create Program objects and add them to the channel object
ProgramList::iterator progIt;
for( progIt = progList.begin(); progIt != progList.end(); ++progIt)
{
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, *progIt, false, bDetails, false ); // No cast info
}
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setDetails ( bDetails );
pGuide->setStartIndex ( nStartIndex );
pGuide->setCount ( chanList.size() );
pGuide->setTotalAvailable( nTotalAvailable );
pGuide->setAsOf ( MythDate::current() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
