Example #1
0
def associateArrayOfSeriesWithSeriesAlias(aSeriesArray, aSeriesAlias, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	for s in aSeriesArray:
		associateSeriesWithSeriesAlias(s, aSeriesAlias, conn)
Example #2
0
def linkMediaFileToMovie(aMediaFile, aMovie, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	dirConf = settingsManager.directorySettings()

	#Set the proper movie as 'Active'
	movieArray = movie.getByMediaFileId(aMediaFile.id, conn)
	for m in movieArray:
		m.active = 0
		if m.id == aMovie.id:
			m.active = 1
		m.save(conn)

	#Delete the existing linked file if there is one
	removeHardLinkForMediaFile(aMediaFile)

	#Generate a new linked file name and path and update the media file accordingly
	movieFileName = generateHardLinkNameFromMediaFileAndMovie(aMediaFile, aMovie)
	moviePath = os.path.join(dirConf.movieDestination, movieFileName)
	aMediaFile.linkedPath = moviePath
	aMediaFile.save(conn)

	#Create the new link
	createHardLinkForMediaFile(aMediaFile)

	return movieFileName
Example #3
0
def associateArrayOfMoviesWithMediaFile(aMovieArray, aMediaFile, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	for m in aMovieArray:
		associateMovieWithMediaFile(m, aMediaFile, conn)
Example #4
0
def associateMovieWithMediaFile(aMovie, aMediaFile, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	aMovie.associatedMediaFileId = aMediaFile.id
	aMovie.save(conn) 
	return aMovie 
Example #5
0
def associateEpisodeWithMediaFile(anEpisode, aMediaFile, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	anEpisode.associatedMediaFileId = aMediaFile.id
	anEpisode.save(conn)
	return anEpisode
Example #6
0
def associateEpisodeWithSeriesAlias(anEpisode, aSeriesAlias, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	anEpisode.associatedSeriesAliasId = aSeriesAlias.id
	anEpisode.save(conn)
	return anEpisode
Example #7
0
def associateSeriesWithSeriesAlias(aSeries, aSeriesAlias, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	aSeries.associatedSeriesAliasId = aSeriesAlias.id
	aSeries.save(conn)
	return aSeries
Example #8
0
def main():
	systemConf = settingsManager.systemSettings()
	dirConf = settingsManager.directorySettings()
	conn = mySql.createConnection()

	addedContent = []
	for root, dirs, files in os.walk(dirConf.contentSource):
		for file in files:
			fullPath = os.path.join(root, file)
			if isNewTvEpisode(file, root, conn):
				tvShowInfo = getSeries(file)
				newMediaFile = mediaFile.createWithPath(fullPath).save(conn)
				anEpisode = episode.create(tvShowInfo[1], tvShowInfo[2])
				aSeriesAlias = seriesAlias.getBySeriesAliasString(tvShowInfo[0], conn)
				anEpisode = mediaLinker.associateEpisodeWithMediaFile(anEpisode, newMediaFile)
				if aSeriesAlias == None:
					aSeriesAlias = seriesAlias.create(tvShowInfo[0]).save(conn)
					anEpisode = mediaLinker.associateEpisodeWithSeriesAlias(anEpisode, aSeriesAlias)
					seriesArray = findImdbSeriesLikeTitle(file)
					if len(seriesArray) > 0:
						mediaLinker.associateArrayOfSeriesWithSeriesAlias(seriesArray, aSeriesAlias)
						episodeName = mediaLinker.linkMediaFileToSeries(newMediaFile, seriesArray[0])
						addedContent.append(episodeName)
						print file, '  ->  ', episodeName
					else:
						print "\t", "No series for " + file
				else:
					anEpisode = mediaLinker.associateEpisodeWithSeriesAlias(anEpisode, aSeriesAlias)
					aSeries = series.getActiveBySeriesAliasId(aSeriesAlias.id, conn)
					episodeName = mediaLinker.linkMediaFileToSeries(newMediaFile, aSeries)
					addedContent.append(episodeName)
					print file, '  ->  ', episodeName
			elif isNewMovie(file, root, conn):
				newMediaFile = mediaFile.createWithPath(fullPath).save(conn)
				#Check to see if the movie is in a sub folder
				#if so then do the search based on folder name instead of file name
				if len(root) > len(dirConf.contentSource):
					folderTitle = os.path.basename(root)
					movies = findImdbMoviesLikeTitle(folderTitle)
				else:
					movies = findImdbMoviesLikeTitle(file)

				if len(movies) > 0:
					mediaLinker.associateArrayOfMoviesWithMediaFile(movies, newMediaFile, conn)
					movieName = mediaLinker.linkMediaFileToMovie(newMediaFile, movies[0], conn)
					addedContent.append(movieName)
					print file, '  ->  ', movieName
				else:
					print "\t", "No movies for " + file			

	conn.close()
	if len(addedContent) == 1:
		sendXbmcNotification("New Content", addedContent[0]+" was added to the library.")
		sendXbmcLibraryUpdate()
	elif len(addedContent) > 1:
		sendXbmcNotification("New Content", str(len(addedContent))+" new items were added to the library.")
		sendXbmcLibraryUpdate()
Example #9
0
def getBySeriesAliasString(seriesAliasString, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM SeriesAlias WHERE string = %s", (seriesAliasString))
	if cursor.rowcount == 0:
		return None
	else:
		seriesAliasInfo = cursor.fetchall()[0]
		seriesAliasResult = createFromArray(seriesAliasInfo)
		return seriesAliasResult
Example #10
0
def getActiveBySeriesAliasId(seriesAliasId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Series WHERE FK_SeriesAlias_id = %s and active = 1", (seriesAliasId))
	if cursor.rowcount == 0:
		return None
	else:
		seriesInfo = cursor.fetchall()[0]
		seriesResult = createFromArray(seriesInfo)
		return seriesResult
Example #11
0
def getByMovieId(movieId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Movies m WHERE m.id = %s", (movieId))
	if cursor.rowcount == 0:
		return None
	else:
		movieInfo = cursor.fetchall()[0]
		movieResult = createFromArray(movieInfo)
		return movieResult
Example #12
0
def getByMediaFileId(mediaFileId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Episodes WHERE FK_MediaFile_id = %s", (mediaFileId))
	if cursor.rowcount == 0:
		return None
	else:
		episodeInfo = cursor.fetchall()[0]
		episodeResult = createFromArray(episodeInfo)
		return episodeResult
Example #13
0
def getByFilePath(path, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM MediaFiles mf WHERE mf.path = %s", (path))
	if cursor.rowcount == 0:
		return None
	else:
		fileInfo = cursor.fetchall()[0]
		movieResult = createFromArray(fileInfo)
		return movieResult
Example #14
0
def getByMediaFileId(mediaFileId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Movies m WHERE m.FK_MediaFile_id = %s", (mediaFileId))
	if cursor.rowcount == 0:
		return []
	else:
		movieListResult = []
		for movieInfoArray in cursor.fetchall():
			movieResult = createFromArray(movieInfoArray)
			movieListResult.append(movieResult)
		return movieListResult
Example #15
0
def getByMediaFilePath(mediaFilePath, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT m FROM MediaFiles mf LEFT JOIN Movies m ON mf.id = m.FK_MediaFile_id WHERE mf.path = %s", (mediaFilePath))
	if cursor.rowcount == 0:
		return []
	else:
		movieListResult = []
		for movieInfoArray in cursor.fetchall():
			movieResult = createFromArray(movieInfoArray)
			movieListResult.append(movieResult)
		return movieListResult
Example #16
0
def getFromLibrary(conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Movies m WHERE m.active = 1")
	if cursor.rowcount == 0:
		return []
	else:
		movieListResult = []
		for movieInfoArray in cursor.fetchall():
			movieResult = createFromArray(movieInfoArray)
			movieListResult.append(movieResult)
		return movieListResult
Example #17
0
def getBySeriesAliasId(seriesAliasId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Episodes WHERE FK_SeriesAlias_id = %s", (seriesAliasId))
	if cursor.rowcount == 0:
		return []
	else:
		episodeListResult = []
		for episodeInfoArray in cursor.fetchall():
			episodeResult = createFromArray(episodeInfoArray)
			episodeListResult.append(episodeResult)
		return episodeListResult
Example #18
0
def get(conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM MediaFiles mf")
	if cursor.rowcount == 0:
		return []
	else:
		mediaFileListResult = []
		for mediaFileInfoArray in cursor.fetchall():
			mediaFileResult = createFromArray(mediaFileInfoArray)
			mediaFileListResult.append(mediaFileResult)
		return mediaFileListResult
Example #19
0
def get(conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM SeriesAlias")
	if cursor.rowcount == 0:
		return []
	else:
		seriesAliasListResult = []
		for seriesAliasInfoArray in cursor.fetchall():
			seriesAliasResult = createFromArray(seriesAliasInfoArray)
			seriesAliasListResult.append(seriesAliasResult)
		return seriesAliasListResult
Example #20
0
def getSibblingsOfSeriesId(seriesId, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	cursor.execute("SELECT * FROM Series s WHERE s.id = %s", (seriesId))
	lookupSeriesInfo = cursor.fetchall()[0]
	lookupSeries = createFromArray(lookupSeriesInfo)

	cursor.execute("SELECT * FROM Series s WHERE s.FK_SeriesAlias_id = %s", (lookupSeries.associatedSeriesAliasId))
	if cursor.rowcount == 0:
		return []
	else:
		seriesListResult = []
		for seriesInfoArray in cursor.fetchall():
			seriesResult = createFromArray(seriesInfoArray)
			seriesListResult.append(seriesResult)
		return seriesListResult
Example #21
0
	def save(self, conn = None):
		if conn == None:
			conn = mySql.createConnection()
		cursor = conn.cursor()

		#New Movie
		if self.id == None and self.title != None and self.associatedMediaFileId != None:
			try:
				cursor.execute("INSERT INTO Movies (title, year, posterUrl, summary, rating, active, FK_MediaFile_id) VALUES (%s, %s, %s, %s, %s, %s, %s)", (self.title, self.year, self.posterUrl, self.summary, self.rating, self.active, self.associatedMediaFileId))
				conn.commit()
				cursor.execute("SELECT id FROM Movies WHERE title = %s AND FK_MediaFile_id = %s", (self.title, self.associatedMediaFileId))
				result = cursor.fetchall()
				self.id = result[0][0]
			except UnicodeEncodeError:
				print "Unicode error"
		#Update existing movie
		elif self.id != None and self.title != None and self.associatedMediaFileId != None:
			cursor.execute("UPDATE Movies SET title = %s, year = %s, posterUrl = %s, summary = %s, rating = %s, active = %s, FK_MediaFile_id = %s WHERE id = %s", (self.title, self.year, self.posterUrl, self.summary, self.rating, self.active, self.associatedMediaFileId, self.id))
			conn.commit()

		return self
Example #22
0
	def save(self, conn = None):
		if conn == None:
			conn = mySql.createConnection()
		cursor = conn.cursor()

		#New Media File
		if self.id == None and self.path != None:
			try:
				cursor.execute("INSERT INTO MediaFiles (path, linkedPath) VALUES (%s, %s)", (self.path, self.linkedPath))
				conn.commit()
				cursor.execute("SELECT id FROM MediaFiles WHERE path = %s", (self.path))
				result = cursor.fetchall()
				self.id = result[0][0]
			except UnicodeEncodeError:
				print "Unicode error"
		#Update existing movie
		elif self.id != None and self.path != None:
			cursor.execute("UPDATE MediaFiles SET path = %s, linkedPath = %s WHERE id = %s", (self.path, self.linkedPath, self.id))
			conn.commit()

		return self
Example #23
0
	def save(self, conn = None):
		if conn == None:
			conn = mySql.createConnection()
		cursor = conn.cursor()

		#New Episode
		if self.id == None and self.season != None and self.episode != None and self.associatedMediaFileId != None:
			try:
				cursor.execute("INSERT INTO Episodes (season, episode, FK_SeriesAlias_id, FK_MediaFile_id) VALUES (%s, %s, %s, %s)", (self.season, self.episode, self.associatedSeriesAliasId, self.associatedMediaFileId))
				conn.commit()
				cursor.execute("SELECT id FROM Episodes WHERE FK_MediaFile_id = %s", (self.associatedMediaFileId))
				result = cursor.fetchall()
				self.id = result[0][0]
			except UnicodeEncodeError:
				print "Unicode error"
		#Update existing episode
		elif self.id != None and self.season != None and self.episode != None and self.associatedMediaFileId != None:
			cursor.execute("UPDATE Episodes SET season = %s, episode = %s, FK_SeriesAlias_id = %s, FK_MediaFile_id = %s WHERE id = %s", (self.season, self.episode, self.associatedSeriesAliasId, self.associatedMediaFileId, self.id))
			conn.commit()

		return self
Example #24
0
	def save(self, conn = None):
		if conn == None:
			conn = mySql.createConnection()
		cursor = conn.cursor()

		#New Series
		if self.id == None and self.title != None and self.associatedSeriesAliasId != None:
			try:
				cursor.execute("INSERT INTO Series (title, FK_SeriesAlias_id) VALUES (%s, %s)", (self.title, self.associatedSeriesAliasId))
				conn.commit()
				cursor.execute("SELECT id FROM Series WHERE title = %s AND FK_SeriesAlias_id = %s", (self.title, self.associatedSeriesAliasId))
				result = cursor.fetchall()
				self.id = result[0][0]
			except UnicodeEncodeError:
				print "Unicode error"
		#Update existing series
		elif self.id != None and self.title != None and self.associatedSeriesAliasId != None:
			cursor.execute("UPDATE Series SET title = %s, active = %s, FK_SeriesAlias_id = %s WHERE id = %s", (self.title, self.active, self.associatedSeriesAliasId, self.id))
			conn.commit()

		return self
Example #25
0
	def save(self, conn = None):
		if conn == None:
			conn = mySql.createConnection()
		cursor = conn.cursor()

		#New series alias
		if self.id == None and self.string != None:
			try:
				cursor.execute("INSERT INTO SeriesAlias (string) VALUES (%s)", (self.string))
				conn.commit()
				cursor.execute("SELECT id FROM SeriesAlias WHERE string = %s", (self.string))
				result = cursor.fetchall()
				self.id = result[0][0]
			except UnicodeEncodeError:
				print "Unicode error"
		#Update existing series alias
		elif self.id != None and self.string != None:
			cursor.execute("UPDATE SeriesAlias SET string = %s WHERE id = %s", (self.string, self.id))
			conn.commit()

		return self
Example #26
0
def linkMediaFileToSeries(aMediaFile, aSeries, conn = None):
	if conn == None:
		conn = mySql.createConnection()
	cursor = conn.cursor()

	dirConf = settingsManager.directorySettings()

	#Get all the episode information needed to do the linking
	anEpisode = episode.getByMediaFileId(aMediaFile.id, conn)
	aSeriesAlias = seriesAlias.getBySeriesAliasId(anEpisode.associatedSeriesAliasId, conn)

	#Set the proper series as 'Active'
	seriesArray = series.getBySeriesAliasId(aSeriesAlias.id, conn)
	for s in seriesArray:
		s.active = 0
		if s.id == aSeries.id:
			s.active = 1
		s.save(conn)

	#Delete the existing linked file if there is one
	removeHardLinkForMediaFile(aMediaFile)
	removeSeasonFolderIfEmptyForMediaFile(aMediaFile)
	removeSeriesFolderIfEmptyForMediaFile(aMediaFile)

	#Generate a new linked file name and path and update the media file accordingly
	episodeFileName = generateHardLinkNameFromMediaFileAndEpisodeAndSeries(aMediaFile, anEpisode, aSeries)
	seasonPath = generateSeasonPathFromEpisodeAndSeries(anEpisode, aSeries)
	episodePath = os.path.join(seasonPath, episodeFileName)
	aMediaFile.linkedPath = episodePath
	aMediaFile.save(conn)

	#Create the new link
	createSeriesFolderForMediaFile(aMediaFile)
	createSeasonFolderForMediaFile(aMediaFile)
	createHardLinkForMediaFile(aMediaFile)

	return episodeFileName