// сохранение выделенных обложек на диск
public static void saveSelectedCovers(ListView listView, ref string DirForSavedCover,
string MessageTitle, FolderBrowserDialog fbdSaveDir)
{
if (listView.Items.Count > 0 && listView.SelectedItems.Count > 0)
{
string TempDesc = fbdSaveDir.Description;
string TargetDir = FilesWorker.OpenDirDlg(DirForSavedCover, fbdSaveDir, "Укажите папку-приемник для сохранения выбранных обложек:");
fbdSaveDir.Description = TempDesc;
DirForSavedCover = TargetDir;
if (TargetDir == null)
{
return;
}
string NotSavedCovers = string.Empty;
foreach (ListViewItem Item in listView.SelectedItems)
{
Image image = ImageWorker.base64ToImage(Item.Tag.ToString());
try {
image.Save(Path.Combine(TargetDir, Item.Text.Trim()));
} catch (System.Exception /*e*/) {
NotSavedCovers += Item.Text.Trim() + "\n";
}
}
if (!string.IsNullOrEmpty(NotSavedCovers))
{
MessageBox.Show(
"Следующие обложки не удалось сохранить корректно (битые):\n" + NotSavedCovers, MessageTitle, MessageBoxButtons.OK, MessageBoxIcon.Warning
);
}
}
}
/// <summary>
/// Распаковка 1-го файла из zip архива ZipPath
/// Возвращает: Строку string с данными распакованного файла, если была распаковка. Иначе - пустую строку
/// </summary>
/// <param name="ZipPath">Путь к исходному zip-файлу</param>
public string UnZipFB2FileToString(string ZipPath)
{
if (FilesWorker.isFB2Archive(ZipPath))
{
MemoryStream ms = new MemoryStream();
ICSharpCode.SharpZipLib.Zip.ZipInputStream zis = new ICSharpCode.SharpZipLib.Zip.ZipInputStream(
new FileStream(ZipPath, FileMode.Open)
);
if (zis.GetNextEntry() != null)
{
int size = 2048;
byte[] data = new byte[2048];
while (true)
{
size = zis.Read(data, 0, data.Length);
if (size > 0)
{
ms.Write(data, 0, size);
}
else
{
break;
}
}
byte[] bdata = ms.ToArray();
return(Encoding.GetEncoding(getEncoding(bdata)).GetString(bdata));
}
}
return(string.Empty);
}
/// <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);
}
void BtnTempDirPathClick(object sender, EventArgs e)
{
// указание пути к временной папке
string TempDir = FilesWorker.OpenDirDlg(tboxTempDirPath.Text, fbdDir, "Укажите путь к временной папке:");
if (!string.IsNullOrWhiteSpace(TempDir))
{
tboxTempDirPath.Text = TempDir;
}
}
/// <summary>
/// Валидация fb2, fb2.zip ли fbz файлов по пути FilePath
/// </summary>
/// <returns>Пустая строка, файл валиден; Строка с сообщением, если файл невалиден</returns>
public string ValidatingFB2File(string FilePath)
{
bool IsZip = false;
string Result = validate(FilePath, Settings.Settings.SchemePath, ref IsZip);
if (IsZip) // удаляем временные файлы только, если проверяли архив
{
FilesWorker.RemoveDir(_TempDir);
}
return(Result);
}
// Создание итемов ListView названий Обложек
public static int makeListViewCoverNameItems(ListView lv, ref IList <BinaryBase64> Covers)
{
int ImageCount = 0;
if (Covers != null && Covers.Count > 0)
{
string Temp = Settings.Settings.TempDirPath;
if (!Directory.Exists(Temp))
{
Directory.CreateDirectory(Temp);
}
foreach (BinaryBase64 Cover in Covers)
{
if (Cover != null)
{
ListViewItem lvi = new ListViewItem(Cover.id);
lvi.SubItems.Add(Cover.contentType);
Image image = null;
try {
image = ImageWorker.base64ToImage(Cover.base64String);
} catch (Exception /*exp*/) {
continue;
}
lvi.SubItems.Add(string.Format("{0} x {1} dpi", image.VerticalResolution, image.HorizontalResolution));
lvi.SubItems.Add(string.Format("{0} x {1} Pixels", image.Width, image.Height));
// string Type = Cover.contentType.Substring( Cover.contentType.IndexOf( '/' ) + 1 );
string TempFile = Path.Combine(Temp, string.Format("__temp_image__{0}", Cover.id));
try {
image.Save(TempFile);
FileInfo file = new FileInfo(TempFile);
lvi.SubItems.Add(FilesWorker.FormatFileLength(file.Length));
if (File.Exists(TempFile))
{
File.Delete(TempFile);
}
} catch (System.Exception /*exp*/) {
lvi.SubItems.Add("? kb");
}
lvi.Tag = Cover.base64String;
lv.Items.Add(lvi);
++ImageCount;
}
}
}
return(ImageCount);
}
/// <summary>
/// Распаковка zip архива в Temp папку и получение пути к распакованному файлу
/// </summary>
/// <param name="SourceZipFBZPath">Путь к исходному zip или fbz-файлу</param>
/// <param name="TempDir">Временный каталог для распаковки архива</param>
/// <returns>Путь к распакованному fb2 файлу из архива; null, если файл не является zip или fbz архивом, или не читается</returns>
public static string getFileFromZipFBZ(string SourceZipFBZPath, string TempDir)
{
if (File.Exists(SourceZipFBZPath))
{
if (!Directory.Exists(TempDir))
{
Directory.CreateDirectory(TempDir);
}
if (FilesWorker.isFB2Archive(SourceZipFBZPath))
{
return((m_sharpZipLib.UnZipFB2Files(SourceZipFBZPath, TempDir) > 0)
? Directory.GetFiles(TempDir)[0] : null);
}
}
return(null);
}
/// <summary>
/// Сравнение 2-х файлов: fb2, fb2 из zip или fb2 из fbz
/// </summary>
/// <param name="DiffPath">Путь к diff-программе сравнения fb2 файла</param>
/// <param name="FB2File1Path">Путь к 1-му исходному fb2, zip или fbz-файлу</param>
/// <param name="FB2File2Path">Путь ко 2-му исходному fb2, zip или fbz-файлу</param>
/// <param name="TempDirForFile1">Путь к временной папке для 1-го распакованного fb2 файла </param>
/// <param name="TempDirForFile2">Путь к временной папке для 2-го распакованного fb2 файла </param>
public static void DiffFB2(string DiffPath, string FB2File1Path, string FB2File2Path, string TempDirForFile1, string TempDirForFile2)
{
Cursor.Current = Cursors.WaitCursor;
string TempFile1Path = null;
string TempFile2Path = null;
// создание путей (или распаковка) к исходным fb2 файлам, участвующим в сравнении
if (FilesWorker.isFB2File(FB2File1Path))
{
TempFile1Path = FB2File1Path;
}
else if (FilesWorker.isFB2Archive(FB2File1Path))
{
TempFile1Path = getFileFromZipFBZ(FB2File1Path, TempDirForFile1);
}
if (FilesWorker.isFB2File(FB2File2Path))
{
TempFile2Path = FB2File2Path;
}
else if (FilesWorker.isFB2Archive(FB2File2Path))
{
TempFile2Path = getFileFromZipFBZ(FB2File2Path, TempDirForFile2);
}
// Сравнение файлов
if (!string.IsNullOrWhiteSpace(TempFile1Path) && !string.IsNullOrWhiteSpace(TempFile2Path))
{
FilesWorker.StartDiff(true, DiffPath, TempFile1Path, TempFile2Path);
}
// завершенн работы (перепаковка файла(ов), если он(они) были извлечены из архива)
if (FilesWorker.isFB2Archive(FB2File1Path) && !string.IsNullOrWhiteSpace(TempFile1Path))
{
WorksWithBooks.zipMoveTempFB2FileTo(m_sharpZipLib, TempFile1Path, FB2File1Path);
}
if (FilesWorker.isFB2Archive(FB2File2Path) && !string.IsNullOrWhiteSpace(TempFile2Path))
{
WorksWithBooks.zipMoveTempFB2FileTo(m_sharpZipLib, TempFile2Path, FB2File2Path);
}
// удаление временных файлов, если они есть
FilesWorker.RemoveDir(TempDirForFile1);
FilesWorker.RemoveDir(TempDirForFile2);
Cursor.Current = Cursors.Default;
}
/// <summary>
/// Правка fb2 и перепаковка fb2 из zip, fbz
/// </summary>
/// <param name="SourceFilePath">Путь к исходному fb2, zip или fbz-файлу</param>
/// <param name="FB2ProgramPath">Путь к программе правки fb2 файла</param>
public static void StartFB2_FBZForEdit(string SourceFilePath, string FB2ProgramPath)
{
Cursor.Current = Cursors.WaitCursor;
if (FilesWorker.isFB2Archive(SourceFilePath))
{
string TempFileFromZipPath = getFileFromZipFBZ(SourceFilePath, m_TempDir);
if (!string.IsNullOrWhiteSpace(TempFileFromZipPath))
{
FilesWorker.StartFile(true, FB2ProgramPath, TempFileFromZipPath);
WorksWithBooks.zipMoveTempFB2FileTo(m_sharpZipLib, TempFileFromZipPath, SourceFilePath);
FilesWorker.RemoveDir(m_TempDir);
}
}
else
{
FilesWorker.StartFile(true, FB2ProgramPath, SourceFilePath);
}
Cursor.Current = Cursors.Default;
}
/// <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);
}
/// <summary>
/// Валидация fb2, fb2.zip ли fbz файлов по пути FilePath, согласно схеме SchemePath
/// </summary>
/// <returns>Пустая строка, файл валиден; Строка с сообщением, если файл невалиден</returns>
private string validate(string FilePath, string SchemePath, ref bool IsZip)
{
string [] files = null;
if (FilesWorker.isFB2Archive(FilePath))
{
IsZip = true;
_sharpZipLib.UnZipFB2Files(FilePath, _TempDir);
files = Directory.GetFiles(_TempDir);
}
string FB2Path = (files != null && files.Length > 0) ? files[0] : FilePath;
XmlDocument xmlDoc = new XmlDocument();
try {
xmlDoc.Load(FB2Path);
// Проверка наличия атрибутов корневого тега <FictionBook
int FictionBookTagIndex = xmlDoc.InnerXml.IndexOf("<FictionBook", StringComparison.CurrentCulture);
if (FictionBookTagIndex != -1)
{
Regex regex = new Regex("<FictionBook [^>]+>", RegexOptions.None);
Match m = regex.Match(xmlDoc.InnerXml);
if (m.Success)
{
string FBookTag = m.Value;
int xmlnsIndex = FBookTag.IndexOf("xmlns=\"http://www.gribuser.ru/xml/fictionbook/2.", StringComparison.CurrentCulture);
int xmlnsLinkIndex = FBookTag.IndexOf("=\"http://www.w3.org/1999/xlink\"", StringComparison.CurrentCulture);
if (xmlnsIndex == -1)
{
return("Файл: " + FilePath + "\r\nВ корневом теге <FictionBook отсутствует атрибут xmlns=\"http://www.gribuser.ru/xml/fictionbook/2.0\"");
}
if (xmlnsLinkIndex == -1)
{
return("Файл: " + FilePath + "\r\nВ корневом теге <FictionBook отсутствует атрибут xmlns:l=\"http://www.w3.org/1999/xlink\"");
}
}
}
// Проверка обязательных тегов
string TI = string.Empty;
string DI = string.Empty;
try {
Regex regDesc = new Regex(@"<description>\s*?.+?\s*?</description>", RegexOptions.Multiline | RegexOptions.Singleline);
Match mDesc = regDesc.Match(xmlDoc.InnerXml);
if (mDesc.Success)
{
string Desc = mDesc.Value;
Regex regTitleInfo = new Regex(@"<title-info>\s*?.+?\s*?</title-info>", RegexOptions.Multiline | RegexOptions.Singleline);
Match mTI = regTitleInfo.Match(Desc);
if (mTI.Success)
{
TI = mTI.Value;
}
Regex regDocumentInfo = new Regex(@"<document-info>\s*?.+?\s*?</document-info>", RegexOptions.Multiline | RegexOptions.Singleline);
Match mDI = regDocumentInfo.Match(Desc);
if (mDI.Success)
{
DI = mDI.Value;
}
}
else
{
regDesc = new Regex("(?:<description[^/]+?(?:\"[^\"]*\"|'[^']*')?>)", RegexOptions.Multiline | RegexOptions.Singleline);
mDesc = regDesc.Match(xmlDoc.InnerXml);
return(mDesc.Success ?
string.Format("Файл: {0}\r\nВ теге <description> присутствует(ет) аттрибут(ы), что недопустимо по стандарту FictionBook", FilePath)
:
string.Format("Файл: {0}\r\nОтсутствует раздел описания книги <description>", FilePath));
}
} catch (RegexMatchTimeoutException /*ex*/) {}
catch (Exception ex) {
if (Settings.Settings.ShowDebugMessage)
{
// Показывать сообщения об ошибках при падении работы алгоритмов
MessageBox.Show(
string.Format("Ошибка алгоритмя Валидации:\r\n{0}", ex.Message), _MessageTitle, MessageBoxButtons.OK, MessageBoxIcon.Error
);
}
}
if (!string.IsNullOrEmpty(TI))
{
// Проверка <genre>
if (TI.IndexOf("<genre", StringComparison.CurrentCulture) == -1)
{
return(string.Format("Файл: {0}\r\nОтсутствует тег <genre> книги", FilePath));
}
else
{
Regex regGenre = new Regex(@"(<genre ?/>)|(<genre></genre>)", RegexOptions.None);
Match mGenre = regGenre.Match(TI);
if (mGenre.Success)
{
return(string.Format("Файл: {0}\r\nТег <genre> книги 'пустой'", FilePath));
}
}
// Проверка <lang>
if (TI.IndexOf("<lang", StringComparison.CurrentCulture) == -1)
{
return(string.Format("Файл: {0}\r\nОтсутствует тег <lang> книги", FilePath));
}
else
{
Regex regLang = new Regex(@"(<lang ?/>)|(<lang></lang>)", RegexOptions.None);
Match mLang = regLang.Match(TI);
if (mLang.Success)
{
return(string.Format("Файл: {0}\r\nТег <lang> книги 'пустой'", FilePath));
}
else
{
regLang = new Regex(@"(?<=<lang>)[^<]+(?=</lang>)", RegexOptions.None);
mLang = regLang.Match(TI);
if (mLang.Success)
{
if (mLang.Value.Length > 2)
{
return(string.Format("Файл: {0}\r\nТег Название языка книги (тег <lang>) не может быть более 2 символов.\r\nЗначение тега <lang>: '{1}'", FilePath, mLang.Value));
}
}
}
}
// Проверка <author>
if (TI.IndexOf("<author", StringComparison.CurrentCulture) == -1)
{
return(string.Format("Файл: {0}\r\nОтсутствует тег <author> Автора книги", FilePath));
}
else
{
Regex regAuthor = new Regex(@"(<author ?/>)|(<author></author>)", RegexOptions.None);
Match mAuthor = regAuthor.Match(TI);
if (mAuthor.Success)
{
return(string.Format("Файл: {0}\r\nТег <author> Автора книги 'пустой'", FilePath));
}
}
// Проверка <book-title>
if (TI.IndexOf("<book-title", StringComparison.CurrentCulture) == -1)
{
return(string.Format("Файл: {0}\r\nОтсутствует тег <book-title> Названия книги", FilePath));
}
else
{
Regex regBT = new Regex(@"(<book-title ?/>)|(<book-title></book-title>)", RegexOptions.None);
Match mBT = regBT.Match(TI);
if (mBT.Success)
{
return(string.Format("Файл: {0}\r\nТег <book-title> Названия книги 'пустой'", FilePath));
}
}
}
else
{
return(string.Format("Файл: {0}\r\nОтсутствует раздел описания книги <title-info>", FilePath));
}
if (!string.IsNullOrEmpty(DI))
{
// Проверка id книги
if (DI.IndexOf("<id", StringComparison.CurrentCulture) == -1)
{
return("Файл: " + FilePath + "\r\nОтсутствует идентификатор книги тег <id>");
}
else
{
Regex regID = new Regex(@"(<id ?/>)|(<id></id>)", RegexOptions.None);
Match mID = regID.Match(DI);
if (mID.Success)
{
return(string.Format("Файл: {0}\r\nИдентификатор книги тег <id> 'пустой'", FilePath));
}
}
}
else
{
return(string.Format("Файл: {0}\r\nОтсутствует раздел описания книги <document-info>", FilePath));
}
} catch (System.Exception e) {
return(string.Format("{0}\r\n\r\nФайл: {1}", e.Message, FilePath));
}
Cursor.Current = Cursors.WaitCursor;
string fb2FileNamespaceURI = xmlDoc.DocumentElement.NamespaceURI;
using (Stream xmlSchemeFile = new FileStream(SchemePath, FileMode.Open)) {
XmlSchemaSet sc = new XmlSchemaSet();
try {
if (fb2FileNamespaceURI.Equals(_aFB21Namespace))
{
sc.Add(_aFB21Namespace, XmlReader.Create(xmlSchemeFile));
}
else
{
sc.Add(_aFB20Namespace, XmlReader.Create(xmlSchemeFile));
}
} catch (System.Xml.Schema.XmlSchemaException e) {
return(string.Format("Файл: {0}\r\n{1}\r\nСтрока: {2}; Позиция: {3}", FilePath, e.Message, e.LineNumber, e.LinePosition));
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = sc;
XmlReader reader = XmlReader.Create(FB2Path, settings);
try {
while (reader.Read())
{
;
}
reader.Close();
Cursor.Current = Cursors.Default;
return(string.Empty);
} catch (System.Xml.Schema.XmlSchemaException e) {
reader.Close();
Cursor.Current = Cursors.Default;
return(string.Format("Файл: {0}\r\n{1}\r\nСтрока: {2}; Позиция: {3}", FilePath, e.Message, e.LineNumber, e.LinePosition));
} catch (System.Exception e) {
reader.Close();
Cursor.Current = Cursors.Default;
return(string.Format("Файл: {0}\r\n{1}", FilePath, e.Message));
}
}
}
// =============================================================================================
// Реализация 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);
}
