vdr-plugin-scraper2vdr/lib/tabledef.h

/*
 * tabledef.h
 *
 * See the README file for copyright information and how to reach the author.
 *
 */

#ifndef __TABLEDEF_H
#define __TABLEDEF_H

#include "db.h"

//***************************************************************************
// cEpgdState
//***************************************************************************

class cEpgdState
{
   public:

      enum State
      {
         esUnknown = na,

         esInit,
         esStandby,
         esStopped,

         // handler pause on this states!

         esBusy,
         esBusyEvents = esBusy,
         esBusyMatch,
         esBusyScraping,

         // handler don't pause on this states!

         esBusyImages,

         esCount
      };

      static const char* toName(State s);
      static State toState(const char* name);
      static int isValid(State s) { return s > esUnknown && s < esCount; }

      static const char* states[];
};

typedef cEpgdState Es;

//***************************************************************************
// cUpdateState
//***************************************************************************

class cUpdateState
{
   public:

      enum State
      {
         // add to VDRs EPG
         
         usActive      = 'A',
         usLink        = 'L',
         usPassthrough = 'P',
         
         // remove from VDRs EPG
         
         usChanged     = 'C',
         usDelete      = 'D', 
         usRemove      = 'R',
         
         // don't care for VDRs EPG
         
         usInactive    = 'I',
         usTarget      = 'T'
      };

      // get lists for SQL 'in' statements

      static const char* getDeletable()      { return "'A','L','P','R','I'"; }
      static const char* getNeeded()         { return "'A','L','P','C','D','R'"; }
      static const char* getVisible()        { return "'A','L','P'"; }

      // checks fpr c++ code

      static int isNeeded(char c)            { return strchr("ALPCDR", c) != 0; }
      static int isRemove(char c)            { return strchr("CDR", c) != 0; }
      
};

typedef cUpdateState Us;

//***************************************************************************
// class cTableFileRef
//***************************************************************************

class cTableFileRefs : public cDbTable
{
   public:

      cTableFileRefs(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "fileref"; }
      
      enum FieldIndex
      {
         fiName,
         fiSource,

         fiInsSp,
         fiUpdSp,

         fiExternalId,
         fiFileRef,
         fiTag,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableImageRef
//***************************************************************************

class cTableImageRefs : public cDbTable
{
   public:

      cTableImageRefs(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "imagerefs"; }

      enum FieldIndex
      {
         fiEventId,
         fiLfn,

         fiInsSp,
         fiUpdSp,
         fiSource,
         fiFileRef,

         fiImgName,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableImage
//***************************************************************************

class cTableImages : public cDbTable
{
   public:

      cTableImages(cDbConnection* aConnection)
         : cDbTable(aConnection, fields) { }

      virtual const char* TableName()    { return "images"; }

      enum FieldIndex
      {
         fiImgName,

         fiInsSp,
         fiUpdSp,
         fiImage,

         fiCount
      };

      static FieldDef fields[];
};

//***************************************************************************
// class cTableEvent
//***************************************************************************

class cTableEvents : public cDbTable
{
   public:

      cTableEvents(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "events"; }

      enum FieldIndex
      {
         fiEventId,
         fiChannelId,

         fiMasterId,
         fiUseId,

         fiSource,
         fiFileRef,
         fiInsSp,
         fiUpdSp,
         fiUpdFlg,           // update flag
         fiDelFlg,           // deletion flag

         fiTableId,
         fiVersion,
         fiTitle,
         fiCompTitle,        // compressed (without whitespace and special characters)
         fiShortText,
         fiCompShortText,    // compressed (without whitespace and special characters)
         fiLongDescription,
         fiStartTime,
         fiDuration,
         fiParentalRating,
         fiVps,
         fiDescription,      // view field, not stored!

         fiShortDescription,
         fiActor,
         fiAudio,
         fiCategory,
         fiCountry,
         fiDirector,
         fiFlags,
         fiGenre,
         fiInfo,
         fiMusic,
         fiProducer,
         fiScreenplay,
         fiShortreview,
         fiTipp,
         fiTopic,
         fiYear,
         fiRating,
         fiFsk,
         fiMovieid,
         fiModerator,
         fiOther,
         fiGuest,
         fiCamera,

         fiExtEpNum,
         fiImageCount,

