private void Add_Click(object sender, RoutedEventArgs e)
{
ScanFile item = (ScanFile)(sender as Button).DataContext;
Scan scan = Scanner.Instance.ActiveScan;
if (scan != null && scan.ScanID == item.ScanID)
{
if (scan.GetScanStatus() == ScanStatus.Running)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.Integerity_ReaddSingleMessage,
Shoko.Commons.Properties.Resources.Integerity_ReaddSingleTitle, MessageBoxButton.OK,
MessageBoxImage.Information);
return;
}
if (scan.GetScanStatus() == ScanStatus.Finish)
{
scan.Status = (int)ScanStatus.Standby;
RepoFactory.Scan.Save(scan);
}
item.Status = (int)ScanFileStatus.Waiting;
RepoFactory.ScanFile.Save(item);
Scanner.Instance.ActiveErrorFiles.Remove(item);
Scanner.Instance.Refresh();
}
}
private void Add_Click(object sender, RoutedEventArgs e)
{
ScanFile item = (ScanFile)(sender as Button)?.DataContext;
SVR_Scan scan = Scanner.Instance.ActiveScan;
if (scan != null && item != null && scan.ScanID == item.ScanID)
{
if (scan.GetScanStatus() == ScanStatus.Running)
{
MessageBox.Show(Shoko.Commons.Properties.Resources.Integerity_ReaddSingleMessage,
Shoko.Commons.Properties.Resources.Integerity_ReaddSingleTitle, MessageBoxButton.OK,
MessageBoxImage.Information);
return;
}
if (scan.GetScanStatus() == ScanStatus.Finish)
{
using (var upd = Repo.Instance.Scan.BeginAddOrUpdate(() => scan))
{
upd.Entity.Status = (int)ScanStatus.Standby;
scan = upd.Commit();
}
}
using (var upd = Repo.Instance.ScanFile.BeginAddOrUpdate(() => item))
{
upd.Entity.Status = (int)ScanFileStatus.Waiting;
item = upd.Commit();
}
Scanner.Instance.ActiveErrorFiles.Remove(item);
Scanner.Instance.Refresh();
}
}
private void Add_Click(object sender, RoutedEventArgs e)
{
ScanFile item = (ScanFile)(sender as Button)?.DataContext;
if (item != null)
{
Scanner.Instance.ReAddErrorFile(item);
}
}
public void AddErrorScan(ScanFile file)
{
Utils.MainThreadDispatch(() =>
{
if (ActiveScan != null && ActiveScan.ScanID == file.ScanID)
{
ActiveErrorFiles.Add(file);
}
});
}
public AudioFile(ScanFile file)
{
Path = file.FullPath;
FileName = file.FileName;
FileExtension = file.FileExtension;
Name = file.Tags?.Title ?? file.FileName;
TrackNumber = file.Tags?.Track ?? 1;
AudioTags = file.Tags;
MimeType = file.MimeType;
}
public void AddErrorScan(ScanFile file)
{
Application.Current.Dispatcher.Invoke(() =>
{
if (ActiveScan != null && ActiveScan.ScanID == file.ScanID)
{
ActiveErrorFiles.Add(file);
}
});
}
public static Option <Scan> Create(ScanFile file, List <Region> regions)
{
var validationRules = new List <LazyOption>
{
Optional.Lazy(() => file != null, "Scan file cannot be empty"),
Optional.Lazy(() => regions != null, "List of regions on the scan cannot be null"),
};
return(validationRules.Reduce()
.Map(() => new Scan(file, regions)));
}
public void ReAddErrorFile(ScanFile sf)
{
ScannerInfo info = Scans.FirstOrDefault(a => a.Scan.ScanID == sf.ScanID);
if (info != null && info.ErrorFiles.Any(a => a.ScanFileID == sf.ScanFileID))
{
ScannerInfo si = Scans.First(a => a.Scan.ScanID == sf.ScanID);
SVR_VideoLocal_Place pl = Repo.Instance.VideoLocal_Place.GetByID(sf.VideoLocal_Place_ID);
if (pl != null)
{
info.ErrorFiles.Remove(sf);
Repo.Instance.ScanFile.Delete(sf);
Queue.Instance.Add(new CmdVerifyFile(pl), BatchName + si.Scan.ScanID);
}
}
}
private void BtnAddcheck_Click(object sender, RoutedEventArgs e)
{
ScanImportFolders frm = new ScanImportFolders();
frm.Owner = GetTopParent();
bool?result = frm.ShowDialog();
if (result.HasValue && result.Value)
{
this.IsEnabled = false;
Cursor = Cursors.Wait;
Scan s = frm.SelectedScan;
HashSet <int> imp = new HashSet <int>(s.GetImportFolderList());
List <SVR_VideoLocal> vl = imp.SelectMany(a => RepoFactory.VideoLocal.GetByImportFolder(a))
.Distinct()
.ToList();
List <ScanFile> files = new List <ScanFile>();
foreach (SVR_VideoLocal v in vl)
{
foreach (SVR_VideoLocal_Place p in v.Places.Where(a => imp.Contains(a.ImportFolderID)))
{
ScanFile sfile = new ScanFile();
sfile.Hash = v.ED2KHash;
sfile.FileSize = v.FileSize;
sfile.FullName = p.FullServerPath;
sfile.ScanID = s.ScanID;
sfile.Status = (int)ScanFileStatus.Waiting;
sfile.ImportFolderID = p.ImportFolderID;
sfile.VideoLocal_Place_ID = p.VideoLocal_Place_ID;
files.Add(sfile);
}
}
RepoFactory.ScanFile.Save(files);
this.IsEnabled = true;
Scanner.Instance.Scans.Add(s);
comboProvider.SelectedItem = s;
Cursor = Cursors.Arrow;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// METHODS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public async Task RenameFileAsync(string newName, NameCollisionOption collisionOption)
{
await ScanFile.RenameAsync(newName, collisionOption);
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(ScanFile)));
}
public AudioBook(ScanFile file)
{
Files = new List <AudioFile>();
Files.Add(new AudioFile(file));
AudioBookDirectoryPath = file.FullPath;
}
//This must be init before queue start
public void Init()
{
List <Scan> scans;
using (var upd = Repo.Instance.Scan.BeginBatchUpdate(Repo.Instance.Scan.GetAll))
{
foreach (Scan s in upd)
{
int cnt = Queue.Instance.GetCommandCount(BatchName + s.ScanID);
int newstatus = cnt > 0 ? (int)ScanStatus.Running : (int)ScanStatus.Finish;
if (s.Status != newstatus)
{
s.Status = newstatus;
upd.Update(s);
}
}
scans = upd.Commit();
}
Queue.Instance.Where(a => a.Batch.StartsWith(BatchName)).Subscribe((cmd) =>
{
CmdVerifyFile vf = cmd as CmdVerifyFile;
List <Expression <Func <object> > > changedProperties = new List <Expression <Func <object> > >();
if (vf != null)
{
string[] spl = vf.Batch.Split('_');
int scanid = int.Parse(spl[1]);
ScannerInfo info = Scans.First(a => a.Scan.ScanID == scanid);
if (vf.Status == CommandStatus.Finished || vf.Status == CommandStatus.Error && vf.Retries == vf.MaxRetries)
{
if (vf.ScanFileStatus != ScanFileStatus.ProcessedOK)
{
ScanFile sf = new ScanFile();
sf.FullName = vf.FullName;
sf.ScanID = scanid;
sf.CheckDate = vf.CheckDate;
sf.FileSize = vf.OriginalSize;
sf.FileSizeResult = vf.VerifiedSize;
sf.Status = (int)vf.ScanFileStatus;
sf.Hash = vf.OriginalHash;
sf.HashResult = vf.VerifiedHash;
sf.ImportFolderID = vf.ImportFolderId;
sf.VideoLocal_Place_ID = vf.VideoLocalPlaceId;
Repo.Instance.ScanFile.BeginAdd(sf).Commit();
info.ErrorFiles.Add(sf);
}
int cnt = Queue.Instance.GetCommandCount(vf.Batch) - 1; //Current command didnt finish yet (thats why 1)
if (cnt <= 0)
{
using (var upd = Repo.Instance.Scan.BeginAddOrUpdate(scanid))
{
upd.Entity.Status = (int)ScanStatus.Finish;
upd.Commit();
changedProperties.AddRange(new Expression <Func <object> >[] { () => info.CanBeCanceled, () => info.CanBeResumed, () => info.CanBePaused, () => info.CanBeStarted });
}
}
info.Count = cnt;
changedProperties.Add(() => info.Count);
}
info.State = vf.PrettyDescription.FormatMessage() + " " + ((int)vf.Progress) + " %";
changedProperties.Add(() => info.State);
info.OnPropertyChanged(changedProperties.ToArray());
}
});
Scans = new AsyncObservableCollection <ScannerInfo>(scans.Select(a => new ScannerInfo(a)));
foreach (ScannerInfo s in Scans)
{
s.ErrorFiles = new AsyncObservableCollection <ScanFile>(Repo.Instance.ScanFile.GetByScanID(s.Scan.ScanID));
}
}
private Scan(ScanFile file, List <Region> regions)
{
File = file;
_regions = regions;
}
