def RemoveFolderFromDb(DB_CONN, FOLDER_LOCATION = None, FOLDER_ID = None):
_folderId = FOLDER_ID
if(not _folderId):
_folderData = Database.Select(DB_CONN,
SELECT = 'Folder_Id',
FROM = dbManager.Db_ContFolder,
WHERE = 'Folder_Location = "%s"' % FOLDER_LOCATION)
if(_folderData):
_folderId = _folderData[0]
if(_folderId):
_folderContents = Database.Select(DB_CONN,
SELECT = 'Content_Id',
FROM = dbManager.Db_Content,
WHERE = 'Folder_id = %i' % _folderId,
fetchall = True)
if(_folderContents):
for _content in _folderContents:
_contentId = _content[0]
RemoveContentFromDb(DB_CONN, CONTENT_ID = _contentId, FOLDER_ID = _folderId)
Database.Delete(DB_CONN,
FROM = dbManager.Db_ContFolder,
WHERE = 'Folder_Id = %i' % _folderId)
else:
DebugLog("Folder Already Removed")
def CheckDatabase(DB_CONN):
checkStruct = True
_updateVersion = False
_dbVersion = -1.0
#Checks to see if an DB Exists if a DB isn't present or has been updated we update or rebuild
for db in dbManager.Db_List:
_returned = Database.Select(DB_CONN,
SELECT="name",
FROM="sqlite_master",
WHERE="type='table' AND name='%s'" % db)
checkStruct = _returned != None and checkStruct
if (db == dbManager.Db_YourFlix and checkStruct):
_versionReturned = Database.Select(DB_CONN,
SELECT="Version",
FROM=db)
print(_versionReturned[0])
if (_versionReturned):
_dbVersion = _versionReturned[0]
_updateVersion = _dbVersion != dbManager.Db_Version
if (not checkStruct):
print(
"Db Builder - Database is Missing Data, Dropping All Tables and Rebuilding"
)
BuildDatabase(DB_CONN)
elif (_updateVersion):
print("Db Builder - Database Needs and Update")
UpdateDatabase(DB_CONN, _dbVersion)
else:
print("Db Builder - Database is setup Correctly")
def ProgramFirstContentScanner(DB_CONN, PROGRAM_ID, PROGRAM_WEB_LOC):
_folderId = -1
_contentId = -1
_folderSearch = Database.Select(DB_CONN,
SELECT = 'Folder_Id',
FROM = dbManager.Db_ContFolder,
WHERE = 'Program_Id = %i AND Folder_Location = "%s"' % (PROGRAM_ID, PROGRAM_WEB_LOC))
if(not _folderSearch):
_folderSearch = Database.Select(DB_CONN,
SELECT = 'Folder_Id',
FROM = dbManager.Db_ContFolder,
WHERE = 'Program_Id = %i' % PROGRAM_ID,
ORDERBY = '%s.Folder_Name COLLATE NOCASE ASC' % dbManager.Db_ContFolder)
if(_folderSearch):
_folderId = _folderSearch[0]
_contentSearch = Database.Select(DB_CONN,
SELECT = 'Content_Id',
FROM = dbManager.Db_Content,
WHERE = 'Folder_Id = %i' % _folderId,
ORDERBY = '%s.Content_Name COLLATE NOCASE ASC' % dbManager.Db_Content)
if(_contentSearch):
_contentId = _contentSearch[0]
Database.Update(DB_CONN,
dbManager.Db_Program,
SET = 'First_Folder = %i, First_Content = %i' % (_folderId, _contentId),
WHERE = 'Program_Id = %i' % PROGRAM_ID)
def RemoveProgramFromDb(DB_CONN, PROGRAM_WEB_LOCATION):
_programData = Database.Select(DB_CONN,
SELECT = 'Program_Id',
FROM = dbManager.Db_Program,
WHERE = 'Program_Web_Location = "%s"' % PROGRAM_WEB_LOCATION)
if(_programData):
_programId = _programData[0]
_programFolders = Database.Select(DB_CONN,
SELECT = 'Folder_Id',
FROM = dbManager.Db_ContFolder,
WHERE = 'Program_Id = %i' % _programId,
fetchall = True)
if(_programFolders):
DebugLog("%i Porgam Folders Found Removing them" % len(_programFolders))
for _folder in _programFolders:
_folderId = _folder[0]
RemoveFolderFromDb(DB_CONN, FOLDER_ID = _folderId)
_programMetaImg = Database.Select(DB_CONN,
SELECT = 'ProgImg_Id',
FROM = dbManager.Db_Img,
WHERE = 'Program_Id = %i' % _programId,
fetchall = True)
if(_programMetaImg):
DebugLog("%i Meta Images Found Removing them" % len(_programMetaImg))
for _metaImg in _programMetaImg:
_metaId = _metaImg[0]
RemoveMetaImgFromDb(DB_CONN, META_ID = _metaId)
_channelPrograms = Database.Select(DB_CONN,
SELECT = 'ChProg_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Program_Id = %i' % _programId,
fetchall = True)
if(_channelPrograms):
DebugLog("%i Channel Programs Found Removing them" % len(_channelPrograms))
for _channelProgram in _channelPrograms:
_channelPorgramId = _channelProgram[0]
RemoveChannelProgramFroDb(DB_CONN, _channelPorgramId)
Database.Delete(DB_CONN,
FROM = dbManager.Db_Program,
WHERE = 'Program_Id = %i' % _programId)
DebugLog("Program with ID: %i has been removed" % _programId)
DebugLog("Program Already Removed")
def AddToDefaultChannel(DB_CONN, PROGRAM_ID, NUMBER_OF_CONTENT, ALL_CHANNEL_ID, FILM_CHANNEL_ID, SHOW_CHANNEL_ID):
_updated = False
#Add Program to All Channel
_channelResult = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Program_Id = %i AND Channel_Id = %i' % (PROGRAM_ID, ALL_CHANNEL_ID))
if(_channelResult):
dbManager.Current_AllChannel.remove(_channelResult)
else:
Database.Insert(DB_CONN,
INTO = dbManager.Db_ChProgram,
ROW = ['Channel_Id, Program_Id'],
VALUES = [ALL_CHANNEL_ID, PROGRAM_ID])
_updated = True
#Add Program to Film Channel
if(NUMBER_OF_CONTENT == 1):
_channelResult = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Program_Id = %i AND Channel_Id = %i' % (PROGRAM_ID, FILM_CHANNEL_ID))
if(_channelResult):
dbManager.Current_FilmsChannel.remove(_channelResult)
else:
Database.Insert(DB_CONN,
INTO = dbManager.Db_ChProgram,
ROW = ['Channel_Id, Program_Id'],
VALUES = [FILM_CHANNEL_ID, PROGRAM_ID])
_updated = True
#Add Program to Show Channel
elif(NUMBER_OF_CONTENT > 1):
_channelResult = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Program_Id = %i AND Channel_Id = %i' % (PROGRAM_ID, SHOW_CHANNEL_ID))
if(_channelResult):
dbManager.Current_ShowsChannel.remove(_channelResult)
else:
Database.Insert(DB_CONN,
INTO = dbManager.Db_ChProgram,
ROW = ['Channel_Id, Program_Id'],
VALUES = [SHOW_CHANNEL_ID, PROGRAM_ID])
_updated = True
return _updated
def RemoveContentFromDb(DB_CONN, FILE_LOCATION = None, CONTENT_ID = None, FOLDER_ID = None):
_contentId = CONTENT_ID
_folderId = FOLDER_ID
if(not _contentId):
_contentData = Database.Select(DB_CONN,
SELECT = 'Content_Id, Folder_Id',
FROM = dbManager.Db_Content,
WHERE = 'Content_Location = "%s"' % FILE_LOCATION)
if(_contentData):
_contentId = _contentData[0]
_folderId = _contentData[1]
if(_contentId and _folderId):
Database.Delete(DB_CONN,
FROM = dbManager.Db_Content,
WHERE = 'Content_Id = %i' % _contentId)
DebugLog("Content with ID: %i has been Removed" % _contentId)
_contentData = Database.Select(DB_CONN,
SELECT = 'Content_Id, Folder_Id',
FROM = dbManager.Db_Content,
WHERE = 'Content_Id = %i' % _contentId,
fetchall = True)
if(len(_contentData) >= 1):
RemoveFolderFromDb(DB_CONN, FOLDER_ID = _folderId)
_programData = Database.Select(DB_CONN,
SELECT = 'Program_Id',
FROM = dbManager.Db_ContFolder,
WHERE = 'Folder_Id = %i' % _folderId)
if(_programData):
_programId = _programData[0]
Database.Update(DB_CONN,
dbManager.Db_Program,
SET = 'Num_Content = Num_Content - 1',
WHERE = 'Program_Id = %i' % _programId)
DebugLog("Program with ID: %i is one less Content in it's DB" % _programId)
programBuilder.BuildProgram(DB_CONN, _programId)
else:
DebugLog("Content Already Removed\nContent ID: %s\nFolder ID: %s" % (str(_contentId), str(_folderId)))
def PullFromDatabase(DB_CONN):
dbManager.Current_Program = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_Program,
fetchall=True)
dbManager.Current_ContFolder = Database.Select(
DB_CONN,
SELECT='Folder_Id, Program_Id',
FROM=dbManager.Db_ContFolder,
fetchall=True)
dbManager.Current_Content = Database.Select(DB_CONN,
SELECT='Content_Id, Folder_Id',
FROM=dbManager.Db_Content,
fetchall=True)
def AddProgramToDb(DB_CONN, PROGAM_WEB_LOC, PROGRAM_NAME):
_programData = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_Program,
WHERE='Program_Web_Location = "%s"' %
PROGAM_WEB_LOC)
if (_programData):
DebugLog("Found Program in Location: %s" % PROGAM_WEB_LOC)
return _programData[0]
else:
DebugLog("Adding Program %s" % PROGRAM_NAME)
_programName = PROGRAM_NAME
_programWebLoc = PROGAM_WEB_LOC
_programPhysLoc = os.path.join(dbManager.YF_Html, _programWebLoc[1:])
_programId = _programId = Database.Insert(
DB_CONN,
INTO=dbManager.Db_Program,
ROW=[
'Program_Name', 'Program_Location', 'Program_Web_Location',
'Num_Content'
],
VALUES=[PROGRAM_NAME, _programPhysLoc, _programWebLoc, 0])
DebugLog("Adding Program %s in Physical Loc: %s - Web Loc: %s" %
(_programName, _programPhysLoc, _programWebLoc))
return _programId
def AddContentToDb(DB_CONN, ROOT, FILE_LOC, FILE_NAME):
_contentData = Database.Select(DB_CONN,
SELECT='Content_Id',
FROM=dbManager.Db_Content,
WHERE='Content_Location = "%s"' % FILE_LOC)
if (not _contentData):
_folderLoc = os.path.dirname(FILE_LOC)
_folderName = os.path.basename(_folderLoc)
_folderRoot = os.path.dirname(_folderLoc)
_folderId = None
DebugLog(
"ROOT: %s\nFOLDER_LOC: %s\n_folderLoc: %s\n_folderName: %s\n_folderRoot: %s\n"
% (ROOT, FILE_LOC, _folderLoc, _folderName, _folderRoot))
_folderData = AddFolderToDb(DB_CONN, _folderRoot, _folderLoc,
_folderName)
if (_folderData):
_folderId = _folderData[0]
_programId = _folderData[1]
if (debug):
print("Added Content: %s in Location: %s" %
(FILE_NAME, FILE_LOC))
_fileType = GetVideoType(DB_CONN, FILE_NAME)
_split = os.path.splitext(FILE_NAME)
_fileName = _split[0]
_updateTime = datetime.datetime.now()
_contentId = Database.Insert(
DB_CONN,
INTO=dbManager.Db_Content,
ROW=[
'Folder_Id', 'FileType_Id', 'Content_Name',
'Content_Location'
],
VALUES=[_folderId, _fileType, _fileName, FILE_LOC])
Database.Update(
DB_CONN,
dbManager.Db_Program,
SET='Num_Content = Num_Content + 1, Program_Last_Updated = "%s"'
% (_updateTime),
WHERE='Program_Id = %i' % _programId)
programBuilder.BuildProgram(DB_CONN, _programId)
DebugLog("Updated and rebuilt Program with Id: %i" % (_programId))
return _contentId
else:
DebugLog("Content: %s already exists" % (FILE_NAME))
return _contentData[0]
def BuildPrograms(DB_CONN):
_programData = Database.Select(DB_CONN,
SELECT = 'Program_Id, Program_Web_Location, Program_Location, Num_Content',
FROM = dbManager.Db_Program,
fetchall = True)
_allChannelId = Database.Select(DB_CONN,
SELECT = 'Channel_Id',
FROM = dbManager.Db_Channel,
WHERE = 'Channel_Name = "%s"' % dbManager.DefaultChannels[0])[0]
_filmChannelId = Database.Select(DB_CONN,
SELECT = 'Channel_Id',
FROM = dbManager.Db_Channel,
WHERE = 'Channel_Name = "%s"' % dbManager.DefaultChannels[1])[0]
_showChannelId = Database.Select(DB_CONN,
SELECT = 'Channel_Id',
FROM = dbManager.Db_Channel,
WHERE = 'Channel_Name = "%s"' % dbManager.DefaultChannels[2])[0]
PullAllMetaData(DB_CONN)
PullAllChannelPrograms(DB_CONN, _allChannelId, _filmChannelId, _showChannelId)
for _program in _programData:
_programId = _program[0]
_programWeb = _program[1]
_programLoc = _program[2]
_numContent = _program[3]
_hasUpdated = ScanProgramMetaFolder(DB_CONN, _programId, _programLoc, _programWeb)
ProgramFirstContentScanner(DB_CONN, _programId, _programWeb)
_hasUpdated = AddToDefaultChannel(DB_CONN, _programId, _numContent, _allChannelId, _filmChannelId, _showChannelId) or _hasUpdated
if(_hasUpdated):
_updateTime = datetime.datetime.now()
DebugLog("Program: %i has been updated @ %s" % (_programId, _updateTime))
Database.Update(DB_CONN,
dbManager.Db_Program,
SET = 'Program_Last_Updated = "%s"' % (_updateTime),
WHERE = 'Program_Id = %i' % _programId)
RemoveUnusedMetaData(DB_CONN)
RemoveUnusedChannelPrograms(DB_CONN)
def UpdateFolderLocation(DB_CONN, ORIG_LOC, NEW_LOC, FOLDER_ID=None):
_folderId = None
if (not FOLDER_ID):
_folderData = Database.Select(DB_CONN,
SELECT='Folder_Id',
FROM=dbManager.Db_ContFolder,
WHERE='Folder_Location = "%s"' %
ORIG_LOC)
if (_folderData):
_folderId = _folderData[0]
else:
_folderId = FOLDER_ID
if (_folderId):
_folderContent = Database.Select(DB_CONN,
SELECT='Content_Id, Content_Location',
FROM=dbManager.Db_Content,
WHERE='Folder_Id = %i' % _folderId,
fetchall=True)
for _content in _folderContent:
_contentId = _content[0]
_originalContentLoc = _content[1]
_newContentLocation = os.path.join(
NEW_LOC,
_originalContentLoc.split(ORIG_LOC)[1][1:])
UpdateContentLocation(DB_CONN, _contentId, _newContentLocation)
Database.Update(DB_CONN,
dbManager.Db_ContFolder,
'Folder_Location = "%s"' % (NEW_LOC),
WHERE='Folder_Id = %i' % _folderId)
if (debug):
print(
"AutoUpdateDB - Updating Folder: %i to change Location to: %s"
% (_folderId, NEW_LOC))
elif (debug):
print("AutoUpdateDB - Folder missing from Location %s" % (ORIG_LOC))
def GetImageType(DB_CONN, IMG_TYPE):
_searchResult = Database.Select(DB_CONN,
SELECT = 'ImgType_Id',
FROM = dbManager.Db_ImageType,
WHERE = 'Image_Type == "%s"' % IMG_TYPE)
if _searchResult:
return _searchResult[0]
return -1
def GetProgramId(DB_CONN, FOLDER_LOC):
_programData = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_Program,
WHERE='Program_Web_Location = "%s"' %
FOLDER_LOC)
if (_programData):
return _programData[0]
raise Exception("FindProgram ERROR: No Program Exists @ %s" + FOLDER_LOC)
def PullAllMetaData(DB_CONN, PROGRAM_ID = None):
_where = ''
if(PROGRAM_ID):
_where = 'Program_Id = %i' %PROGRAM_ID
dbManager.Current_MetaImages = Database.Select(DB_CONN,
SELECT = 'ProgImg_Id',
FROM = dbManager.Db_Img,
WHERE = _where,
fetchall = True)
def PullAllChannelPrograms(DB_CONN, ALL_CHANNEL_ID, FILM_CHANNEL_ID, SHOW_CHANNEL_ID, PROGRAM_ID = None):
_programContition = ''
if(PROGRAM_ID):
_programContition = ' AND Program_Id = %i' % PROGRAM_ID
dbManager.Current_AllChannel = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Channel_Id = %i%s' % (ALL_CHANNEL_ID, _programContition),
fetchall = True)
dbManager.Current_FilmsChannel = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Channel_Id = %i%s' % (FILM_CHANNEL_ID, _programContition),
fetchall = True)
dbManager.Current_ShowsChannel = Database.Select(DB_CONN,
SELECT = 'ChProg_Id, Channel_Id, Program_Id',
FROM = dbManager.Db_ChProgram,
WHERE = 'Channel_Id = %i%s' % (SHOW_CHANNEL_ID, _programContition),
fetchall = True)
def RemoveFromDatabase(DB_CONN):
changed = False
for content in dbManager.Current_Content:
print("Content %s Removed from Db" % str(content))
_contentId = content[0]
_folderId = content[1]
_programId = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_ContFolder,
WHERE='Folder_Id = %i' % _folderId)[0]
Database.Update(DB_CONN,
dbManager.Db_Program,
SET='Num_Content = Num_Content - 1',
WHERE='Program_Id = %i' % _programId)
Database.Delete(DB_CONN,
FROM=dbManager.Db_Content,
WHERE="Content_Id = %i" % _contentId)
changed = True
for contentFolder in dbManager.Current_ContFolder:
print("Folder %s Removed from Db" % str(contentFolder))
_folderId = contentFolder[0]
Database.Delete(DB_CONN,
FROM=dbManager.Db_ContFolder,
WHERE="Folder_Id = %i" % _folderId)
changed = True
for program in dbManager.Current_Program:
print("Program %s Removed from Db" % str(program))
_programId = program[0]
Database.Delete(DB_CONN,
FROM=dbManager.Db_Program,
WHERE="Program_Id = %i" % _programId)
changed = True
if changed:
print("New items added to Db")
def CheckFileType(DB_CONN, FILE):
_split = os.path.splitext(FILE)
_search = (_split[len(_split)-1]).lower()
if(_search != None):
DebugLog("Extention is: %s" % _search)
_searchResult = Database.Select(DB_CONN,
SELECT = 'FileType',
FROM = dbManager.Db_File,
WHERE = 'FileType_Extention = "%s"' % (_search))
if _searchResult:
return _searchResult[0]
return dbManager.FolderType
def GetPhotoType(DB_CONN, PATH):
_search = None
if os.path.isfile(PATH):
_split = os.path.splitext(PATH)
_search = (_split[len(_split)-1]).lower()
if(_search != None):
_searchResult = Database.Select(DB_CONN,
SELECT = 'FileType_Id',
FROM = dbManager.Db_File,
WHERE = 'FileType = "%s" AND FileType_Extention = "%s"' % (dbManager.ImageType, _search))
if _searchResult:
return _searchResult[0]
return -1
def AddFolderToDb(DB_CONN, ROOT, FOLDER_LOC, FOLDER_NAME):
if (FOLDER_NAME not in dbManager.ScannerIgnore):
_folderData = Database.Select(DB_CONN,
SELECT='Folder_Id, Program_Id',
FROM=dbManager.Db_ContFolder,
WHERE='Folder_Location = "%s"' %
FOLDER_LOC)
if (_folderData):
DebugLog("Folder %s exists at location %s" %
(FOLDER_NAME, FOLDER_LOC))
return (_folderData[0], _folderData[1])
elif (FOLDER_NAME not in dbManager.ScannerIgnore):
_programId = None
_programId = FindProgram(DB_CONN, ROOT, FOLDER_LOC, FOLDER_NAME)
if (_programId != -1):
_folderId = 0
_folderId = Database.Insert(
DB_CONN,
INTO=dbManager.Db_ContFolder,
ROW=['Folder_Name', 'Folder_Location', 'Program_Id'],
VALUES=[FOLDER_NAME, FOLDER_LOC, _programId])
DebugLog("Adding Folder: %s to Location: %s" %
(FOLDER_NAME, FOLDER_LOC))
return (_folderId, _programId)
elif (debug):
raise Exception(
"Program not found for Folder: %s in Location: %s" %
(FOLDER_NAME, FOLDER_LOC))
else:
DebugLog("Folder %s has been ignored at location %s" %
(FOLDER_NAME, FOLDER_LOC))
return None
DebugLog("Folder %s is being skipped" % (FOLDER_NAME))
def GetVideoType(DB_CONN, PATH):
_search = None
_split = os.path.splitext(PATH)
_search = (_split[len(_split) - 1]).lower()
if (_search != None):
DebugLog("Looking for File Extention %s" % _search)
_searchResult = Database.Select(
DB_CONN,
SELECT='FileType_Id',
FROM=dbManager.Db_File,
WHERE='FileType = "%s" AND FileType_Extention = "%s"' %
(dbManager.VideoType, _search))
if _searchResult:
return _searchResult[0]
return -1
def RemoveMetaImgFromDb(DB_CONN, FILE_LOCATION = None, META_ID = None):
_metaImgData = META_ID
if(not _metaImgData):
_metaImgData = Database.Select(DB_CONN,
SELECT = 'ProgImg_Id',
FROM = dbManager.Db_Img,
WHERE = 'Img_Location = "%s"' % FILE_LOCATION)
if(_metaImgData):
_programId = _metaImgData[0]
if(_metaImgData):
Database.Delete(DB_CONN,
FROM = dbManager.Db_Img,
WHERE = 'ProgImg_Id = %i' % _metaImgData)
DebugLog("Meta with ID: %i has been removed" % _metaImgData)
else:
DebugLog("MetaImg Removal Error, No Meta with ID %s" % str(_metaImgData))
def FindFolder(DB_CONN, PHYSICAL_PATH, WEB_PATH, FOLDER_NAME, PROGRAM_ID):
DebugLog("Checking if Content Folder %s: is in Database" % FOLDER_NAME)
_searchResult = Database.Select(DB_CONN,
SELECT='Folder_Id, Program_Id',
FROM=dbManager.Db_ContFolder,
WHERE='Folder_Location == "%s"' % WEB_PATH)
if (FOLDER_NAME not in dbManager.MetaFolder):
if (_searchResult):
DebugLog("Folder %s has been Found" % FOLDER_NAME)
if (PROGRAM_ID == _searchResult[1]):
DebugLog("Folder %s Information up to date" % FOLDER_NAME)
dbManager.Current_ContFolder.remove(_searchResult)
return _searchResult[0]
else:
DebugLog("Updating Folder %s with new Program ID: %i" %
(FOLDER_NAME, PROGRAM_ID))
Database.Update(DB_CONN,
dbManager.Db_ContFolder,
SET='Program_Id = %i' % PROGRAM_ID,
WHERE='Folder_Id = %i' % _searchResult[0])
return _searchResult[0]
else:
DebugLog("Adding Folder %s to Database" % FOLDER_NAME)
_folderId = Database.Insert(
DB_CONN,
INTO=dbManager.Db_ContFolder,
ROW=['Folder_Name', 'Folder_Location', 'Program_Id'],
VALUES=[FOLDER_NAME, WEB_PATH, PROGRAM_ID])
return _folderId
return None
def ScanProgramMetaFolder(DB_CONN, PROGRAM_ID, PROGRAM_LOC, PROGRAM_WEB_LOC):
_programMetaLoc = os.path.join(PROGRAM_LOC, dbManager.MetaFolder)
_programWebLoc = os.path.join(PROGRAM_WEB_LOC, dbManager.MetaFolder)
_updated = False
DebugLog("Scanning %s for MetaData" % _programMetaLoc)
if(os.path.exists(_programMetaLoc)):
for _item in os.listdir(_programMetaLoc):
DebugLog("Found Meta Data %s" % _item)
_physicalLoc = os.path.join(_programMetaLoc, _item)
_webLoc = os.path.join(_programWebLoc, _item)
_fileType = GetPhotoType(DB_CONN, _physicalLoc)
_imageType = GetImageType(DB_CONN, "Default")
DebugLog("%s File type is %i" % (_item, _fileType))
if(_fileType != -1):
_searchResult = Database.Select(DB_CONN,
SELECT = 'ProgImg_Id',
FROM = dbManager.Db_Img,
WHERE = 'Img_Location = "%s"' % _webLoc)
if(_searchResult):
DebugLog("%s Exists in Database" % (_item))
dbManager.Current_MetaImages.remove(_searchResult)
else:
DebugLog("%s is being added to Database" % (_item))
Database.Insert(DB_CONN,
INTO = dbManager.Db_Img,
ROW = ['Program_Id', 'Image_Type', 'File_Type', 'Img_Location'],
VALUES = [PROGRAM_ID, _imageType, _fileType, _webLoc])
_updated = True
else:
DebugLog("Meta Data Folder Does not Exist for Program with ID = %i" % PROGRAM_ID)
return _updated
def AddProgram(DB_CONN, ITEM, PHYSICAL_ROOT, WEB_ROOT):
DebugLog("Adding Program %s to Database" % ITEM)
_physicalLoc = os.path.join(PHYSICAL_ROOT, ITEM)
_webLoc = os.path.join(WEB_ROOT, ITEM)
if (ITEM not in dbManager.ScannerIgnore and os.path.isdir(_physicalLoc)):
_programId = -1
_searchResult = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_Program,
WHERE='Program_Location == "%s"' %
_physicalLoc)
if (_searchResult):
_programId = _searchResult[0]
dbManager.Current_Program.remove(_searchResult)
else:
DebugLog("Adding Program at %s" % _physicalLoc)
_programId = Database.Insert(
DB_CONN,
INTO=dbManager.Db_Program,
ROW=[
'Program_Name', 'Program_Location', 'Program_Web_Location',
'Num_Content'
],
VALUES=[ITEM, _physicalLoc, _webLoc, 0])
if (_programId == -1):
raise Exception("ERROR: No Program Id Created")
ContentManager.FindContent(DB_CONN, PHYSICAL_ROOT, WEB_ROOT, ITEM,
_programId)
def BuildDatabase(DB_CONN):
#Checks to see if Database exists and if it does drop it
listOfDb = dbManager.Db_Old + dbManager.Db_List
for db in listOfDb:
if (Database.Select(DB_CONN,
SELECT="name",
FROM="sqlite_master",
WHERE="type='table' AND name='%s'" % db) != None):
Database.Drop(DB_CONN, db)
#Building YourFlix Table and Setting Version
Database.CreateTable(DB_CONN,
TABLE=dbManager.Db_YourFlix,
VALUES=[["Version", "REAL NOT NULL"]])
Database.Insert(DB_CONN,
INTO=dbManager.Db_YourFlix,
VALUES=[dbManager.Db_Version])
#Building Channel Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_Channel,
VALUES=[["Channel_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Channel_Name", "TEXT UNIQUE NOT NULL"],
["Channel_Desctiption", "TEXT"]])
for _channelName in dbManager.DefaultChannels:
Database.Insert(DB_CONN,
INTO=dbManager.Db_Channel,
ROW=["Channel_Name"],
VALUES=[_channelName])
#Building Channel Program Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_ChProgram,
VALUES=[["ChProg_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Channel_Id", "INTEGER"], ["Program_Id", "INTEGER"]])
#Building Program Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_Program,
VALUES=[["Program_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Program_Name", "TEXT UNIQUE NOT NULL"],
["Program_Desctiption", "TEXT"],
["Program_Location", "TEXT NOT NULL"],
["Program_Web_Location", "TEXT NOT NULL"],
["First_Content", "INTEGER"], ["First_Folder", "INTEGER"],
["Num_Content", "INTEGER NOT NULL"],
["Program_Last_Updated", "DATETIME"]])
#Building Program Image Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_Img,
VALUES=[["ProgImg_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Program_Id", "INTEGER NOT NULL"],
["Image_Type", "INTEGER NOT NULL"],
["File_Type", "INTEGER NOT NULL"],
["Img_Location", "TEXT UNIQUE NOT NULL"]])
#Building Image Type Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_ImageType,
VALUES=[["ImgType_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Image_Type", "TEXT UNIQUE NOT NULL"]])
Database.Insert(DB_CONN,
INTO=dbManager.Db_ImageType,
ROW=["Image_Type"],
VALUES=['Default'])
#Building FileType Table and Setting Set Media Types
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_File,
VALUES=[["FileType_Id", "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL"],
["FileType", "TEXT NOT NULL"],
["FileType_Extention", "TEXT UNIQUE NOT NULL"]])
#adding Folder to DB
Database.Insert(DB_CONN,
INTO=dbManager.Db_File,
ROW=["FileType", "FileType_Extention"],
VALUES=[dbManager.FolderType, ''])
#Adding Supported Images
for _type in dbManager.SupportedImg:
fileExtention = "." + _type.lower()
Database.Insert(DB_CONN,
INTO=dbManager.Db_File,
ROW=["FileType", "FileType_Extention"],
VALUES=[dbManager.ImageType, fileExtention])
#Adding Supported Videos
for _type in dbManager.SupportedVideos:
fileExtention = "." + _type.lower()
Database.Insert(DB_CONN,
INTO=dbManager.Db_File,
ROW=["FileType", "FileType_Extention"],
VALUES=[dbManager.VideoType, fileExtention])
#Building Program Folder Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_ContFolder,
VALUES=[["Folder_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Folder_Name", "TEXT NOT NULL"],
["Folder_Location", "TEXT NOT NULL"],
["Program_Id", "INTEGER NOT NULL"]])
#Building Content Table
Database.CreateTable(
DB_CONN,
TABLE=dbManager.Db_Content,
VALUES=[["Content_Id", "INTEGER PRIMARY KEY AUTOINCREMENT"],
["Folder_Id", "INTEGER NOT NULL"],
["FileType_Id", "INTEGER NOT NULL"],
["Content_Name", "TEXT NOT NULL"],
["Content_Location", "TEXT UNIQUE NOT NULL"]])
def UpdateProgramLocation(DB_CONN, ORIG_LOC, NEW_LOC):
_programId = None
_programData = Database.Select(DB_CONN,
SELECT='Program_Id',
FROM=dbManager.Db_Program,
WHERE='Program_Web_Location = "%s"' %
ORIG_LOC)
if (_programData):
_programId = _programData[0]
if (_programId):
_programPhysicalLoc = os.path.join(dbManager.YF_Html, NEW_LOC)
_programFolders = Database.Select(DB_CONN,
SELECT='Folder_Id, Folder_Location',
FROM=dbManager.Db_ContFolder,
WHERE='Program_Id = %i' % _programId,
fetchall=True)
for _folder in _programFolders:
print(_folder)
_folderId = _folder[0]
_originalFolderLoc = _folder[1]
_newContentLocation = os.path.join(
NEW_LOC,
_originalFolderLoc.split(ORIG_LOC)[1][1:])
UpdateFolderLocation(DB_CONN,
_originalFolderLoc,
_newContentLocation,
FOLDER_ID=_folderId)
_programMeta = Database.Select(DB_CONN,
SELECT='ProgImg_Id, Img_Location',
FROM=dbManager.Db_Img,
WHERE='Program_Id = %i' % _programId,
fetchall=True)
for _meta in _programMeta:
_folderId = _meta[0]
_originalMetaLoc = _meta[1]
_newContentLocation = os.path.join(
NEW_LOC,
_originalMetaLoc.split(ORIG_LOC)[1][1:])
UpdateProgramMetaImgLocation(DB_CONN, _folderId,
_newContentLocation)
Database.Update(
DB_CONN,
dbManager.Db_Program,
'Program_Web_Location = "%s", Program_Location = "%s"' %
(NEW_LOC, _programPhysicalLoc),
WHERE='Program_Id = %i' % _programId)
if (debug):
print(
"AutoUpdateDB - Updating Program: %i to change Location to: %s"
% (_programId, NEW_LOC))
elif (debug):
print("AutoUpdateDB - Program missing from Location %s" % (ORIG_LOC))
def FindContent(DB_CONN, PHYSICAL_ROOT, WEB_ROOT, FOLDER_NAME, PROGRAM_ID):
_currentPhysicalFolder = os.path.join(PHYSICAL_ROOT, FOLDER_NAME)
_foundOrAddedContent = 0
if os.path.isdir(_currentPhysicalFolder):
DebugLog("Checking DIR %s" % _currentPhysicalFolder)
_currentWebFolder = os.path.join(WEB_ROOT, FOLDER_NAME)
_currentFolderId = -1
for _item in os.listdir(_currentPhysicalFolder):
DebugLog("Found %s" % _item)
if (_item not in dbManager.ScannerIgnore):
_physicalContent = os.path.join(_currentPhysicalFolder, _item)
_webContent = os.path.join(_currentWebFolder, _item)
if (os.path.isdir(_physicalContent)):
_foundOrAddedContent += FindContent(
DB_CONN, _currentPhysicalFolder, _currentWebFolder,
_item, PROGRAM_ID)
else:
#Make Sure it has the same select data as the Pull data
_searchResult = Database.Select(
DB_CONN,
SELECT='Content_Id, Folder_Id',
FROM=dbManager.Db_Content,
WHERE='Content_Location == "%s"' % _webContent)
if (_currentFolderId == -1):
_currentFolderId = FindFolder(DB_CONN, PHYSICAL_ROOT,
_currentWebFolder,
FOLDER_NAME, PROGRAM_ID)
if (_currentFolderId):
if (_searchResult):
DebugLog("Content: %s is already in DB" % _item)
dbManager.Current_Content.remove(_searchResult)
_foundOrAddedContent += 1
else:
_fileType = GetVideoType(DB_CONN, _physicalContent)
_split = os.path.splitext(_item)
_fileName = _split[0]
_updateTime = datetime.datetime.now()
if (_fileType != -1):
DebugLog("Adding %s to Database" % _item)
Database.Insert(DB_CONN,
INTO=dbManager.Db_Content,
ROW=[
'Folder_Id', 'FileType_Id',
'Content_Name',
'Content_Location'
],
VALUES=[
_currentFolderId,
_fileType, _fileName,
_webContent
])
Database.Update(
DB_CONN,
dbManager.Db_Program,
SET=
'Num_Content = Num_Content + 1, Program_Last_Updated = "%s"'
% (_updateTime),
WHERE='Program_Id = %i' % PROGRAM_ID)
_foundOrAddedContent += 1
return _foundOrAddedContent