         fiEpisode,
         fiEpisodePart,
         fiEpisodeLang,

         fiScrSeriesId,
         fiScrSeriesEpisode,
         fiScrMovieId,
         fiScrSp,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableComponent
//***************************************************************************

class cTableComponents : public cDbTable
{
   public:

      cTableComponents(cDbConnection* aConnection)
         : cDbTable(aConnection, fields) { }

      virtual const char* TableName()    { return "components"; }

      enum FieldIndex
      {
         fiEventId,
         fiChannelId,
         fiStream,
         fiType,
         fiLang,
         fiDescription,

         fiInsSp,
         fiUpdSp
      };

      static FieldDef fields[];
};

//***************************************************************************
// class cTableEpisode
//***************************************************************************

class cTableEpisodes : public cDbTable
{
   public:

      cTableEpisodes(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "episodes"; }


      enum FieldIndex
      {
         // primary key 

         fiCompName,      // compressed name (without whitespace and special characters)
         fiCompPartName,  //      "      "       "
         fiLang,          // "de", "en", ...

         fiInsSp,
         fiUpdSp,
         fiLink,

         // episode data 

         fiShortName,
         fiEpisodeName,   // episode name (fielname without path and suffix)

         // part data

         fiPartName,      // part name
         fiSeason,
         fiPart,
         fiParts,
         fiNumber,

         fiExtraCol1,
         fiExtraCol2,
         fiExtraCol3,
         fiComment,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableChannelMap
//***************************************************************************

class cTableChannelMap : public cDbTable
{
   public:

      cTableChannelMap(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "channelmap"; }

      enum FieldIndex
      {
         fiExternalId,   // 
         fiChannelId,    // 
         fiSource,

         fiChannelName,

         fiVps,
         fiMerge,
         fiMergeSp,

         fiInsSp,
         fiUpdSp,
         fiUpdFlg,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableVdr
//***************************************************************************

class cTableVdrs : public cDbTable
{
   public:

      cTableVdrs(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "vdrs"; }

      enum FieldIndex
      {
         fiUuid,

         fiInsSp,
         fiUpdSp,

         fiName,
         fiVersion,
         fiDbApi,
         fiLastUpdate,
         fiNextUpdate,
         fiState,
         fiMaster,
         fiIp,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableParameters
//***************************************************************************

class cTableParameters : public cDbTable
{
   public:

      cTableParameters(cDbConnection* aConnection)
         : cDbTable(aConnection, fields) { }

      virtual const char* TableName()    { return "parameters"; }

      enum FieldIndex
      {
         fiOwner,
         fiName,

         fiInsSp,
         fiUpdSp,

         fiValue,

         fiCount
      };

      static FieldDef fields[];
};

//***************************************************************************
// cTableAnalyse
//***************************************************************************

class cTableAnalyse : public cDbTable
{
   public:

      cTableAnalyse(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "analyse"; }

      enum FieldIndex
      {
         fiChannelId,   
         fiVdrMasterId, 
         fiVdrEventId,  

         fiVdrStartTime,
         fiVdrDuration, 
         fiVdrTitle,    
         fiVdrShortText,
         
         fiExtMasterId, 
         fiExtEventId,  
         fiExtStartTime,
         fiExtDuration, 
         fiExtTitle,    
         fiExtShortText,
         fiExtEpisode,
         fiExtMerge,
         fiExiImages,

         fiLvMin,
         fiRank,

         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// cTableSnapshot
//***************************************************************************

class cTableSnapshot : public cDbTable
{
   public:

      cTableSnapshot(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "snapshot"; }

      enum FieldIndex
      {
         fiChannelId,    
         fiSource,
         fiVdrMasterId,  
         fiEventId,      
         fiUseId,        
         fiStartTime,    
         fiDuration,     
         fiTitle,        
         fiCompTitle,    
         fiShortText,
         fiCompShortText,
         fiUpdsp,
         fiEpisode,
         fiMerge,
         fiImages,
         
         fiCount
      };

      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableTimers
//***************************************************************************

class cTableTimers : public cDbTable
{
   public:

      cTableTimers(cDbConnection* aConnection)
         : cDbTable(aConnection, fields) { }

      virtual const char* TableName()    { return "timers"; }

      enum FieldIndex
      {
         fiEventId,
         fiChannelId,
         fiVdrUuid,
         
