MARKUS



using log4net;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Globalization;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace DownloadManager

{

    class Program

    {

        private static ILog logger = LogManager.GetLogger(typeof(Program));

        private static string TEMP_FOLDER = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "MARKUS");

        static IIpc.WcfClient wcfClient;

        static bool IsDownload;

        static bool IsDebug;

        static int TotalPages = 0;

        //private const string SECTION_DOWNLOAD_FILE = "DOWNLOAD_FILE";

        //private const string SECTION_DOWNLOAD_DIR = "DOWNLOAD_DIR";

        //private const string KEY_VALUES = "VALUE";

        //private static string DOWNLOAD_LOG_FILE = System.IO.Path.Combine(TEMP_FOLDER, "Download.log");

        //private static ConfigParser DOWNLOAD_LOG = new ConfigParser(DOWNLOAD_LOG_FILE,

        //                                            new ConfigParserSettings

        //                                            {

        //                                                MultiLineValues = MultiLineValues.Simple | MultiLineValues.AllowValuelessKeys | MultiLineValues.QuoteDelimitedValues,

        //                                                Culture = new CultureInfo("en-US")

        //                                            });

        static void Main(string[] args)

        {

            try

            {

                logger.Info($"param : {string.Join(",", args)}");

                if (args.Length > 0)

                {

                    for (int i = 0; i < args.Length; i++)

                    {

                        ConsoleWrite(args[i]);

                    }

                    //if (args[0] == IIpc.ProcessTypeDefine.DEFINE_DELETE)

                    //{

                    //    IsDebug = bool.Parse(args[1]);

                    //    DeleteFiles();

                    //}

                    if (args[0] == IIpc.ProcessTypeDefine.DEFINE_MONITOR)

                    {

                        CheckAutoUpdate.Validation();

                        IsDebug = bool.Parse(args[1]);

                        int processId = int.Parse(args[2]); /// kcom process id

                        int thumbnamilPID = int.Parse(args[3]);

                        int filePID = int.Parse(args[4]);

                        string folder1 = args[5];              // folder

                        string folder2 = args[6];              // folder

                        string file = args[7];              // file

                        try

                        {

                            Process process = FindProcess(processId);

                            while (process != null)

                            {

                                process = FindProcess(processId);

                                ConsoleWrite("Process Check");

                                System.Threading.Thread.Sleep(10000);

                            }

                            var p1 = FindProcess(thumbnamilPID);

                            if (p1 != null)

                            {

                                p1.Kill();

                            }

                            var p2 = FindProcess(filePID);

                            if (p2 != null)

                            {

                                p2.Kill();

                            }

                        }

                        catch (Exception ex)

                        {

                            ConsoleWrite(ex.ToString());

                        }

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL, folder1);

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL, folder2);

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_FILE, file);

                    }

                    else

                    {

                        wcfClient = new IIpc.WcfClient(args[1]);

                        IsDebug = bool.Parse(args[2]);

                        if (args[0] == IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL)

                        {

                            string BaseUri = args[3];

                            string localStoragePath = args[4];

                            string fileExt = args[5];

                            int totalPages = int.Parse(args[6]);

                            int takeCount = int.Parse(args[6]);

                            TotalPages = totalPages;

                            KCOM.PageManager.PageStorage pageStorage = new KCOM.PageManager.PageStorage(BaseUri, localStoragePath, fileExt, totalPages, takeCount);

                            pageStorage.PageLoadCompleted += PageStorage_PageLoadCompleted;

                            pageStorage.DownloadWork(1, totalPages);

                        }

                        else if (args[0] == IIpc.ProcessTypeDefine.DEFINE_FILE)

                        {

                            using (System.Net.WebClient client = new System.Net.WebClient())

                            {

                                client.DownloadFileCompleted += Client_DownloadFileCompleted;

                                client.DownloadProgressChanged += Client_DownloadProgressChanged;

                                client.UseDefaultCredentials = true;

                                System.Net.IWebProxy webProxy = client.Proxy;

                                if (webProxy != null)

                                {

                                    webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;

                                }

                                client.DownloadFileAsync(new Uri(System.Web.HttpUtility.UrlDecode(args[3])), args[4]);

                            }

                        }

                        while (!IsDownload)

                        {

                            System.Threading.Thread.Sleep(1000);

                        }

                    }

                    if (IsDebug)

                    {

                        Console.ReadLine();

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"param : {string.Join(",", args)}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        public static void DeleteFiles(string processType, string path)

        {

            try

            {

                if (processType == IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL)

                {

                    var dir = System.IO.Directory.GetDirectories(path, "*.*", System.IO.SearchOption.AllDirectories);

                    for (int i = 0; i < dir.Length; i++)

                    {

                        System.IO.Directory.Delete(dir[i], true);

                    }

                }

                else

                {

                    if (System.IO.File.Exists(path))

                    {

                        System.IO.File.Delete(path);

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"DeleteFiles Error {processType} {path}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        private static Process FindProcess(int id)

        {

            Process result = null;

            try

            {

                var process = Process.GetProcesses().Where(x=>x.Id == id);

                if(process.Count()> 0)

                {

                    result = process.First();

                }

            }

            catch (Exception ex)

            {

                logger.Error($"FindProcess Error {id}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

            return result;

        }

        private static void ConsoleWrite(string data)

        {

            logger.Info(data);

            if (IsDebug)

            {

                Console.WriteLine(data);

            }

        }

        private static void Client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

        {

            try

            {

                wcfClient.SendFileDownloadReceived(100, true);

                ConsoleWrite($"Download file Completed");

                IsDownload = true;

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

        private static void Client_DownloadProgressChanged(object sender, System.Net.DownloadProgressChangedEventArgs e)

        {

            try

            {

                wcfClient.SendFileDownloadReceived(e.ProgressPercentage, false);

                ConsoleWrite($"Download file {e.ProgressPercentage}");

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

        private static void PageStorage_PageLoadCompleted(object sender, KCOM.PageManager.PageLoadCompletedEventArgs e)

        {

            try

            {

                wcfClient.SendThumbnailReceived(e.PageItem.PageNo, e.PageItem.LocalFilePath);

                ConsoleWrite($"{e.PageItem.PageNo} {e.PageItem.LocalUri}");

                if (e.PageItem.PageNo == TotalPages)

                {

                    IsDownload = true;

                }

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

    }

}