finalize !

Author: balbarak

src/Balbarak.WeasyPrint.Test/WeasyPrintClientTest.cs

@@ -51,5 +51,42 @@ public void Should_Create_Pdf_From_Input_File()
 
             }
         }
+
+        [Fact]
+        public async Task Should_Create_Pdf_From_Input_File_Async()
+        {
+            var trace = new DebugTraceWriter();
+
+            var input = $"{_inputFolder}\\complex.html";
+            var output = $"{_outputFolder}\\output.pdf";
+
+            using (WeasyPrintClient client = new WeasyPrintClient(trace))
+            {
+                await client.GeneratePdfAsync(input, output);
+
+            }
+        }
+
+        [Fact]
+        public async Task Should_Create_Pdf_From_Url_Async()
+        {
+            var trace = new DebugTraceWriter();
+
+            var url = "https://www.google.com";
+
+            using (WeasyPrintClient client = new WeasyPrintClient(trace))
+            {
+               var result =  await client.GeneratePdfFromUrlAsync(url);
+
+                File.WriteAllBytes($"{_outputFolder}\\url.pdf", result);
+
+            }
+        }
+
+        [Fact]
+        public void Should_Create_Pdf_From_Url_Output_File()
+        {
+           
+        }
     }
 }

src/Balbarak.WeasyPrint.Test/outputs/output.pdf

@@ -15,8 +15,6 @@ namespace Balbarak.WeasyPrint
 {
     public class WeasyPrintClient : IDisposable
     {
-        private readonly string _libDir = Path.Combine(Directory.GetCurrentDirectory(), "weasyprint-v48");
-        private Process _nativeProccess;
         private readonly FilesManager _fileManager;
         private readonly ProcessInvoker _invoker;
         private readonly ITraceWriter _trace;
@@ -110,77 +108,40 @@ public async Task GeneratePdfAsync(string inputPathFile, string outputPathFile)
             }
         }
 
-        private async Task GeneratePdfInternal(string inputPathFile, string outputPathFile)
-        {
-            if (!File.Exists(inputPathFile))
-                throw new FileNotFoundException();
-
-            await EnsureFilesExisted()
-                .ConfigureAwait(false);
-
-            var cmd = $"/c python.exe scripts/weasyprint.exe {inputPathFile} {outputPathFile} -e utf8";
-
-            var workingDir = _fileManager.FolderPath;
-
-            await _invoker.ExcuteAsync(workingDir, "cmd.exe", cmd)
-                .ConfigureAwait(false);
-        }
-
         public byte[] GeneratePdfFromUrl(string url)
         {
-            if (!CheckFiles())
-                InitFiles();
-
-            byte[] result = null;
+            byte[] result;
 
             try
             {
-                LogOutput($"Generating pdf from url {url} ...");
-
-                var fileName = $"{Guid.NewGuid().ToString().ToLower()}";
-                var dirSeparator = Path.DirectorySeparatorChar;
-
-                var outputFileName = $"{fileName}.pdf";
-
-                var outputFullName = Path.Combine(_libDir, outputFileName);
+                result = GeneratePdfFromUrlInternal(url).GetAwaiter().GetResult();
 
-                ExcuteCommand($"python.exe weasyprint.exe {url} {outputFileName} ");
-
-                result = File.ReadAllBytes(outputFullName);
-
-                if (File.Exists(outputFullName))
-                    File.Delete(outputFullName);
-
-                LogOutput("Pdf generated successfully");
+                return result;
 
             }
             catch (Exception ex)
             {
-                OnDataError?.Invoke(new OutputEventArgs(ex.ToString()));
+                LogError(ex.ToString());
+                throw new WeasyPrintException(ex.Message, ex);
             }
-
-            return result;
         }
 
-        public void GeneratePdfFromUrl(string url, string outputFilePath)
+        public async Task<byte[]> GeneratePdfFromUrlAsync(string url)
         {
-            if (!CheckFiles())
-                InitFiles();
+            byte[] result;
 
             try
             {
-                LogOutput($"Generating pdf from url {url} ...");
-
-                ExcuteCommand($"python.exe weasyprint.exe {url} {outputFilePath} ");
-
-                LogOutput("Pdf generated successfully");
+                result = await GeneratePdfFromUrlInternal(url);
 
+                return result; 
             }
             catch (Exception ex)
             {
-                OnDataError?.Invoke(new OutputEventArgs(ex.ToString()));
-            }
+                LogError(ex.ToString());
 
+                throw new WeasyPrintException(ex.Message, ex);
+            }
         }
 
         private async Task<byte[]> GeneratePdfInternal(string htmlText)
@@ -218,125 +179,54 @@ await _fileManager.Delete(outputFileName)
             return result;
         }
 
