public static string DeleteImportFolder(int importFolderID)
{
try
{
ImportFolderRepository repNS = new ImportFolderRepository();
ImportFolder ns = repNS.GetByID(importFolderID);
if (ns == null) return "Could not find Import Folder ID: " + importFolderID;
// first delete all the files attached to this import folder
Dictionary<int, AnimeSeries> affectedSeries = new Dictionary<int, AnimeSeries>();
VideoLocalRepository repVids = new VideoLocalRepository();
foreach (VideoLocal vid in repVids.GetByImportFolder(importFolderID))
{
//Thread.Sleep(5000);
logger.Info("Deleting video local record: {0}", vid.FullServerPath);
AnimeSeries ser = null;
List<AnimeEpisode> animeEpisodes = vid.GetAnimeEpisodes();
if (animeEpisodes.Count > 0)
{
ser = animeEpisodes[0].GetAnimeSeries();
if (ser != null && !affectedSeries.ContainsKey(ser.AnimeSeriesID))
affectedSeries.Add(ser.AnimeSeriesID, ser);
}
repVids.Delete(vid.VideoLocalID);
}
// delete any duplicate file records which reference this folder
DuplicateFileRepository repDupFiles = new DuplicateFileRepository();
foreach (DuplicateFile df in repDupFiles.GetByImportFolder1(importFolderID))
repDupFiles.Delete(df.DuplicateFileID);
foreach (DuplicateFile df in repDupFiles.GetByImportFolder2(importFolderID))
repDupFiles.Delete(df.DuplicateFileID);
// delete the import folder
repNS.Delete(importFolderID);
ServerInfo.Instance.RefreshImportFolders();
foreach (AnimeSeries ser in affectedSeries.Values)
{
ser.UpdateStats(true, true, true);
StatsCache.Instance.UpdateUsingSeries(ser.AnimeSeriesID);
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public Contract_ImportFolder_SaveResponse SaveImportFolder(Contract_ImportFolder contract)
{
Contract_ImportFolder_SaveResponse response = new Contract_ImportFolder_SaveResponse();
response.ErrorMessage = "";
response.ImportFolder = null;
try
{
ImportFolderRepository repNS = new ImportFolderRepository();
ImportFolder ns = null;
if (contract.ImportFolderID.HasValue)
{
// update
ns = repNS.GetByID(contract.ImportFolderID.Value);
if (ns == null)
{
response.ErrorMessage = "Could not find Import Folder ID: " + contract.ImportFolderID.Value.ToString();
return response;
}
}
else
{
// create
ns = new ImportFolder();
}
if (string.IsNullOrEmpty(contract.ImportFolderName))
{
response.ErrorMessage = "Must specify an Import Folder name";
return response;
}
if (string.IsNullOrEmpty(contract.ImportFolderLocation))
{
response.ErrorMessage = "Must specify an Import Folder location";
return response;
}
if (!Directory.Exists(contract.ImportFolderLocation))
{
response.ErrorMessage = "Cannot find Import Folder location";
return response;
}
if (!contract.ImportFolderID.HasValue)
{
ImportFolder nsTemp = repNS.GetByImportLocation(contract.ImportFolderLocation);
if (nsTemp != null)
{
response.ErrorMessage = "An entry already exists for the specified Import Folder location";
return response;
}
}
if (contract.IsDropDestination == 1 && contract.IsDropSource == 1)
{
response.ErrorMessage = "A folder cannot be a drop source and a drop destination at the same time";
return response;
}
// check to make sure we don't have multiple drop folders
List<ImportFolder> allFolders = repNS.GetAll();
if (contract.IsDropDestination == 1)
{
foreach (ImportFolder imf in allFolders)
{
if (imf.IsDropDestination == 1 && (!contract.ImportFolderID.HasValue || (contract.ImportFolderID.Value != imf.ImportFolderID)))
{
imf.IsDropDestination = 0;
repNS.Save(imf);
}
}
}
ns.ImportFolderName = contract.ImportFolderName;
ns.ImportFolderLocation = contract.ImportFolderLocation;
ns.IsDropDestination = contract.IsDropDestination;
ns.IsDropSource = contract.IsDropSource;
ns.IsWatched = contract.IsWatched;
repNS.Save(ns);
response.ImportFolder = ns.ToContract();
MainWindow.StopWatchingFiles();
MainWindow.StartWatchingFiles();
return response;
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
response.ErrorMessage = ex.Message;
return response;
}
}
public static void RunImport_ScanFolder(int importFolderID)
{
// get a complete list of files
List<string> fileList = new List<string>();
ImportFolderRepository repFolders = new ImportFolderRepository();
int filesFound = 0, videosFound = 0;
int i = 0;
try
{
ImportFolder fldr = repFolders.GetByID(importFolderID);
if (fldr == null) return;
VideoLocalRepository repVidLocals = new VideoLocalRepository();
// first build a list of files that we already know about, as we don't want to process them again
List<VideoLocal> filesAll = repVidLocals.GetAll();
Dictionary<string, VideoLocal> dictFilesExisting = new Dictionary<string, VideoLocal>();
foreach (VideoLocal vl in filesAll)
{
try
{
dictFilesExisting[vl.FullServerPath] = vl;
}
catch (Exception ex)
{
string msg = string.Format("Error RunImport_ScanFolder XREF: {0} - {1}", vl.ToStringDetailed(), ex.ToString());
logger.Info(msg);
}
}
logger.Debug("ImportFolder: {0} || {1}", fldr.ImportFolderName, fldr.ImportFolderLocation);
Utils.GetFilesForImportFolder(fldr.ImportFolderLocation, ref fileList);
// get a list of all files in the share
foreach (string fileName in fileList)
{
i++;
if (dictFilesExisting.ContainsKey(fileName)) continue;
filesFound++;
logger.Info("Processing File {0}/{1} --- {2}", i, fileList.Count, fileName);
if (!FileHashHelper.IsVideo(fileName)) continue;
videosFound++;
CommandRequest_HashFile cr_hashfile = new CommandRequest_HashFile(fileName, false);
cr_hashfile.Save();
}
logger.Debug("Found {0} new files", filesFound);
logger.Debug("Found {0} videos", videosFound);
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
}
}