private void AddUploadFile(string srcPath)
{
// 除外ファイルはリストに載せない
if (UploadInfo.IsExclude(srcPath))
{
return;
}
// ベースフォルダのサブフォルダ以外はコピー対象に含めない
if (!srcPath.ToLower().Contains(BaseDir))
{
return;
}
Debug.Assert(srcPath.Length > BaseDir.Length);
TargetFiles.Add(srcPath); // フルパスのままセットする(物理パス参照したいことが多いため)
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="copyThis"></param>
public Project(Project copyThis)
: this()
{
if (copyThis == null)
{
return;
}
SourceFile = new FileReference(copyThis.SourceFile);
TargetFiles.Clear();
foreach (var item in copyThis.TargetFiles)
{
_TargetFiles.Add(item.Path, new FileReference(item));
}
}
public TargetFiles CopyFiles(SourceFiles sourceFiles, string sourceBaseFolder, string targetBaseFolder)
{
var targetFiles = new TargetFiles();
var files = new List <string>();
foreach (var copyJob in GetCopyJobs(sourceFiles, sourceBaseFolder, targetBaseFolder))
{
Directory.CreateDirectory(Path.GetDirectoryName(copyJob.Target));
File.Copy(copyJob.Source, copyJob.Target, true);
files.Add(copyJob.Target);
}
targetFiles.Files = files.ToArray();
return(targetFiles);
}
public void SetDestFiles(string myPath, string myTargetExtention)
{
Regex regex = new Regex(myTargetExtention, RegexOptions.IgnoreCase);
Regex regexEdited = new Regex("^\\[AV|^\\[裏AV|^\\[IV");
//IEnumerable<string> files = from file in Directory.GetFiles(@"\\SANDY2500\BitTorrent\JDownloader", "*", SearchOption.AllDirectories) where regex.IsMatch(file) select file;
string[] files = Directory.GetFiles(@myPath, "*", System.IO.SearchOption.TopDirectoryOnly);
if (listTargetFiles == null)
{
listTargetFiles = new List <TargetFiles>();
}
else
{
listTargetFiles.Clear();
}
foreach (var file in files)
{
if (!regex.IsMatch(file))
{
continue;
}
FileInfo fileinfo = new FileInfo(file.ToString());
if (regexEdited.IsMatch(fileinfo.Name))
{
continue;
}
TargetFiles targetfiles = new TargetFiles();
targetfiles.FileInfo = fileinfo;
targetfiles.ListUpdateDate = fileinfo.LastWriteTime;
targetfiles.FileSize = fileinfo.Length;
targetfiles.DispRelativePath = fileinfo.Directory.ToString().Replace(@BasePath + "\\", "").Replace(@BasePath, "");
targetfiles.IsSelected = false;
listTargetFiles.Add(targetfiles);
}
return;
}
public void ExecuteRarFile()
{
ExecuteRar = true;
ColViewListTargetFiles.Filter = delegate(object o)
{
TargetFiles data = o as TargetFiles;
if (!data.FileInfo.Extension.ToUpper().Equals(".RAR"))
{
return(false);
}
if (FilterListProductNumber == null || FilterListProductNumber.Count <= 0)
{
return(true);
}
string filename = data.FileInfo.Name;
foreach (string searchText in FilterListProductNumber)
{
if (filename.ToUpper().IndexOf(searchText) >= 0)
{
if (filename.IndexOf("part1.rar") >= 0)
{
string patternStr = Regex.Replace(filename, "part.[0-9]*", "*");
string[] arrFile = Directory.GetFiles(BasePath, patternStr, System.IO.SearchOption.TopDirectoryOnly);
data.FileCount = arrFile.Length;
return(true);
}
}
}
//Debug.Print(_FilterSearchProductNumber + " " + Convert.ToString(matchCount) + " " + filename);
return(false);
};
}
public void Run(IIntegrationResult result)
{
try
{
string label = GetLabel(result.Label);
foreach (string targetFileIter in TargetFiles.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries))
{
string targetFile = targetFileIter.Trim();
FileInfo fi = new FileInfo(targetFile);
StreamReader reader = new StreamReader(targetFile, System.Text.Encoding.GetEncoding(1251));
char[] buffer = new char[fi.Length];
int size = 0;
size = reader.Read(buffer, 0, buffer.Length);
string fileInMem = null;
if (0 < size)
{
fileInMem = new string(buffer, 0, size);
fileInMem = fileInMem.Replace("0.0.0.0", label);
}
reader.Close();
if (null != fileInMem)
{
FileStream fs = new FileStream(targetFile,
FileMode.Truncate, FileAccess.Write, FileShare.None);
StreamWriter writer = new StreamWriter(fs, System.Text.Encoding.GetEncoding(1251));
writer.Write(fileInMem.ToCharArray());
writer.Flush();
writer.Close();
}
}
}
catch (Exception ex)
{
throw new Exception("Failed during multiple version replace " + ex.ToString());
}
}
public EasyModeViewModel(IRegionManager regionManager)
{
runner = Service.Provider.GetService <Runner>();
_regionManager = regionManager;
BackButtonCommand = new DelegateCommand(() =>
{
_regionManager.RequestNavigate(nameof(Region.MainRegion), nameof(Home));
});
UpButtonCommand = new DelegateCommand(() =>
{
if (SelectedIndex > 0)
{
var selectedIndex = SelectedIndex;
var targetFile = TargetFiles[selectedIndex];
TargetFiles.RemoveAt(selectedIndex);
TargetFiles.Insert(selectedIndex - 1, targetFile);
}
});
DownButtonCommand = new DelegateCommand(() =>
{
if (0 <= SelectedIndex && SelectedIndex < TargetFiles.Count() - 1)
{
var selectedIndex = SelectedIndex;
var targetFile = TargetFiles[selectedIndex];
TargetFiles.RemoveAt(selectedIndex);
TargetFiles.Insert(selectedIndex + 1, targetFile);
}
});
DeleteButtonCommand = new DelegateCommand(() =>
{
if (SelectedIndex >= 0 && TargetFiles.Count() > 0)
{
TargetFiles.RemoveAt(SelectedIndex);
}
});
ClearButtonCommand = new DelegateCommand(() => TargetFiles.Clear());
}
public void SetSourceFile(DataGrid myDataGrid)
{
DateCopyService.CheckDataGridSelectItem(myDataGrid, "コピー元", 1);
SourceFile = (TargetFiles)myDataGrid.SelectedItem;
}
public void Execute(MovieImportData myImportData, MovieFileContents myFileContents)
{
string destDir = "HD-" + myFileContents.GetLastSentenceFromLabel();
string fullPath = Path.Combine(BasePath, destDir);
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
long size = 0;
string ext = "";
DateTime dt = new DateTime(1900, 1, 1);
foreach (TargetFiles data in listSelectedFiles)
{
string destFilename = Path.Combine(fullPath, myImportData.Filename + data.FileInfo.Extension);
size += data.FileInfo.Length;
ext = data.FileInfo.Extension.Substring(1);
dt = data.FileInfo.LastWriteTime;
File.Move(data.FileInfo.FullName, destFilename);
}
// JPEGなどのファイルのファイル名を変更（ファイル名を「XXX FHD」に更新する前にファイル名変更を実行）
string[] mvFiles = Directory.GetFiles(myFileContents.Label, myFileContents.Name + "*");
Debug.Print(" " + myFileContents.Label + " " + myFileContents.Name);
foreach (string pathname in mvFiles)
{
FileInfo fileinfo = new FileInfo(pathname);
string sourcePathname = pathname;
string sufix = fileinfo.Name.Replace(myFileContents.Name, "");
Debug.Print("sufix" + sufix + " pathname " + pathname);
string destPathname = Path.Combine(myFileContents.Label, myImportData.Filename + sufix.ToLower());
File.Move(sourcePathname, destPathname);
}
MovieFileContentsService service = new MovieFileContentsService();
myFileContents.Name = myImportData.Filename;
myFileContents.Size = size;
if (!myFileContents.Extension.ToUpper().Equals(ext.ToUpper()))
{
MessageBoxResult result = MessageBox.Show("既存のファイルは削除しますか？", "削除確認", MessageBoxButton.OKCancel);
if (result == MessageBoxResult.OK)
{
string[] files = Directory.GetFiles(myFileContents.Label, myFileContents.Name + "*" + myFileContents.Extension);
List <TargetFiles> delTargetList = new List <TargetFiles>();
foreach (string pathname in files)
{
TargetFiles targetFiles = new TargetFiles();
targetFiles.FileInfo = new FileInfo(pathname);
delTargetList.Add(targetFiles);
}
FilesRegisterService serviceFileRegister = new FilesRegisterService(dbcon);
serviceFileRegister.BasePath = BasePath;
serviceFileRegister.SetDbMovieFilesInfo(myImportData, null);
serviceFileRegister.DeleteFiles(delTargetList);
}
myFileContents.Extension = ext;
}
try
{
dbcon.BeginTransaction("MOVIE_REGISTER");
service.DbUpdateFileInfo(myFileContents, dbcon);
dbcon.CommitTransaction();
// MOVIE_IMPORTから削除
MovieImportService serviceImportService = new MovieImportService();
serviceImportService.DbDelete(myImportData, new MySqlDbConnection());
}
catch (Exception ex)
{
Debug.Write(ex);
dbcon.RollbackTransaction();
throw new Exception(ex.Message);
}
return;
}
public override IEnumerable <string> GetTargetFilePaths()
{
return(TargetFiles.Select(f => Collection.GetRegistryFilePath(f)));
}
public async Task <bool> StartAsync()
{
var files = TargetFiles.Select(x => x.File);
return(await runner.RunAsync(files, OutputFile, Setting));
}
public void Run()
{
// Create master thread to manage running threads
Thread t = new Thread(() =>
{
// Create local copies of databases to work with
SignatureController localSignatures = this.Signatures;
TargetProcess = Process.ProcessQueue();
bool loadProcess = false;
//MaxThreads = 1;
//MaxThreads /=2;
// While we are not canceling the whole scan...
while (!Cancel)
{
while (Pause)
{
Thread.Sleep(500);
// exit
if (Cancel == true)
{
// exit
return;
}
}
//detmine number of threads to use when scanning
if (Settings.ReducePriority)
{
this.MaxThreads = Environment.ProcessorCount / 2;
}
else
{
this.MaxThreads = Environment.ProcessorCount;
}
// If all scans have finished and there is nothing left to scan...
if (RunningThreads == 0 && TargetFiles.Count() == 0 && TargetProcess.Count() == 0)
{
// All files have been scanned... time to implement a process scanner....
// Attempt to raise event for scan complete
// Raise the event
ThreatScanComplete?.Invoke(this);
// And then exit the loop
break;
}
else if (TargetFiles.Count() == 0 && !loadProcess)
{
loadProcess = true;
// Get a queue of new process...
TargetProcess = Process.ProcessQueue();
}
else
{
// Check for existing dead threads in the thread list
//var dead = ScannerThreads.FirstOrDefault(th => th.ThreadState == ThreadState.Stopped);
// // while there are dead threads to remove...
// while (dead != null && !Cancel)
// {
// // Remove dead thread
// ScannerThreads.Remove(dead);
// // Check for more
// dead = ScannerThreads.FirstOrDefault(th => th.ThreadState == ThreadState.Stopped);
// }
if (ScannerThreads.Count > 0)
{
for (int i = 0; i < ScannerThreads.Count; i++)
{
//if(ScannerThreads[i].ThreadState == ThreadState.Stopped)
ScannerThreads[i].Join();
ScannerThreads.Remove(ScannerThreads[i]);
}
}
// Clean garbage left behind by scans...
GC.Collect();
// All target files were scanned... start a process scanning...
if (TargetFiles.Count == 0)
{
// Loop through the process queue time..
while (RunningThreads < MaxThreads && TargetProcess.Count > 0 && !Cancel)
{
// Get next process
var target = TargetProcess.Dequeue();
// Create a scanner for it..
Thread scan = new Thread(() =>
{
try
{
// Check white list against process before scanning it
if (Settings.WhiteList.Contains(NativeMethods.GetExecutablePath(target)))
{
return;
}
// Heuristically analyze file first
var heur = BerzerkAPI.IO.Heuristic.Analyze(API.NativeMethods.GetExecutablePath(target));
if (heur != null)
{
ThreatDetectedArgs args = new Controllers.ThreatDetectedArgs()
{
Detection = heur, FilePath = API.NativeMethods.GetExecutablePath(target)
};
ThreatDetected?.Invoke(this, args);
}
else
{
// create a scan of the process
Signature res = Process.ScanProcess(target, ref localSignatures);
// Scan the file and get results
//Signature result = BerzerkAPI.IO.File.ScanFile(target, ref localSignatures, ref localCache);
ScanResultArgs result = BerzerkAPI.IO.File.ScanFile(NativeMethods.GetExecutablePath(target), localSignatures);
// accumulate the total scanned data in MB
ScannedData += (result.Size / 1024) / 1024;
// Check results
if (result.Detection != null)
{
// Attempt to raise detection event
// Create event args
ThreatDetectedArgs args = new ThreatDetectedArgs()
{
Detection = result.Detection, FilePath = NativeMethods.GetExecutablePath(target)
};
// Raise event ?
ThreatDetected?.Invoke(this, args);
}
} // end of heuristic else
// Try to scan the process
//var result = BerzerkAPI.IO.Process.ScanProcess(target, ref localSignatures);
//// If a threat was found in the process
//if(result != null)
//{
// ThreatDetectedArgs args = new Controllers.ThreatDetectedArgs()
// {
// Detection = result,
// FilePath = NativeMethods.GetExecutablePath(target)
// };
// ThreatDetected?.Invoke(this, args);
//}
}
catch (Exception ex)
{
#if DEBUG
Console.WriteLine(ex.Message);
#endif
}
//ScannerThreads.Remove(Thread.CurrentThread);
});
// Add thread to list
ScannerThreads.Add(scan);
// Run thread in bg
scan.IsBackground = true;
scan.SetApartmentState(ApartmentState.MTA);
// Run the scan
scan.Start();
// scan.Join();
}
}
// Now that we have freed space in the thread list, we need to create new threads
// Loop while there is room left for more threads
// And while there are files left to scan
while (RunningThreads < MaxThreads && TargetFiles.Count > 0 && !Cancel)
{
// Get the next scannable file
string target = TargetFiles.Dequeue();
// Create new scan thrad for the next file
Thread scan = new Thread(() =>
{
try
{
// Scan the file and get results
//Signature result = BerzerkAPI.IO.File.ScanFile(target, ref localSignatures, ref localCache);
ScanResultArgs result = BerzerkAPI.IO.File.ScanFile(target, localSignatures);
// accumulate the total scanned data in MB
ScannedData += (result.Size / 1024) / 1024;
// Check results
if (result.Detection != null)
{
// Attempt to raise detection event
// Create event args
ThreatDetectedArgs args = new ThreatDetectedArgs()
{
Detection = result.Detection, FilePath = target
};
// Raise event ?
ThreatDetected?.Invoke(this, args);
}
// Sleep thread before ending it to provide some timeout for the cpu
//Thread.Sleep(20);
}
catch (Exception ex) // debugging purposes
{
// something went wrong...
#if DEBUG
Console.WriteLine(ex.Message);
#endif
}
//ScannerThreads.Remove(Thread.CurrentThread);
});
// Add thread to list
ScannerThreads.Add(scan);
// Run thread in bg
scan.IsBackground = true;
scan.SetApartmentState(ApartmentState.MTA);
// Run the scan
scan.Start();
//scan.Join();
}
}
}
});
// Set the thread to run in the bg and run it
t.IsBackground = true;
t.Start();
}
