621 lines
17 KiB
C++
621 lines
17 KiB
C++
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MODULE: PROGSCHD.CPP
|
|
//
|
|
// PURPOSE: Provides the implementation of the
|
|
// CEpisodeTimeSlotRecordProcessor class
|
|
// These methods parse and collection program and schedule
|
|
// data that is then stored into the GuideStore using the
|
|
// gsPrograms and gsScheduleEntries methods.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "errcodes.h"
|
|
#include <Afxtempl.h>
|
|
#include <crtdbg.h>
|
|
#include <fstream.h>
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <string.h>
|
|
#include "guidestore.h"
|
|
#include "services.h"
|
|
#include "channels.h"
|
|
#include "programs.h"
|
|
#include "schedules.h"
|
|
#include "tmsparse.h"
|
|
#include "servchan.h"
|
|
#include "progschd.h"
|
|
#include "wtmsload.h"
|
|
#define TIMING 0
|
|
#include "..\..\timing.h"
|
|
|
|
#ifdef _DUMP_LOADER
|
|
CString csDiagMil;
|
|
extern HANDLE hDiagFile;
|
|
extern char szDiagBuff[1024];
|
|
int ChannelCnt = 0;
|
|
int TimeSlotCnt = 0;
|
|
extern DWORD dwBytesWritten;
|
|
#endif
|
|
|
|
|
|
SRatingsID srMPAARatingIDMap[EPGMPAARatings_Fields] =
|
|
{
|
|
{_T("NA"), 0},
|
|
{_T("G"), 2},
|
|
{_T("PG"), 4},
|
|
{_T("PG13"), 6},
|
|
{_T("R"), 8},
|
|
{_T("NC17"), 10},
|
|
{_T("X"), 12},
|
|
{_T("NR"), 14}
|
|
};
|
|
|
|
|
|
SRatingsID srTVRatingIDMap[EPGTVRatings_Fields] =
|
|
{
|
|
{_T("TVY"), 0},
|
|
{_T("TVY7"), 1},
|
|
{_T("TVY7FV"), 2},
|
|
{_T("TVG"), 3},
|
|
{_T("TVPG"), 4},
|
|
{_T("TV14"), 5},
|
|
{_T("TVMA"), 6}
|
|
};
|
|
|
|
SDataFileFields ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Fields] =
|
|
{
|
|
TRUE, 120,
|
|
TRUE, 1,
|
|
TRUE, 25,
|
|
TRUE, 255,
|
|
TRUE, 30,
|
|
TRUE, 30,
|
|
TRUE, 30,
|
|
TRUE, 30,
|
|
TRUE, 30,
|
|
TRUE, 30,
|
|
TRUE, 10,
|
|
TRUE, 10,
|
|
TRUE, 8,
|
|
TRUE, 4,
|
|
TRUE, 4,
|
|
TRUE, 1,
|
|
TRUE, 1,
|
|
TRUE, 1,
|
|
TRUE, 1,
|
|
TRUE, 4,
|
|
TRUE, 12
|
|
};
|
|
|
|
|
|
|
|
// CEpisodeTimeSlotRecordProcessor
|
|
//
|
|
CEpisodeTimeSlotRecordProcessor::CEpisodeTimeSlotRecordProcessor(int nNumFields,
|
|
SDataFileFields ssfFieldsInfo[])
|
|
{
|
|
TCHAR ConvBuffer[20] = {0};
|
|
|
|
m_Init();
|
|
m_pFieldsDesc = ssfFieldsInfo;
|
|
m_nNumFields = nNumFields;
|
|
m_cmRecordMap.InitHashTable(m_nNumFields, TRUE);
|
|
|
|
int iRatingsCount = 0;
|
|
for (iRatingsCount=0; iRatingsCount<EPGMPAARatings_Fields; iRatingsCount++)
|
|
{
|
|
m_MPAARatingsMap[srMPAARatingIDMap[iRatingsCount].szRating] =
|
|
_ltot(srMPAARatingIDMap[iRatingsCount].lRatingID, ConvBuffer, 10);
|
|
}
|
|
for (iRatingsCount=0; iRatingsCount<EPGTVRatings_Fields; iRatingsCount++)
|
|
{
|
|
m_TVRatingsMap[srTVRatingIDMap[iRatingsCount].szRating] =
|
|
_ltot(srTVRatingIDMap[iRatingsCount].lRatingID, ConvBuffer, 10);
|
|
}
|
|
|
|
}
|
|
|
|
CEpisodeTimeSlotRecordProcessor::CEpisodeTimeSlotRecordProcessor()
|
|
{
|
|
TCHAR ConvBuffer[20] = {0};
|
|
|
|
m_Init();
|
|
m_pFieldsDesc = ssfEpisodeTimeSlotFieldInfo;
|
|
m_nNumFields = EpisodeTimeSlotRec_Fields;
|
|
m_cmRecordMap.InitHashTable(m_nNumFields, TRUE);
|
|
|
|
int iRatingsCount = 0;
|
|
for (iRatingsCount=0; iRatingsCount<EPGMPAARatings_Fields; iRatingsCount++)
|
|
{
|
|
m_MPAARatingsMap[srMPAARatingIDMap[iRatingsCount].szRating] =
|
|
_ltot(srMPAARatingIDMap[iRatingsCount].lRatingID, ConvBuffer, 10);
|
|
}
|
|
for (iRatingsCount=0; iRatingsCount<EPGTVRatings_Fields; iRatingsCount++)
|
|
{
|
|
m_TVRatingsMap[srTVRatingIDMap[iRatingsCount].szRating] =
|
|
_ltot(srTVRatingIDMap[iRatingsCount].lRatingID, ConvBuffer, 10);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
CEpisodeTimeSlotRecordProcessor::~CEpisodeTimeSlotRecordProcessor()
|
|
{
|
|
m_MPAARatingsMap.RemoveAll();
|
|
m_TVRatingsMap.RemoveAll();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// METHOD: m_Process
|
|
//
|
|
// PARAMETERS: [IN] lpData - Data to be processed
|
|
// [IN] nDataSize - Size of data
|
|
//
|
|
// PURPOSE: Processes the Data stream for Channel records
|
|
// Once Channel records have been parsed and
|
|
// prepared for table updation signals end of channel records
|
|
// to the file processor
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
int CEpisodeTimeSlotRecordProcessor::m_Process(LPCTSTR lpData, int nDataSize, int* pBytesProcessed)
|
|
{
|
|
int nFields = 0;
|
|
int nFieldSize = 0;
|
|
int nParsePos = 0;
|
|
int nBytesProcessed = 0;
|
|
|
|
// Parameter validation
|
|
//
|
|
if (NULL == lpData || 0 == nDataSize)
|
|
{
|
|
return ERROR_INVALID_ARGS;
|
|
}
|
|
else
|
|
{
|
|
*pBytesProcessed = 0;
|
|
|
|
// Data Integrity Check
|
|
//
|
|
ASSERT( _CrtIsValidPointer((const void *)lpData, nDataSize, FALSE) );
|
|
|
|
{
|
|
// Data is valid - Start processing
|
|
//
|
|
do
|
|
{
|
|
|
|
if (STATE_RECORD_INCOMPLETE == m_nState)
|
|
{
|
|
nFields = m_nCurrField;
|
|
nFieldSize = m_nCurrFieldSize;
|
|
}
|
|
|
|
for(;nParsePos < nDataSize; nParsePos++)
|
|
{
|
|
DeclarePerfTimer("CEpisodeTimeSlotRecordProcessor");
|
|
MSG msg;
|
|
while(PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
PerfTimerReset();
|
|
if (lpData[nParsePos] == EOC)
|
|
{
|
|
// End of field
|
|
//
|
|
//if (nParsePos > 0 && (lpData[nParsePos-1] != EOC))
|
|
if (nFieldSize > 0)
|
|
{
|
|
// TODO ASSERT(nFields <= StationRec_Fields);
|
|
|
|
m_szValidField[nFieldSize] = '\0';
|
|
m_cmRecordMap[nFields] = m_szValidField;
|
|
nFieldSize = 0;
|
|
m_nCurrFieldSize = 0;
|
|
}
|
|
else
|
|
{
|
|
//nFieldDataPos = nParsePos;
|
|
nFieldSize = 0;
|
|
m_nCurrFieldSize = 0;
|
|
}
|
|
|
|
nFields++;
|
|
m_nCurrField++;
|
|
}
|
|
else if (lpData[nParsePos] == EOR)
|
|
{
|
|
// End of the record
|
|
|
|
//
|
|
|
|
#ifdef _DUMP_LOADER
|
|
TimeSlotCnt++;
|
|
wsprintf(szDiagBuff, _T("\r\nRec No#%d:\n"), TimeSlotCnt);
|
|
::WriteFile(hDiagFile, szDiagBuff, lstrlen(szDiagBuff), &dwBytesWritten, 0);
|
|
for (int nCnt=0; nCnt<EpisodeTimeSlotRec_Fields; nCnt++)
|
|
{
|
|
m_cmRecordMap.Lookup(nCnt, csDiagMil);
|
|
wsprintf(szDiagBuff, _T("%s\n"), csDiagMil);
|
|
if (NULL != hDiagFile)
|
|
{
|
|
::WriteFile(hDiagFile, szDiagBuff, lstrlen(szDiagBuff), &dwBytesWritten, 0);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
DeclarePerfTimer("CEpisodeTimeSlotRecordProcessor");
|
|
PerfTimerReset();
|
|
if (UPDATE_SUCCEEDED != m_UpdateDatabase(m_cmRecordMap))
|
|
{
|
|
if (STATE_RECORD_ERROR == m_nState)
|
|
{
|
|
m_nState = STATE_RECORDS_FAIL;
|
|
return m_nState;
|
|
}
|
|
else
|
|
m_nState = STATE_RECORD_ERROR;
|
|
}
|
|
PerfTimerDump("m_UpdateDatabase");
|
|
|
|
m_cmRecordMap.RemoveAll();
|
|
m_nCurrField = nFields = 0;
|
|
m_nCurrFieldSize = nFieldSize = 0;
|
|
continue;
|
|
}
|
|
else if (lpData[nParsePos] == EOT)
|
|
{
|
|
// End of the table
|
|
//
|
|
m_nState = STATE_RECORDS_PROCESSED;
|
|
nParsePos += 2*sizeof(TCHAR);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Valid field data
|
|
//
|
|
m_szValidField[nFieldSize] = lpData[nParsePos];
|
|
nFieldSize++;
|
|
m_nCurrFieldSize++;
|
|
}
|
|
PerfTimerDump("for loop");
|
|
}
|
|
|
|
} while ((nParsePos < nDataSize) && (m_nState != STATE_RECORDS_PROCESSED));
|
|
|
|
|
|
*pBytesProcessed = nParsePos;
|
|
|
|
if (m_nState != STATE_RECORDS_PROCESSED)
|
|
{
|
|
if (lpData[--nParsePos] == EOR)
|
|
{
|
|
// More records
|
|
//
|
|
m_nState = STATE_RECORDS_INCOMPLETE;
|
|
}
|
|
else
|
|
{
|
|
// record incomplete
|
|
//
|
|
m_nState = STATE_RECORD_INCOMPLETE;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return m_nState;
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// METHOD: m_UpdateDatabase
|
|
//
|
|
// PARAMETERS: [IN] cmStationRecord - map containing record fields
|
|
//
|
|
// PURPOSE: Updates the GuideStore, adding program entries when necessary
|
|
// Then adds the schedule entry to the schedule entries
|
|
// collection
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////
|
|
//
|
|
int CEpisodeTimeSlotRecordProcessor::m_UpdateDatabase(CRecordMap& cmRecord)
|
|
{
|
|
int iRet = ERROR_UPDATE;
|
|
CString csRerun, csClosed_captioned, csStereo, csPayPerView, csLength;
|
|
CString csTitle, csProgramID, csDescription, csRated, csMPAARating;
|
|
CWtmsloadApp* ctmsLoapApp = (CWtmsloadApp*) AfxGetApp();
|
|
CStatChanRecordProcessor* pStatChan = ctmsLoapApp->m_scrpStatChans;
|
|
long lEpisodeID=0, lServiceID=0, lLength=0;
|
|
CString csGenre;
|
|
CString csTVRating;
|
|
LONG lTVRatingID = -1;
|
|
LONG lMPAARatingID = -1;
|
|
IProgramPtr pTMSProgram = NULL;
|
|
IServicePtr pTMSService = NULL;
|
|
|
|
// Lookup the program Title
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Title, csTitle);
|
|
csTitle = csTitle.Left(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Title].nWidth);
|
|
csTitle.TrimLeft();
|
|
csTitle.TrimRight();
|
|
|
|
// Lookup the program unique Identifier
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_ProgramID, csProgramID);
|
|
csDescription = csDescription.Left(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_ProgramID].nWidth);
|
|
csDescription.TrimLeft();
|
|
csDescription.TrimRight();
|
|
|
|
// Lookup the program Description
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Description, csDescription);
|
|
csDescription = csDescription.Left(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Description].nWidth);
|
|
csDescription.TrimLeft();
|
|
csDescription.TrimRight();
|
|
|
|
// Lookup the program Rating Data: Rated?
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Rated, csRated);
|
|
csRated.TrimLeft();
|
|
csRated.TrimRight();
|
|
|
|
// Lookup the program Rating Data: MPAA Rating
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_MPAARating, csMPAARating);
|
|
csMPAARating.TrimLeft();
|
|
csMPAARating.TrimRight();
|
|
|
|
// Lookup the program Rating Data: TV Rating
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_TVRating, csTVRating);
|
|
csTVRating.TrimLeft();
|
|
csTVRating.TrimRight();
|
|
|
|
BOOL bRated = _ttoi(csRated);
|
|
|
|
if (bRated)
|
|
{
|
|
// If this Program has an MPAA rating, it is a movie
|
|
//
|
|
if (!csMPAARating.IsEmpty())
|
|
{
|
|
CString csRatingID;
|
|
|
|
// Lookup the Rating ID - metaproperty value
|
|
//
|
|
m_MPAARatingsMap.Lookup(csMPAARating, csRatingID);
|
|
|
|
if (!csRatingID.IsEmpty())
|
|
{
|
|
lMPAARatingID = _ttol(csRatingID);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!csTVRating.IsEmpty())
|
|
{
|
|
CString csRatingID;
|
|
|
|
// Lookup the Rating ID - metaproperty value
|
|
//
|
|
m_TVRatingsMap.Lookup(csTVRating, csRatingID);
|
|
|
|
if (!csRatingID.IsEmpty())
|
|
{
|
|
lTVRatingID = _ttol(csRatingID);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// For the moment we're using a dummy copyright date
|
|
//
|
|
DATE dtCopyrightDate = 0;
|
|
|
|
// Find a Match for this program in the Programs Collection
|
|
//
|
|
pTMSProgram = ctmsLoapApp->m_pgsPrograms.FindProgramMatch(
|
|
csTitle.GetBuffer(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Title].nWidth),
|
|
csProgramID.GetBuffer(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_ProgramID].nWidth));
|
|
|
|
if (NULL == pTMSProgram)
|
|
{
|
|
// There is no matching program in the collection - add it
|
|
//
|
|
pTMSProgram = ctmsLoapApp->m_pgsPrograms.AddProgram(
|
|
csTitle.GetBuffer(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Title].nWidth),
|
|
csDescription.GetBuffer(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_Description].nWidth),
|
|
csProgramID.GetBuffer(ssfEpisodeTimeSlotFieldInfo[EpisodeTimeSlotRec_ProgramID].nWidth),
|
|
dtCopyrightDate,
|
|
lTVRatingID,
|
|
lMPAARatingID);
|
|
|
|
|
|
if (NULL != pTMSProgram)
|
|
{
|
|
IMetaPropertiesPtr pProgramProps = pTMSProgram->GetMetaProperties();
|
|
|
|
|
|
if (NULL != pProgramProps)
|
|
{
|
|
// Set the Program Categorization metaproperties
|
|
//
|
|
for (int iGenreCount = EpisodeTimeSlotRec_Genre1Desc;
|
|
iGenreCount < EpisodeTimeSlotRec_Genre6Desc; iGenreCount++)
|
|
{
|
|
CString csGenre;
|
|
cmRecord.Lookup(iGenreCount, csGenre);
|
|
if (!csGenre.IsEmpty())
|
|
{
|
|
// There is a valid Category to be set for this Program
|
|
// Set the Program Categorization metaproperties
|
|
//
|
|
ctmsLoapApp->m_pgsPrograms.AddProgramCategory(pProgramProps,
|
|
csGenre.GetBuffer(ssfEpisodeTimeSlotFieldInfo[iGenreCount].nWidth+1));
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return ERROR_UPDATE_ADD;
|
|
}
|
|
|
|
// Lookup the associated Channel Number
|
|
//
|
|
CString csTimeSlotChannelNumStr;
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Channel, csTimeSlotChannelNumStr);
|
|
|
|
// Lookup the associated Station Number
|
|
//
|
|
CString csTimeSlotStationNumStr;
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_StationNum, csTimeSlotStationNumStr);
|
|
|
|
CString csStatChan = csTimeSlotStationNumStr + _T(",") + csTimeSlotChannelNumStr;
|
|
|
|
// Get the corresponding Service ID
|
|
//
|
|
lServiceID = pStatChan->m_GetChannelID(csStatChan);
|
|
|
|
// Lookup the rerun field
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Rerun, csRerun);
|
|
LONG lRerun = _ttol(csRerun);
|
|
|
|
#ifdef _DUMP_LOADER
|
|
wsprintf(szDiagBuff, _T("Fetching #%d Channel ID for %s : %d\r\n"), TimeSlotCnt, csStatChan, lChannelID);
|
|
if (NULL != hDiagFile)
|
|
{
|
|
::WriteFile(hDiagFile, szDiagBuff, lstrlen(szDiagBuff), &dwBytesWritten, 0);
|
|
}
|
|
#endif
|
|
|
|
// Lookup the Close Captioned field
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_ClosedCaption, csClosed_captioned);
|
|
LONG lClosed_captioned = _ttol(csClosed_captioned);
|
|
|
|
// Lookup the Stereo field
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Stereo, csStereo);
|
|
LONG lStereo = _ttol(csStereo);
|
|
|
|
// Lookup the Pay per view field
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_PayPerView, csPayPerView);
|
|
LONG lPayPerView = _ttol(csPayPerView);
|
|
|
|
CString csStartYYYYMMDD, csStartHHMM;
|
|
IScheduleEntryPtr pScheduleEntry = NULL;
|
|
|
|
// Lookup the Schedule Entry Date
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_StartYYYYMMDD, csStartYYYYMMDD);
|
|
|
|
// Lookup the Schedule Entry Time
|
|
//
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_StartHHMM, csStartHHMM);
|
|
|
|
int nmin = _ttoi(csStartHHMM.Right(2));
|
|
int nhour = _ttoi(csStartHHMM.Left(2));
|
|
int nmday = _ttoi(csStartYYYYMMDD.Right(2));
|
|
int nwday = 0;
|
|
int nyday = 0;
|
|
int nmon = _ttoi(csStartYYYYMMDD.Mid(4,2));
|
|
int nyear = _ttoi(csStartYYYYMMDD.Left(4));
|
|
|
|
cmRecord.Lookup(EpisodeTimeSlotRec_Length, csLength);
|
|
lLength = _ttol(csLength.Left(2))*60 + _ttol(csLength.Right(2));
|
|
|
|
COleDateTime codtStart(nyear, nmon, nmday, nhour, nmin, 0);
|
|
COleDateTime codtEnd = codtStart + COleDateTimeSpan(0, 0, lLength, 0);
|
|
// This recalulation is necessary to eliminate the unseen fractional
|
|
// second that messes up datetime comparisons. We only have to do
|
|
// it for this one because this is calculated with the DateTimeSpan.
|
|
codtEnd.SetDateTime(codtEnd.GetYear(), codtEnd.GetMonth(),
|
|
codtEnd.GetDay(), codtEnd.GetHour(), codtEnd.GetMinute(), 0);
|
|
|
|
pTMSService = ctmsLoapApp->m_pgsServices.GetService(lServiceID);
|
|
|
|
if ( NULL != pTMSService
|
|
&& NULL != pTMSProgram)
|
|
{
|
|
// Add the new schdule entry
|
|
//
|
|
pScheduleEntry = ctmsLoapApp->m_pgsScheduleEntries.AddScheduleEntry(codtStart,
|
|
codtEnd,
|
|
COleDateTime::GetCurrentTime() + ctmsLoapApp->m_odtsTimeZoneAdjust,
|
|
lRerun,
|
|
lClosed_captioned,
|
|
lStereo,
|
|
lPayPerView,
|
|
pTMSService,
|
|
pTMSProgram);
|
|
}
|
|
|
|
|
|
|
|
if (NULL != pScheduleEntry)
|
|
{
|
|
#ifdef _DUMP_LOADER
|
|
wsprintf(szDiagBuff, _T("Failure: Updating #%d TimeSlot ID Title: %s : %d\r\n"), TimeSlotCnt, csTitle);
|
|
if (NULL != hDiagFile)
|
|
{
|
|
::WriteFile(hDiagFile, szDiagBuff, lstrlen(szDiagBuff), &dwBytesWritten, 0);
|
|
}
|
|
#endif
|
|
// Update the Guide Start time
|
|
//
|
|
if (COleDateTime::invalid == ctmsLoapApp->m_codtGuideStartTime.GetStatus()
|
|
|| codtStart < ctmsLoapApp->m_codtGuideStartTime)
|
|
ctmsLoapApp->m_codtGuideStartTime = codtStart;
|
|
|
|
// Update the Guide End time
|
|
//
|
|
if (COleDateTime::invalid == ctmsLoapApp->m_codtGuideEndTime.GetStatus()
|
|
|| codtEnd > ctmsLoapApp->m_codtGuideEndTime)
|
|
ctmsLoapApp->m_codtGuideEndTime = codtEnd;
|
|
|
|
iRet = UPDATE_SUCCEEDED;
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
int CEpisodeTimeSlotRecordProcessor::m_GetState()
|
|
{
|
|
return m_nState;
|
|
}
|
|
|
|
int CEpisodeTimeSlotRecordProcessor::m_GetError()
|
|
{
|
|
return m_nError;
|
|
}
|
|
|
|
int CEpisodeTimeSlotRecordProcessor::m_GetErrorString(CString& csErrStr)
|
|
{
|
|
if (m_nError)
|
|
{
|
|
// If there is an error to return
|
|
//
|
|
return csErrStr.LoadString(m_nError);
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
}
|