/// <summary>
/// Распаковка файла из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Наличие нескольких файлов и/или папок не проверяется (будет ошибка)
/// Возвращает: false, если архив 'битый' (не смог открыть).
/// </summary>
/// <param name="SourceZipFile">Путь к исходному zip-файлу</param>
/// <param name="DestinationDir">папка для распакованного фвйла</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <param name="BufferSize">буфер, обычно 4096</param>
/// <returns>true - если архив удалось распаковать; false - если не удалось распаковать</returns>
public bool UnZipFile(string SourceZipFile, string DestinationDir, int IsFileExistsMode, int BufferSize)
{
FileStream fileStreamIn = new FileStream(SourceZipFile, FileMode.Open, FileAccess.Read);
ZipInputStream zipInStream = null;
try {
zipInStream = new ZipInputStream(fileStreamIn);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipFile()."
);
return(false);
}
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
ZipEntry zipEntry = zipInStream.GetNextEntry();
string path = Path.Combine(DestinationDir, zipEntry.Name.Replace('/', '\\'));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
try {
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStreamOut = new FileStream(path, FileMode.Create, FileAccess.Write)) {
CopyStream(zipInStream, fileStreamOut, BufferSize);
zipInStream.Close();
fileStreamOut.Close();
fileStreamIn.Close();
}
if (File.Exists(path))
{
ZipFile zipFile = new ZipFile(SourceZipFile);
if (zipFile[0].IsFile)
{
File.SetCreationTime(path, File.GetCreationTime(SourceZipFile));
File.SetLastAccessTime(path, File.GetLastAccessTime(SourceZipFile));
File.SetLastWriteTime(path, File.GetLastWriteTime(SourceZipFile));
}
}
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipFile()."
);
fileStreamIn.Close();
return(false);
}
return(true);
}
/// <summary>
/// Распаковка выбранных файлов из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Возвращает: Число распакованных файлов, или -1, если архив 'битый' (не смог открыть).
/// </summary>
/// <param name="SourceZipFile">Путь к исходному zip-файлу</param>
/// <param name="FilesFromZipList">Путь к списку из string для списка распаковываемых файлов из zip</param>
/// <param name="DestinationDir">папка для распаковываемых фвйлов</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <param name="FB2Only">true - распаковка только fb2 файлов</param>
/// <param name="Password">пароль архива. Если его нет, то задаем null</param>
/// <param name="BufferSize">буфер, обычно 4096</param>
public long UnZipSelectedFiles(string SourceZipFile, ref List <string> FilesFromZipList, string DestinationDir,
int IsFileExistsMode, bool FB2Only, string Password, int BufferSize)
{
long count = 0;
bool b_fileExists = false;
try {
// на случай, если в имени файла есть нечитаемые символы
b_fileExists = File.Exists(SourceZipFile);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFiles(). Не возможно открыть архив (в имени файла есть нечитаемые символы)."
);
return(-1);
}
if (b_fileExists)
{
ZipFile zipFile = null;
try {
zipFile = new ZipFile(SourceZipFile);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFiles(). Не возможно открыть архив."
);
return(-1);
}
if (Password != null)
{
zipFile.Password = Password;
}
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
string path = string.Empty;
string dir = string.Empty;
foreach (string file in FilesFromZipList)
{
int fileExists = zipFile.FindEntry(file, false);
if (fileExists != -1)
{
if (zipFile[fileExists].IsFile)
{
try {
if (FB2Only && Path.GetExtension(zipFile[fileExists].Name.ToLower()) != ".fb2")
{
continue;
}
} catch (ArgumentException ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFiles(). Исключение ArgumentException."
);
continue;
}
Stream inputStream = zipFile.GetInputStream(zipFile[fileExists]);
path = Path.Combine(DestinationDir, file.Replace('/', '\\'));
dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
try {
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
CopyStream(inputStream, fileStream, BufferSize);
fileStream.Close();
inputStream.Close();
}
if (File.Exists(path))
{
DateTime dtFile = zipFile[fileExists].DateTime;
File.SetCreationTime(path, dtFile);
File.SetLastAccessTime(path, dtFile);
File.SetLastWriteTime(path, dtFile);
}
++count;
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFiles(). Не возможно открыть архив (скорее всего в имени файла есть нечитаемые символы). Исключение Exception."
);
inputStream.Close();
}
}
}
}
zipFile.Close();
}
return(count);
}
/// <summary>
/// Распаковка файла из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Возвращает: false, если архив 'битый' (не смог открыть).
/// </summary>
/// <param name="SourceZipFile">Путь к исходному zip-файлу</param>
/// <param name="FileFromZip">Файл для распаковки</param>
/// <param name="DestinationDir">папка для распаковываемого фвйла</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <param name="Password">пароль архива. Если его нет, то задаем null</param>
/// <param name="BufferSize">буфер, обычно 4096</param>
public bool UnZipSelectedFile(string SourceZipFile, string FileFromZip, string DestinationDir,
int IsFileExistsMode, string Password, int BufferSize)
{
bool b_fileExists = false;
try {
// на случай, если в имени файла есть нечитаемые символы
b_fileExists = File.Exists(SourceZipFile);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFile(). Не возможно открыть архив (в имени файла есть нечитаемые символы)."
);
return(false);
}
if (b_fileExists)
{
ZipFile zipFile = null;
try {
zipFile = new ZipFile(SourceZipFile);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFile(). Не возможно открыть архив."
);
return(false);
}
if (Password != null)
{
zipFile.Password = Password;
}
string path = string.Empty;
int fileExists = zipFile.FindEntry(FileFromZip, false);
if (fileExists != -1)
{
if (zipFile[fileExists].IsFile)
{
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
Stream inputStream = zipFile.GetInputStream(zipFile[fileExists]);
path = Path.Combine(DestinationDir, FileFromZip.Replace('/', '\\'));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
try {
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
CopyStream(inputStream, fileStream, BufferSize);
fileStream.Close();
inputStream.Close();
}
if (File.Exists(path))
{
DateTime dtFile = zipFile[fileExists].DateTime;
File.SetCreationTime(path, dtFile);
File.SetLastAccessTime(path, dtFile);
File.SetLastWriteTime(path, dtFile);
}
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipSelectedFile(). Не возможно открыть архив (скорее всего в имени файла есть нечитаемые символы)."
);
inputStream.Close();
}
}
}
zipFile.Close();
return(true);
}
return(false);
}
/// <summary>
/// Распаковка только fb2 файлов из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Не воспринимает символы « и » в имени архива - вылетает
/// </summary>
/// <param name="SourceZipPath">Путь к исходному zip-файлу</param>
/// <param name="DestinationDir">Папка для распаковываемых фвйлов</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <returns>Число распакованных файлов, или -1, если архив 'битый' (не смог открыть)</returns>
public long UnZipFB2Files(string SourceZipPath, string DestinationDir, int IsFileExistsMode = 1)
{
long count = 0;
bool fileExists = false;
try {
// на случай, если в имени файла есть нечитаемые символы
fileExists = File.Exists(SourceZipPath);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipPath, ex, "SharpZipLibWorker.UnZipFiles(). Не возможно открыть архив (в имени файла есть нечитаемые символы)."
);
return(-1);
}
if (fileExists)
{
ZipFile zipFile = null;
try {
zipFile = new ZipFile(SourceZipPath);
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipPath, ex, "SharpZipLibWorker.UnZipFiles(). Не возможно открыть архив."
);
return(-1);
}
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
ZipConstants.DefaultCodePage = 866; // Для кирилических наваний файлов
for (int i = 0; i != zipFile.Count; ++i)
{
if (zipFile[i] != null)
{
if (zipFile[i].IsFile)
{
// только корректные символы для имен файлов
string zipFileName = StringProcessing.OnlyCorrectSymbolsForString(
zipFile[i].Name.Replace('<', '«').Replace('>', '»').Replace(':', '_')
);
try {
if (Path.GetExtension(zipFileName.ToLower()) != ".fb2")
{
continue;
}
} catch (ArgumentException ex) {
Debug.DebugMessage(
SourceZipPath, ex, "SharpZipLibWorker.UnZipFiles(). Исключение ArgumentException."
);
continue;
}
try {
Stream inputStream = zipFile.GetInputStream(zipFile[i]);
string path = Path.Combine(DestinationDir, zipFileName.Replace('/', '\\'));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
//using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
// inputStream.CopyTo(fileStream);
// inputStream.Close();
// fileStream.Close();
//}
//if (File.Exists(path)) {
// DateTime dtFile = zipFile[i].DateTime;
// File.SetCreationTime(path, dtFile);
// File.SetLastAccessTime(path, dtFile);
// File.SetLastWriteTime(path, dtFile);
//}
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
CopyStream(inputStream, fileStream, 4096);
fileStream.Close();
inputStream.Close();
}
if (File.Exists(path))
{
DateTime dtFile = zipFile[i].DateTime;
File.SetCreationTime(path, dtFile);
File.SetLastAccessTime(path, dtFile);
File.SetLastWriteTime(path, dtFile);
}
++count;
}
catch (Exception ex) {
Debug.DebugMessage(
SourceZipPath, ex, "SharpZipLibWorker.UnZipFiles(). Исключение Exception."
);
//inputStream.Close();
}
}
}
}
zipFile.Close();
}
return(count);
}
/// <summary>
/// Распаковка файла из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Не воспринимает символы « и » в имени архива - вылетает
/// </summary>
/// <param name="SourceZipFile">Путь к исходному zip-файлу</param>
/// <param name="DestinationDir">папка для распаковываемых фвйлов</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <param name="FB2Only">true - распаковка только fb2 файлов</param>
/// <param name="Password">пароль архива. Если его нет, то задаем null</param>
/// <param name="BufferSize">буфер, обычно 4096</param>
/// <returns>Число распакованных файлов, или -1, если архив 'битый' (не смог открыть)</returns>
public long UnZipFiles(string SourceZipFile, string DestinationDir,
int IsFileExistsMode, bool FB2Only, string Password, int BufferSize)
{
long count = 0;
if (File.Exists(SourceZipFile))
{
ZipFile zipFile = null;
try {
zipFile = new ZipFile(SourceZipFile);
} catch {
return(-1);
}
if (Password != null)
{
zipFile.Password = Password;
}
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
for (int i = 0; i != zipFile.Count; ++i)
{
if (zipFile[i] != null)
{
if (zipFile[i].IsFile)
{
string zipFileName = zipFile[i].Name.Replace('<', '«').Replace('>', '»').Replace(':', '_');
try {
if (FB2Only && Path.GetExtension(zipFileName.ToLower()) != ".fb2")
{
continue;
}
} catch (ArgumentException ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipFiles(). Исключение ArgumentException."
);
continue;
}
Stream inputStream = zipFile.GetInputStream(zipFile[i]);
string path = Path.Combine(DestinationDir, zipFileName.Replace('/', '\\'));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
try {
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
CopyStream(inputStream, fileStream, BufferSize);
fileStream.Close();
inputStream.Close();
}
if (File.Exists(path))
{
DateTime dtFile = zipFile[i].DateTime;
File.SetCreationTime(path, dtFile);
File.SetLastAccessTime(path, dtFile);
File.SetLastWriteTime(path, dtFile);
}
++count;
} catch (Exception ex) {
Debug.DebugMessage(
SourceZipFile, ex, "SharpZipLibWorker.UnZipFiles(). Исключение Exception."
);
inputStream.Close();
}
}
}
}
zipFile.Close();
}
return(count);
}
// =============================================================================================
// Реализация Copy/Move/Delete помеченных книг
// =============================================================================================
#region еализация Copy/Move/Delete помеченных книг
// копировать или переместить файлы в...
public void CopyOrMoveCheckedFilesTo(ref BackgroundWorker bw, ref DoWorkEventArgs e,
bool IsCopy, string SourceDir, string TargetDir,
ListView lvResult, int nFileExistMode)
{
int i = 0;
ListView.CheckedListViewItemCollection checkedItems = lvResult.CheckedItems;
foreach (ListViewItem lvi in checkedItems)
{
// Проверить флаг на остановку процесса
if ((bw.CancellationPending))
{
e.Cancel = true; // Выставить окончание - по отмене, сработает событие bwcmd_RunWorkerCompleted
return;
}
else
{
string FilePath = Path.Combine(SourceDir, lvi.Text);
// есть ли такая книга на диске? Если нет - то смотрим следующую
if (File.Exists(FilePath))
{
string NewPath = Path.Combine(TargetDir, Path.GetFileName(FilePath));
FileInfo fi = new FileInfo(NewPath);
if (!fi.Directory.Exists)
{
Directory.CreateDirectory(fi.Directory.ToString());
}
if (File.Exists(NewPath))
{
if (nFileExistMode == 0)
{
File.Delete(NewPath);
}
else
{
NewPath = FilesWorker.createFilePathWithSufix(NewPath, nFileExistMode);
}
}
if (IsCopy)
{
File.Copy(FilePath, NewPath);
}
else
{
File.Move(FilePath, NewPath);
if (!m_Fast)
{
lvResult.Items.Remove(lvi);
}
else
{
// пометка цветом и зачеркиванием удаленных книг с диска, но не из списка (быстрый режим удаления)
WorksWithBooks.markRemoverFileInCopyesList(lvi);
}
}
m_bFilesWorked |= true;
bw.ReportProgress(++i);
}
}
}
}
/// <summary>
/// Распаковка только fb2 файлов из zip архива: с учетом вложенных папок, относительно исходной, и наличия копий в папке распаковки
/// Не воспринимает символы « и » в имени архива - вылетает
/// </summary>
/// <param name="SourceZipPath">Путь к исходному zip-файлу</param>
/// <param name="DestinationDir">Папка для распаковываемых фвйлов</param>
/// <param name="IsFileExistsMode">Режим для суффикса: 0 - замена; 1 - новый номер; 2 - дата</param>
/// <returns>Число распакованных файлов, или -1, если архив 'битый' (не смог открыть)</returns>
public long UnZipFB2Files(string SourceZipPath, string DestinationDir, int IsFileExistsMode = 1)
{
long count = 0;
bool fileExists = false;
try {
// на случай, если в имени файла есть нечитаемые символы
fileExists = File.Exists(SourceZipPath);
} catch {
return(-1);
}
if (fileExists)
{
ZipFile zipFile = null;
try {
zipFile = new ZipFile(SourceZipPath);
} catch {
return(-1);
}
if (!Directory.Exists(DestinationDir))
{
Directory.CreateDirectory(DestinationDir);
}
for (int i = 0; i != zipFile.Count; ++i)
{
if (zipFile[i] != null)
{
if (zipFile[i].IsFile)
{
string zipFileName = zipFile[i].Name.Replace('<', '«').Replace('>', '»').Replace(':', '_');
try {
if (Path.GetExtension(zipFileName.ToLower()) != ".fb2")
{
continue;
}
} catch (ArgumentException) {
continue;
}
Stream inputStream = zipFile.GetInputStream(zipFile[i]);
string path = Path.Combine(DestinationDir, zipFileName.Replace('/', '\\'));
string dir = Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
if (File.Exists(path))
{
path = FilesWorker.createFilePathWithSufix(path, IsFileExistsMode);
}
try {
// на случай, если в имени файла есть нечитаемые символы
using (FileStream fileStream = new FileStream(path, FileMode.Create)) {
CopyStream(inputStream, fileStream, 4096);
fileStream.Close();
inputStream.Close();
}
if (File.Exists(path))
{
DateTime dtFile = zipFile[i].DateTime;
File.SetCreationTime(path, dtFile);
File.SetLastAccessTime(path, dtFile);
File.SetLastWriteTime(path, dtFile);
}
++count;
} catch {
inputStream.Close();
}
}
}
}
zipFile.Close();
}
return(count);
}