         fiInsSp,
         fiUpdSp,
         
         fiState,
         fiStartTime,
         fiEndTime
      };

      static FieldDef fields[];
};

//***************************************************************************
// class cTableSeries
//***************************************************************************

class cTableSeries : public cDbTable
{
   public:

      cTableSeries(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "series"; }

      enum FieldIndex
      {
         fiSeriesId,

         fiSeriesName,
         fiSeriesLastScraped,
         fiSeriesLastUpdated,
         fiSeriesOverview,
         fiSeriesFirstAired,
         fiSeriesNetwork,
         fiSeriesIMDBId,
         fiSeriesGenre,
         fiSeriesRating,
         fiSeriesStatus,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableSeriesEpisode
//***************************************************************************

class cTableSeriesEpisode : public cDbTable
{
   public:

      cTableSeriesEpisode(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "series_episode"; }

      enum FieldIndex
      {
         fiEpisodeId,

         fiEpisodeNumber,
         fiSeasonNumber,
         fiEpisodeName,
         fiEpisodeOverview,
         fiEpisodeFirstAired,
         fiEpisodeGuestStars,
         fiEpisodeRating,
         fiEpisodeLastUpdated,
         fiSeriesId,   

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableSeriesMedia
//***************************************************************************

class cTableSeriesMedia : public cDbTable
{
   public:

      cTableSeriesMedia(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "series_media"; }

      enum FieldIndex
      {
         fiSeriesId,
         fiSeasonNumber,
         fiEpisodeId,
         fiActorId,
         fiMediaType,

         fiMediaUrl,
         fiMediaWidth,
         fiMediaHeight,
         fiMediaRating,
         fiMediaContent,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableSeriesActor
//***************************************************************************

class cTableSeriesActor : public cDbTable
{
   public:

      cTableSeriesActor(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "series_actor"; }

      enum FieldIndex
      {
         fiActorId,

         fiActorName,
         fiActorRole,
         fiSortOrder,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableMovies
//***************************************************************************

class cTableMovies : public cDbTable
{
   public:

      cTableMovies(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "movie"; }

      enum FieldIndex
      {
         fiMovieId,

         fiTitle,
         fiOriginalTitle,
         fiTagline,
         fiOverview,
         fiIsAdult,
         fiCollectionId,
         fiCollectionName,
         fiBudget,
         fiRevenue,
         fiGenres,
         fiHomepage,
         fiReleaaseDate,
         fiRuntime,
         fiPopularity,
         fiVoteAverage,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableMovieActor
//***************************************************************************

class cTableMovieActor : public cDbTable
{
   public:

      cTableMovieActor(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "movie_actor"; }

      enum FieldIndex
      {
         fiActorId,

         fiActorName,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableMovieActors
//***************************************************************************

class cTableMovieActors : public cDbTable
{
   public:

      cTableMovieActors(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "movie_actors"; }

      enum FieldIndex
      {
         fiMovieId,
         fiActorId,

         fiRole,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableMovieMedia
//***************************************************************************

class cTableMovieMedia : public cDbTable
{
   public:

      cTableMovieMedia(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "movie_media"; }

      enum FieldIndex
      {
         fiMovieId,
         fiActorId,
         fiMediaType,

         fiMediaUrl,
         fiMediaWidth,
         fiMediaHeight,
         fiMediaContent,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

//***************************************************************************
// class cTableRecordings
//***************************************************************************

class cTableRecordings : public cDbTable
{
   public:

      cTableRecordings(cDbConnection* aConnection)
         : cDbTable(aConnection, fields, indices) { }

      virtual const char* TableName()    { return "recordings"; }

      enum FieldIndex
      {
         fiUuid,
         fiRecPath,
         fiRecStart,

         fiEventId,
         fiChannelId,
         fiScrapInfoMovieId,
         fiScrapInfoSeriesId,
         fiScrapInfoEpisodeId,
         fiScrapNew,
         fiRecTitle,
         fiRecSubTitle,
         fiRecDuration,
         fiMovieId,
         fiSeriesId,
         fiEpisodeId,

         fiCount
      };

      static FieldDef* toField(const char* name);      
      static FieldDef fields[];
      static IndexDef indices[];
};

#endif //__TABLEDEF_H