/**
* Find tv episodes.
*
* @param tvShow the tv show
* @param dir the dir
*/
private void findTvEpisodes(TvShow tvShow, File dir) {
LOGGER.debug("parsing " + dir.getPath());
// crawl this folder and try to find every episode and its corresponding files in it
File[] content = dir.listFiles();
if (content == null) {
LOGGER.error("Whops. Cannot access directory: " + dir.getName());
return;
}
Arrays.sort(content);
for (File file : content) {
if (file.isFile()) {
if (!file.getName().startsWith(skipFilesStartingWith)) {
MediaFile mf = new MediaFile(file);
// check filetype - we only proceed here if it's a video file
if (!mf.getType().equals(MediaFileType.VIDEO)) {
continue;
}
// is this file already assigned to another episode?
List<TvShowEpisode> episodes = tvShowList.getTvEpisodesByFile(tvShow, file);
if (episodes.size() == 0) {
// try to check what episode//season
// EpisodeMatchingResult result =
// TvShowEpisodeAndSeasonParser.detectEpisodeFromFilename(file);
String relativePath =
new File(tvShow.getPath()).toURI().relativize(file.toURI()).getPath();
EpisodeMatchingResult result =
TvShowEpisodeAndSeasonParser.detectEpisodeFromFilenameAlternative(
relativePath, tvShow.getTitle());
// second check: is the detected episode (>-1; season >-1) already in tmm and any valid
// stacking markers found?
if (result.episodes.size() == 1 && result.season > -1 && result.stackingMarkerFound) {
// get any assigned episode
TvShowEpisode ep = tvShow.getEpisode(result.season, result.episodes.get(0));
if (ep != null) {
ep.setNewlyAdded(true);
ep.addToMediaFiles(mf);
continue;
}
}
if (result.episodes.size() == 0) {
// try to parse out episodes/season from parent directory
result =
TvShowEpisodeAndSeasonParser.detectEpisodeFromDirectory(dir, tvShow.getPath());
}
if (result.season == -1) {
// did the search find a season?
// no -> search for it in the folder name (relative path between tv show root and the
// current dir)
result.season = TvShowEpisodeAndSeasonParser.detectSeason(relativePath);
}
List<TvShowEpisode> episodesInNfo = TvShowEpisode.parseNFO(file);
// did we find any episodes in the NFO?
if (episodesInNfo.size() > 0) {
// these have priority!
for (TvShowEpisode e : episodesInNfo) {
e.setPath(dir.getPath());
e.setTvShow(tvShow);
e.addToMediaFiles(mf);
e.setDateAddedFromMediaFile(mf);
findAdditionalEpisodeFiles(e, file, content);
e.setNewlyAdded(true);
e.saveToDb();
tvShow.addEpisode(e);
}
} else if (result.episodes.size() > 0) {
// something found with the season detection?
for (int ep : result.episodes) {
TvShowEpisode episode = new TvShowEpisode();
episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
episode.setEpisode(ep);
episode.setSeason(result.season);
episode.setFirstAired(result.date);
if (result.name.isEmpty()) {
result.name = FilenameUtils.getBaseName(file.getName());
}
episode.setTitle(result.name);
episode.setPath(dir.getPath());
episode.setTvShow(tvShow);
episode.addToMediaFiles(mf);
episode.setDateAddedFromMediaFile(mf);
findAdditionalEpisodeFiles(episode, file, content);
episode.setNewlyAdded(true);
episode.saveToDb();
tvShow.addEpisode(episode);
}
} else {
// episode detection found nothing - simply add this file
TvShowEpisode episode = new TvShowEpisode();
episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
episode.setEpisode(-1);
episode.setSeason(-1);
episode.setPath(dir.getPath());
episode.setTitle(FilenameUtils.getBaseName(file.getName()));
episode.setTvShow(tvShow);
episode.setFirstAired(result.date);
episode.addToMediaFiles(mf);
episode.setDateAddedFromMediaFile(mf);
findAdditionalEpisodeFiles(episode, file, content);
episode.setNewlyAdded(true);
episode.saveToDb();
tvShow.addEpisode(episode);
}
} else {
// episode already added; look if any new additional files have been added
for (TvShowEpisode episode : episodes) {
if (findAdditionalEpisodeFiles(episode, file, content)) {
episode.saveToDb();
}
}
}
} // end skipFilesStartingWith
} // end isFile
if (file.isDirectory()
&& !skipFolders.contains(file.getName().toUpperCase())
&& !file.getName().matches(skipFoldersRegex)
&& !TvShowModuleManager.TV_SHOW_SETTINGS
.getTvShowSkipFolders()
.contains(file.getAbsolutePath())) {
// check if that directory contains a .tmmignore file
File tmmIgnore = new File(file, ".tmmignore");
if (!tmmIgnore.exists()) {
// dig deeper
if (file.getName().toUpperCase().equals("VIDEO_TS")) {
findTvEpisodesAsDisc(tvShow, file);
} else if (file.getName().toUpperCase().equals("BDMV")) {
findTvEpisodesAsDisc(tvShow, file);
} else {
findTvEpisodes(tvShow, file);
}
}
}
}
}
/**
* Find tv episodes.
*
* @param tvShow the tv show
* @param dir the dir
*/
private void findTvEpisodesAsDisc(TvShow tvShow, File dir) {
String parentDir = dir.getParent();
LOGGER.debug("parsing disc structure in " + dir.getPath() + " parent: " + parentDir);
// crawl this folder and try to find every episode in it
List<MediaFile> videoFiles = new ArrayList<MediaFile>();
File firstVideoFile = null;
File[] content = dir.listFiles();
if (content == null) {
LOGGER.error("Whops. Cannot access directory: " + dir.getName());
return;
}
for (File file : content) {
if (file.isFile()) {
// check filetype
if (!Globals.settings
.getVideoFileType()
.contains("." + FilenameUtils.getExtension(file.getName()).toLowerCase())
|| file.getName().startsWith(skipFilesStartingWith)) { // MacOS ignore
continue;
}
videoFiles.add(new MediaFile(file));
if (firstVideoFile == null) {
firstVideoFile = file;
}
}
}
List<TvShowEpisode> episodes = tvShowList.getTvEpisodesByFile(tvShow, firstVideoFile);
if (episodes.size() == 0) {
String relativePath =
new File(tvShow.getPath()).toURI().relativize(firstVideoFile.toURI()).getPath();
EpisodeMatchingResult result =
TvShowEpisodeAndSeasonParser.detectEpisodeFromFilenameAlternative(
relativePath, tvShow.getTitle());
if (result.season == -1) {
// did the search find a season?
// no -> search for it in the folder name (relative path between tv show root and the
// current dir)
result.season = TvShowEpisodeAndSeasonParser.detectSeason(relativePath);
}
if (result.episodes.size() == 0) {
// try to parse out episodes/season from parent directory
result =
TvShowEpisodeAndSeasonParser.detectEpisodeFromDirectory(
dir.getParentFile(), tvShow.getPath());
}
List<TvShowEpisode> episodesInNfo = TvShowEpisode.parseNFO(firstVideoFile);
// FIXME: Episode root is outside of disc folders ?!
while (dir.getPath().toUpperCase().contains("BDMV")
|| dir.getPath().toUpperCase().contains("VIDEO_TS")) {
dir = dir.getParentFile();
}
if (result.episodes.size() > 0) {
// add it
for (int ep : result.episodes) {
TvShowEpisode episode = null;
// search in the NFO list if an episode has been found
for (int i = episodesInNfo.size() - 1; i >= 0; i--) {
TvShowEpisode e = episodesInNfo.get(i);
if (e.getSeason() == result.season && e.getEpisode() == ep) {
episode = e;
episodesInNfo.remove(i);
break;
}
}
if (episode == null) {
episode = new TvShowEpisode();
episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
episode.setEpisode(ep);
episode.setSeason(result.season);
episode.setNewlyAdded(true);
episode.setFirstAired(result.date);
}
episode.setPath(dir.getPath());
episode.setTvShow(tvShow);
episode.setDisc(true);
episode.setNewlyAdded(true);
episode.addToMediaFiles(videoFiles);
episode.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
findAdditionalEpisodeFiles(episode, firstVideoFile, content);
episode.saveToDb();
tvShow.addEpisode(episode);
}
} else {
// episode detection found nothing - simply add this file
if (episodesInNfo.size() > 0) {
for (TvShowEpisode e : episodesInNfo) {
e.setPath(dir.getPath());
e.setTvShow(tvShow);
e.addToMediaFiles(videoFiles);
e.setNewlyAdded(true);
// e.findImages();
e.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
findAdditionalEpisodeFiles(e, firstVideoFile, content);
e.saveToDb();
tvShow.addEpisode(e);
}
} else {
TvShowEpisode episode = new TvShowEpisode();
episode.setPath(dir.getPath());
episode.setDvdOrder(Globals.settings.getTvShowSettings().isDvdOrder());
episode.setEpisode(-1);
episode.setSeason(-1);
episode.setTvShow(tvShow);
episode.setFirstAired(result.date);
episode.setDisc(true);
episode.setNewlyAdded(true);
episode.addToMediaFiles(videoFiles);
episode.setDateAddedFromMediaFile(new MediaFile(firstVideoFile));
findAdditionalEpisodeFiles(episode, firstVideoFile, content);
episode.saveToDb();
tvShow.addEpisode(episode);
}
}
} else {
// episode already added; look if any new additional files have been added
for (TvShowEpisode episode : episodes) {
if (findAdditionalEpisodeFiles(episode, firstVideoFile, content)) {
episode.saveToDb();
}
}
}
}
/**
* Renames a MediaFiles<br>
* gets all episodes of it, creates season folder, updates MFs & DB
*
* @param mf the MediaFile
* @param show the tvshow (only needed for path)
*/
public static void renameMediaFile(MediaFile mf, TvShow show) {
// #######################################################
// Assumption: all multi-episodes share the same season!!!
// #######################################################
List<TvShowEpisode> eps = TvShowList.getInstance().getTvEpisodesByFile(show, mf.getFile());
if (eps == null || eps.size() == 0) {
// this should not happen, but unluckily ODB does it sometimes; try a second time to get the
// episode
try {
Thread.sleep(250);
} catch (Exception e) {
}
eps = TvShowList.getInstance().getTvEpisodesByFile(show, mf.getFile());
}
if (eps == null || eps.size() == 0) {
// FIXME: workaround for r1972
// when moving video file, all NFOs get deleted and a new gets created.
// so this OLD NFO is not found anylonger - just delete it
if (mf.getType() == MediaFileType.NFO) {
FileUtils.deleteQuietly(mf.getFile());
return;
}
LOGGER.warn("No episodes found for file '" + mf.getFilename() + "' - skipping");
return;
}
// get first, for isDisc and season
TvShowEpisode ep = eps.get(0);
// test access rights or return
LOGGER.debug(
"testing file S:"
+ ep.getSeason()
+ " E:"
+ ep.getEpisode()
+ " MF:"
+ mf.getFile().getAbsolutePath());
File f = mf.getFile();
boolean testRenameOk = false;
for (int i = 0; i < 5; i++) {
testRenameOk = f.renameTo(f); // haahaa, try to rename to itself :P
if (testRenameOk) {
break; // ok it worked, step out
}
try {
if (!f.exists()) {
LOGGER.debug("Hmmm... file " + f + " does not even exists; delete from DB");
// delete from MF
for (TvShowEpisode e : eps) {
e.removeFromMediaFiles(mf);
e.saveToDb();
e.writeNFO();
}
return;
}
LOGGER.debug("rename did not work - sleep a while and try again...");
Thread.sleep(1000);
} catch (InterruptedException e) {
LOGGER.warn("I'm so excited - could not sleep");
}
}
if (!testRenameOk) {
LOGGER.warn("File " + mf.getFile().getAbsolutePath() + " is not accessible!");
MessageManager.instance.pushMessage(
new Message(MessageLevel.ERROR, mf.getFilename(), "message.renamer.failedrename"));
return;
}
// create SeasonDir
// String seasonName = "Season " + String.valueOf(ep.getSeason());
String seasonName = generateSeasonDir(SETTINGS.getRenamerSeasonFoldername(), ep);
File seasonDir = null;
if (StringUtils.isNotBlank(seasonName)) {
seasonDir = new File(show.getPath(), seasonName);
if (!seasonDir.exists()) {
seasonDir.mkdir();
}
} else {
seasonDir = new File(show.getPath());
}
// rename epFolder accordingly
if (ep.isDisc() || mf.isDiscFile()) {
// \Season 1\S01E02E03\VIDEO_TS\VIDEO_TS.VOB
// ........ \epFolder \disc... \ file
File disc = mf.getFile().getParentFile();
File epFolder = disc.getParentFile();
// sanity check
if (!disc.getName().equalsIgnoreCase("BDMV")
&& !disc.getName().equalsIgnoreCase("VIDEO_TS")) {
LOGGER.error(
"Episode is labeled as 'on BD/DVD', but structure seems not to match. Better exit and do nothing... o_O");
return;
}
String newFoldername =
FilenameUtils.getBaseName(generateFolderename(show, mf)); // w/o extension
if (newFoldername != null && !newFoldername.isEmpty()) {
File newEpFolder = new File(seasonDir + File.separator + newFoldername);
File newDisc = new File(newEpFolder + File.separator + disc.getName()); // old disc name
try {
// if (!epFolder.equals(newEpFolder)) {
if (!epFolder.getAbsolutePath().equals(newEpFolder.getAbsolutePath())) {
boolean ok = false;
try {
ok = Utils.moveDirectorySafe(epFolder, newEpFolder);
} catch (Exception e) {
LOGGER.error(e.getMessage());
MessageManager.instance.pushMessage(
new Message(
MessageLevel.ERROR,
epFolder.getName(),
"message.renamer.failedrename",
new String[] {":", e.getLocalizedMessage()}));
}
if (ok) {
// iterate over all EPs & MFs and fix new path
LOGGER.debug("updating *all* MFs for new path -> " + newEpFolder);
for (TvShowEpisode e : eps) {
e.updateMediaFilePath(disc, newDisc);
e.setPath(newEpFolder.getPath());
e.saveToDb();
e.writeNFO();
}
}
// and cleanup
cleanEmptyDir(epFolder);
} else {
// old and new folder are equal, do nothing
}
} catch (Exception e) {
LOGGER.error("error moving video file " + disc.getName() + " to " + newFoldername, e);
MessageManager.instance.pushMessage(
new Message(
MessageLevel.ERROR,
mf.getFilename(),
"message.renamer.failedrename",
new String[] {":", e.getLocalizedMessage()}));
}
}
} // end isDisc
else {
MediaFile newMF = new MediaFile(mf); // clone MF
if (mf.getType().equals(MediaFileType.TRAILER)) {
// move trailer into separate dir - not supported by XBMC
File sample = new File(seasonDir, "sample");
if (!sample.exists()) {
sample.mkdir();
}
seasonDir = sample; // change directory storage
}
String filename = generateFilename(show, mf);
LOGGER.debug("new filename should be " + filename);
if (filename != null && !filename.isEmpty()) {
File newFile = new File(seasonDir, filename);
try {
// if (!mf.getFile().equals(newFile)) {
if (!mf.getFile().getAbsolutePath().equals(newFile.getAbsolutePath())) {
File oldMfFile = mf.getFile();
boolean ok = false;
try {
ok = Utils.moveFileSafe(oldMfFile, newFile);
} catch (Exception e) {
LOGGER.error(e.getMessage());
MessageManager.instance.pushMessage(
new Message(
MessageLevel.ERROR,
oldMfFile.getPath(),
"message.renamer.failedrename",
new String[] {":", e.getLocalizedMessage()}));
}
if (ok) {
newMF.setPath(seasonDir.getAbsolutePath());
newMF.setFilename(filename);
// iterate over all EPs and delete old / set new MF
for (TvShowEpisode e : eps) {
e.removeFromMediaFiles(mf);
e.addToMediaFiles(newMF);
e.setPath(seasonDir.getAbsolutePath());
e.saveToDb();
e.writeNFO();
}
}
// and cleanup
cleanEmptyDir(oldMfFile.getParentFile());
} else {
// old and new file are equal, keep MF
}
} catch (Exception e) {
LOGGER.error(
"error moving video file " + mf.getFilename() + " to " + newFile.getPath(), e);
MessageManager.instance.pushMessage(
new Message(
MessageLevel.ERROR,
mf.getFilename(),
"message.renamer.failedrename",
new String[] {":", e.getLocalizedMessage()}));
}
}
}
}