public async Task <IActionResult> OnPost(IFormFileCollection uploadedFiles, string archiveType)
{
if (uploadedFiles != null)
{
ArchiveSettings settings = new ArchiveSettings(archiveType);
IArchivator archivator = ArchivatorFactory.CreateArchivator(settings);
if (archivator != null)
{
try
{
string archivePath = await archivator.CompressToFile(uploadedFiles, _appEnvironment.WebRootPath);
return(PhysicalFile(archivePath, "application/" + Path.GetExtension(archivePath), Path.GetFileName(archivePath)));
}
catch (Exception e)
{
return(Content(e.Message));
}
}
else
{
return(Content("Error: Cannot create an archivator"));
}
}
return(RedirectToAction("Index"));
}
public void Archivator_Compress_Test()
{
string testStr = "It's test string";
string sourceFile = AppDomain.CurrentDomain.BaseDirectory + "test.txt";
string destinationFile = AppDomain.CurrentDomain.BaseDirectory + "test.gz";
if (File.Exists(sourceFile))
{
File.Delete(sourceFile);
}
if (File.Exists(destinationFile))
{
File.Delete(destinationFile);
}
File.WriteAllText(sourceFile, testStr);
using (IManager manager = new Manager(sourceFile, destinationFile, Operations.Compress))
{
_archivator = new Archivator(manager);
_archivator.Perform();
}
Assert.IsTrue(File.Exists(destinationFile));
Assert.IsTrue(File.ReadAllBytes(destinationFile).Length > 0);
File.Delete(sourceFile);
File.Delete(destinationFile);
}
public ConsoleFacade(IArchivator archivator, IWriter <string> writer, IReader <string> reader,
string inputPath, string outputPath, string resultPath)
{
_archivator = archivator;
_writer = writer;
_reader = reader;
_inputPath = inputPath;
_outputPath = outputPath;
_resultPath = resultPath;
}
public GZip(string input, string output, IReader fileReader, IWriter fileWriter, IArchivator archivator, IPerfomanceCounter perfomance)
{
sourceFile = input;
destinationFile = output;
_fileReader = fileReader;
_queueReader = _fileReader.GetQueue();
_readerEvent = _fileReader.GetResetEvent();
_fileWriter = fileWriter;
_queueWriter = _fileWriter.GetQueue();
_writerEvent = _fileWriter.GetResetEvent();
_archivator = archivator;
_perfomance = perfomance;
}
static void Main(string[] args)
{
List <string> errors = new List <string>();
Operations operation = args.Length > 0 ? _operationParser.Parse(args[0]) : Operations.Nothing;
if (operation == Operations.Nothing)
{
errors.Add("Nothing to do");
}
string inPath = args.Length > 1 ? args[1] : string.Empty;
string outPath = args.Length > 2 ? args[2] : string.Empty;
string pathValidationResult = _pathValidator.Validate(inPath);
if (pathValidationResult != null)
{
errors.Add($"{inPath} - {pathValidationResult}");
}
if (outPath == null)
{
errors.Add($"{outPath} - is empty");
}
if (errors.Any())
{
Console.WriteLine(string.Join("\\n", errors));
Console.ReadKey();
}
else
{
string result;
IArchivator archivator = null;
try
{
using (IManager manager = new Manager(inPath, outPath, operation))
{
archivator = new Archivator(manager);
result = archivator.Perform();
}
}
catch {
result = Responses.NOT_SUCCESS;
}
Console.WriteLine(result);
Console.ReadKey();
}
}
private void btnSave_Click(object sender, EventArgs e)
{
if (saveFileDialog.ShowDialog() == DialogResult.Cancel)
{
return;
}
ISerializer serializer = (ISerializer)Activator.CreateInstance((Type)comboBoxType.SelectedValue);
using (FileStream fs = new FileStream(saveFileDialog.FileName, FileMode.OpenOrCreate))
{
serializer.Serialize(GetUserCreatedObjs(), fs);
}
IArchivator archivator = (IArchivator)Activator.CreateInstance(comboBoxPlugin.SelectedValue.GetType());
archivator.Compress(new FileInfo(saveFileDialog.FileName));
}
static int Main(string[] args)
{
Console.WriteLine(Help());
try
{
args = Console.ReadLine().Split(' ');
ArgsValidation(args);
var discName = new string(args[2].Take(2).ToArray());
switch (args[0].ToLower())
{
case "compress":
reader = new FileReader();
writer = new FileWriter();
archivator = new Compressor(reader.GetQueue(), writer.GetQueue());
perfomance = new DiscPerfomanceCounter(discName);
zipper = new WorkManager(args[1], args[2], reader, writer, archivator, perfomance);
break;
case "decompress":
reader = new GZipReader();
writer = new GZipWriter();
archivator = new Decompressor(reader.GetQueue(), writer.GetQueue());
perfomance = new DiscPerfomanceCounter(discName);
zipper = new WorkManager(args[1], args[2], reader, writer, archivator, perfomance);
break;
}
reader.Reading += Progress;
zipper.Launch();
Console.ReadKey();
return(zipper.CallBackResult());
}
catch (Exception ex)
{
Console.WriteLine("Обнаружена ошибка!\n Метод: {0}\n Описание ошибки {1}", ex.TargetSite, ex.Message);
Console.ReadKey();
return(0);
}
}
public void Archivator_Decompress_Test()
{
string testStr = "It's test string";
string sourceFile = AppDomain.CurrentDomain.BaseDirectory + "original.txt";
string destinationFile = AppDomain.CurrentDomain.BaseDirectory + "original.zip";
string compressedFile = destinationFile;
string decompressedSourceFile = AppDomain.CurrentDomain.BaseDirectory + "decompress_original.txt";
if (File.Exists(sourceFile))
{
File.Delete(sourceFile);
}
if (File.Exists(destinationFile))
{
File.Delete(destinationFile);
}
if (File.Exists(decompressedSourceFile))
{
File.Delete(decompressedSourceFile);
}
File.WriteAllText(sourceFile, testStr);
using (IManager manager = new Manager(sourceFile, destinationFile, Operations.Compress))
{
_archivator = new Archivator(manager);
_archivator.Perform();
}
using (IManager manager = new Manager(compressedFile, decompressedSourceFile, Operations.Decompress))
{
_archivator = new Archivator(manager);
_archivator.Perform();
}
string decompressedTestStr = File.ReadAllText(decompressedSourceFile);
Assert.AreEqual(testStr, decompressedTestStr);
File.Delete(sourceFile);
File.Delete(destinationFile);
File.Delete(decompressedSourceFile);
}
static void DeCompress(string archPath, string initPath, IArchivator e, int sizeMb)
{
try
{
using (var cs = new FileStream(archPath, FileMode.Open, FileAccess.Read,
FileShare.None, STREAM_BUFFER_SIZE, FileOptions.Asynchronous))
{
using (var fs = new FileStream(initPath, FileMode.Create, FileAccess.Write,
FileShare.None, STREAM_BUFFER_SIZE, FileOptions.Asynchronous))
{
_isCompleted = e.DoAction(cs, fs, sizeMb);
}
}
}
catch (ThreadAbortException)
{
_isError = true;
}
catch (Exception)
{
_isError = true;
}
finally
{
_mainEvent.Set();
}
}
public WorkManager(string input, string output, IReader fileReader, IWriter fileWriter, IArchivator archivator, IPerfomanceCounter perfomance)
: base(input, output, fileReader, fileWriter, archivator, perfomance)
{
}
public ReportsArchive(string pathToArchive, HashSet <string> reportsExtensions, IArchivator archivator)
{
this.ReportsPath = pathToArchive;
this.ReportsExtensions = reportsExtensions;
this.Archivator = archivator;
}