-        private async Task EnsureFilesExisted()
-        {
-            if (!_fileManager.IsFilesExsited())
-                await _fileManager.InitFilesAsync();
-        }
-
-        private void ExcuteCommand(string cmd)
-        {
-            InitProccess();
-
-            _nativeProccess.StartInfo.Arguments = $@"/c {cmd}";
-
-            _nativeProccess.Start();
-
-            _nativeProccess.BeginOutputReadLine();
-            _nativeProccess.BeginErrorReadLine();
-
-            _nativeProccess.WaitForExit();
-
-        }
-
-        private bool CheckFiles()
-        {
-            LogOutput("Checking files ...");
-
-            if (!Directory.Exists(_libDir))
-                return false;
-
-            var files = Directory.GetFiles(_libDir);
-
-            if (files.Count() < 22)
-                return false;
-
-            var containPython = files.Where(a => a.Contains("python.exe")).FirstOrDefault() != null;
-
-            if (!containPython)
-                return false;
-
-            return true;
-        }
-
-        private void InitFiles()
+        private async Task GeneratePdfInternal(string inputPathFile, string outputPathFile)
         {
-            LogOutput($"Checking {_libDir} direcoty");
-
-            if (!Directory.Exists(_libDir))
-            {
-                LogOutput("Creating direcotry");
-
-                Directory.CreateDirectory(_libDir);
-            }
-            else
-            {
-                LogOutput("Deleting corrupted files ...");
-
-                Directory.Delete(_libDir, true);
-
-                Directory.CreateDirectory(_libDir);
-            }
-
-            var filesData = FileResx.libCompress;
-
-            var zipFileName = Path.Combine(_libDir, "weasyFile.zip");
-
-            File.WriteAllBytes(zipFileName, filesData);
+            if (!File.Exists(inputPathFile))
+                throw new FileNotFoundException();
 
-            LogOutput("Extracting files ...");
+            await EnsureFilesExisted()
+                .ConfigureAwait(false);
 
-            ZipFile.ExtractToDirectory(zipFileName, _libDir);
+            var cmd = $"/c python.exe scripts/weasyprint.exe {inputPathFile} {outputPathFile} -e utf8";
 
-            LogOutput($"Deleting {zipFileName}");
+            var workingDir = _fileManager.FolderPath;
 
-            File.Delete(zipFileName);
+            await _invoker.ExcuteAsync(workingDir, "cmd.exe", cmd)
+                .ConfigureAwait(false);
         }
 
-        private void InitProccess()
+        private async Task<byte[]> GeneratePdfFromUrlInternal(string url)
         {
-            KillProc();
+            byte[] result;
 
-            var workingDir = _libDir;
+            await EnsureFilesExisted()
+                .ConfigureAwait(false);
 
-            _nativeProccess = new Process();
+            var fileName = $"{Guid.NewGuid().ToString().ToLower()}.pdf";
 
-            _nativeProccess.StartInfo.FileName = @"cmd.exe";
+            var outputFileName = Path.Combine(_fileManager.FolderPath, $"{fileName}");
 
-            _nativeProccess.StartInfo.EnvironmentVariables["PATH"] = "gtk3;%PATH%";
+            var cmd = $"/c python.exe scripts/weasyprint.exe {url} {outputFileName} -e utf8";
 
-            _nativeProccess.StartInfo.EnvironmentVariables["FONTCONFIG_FILE"] = $"{workingDir}\\gtk3\\fonts.config";
+            var workingDir = _fileManager.FolderPath;
 
-            _nativeProccess.StartInfo.WorkingDirectory = workingDir;
-            _nativeProccess.StartInfo.UseShellExecute = false;
-            _nativeProccess.StartInfo.RedirectStandardInput = true;
-            _nativeProccess.StartInfo.RedirectStandardOutput = true;
-            _nativeProccess.StartInfo.RedirectStandardError = true;
-            _nativeProccess.StartInfo.CreateNoWindow = true;
+            await _invoker.ExcuteAsync(workingDir, "cmd.exe", cmd)
+                .ConfigureAwait(false);
 
-            _nativeProccess.OutputDataReceived += OnOutputDataReceived;
-            _nativeProccess.ErrorDataReceived += OnErrorDataReceived;
-            _nativeProccess.Exited += OnExited;
 
-        }
-
-        private void OnExited(object sender, EventArgs e)
-        {
-            Debug.WriteLine("Proccess exited");
-        }
+            result = await _fileManager.ReadFile(fileName)
+                .ConfigureAwait(false);
 
-        private void OnErrorDataReceived(object sender, DataReceivedEventArgs e)
-        {
-            LogError(e.Data);
+            await _fileManager.Delete(fileName)
+                .ConfigureAwait(false);
 
-            Debug.WriteLine($"Error: {e.Data}");
+            return result;
         }
 
-        private void OnOutputDataReceived(object sender, DataReceivedEventArgs e)
+        private async Task EnsureFilesExisted()
         {
-            LogOutput(e.Data);
-
-            Debug.WriteLine(e.Data);
+            if (!_fileManager.IsFilesExsited())
+                await _fileManager.InitFilesAsync();
         }
 
         private void LogOutput(string data)
@@ -361,28 +251,9 @@ private void LogError(string data)
 
         public void Dispose()
         {
-            KillProc();
-
             _invoker.Dispose();
         }
 
-        private void KillProc()
-        {
-            if (_nativeProccess != null)
-            {
-                try
-                {
-                    _nativeProccess.Kill();
-                }
-                catch
-                {
-
-                }
-
-                _nativeProccess.Dispose();
-            }
-        }
-
         private void SetEnviromentVariables()
         {
             var variables = new Dictionary<string, string>()