void btnDeleteImportFolder_Click(object sender, RoutedEventArgs e)
{
object obj = lbImportFolders.SelectedItem;
if (obj == null)
{
return;
}
try
{
if (obj.GetType() == typeof(ImportFolder))
{
ImportFolder ns = (ImportFolder)obj;
MessageBoxResult res = MessageBox.Show(string.Format(JMMServer.Properties.Resources.ImportFolders_DeleteFolder, ns.ImportFolderLocation), JMMServer.Properties.Resources.Confirm, MessageBoxButton.YesNo, MessageBoxImage.Question);
if (res == MessageBoxResult.Yes)
{
this.Cursor = Cursors.Wait;
Importer.DeleteImportFolder(ns.ImportFolderID);
this.Cursor = Cursors.Arrow;
}
}
}
catch (Exception ex)
{
this.Cursor = Cursors.Arrow;
Utils.ShowErrorMessage(ex);
}
}
public static void Init()
{
JMMUser.Populate(a => a.JMMUserID);
CloudAccount.Populate(a => a.CloudID);
ImportFolder.Populate(a => a.ImportFolderID);
AniDB_Anime.Populate(a => a.AniDB_AnimeID);
AniDB_Episode.Populate(a => a.AniDB_EpisodeID);
AniDB_File.Populate(a => a.AniDB_FileID);
AniDB_Anime_Title.Populate(a => a.AniDB_Anime_TitleID);
AniDB_Anime_Tag.Populate(a => a.AniDB_Anime_TagID);
AniDB_Tag.Populate(a => a.AniDB_TagID);
CustomTag.Populate(a => a.CustomTagID);
CrossRef_CustomTag.Populate(a => a.CrossRef_CustomTagID);
CrossRef_File_Episode.Populate(a => a.CrossRef_File_EpisodeID);
VideoLocalPlace.Populate(a => a.VideoLocal_Place_ID);
VideoLocal.Populate(a => a.VideoLocalID);
VideoLocalUser.Populate(a => a.VideoLocal_UserID);
GroupFilter.Populate(a => a.GroupFilterID);
AnimeEpisode.Populate(a => a.AnimeEpisodeID);
AnimeEpisode_User.Populate(a => a.AnimeEpisode_UserID);
AnimeSeries.Populate(a => a.AnimeSeriesID);
AnimeSeries_User.Populate(a => a.AnimeSeries_UserID);
AnimeGroup.Populate(a => a.AnimeGroupID);
AnimeGroup_User.Populate(a => a.AnimeGroup_UserID);
GroupFilter.PostProcess();
CleanUpMemory();
}
public string TranslateDirectory(ImportFolder impfolder, string path)
{
if (impfolder == null)
{
return(string.Empty);
}
if (impfolder.CloudID.HasValue)
{
return("Somewhere over the rainbow (in the clouds)");
}
string result = TranslateDirectory(impfolder.ImportFolderID, path);
try
{
if (result == string.Empty && Directory.Exists(impfolder.ImportFolderLocation))
{
string npath = Path.Combine(impfolder.ImportFolderLocation, path);
if (Directory.Exists(npath))
{
return(npath);
}
}
}
catch
{
}
return(result);
}
public ActionResult PatchImportFolder(int id, [FromBody] JsonPatchDocument <ImportFolder> folder)
{
if (folder == null)
{
return(BadRequest("object is invalid."));
}
var existing = RepoFactory.ImportFolder.GetByID(id);
if (existing == null)
{
return(BadRequest("No Import Folder with ID"));
}
var patchModel = new ImportFolder(existing);
folder.ApplyTo(patchModel, ModelState);
TryValidateModel(patchModel);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var serverModel = patchModel.GetServerModel();
RepoFactory.ImportFolder.SaveImportFolder(serverModel);
return(Ok());
}
public void Init(ImportFolder ifldr)
{
try
{
ServerInfo.Instance.RefreshFolderProviders();
importFldr = new ImportFolder()
{
ImportFolderID = ifldr.ImportFolderID,
ImportFolderType = ifldr.ImportFolderType,
ImportFolderLocation = ifldr.ImportFolderLocation,
ImportFolderName = ifldr.ImportFolderName,
IsDropSource = ifldr.IsDropSource,
IsDropDestination = ifldr.IsDropDestination,
CloudID = ifldr.CloudID,
IsWatched = ifldr.IsWatched
};
txtImportFolderLocation.Text = importFldr.ImportFolderLocation;
chkDropDestination.IsChecked = importFldr.IsDropDestination == 1;
chkDropSource.IsChecked = importFldr.IsDropSource == 1;
chkIsWatched.IsChecked = importFldr.IsWatched == 1;
if (ifldr.CloudID.HasValue)
{
comboProvider.SelectedItem = ServerInfo.Instance.FolderProviders.FirstOrDefault(a => a.CloudID == ifldr.CloudID.Value);
}
else
{
comboProvider.SelectedIndex = 0;
}
txtImportFolderLocation.Focus();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public SVR_ImportFolder SaveImportFolder(ImportFolder folder)
{
SVR_ImportFolder ns;
if (folder.ImportFolderID > 0)
{
// update
ns = GetByID(folder.ImportFolderID);
if (ns == null)
{
throw new Exception($"Could not find Import Folder ID: {folder.ImportFolderID}");
}
}
else
{
// create
ns = new SVR_ImportFolder();
}
if (string.IsNullOrEmpty(folder.ImportFolderName))
{
throw new Exception("Must specify an Import Folder name");
}
if (string.IsNullOrEmpty(folder.ImportFolderLocation))
{
throw new Exception("Must specify an Import Folder location");
}
if (!Directory.Exists(folder.ImportFolderLocation))
{
throw new Exception("Cannot find Import Folder location");
}
if (folder.ImportFolderID == 0)
{
SVR_ImportFolder nsTemp =
GetByImportLocation(folder.ImportFolderLocation);
if (nsTemp != null)
{
throw new Exception("Another entry already exists for the specified Import Folder location");
}
}
ns.ImportFolderName = folder.ImportFolderName;
ns.ImportFolderLocation = folder.ImportFolderLocation;
ns.IsDropDestination = folder.IsDropDestination;
ns.IsDropSource = folder.IsDropSource;
ns.IsWatched = folder.IsWatched;
ns.ImportFolderType = folder.ImportFolderType;
Save(ns);
Utils.MainThreadDispatch(() => { ServerInfo.Instance.RefreshImportFolders(); });
ShokoServer.StopWatchingFiles();
ShokoServer.StartWatchingFiles();
return(ns);
}
public static void Init()
{
JMMUser.Populate();
CloudAccount.Populate();
ImportFolder.Populate();
AniDB_Anime.Populate();
AniDB_Episode.Populate();
AniDB_File.Populate();
AniDB_Anime_Title.Populate();
AniDB_Anime_Tag.Populate();
AniDB_Tag.Populate();
CustomTag.Populate();
CrossRef_CustomTag.Populate();
CrossRef_File_Episode.Populate();
VideoLocalPlace.Populate();
VideoLocal.Populate();
VideoLocalUser.Populate();
GroupFilter.Populate();
AnimeEpisode.Populate();
AnimeEpisode_User.Populate();
AnimeSeries.Populate();
AnimeSeries_User.Populate();
AnimeGroup.Populate();
AnimeGroup_User.Populate();
// Update Contracts if necessary
try
{
JMMUser.RegenerateDb();
CloudAccount.RegenerateDb();
ImportFolder.RegenerateDb();
AniDB_Anime.RegenerateDb();
AniDB_Episode.RegenerateDb();
AniDB_File.RegenerateDb();
AniDB_Anime_Title.RegenerateDb();
AniDB_Anime_Tag.RegenerateDb();
AniDB_Tag.RegenerateDb();
CustomTag.RegenerateDb();
CrossRef_CustomTag.RegenerateDb();
CrossRef_File_Episode.RegenerateDb();
VideoLocalPlace.RegenerateDb();
VideoLocal.RegenerateDb();
VideoLocalUser.RegenerateDb();
AnimeEpisode.RegenerateDb();
AnimeEpisode_User.RegenerateDb();
AnimeSeries.RegenerateDb();
AnimeSeries_User.RegenerateDb();
AnimeGroup.RegenerateDb();
AnimeGroup_User.RegenerateDb();
GroupFilter.RegenerateDb();
GroupFilter.PostProcess();
}
catch (Exception e)
{
LogManager.GetCurrentClassLogger().Error(e, "There was an error starting the Database Factory");
}
CleanUpMemory();
}
public void TestAddFilesToFolder()
{
var file = new ImportFile();
var folder = new ImportFolder();
folder.Add(file);
Assert.AreEqual(folder, file.Parent);
}
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.QueueUpdateStats();
//StatsCache.Instance.UpdateUsingSeries(ser.AnimeSeriesID);
}
return "";
}
catch (Exception ex)
{
logger.ErrorException(ex.ToString(), ex);
return ex.Message;
}
}
public ImportFolder GetByImportLocation(string importloc)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
ImportFolder cr = session
.CreateCriteria(typeof(ImportFolder))
.Add(Restrictions.Eq("ImportFolderLocation", importloc))
.UniqueResult <ImportFolder>();
return(cr);
}
}
private ImportItem Load(string name)
{
var directory = new DirectoryInfo(name);
var item = new ImportFolder
{
SourceDirectory = directory,
Name = m_filenameConverter.Convert(directory.Name),
CreatedBy = MetaDataProvider.GetAuthor(directory.FullName),
ModifiedBy = MetaDataProvider.GetEditor(directory.FullName),
MetaData = MetaDataProvider.GetMetaData(directory.FullName)
};
var result = m_validator.Validate(item);
if (result.IsValid)
{
foreach (var folder in directory.GetDirectories())
{
if ((folder.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden || m_settings.ImportHiddenFiles)
{
item.Add(Load(folder.FullName));
}
}
foreach (var file in directory.GetFiles())
{
if ((file.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden || m_settings.ImportHiddenFiles)
{
var importFile = new ImportFile
{
SourceFile = file,
Name = m_filenameConverter.Convert(file.Name),
CreatedBy = MetaDataProvider.GetAuthor(file.FullName),
ModifiedBy = MetaDataProvider.GetEditor(file.FullName),
MetaData = MetaDataProvider.GetMetaData(file.FullName),
};
var fileResult = m_validator.Validate(importFile);
if (fileResult.IsValid)
{
item.Add(importFile);
}
else
{
Log(fileResult);
}
}
}
}
else
{
Log(result);
}
return(item);
}
void lbImportFolders_SelectedIndexChanged(object sender, EventArgs e)
{
txtFolderLocalPath.Text = "";
ImportFolder fldr = _importFolders[lbImportFolders.SelectedIndex];
if (fldr == null)
{
return;
}
txtFolderLocalPath.Text = fldr.GetLocalFileSystemFullPath();
}
public (ImportFolder dest, string folder) GetDestinationFolder(SVR_VideoLocal_Place video)
{
try
{
SVR_AnimeSeries series = video.VideoLocal?.GetAnimeEpisodes().FirstOrDefault()?.GetAnimeSeries();
if (series == null)
{
return(null, "Series is null");
}
string name = Utils.ReplaceInvalidFolderNameCharacters(series.GetSeriesName());
if (string.IsNullOrEmpty(name))
{
return(null, "Unable to get series name");
}
var anime = series.GetAnime();
ImportFolder destFolder = RepoFactory.ImportFolder.GetAll()
.FirstOrDefault(a => a.ImportFolderLocation.Contains("Anime"));
if (anime.Restricted == 1)
{
destFolder = RepoFactory.ImportFolder.GetAll()
.FirstOrDefault(a => a.ImportFolderLocation.Contains("Hentai"));
}
if (destFolder == null)
{
destFolder = RepoFactory.ImportFolder.GetAll().FirstOrDefault(a => a.FolderIsDropDestination) ??
RepoFactory.ImportFolder.GetAll().FirstOrDefault();
}
string path;
var group = series.AnimeGroup;
if (group == null)
{
return(null, "group is null");
}
if (group.GetAllSeries().Count == 1)
{
path = name;
}
else
{
var groupName = Utils.ReplaceInvalidFolderNameCharacters(group.GroupName);
path = Path.Combine(groupName, name);
}
return(destFolder, path);
}
catch
{
return(null, "ERROR");
}
}
public void Save(ImportFolder obj)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
session.SaveOrUpdate(obj);
transaction.Commit();
}
}
}
public static void Init()
{
JMMUser.Populate();
CloudAccount.Populate();
ImportFolder.Populate();
AniDB_Anime.Populate();
AniDB_Episode.Populate();
AniDB_File.Populate();
AniDB_Anime_Title.Populate();
AniDB_Anime_Tag.Populate();
AniDB_Tag.Populate();
CustomTag.Populate();
CrossRef_CustomTag.Populate();
CrossRef_File_Episode.Populate();
VideoLocalPlace.Populate();
VideoLocal.Populate();
VideoLocalUser.Populate();
GroupFilter.Populate();
AnimeEpisode.Populate();
AnimeEpisode_User.Populate();
AnimeSeries.Populate();
AnimeSeries_User.Populate();
AnimeGroup.Populate();
AnimeGroup_User.Populate();
// Update Contracts if necessary
JMMUser.RegenerateDb();
CloudAccount.RegenerateDb();
ImportFolder.RegenerateDb();
AniDB_Anime.RegenerateDb();
AniDB_Episode.RegenerateDb();
AniDB_File.RegenerateDb();
AniDB_Anime_Title.RegenerateDb();
AniDB_Anime_Tag.RegenerateDb();
AniDB_Tag.RegenerateDb();
CustomTag.RegenerateDb();
CrossRef_CustomTag.RegenerateDb();
CrossRef_File_Episode.RegenerateDb();
VideoLocalPlace.RegenerateDb();
VideoLocal.RegenerateDb();
VideoLocalUser.RegenerateDb();
AnimeEpisode.RegenerateDb();
AnimeEpisode_User.RegenerateDb();
AnimeSeries.RegenerateDb();
AnimeSeries_User.RegenerateDb();
AnimeGroup.RegenerateDb();
AnimeGroup_User.RegenerateDb();
GroupFilter.RegenerateDb();
GroupFilter.PostProcess();
CleanUpMemory();
}
void btnSaveLocalFolderPath_Click(object sender, EventArgs e)
{
if (lbImportFolders.SelectedItem != null)
{
ImportFolder fldr = _importFolders[lbImportFolders.SelectedIndex];
if (fldr == null)
{
return;
}
FolderMappings.Instance.MapFolder(fldr.ImportFolderID, txtFolderLocalPath.Text.Trim());
BaseConfig.Settings.Save();
}
}
public override void Import(ImportItem importItem)
{
var folder = new ImportFolder(importItem as ImportFolder);
var flatList = GetFiles(importItem as ImportFolder);
foreach (var file in flatList)
{
var newFile = new ImportFile(file);
newFile.Name = NameResolver.ResolveName(file);
folder.Add(newFile);
ImportFile(file, newFile);
}
}
private ImportItem Load(string name)
{
DirectoryInfo directoryInfo = new DirectoryInfo(name);
ImportFolder importFolder = new ImportFolder();
importFolder.SourceDirectory = directoryInfo;
importFolder.Name = this.m_filenameConverter.Convert(directoryInfo.Name);
importFolder.CreatedBy = this.MetaDataProvider.GetAuthor(directoryInfo.FullName);
importFolder.ModifiedBy = this.MetaDataProvider.GetEditor(directoryInfo.FullName);
importFolder.MetaData = this.MetaDataProvider.GetMetaData(directoryInfo.FullName);
ImportFolder directory1 = importFolder;
ValidationResult result1 = this.m_validator.Validate(directory1);
if (result1.IsValid)
{
foreach (DirectoryInfo directory2 in directoryInfo.GetDirectories())
{
if ((directory2.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden || this.m_settings.ImportHiddenFiles)
{
directory1.Add(this.Load(directory2.FullName));
}
}
foreach (FileInfo file1 in directoryInfo.GetFiles())
{
if ((file1.Attributes & FileAttributes.Hidden) != FileAttributes.Hidden || this.m_settings.ImportHiddenFiles)
{
ImportFile importFile = new ImportFile();
importFile.SourceFile = file1;
importFile.Name = this.m_filenameConverter.Convert(file1.Name);
importFile.CreatedBy = this.MetaDataProvider.GetAuthor(file1.FullName);
importFile.ModifiedBy = this.MetaDataProvider.GetEditor(file1.FullName);
importFile.MetaData = this.MetaDataProvider.GetMetaData(file1.FullName);
ImportFile file2 = importFile;
ValidationResult result2 = this.m_validator.Validate(file2);
if (result2.IsValid)
{
directory1.Add((ImportItem)file2);
}
else
{
this.Log(result2);
}
}
}
}
else
{
this.Log(result1);
}
return((ImportItem)directory1);
}
private IEnumerable <ImportFile> GetFiles(ImportFolder folder)
{
foreach (ImportFolder folder1 in (IEnumerable <ImportFolder>)folder.Folders)
{
foreach (ImportFile file in this.GetFiles(folder1))
{
yield return(file);
}
}
foreach (ImportFile file in (IEnumerable <ImportFile>)folder.Files)
{
yield return(file);
}
}
private IEnumerable <ImportFile> GetFiles(ImportFolder folder)
{
foreach (var fol in folder.Folders)
{
foreach (var file in GetFiles(fol))
{
yield return(file);
}
}
foreach (var file in folder.Files)
{
yield return(file);
}
}
void EnsureFolder(ImportFolder folder)
{
if (folder == null)
{
return;
}
var target = folder.OriginalFullName.Replace(m_settings.SourceFolder, m_settings.ArchiveFolder);
if (!Directory.Exists(target))
{
EnsureFolder(folder.Parent);
Directory.CreateDirectory(target);
log.Info("created directory " + target);
}
}
public void ImportContents(ImportFolder folder)
{
if (!folder.IsRoot)
{
this.ImportFolder(folder);
}
foreach (ImportFolder folder1 in (IEnumerable <ImportFolder>)folder.Folders)
{
this.ImportContents(folder1);
}
foreach (ImportFile file in (IEnumerable <ImportFile>)folder.Files)
{
this.ImportFile(file);
}
}
public void ImportContents(ImportFolder folder)
{
if (!folder.IsRoot)
{
ImportFolder(folder);
}
foreach (var subfolder in folder.Folders)
{
ImportContents(subfolder);
}
foreach (var file in folder.Files)
{
ImportFile(file);
}
}
public void TestRelativePath()
{
var file = new ImportFile {
Name = "file"
};
var folder = new ImportFolder {
Name = "folder"
};
var rootfolder = new ImportFolder {
Name = "root"
};
folder.Add(file);
rootfolder.Add(folder);
Assert.AreEqual("/folder/file", file.ServerRelativePath);
}
public ImportFolder ToContract()
{
var result = new ImportFolder
{
ImportFolderID = ImportFolderID,
CloudID = CloudID,
ImportFolderLocation = ImportFolderLocation,
ImportFolderName = ImportFolderName,
ImportFolderType = ImportFolderType,
IsDropDestination = IsDropDestination,
IsDropSource = IsDropSource,
IsWatched = IsWatched
};
return(result);
}
public void Delete(int id)
{
using (var session = JMMService.SessionFactory.OpenSession())
{
// populate the database
using (var transaction = session.BeginTransaction())
{
ImportFolder cr = GetByID(id);
if (cr != null)
{
session.Delete(cr);
transaction.Commit();
}
}
}
}
private void EnsureFolder(ImportFolder folder)
{
if (folder == null)
{
return;
}
string path = folder.OriginalFullName.Replace(this.m_settings.SourceFolder, this.m_settings.ArchiveFolder);
if (Directory.Exists(path))
{
return;
}
this.EnsureFolder(folder.Parent);
Directory.CreateDirectory(path);
PostImportFileProcessor.log.Info((object)("created directory " + path));
}
void lbImportFolders_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
object obj = lbImportFolders.SelectedItem;
if (obj == null)
{
return;
}
VM_ImportFolder ns = (VM_ImportFolder)obj;
ImportFolder frm = new ImportFolder();
frm.Owner = GetTopParent();
frm.Init(ns);
bool?result = frm.ShowDialog();
}
void btnAddImportFolder_Click(object sender, RoutedEventArgs e)
{
try
{
ImportFolder frm = new ImportFolder();
frm.Owner = GetTopParent();
frm.Init(null);
bool?result = frm.ShowDialog();
VM_ShokoServer.Instance.RefreshImportFolders();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
public void Init(ImportFolder ifldr)
{
try
{
importFldr = ifldr;
txtImportFolderLocation.Text = importFldr.ImportFolderLocation;
chkDropDestination.IsChecked = importFldr.IsDropDestination == 1;
chkDropSource.IsChecked = importFldr.IsDropSource == 1;
chkIsWatched.IsChecked = importFldr.IsWatched == 1;
txtImportFolderLocation.Focus();
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
/// <summary>Edits the selected import folder.</summary>
public void EditImportFolder()
{
if (this.SelectedImportFolder == null)
{
return;
}
ImportFolderManagerViewModel viewModel = new ImportFolderManagerViewModel(this.SelectedImportFolder);
bool? answer = this.windowManager.ShowDialog(viewModel);
if (answer.HasValue && answer.Value)
{
this.ImportFolders.Remove(this.SelectedImportFolder);
this.ImportFolders.Add(viewModel.Folder);
this.SelectedImportFolder = null;
}
this.SaveSolution();
}
/// <summary>Initialises a new instance of the <see cref="ImportFolderManagerViewModel"/> class.</summary>
/// <param name="folder">The import folder to change.</param>
public ImportFolderManagerViewModel(ImportFolder folder)
{
this.DisplayName = "Edit Import Folder";
this.Folder = folder;
}
