Esempio n. 1
0
        static void Main(string[] args)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog()
            {
                Multiselect = true, Filter = "PDF|*.pdf"
            };
            List <List <string> > batch = new List <List <string> >();

            LogWriter.AddLogger(new FileLogger("D:/"), LogDepth.Debug);
            DialogResult result;

            while ((result = openFileDialog.ShowDialog()) == DialogResult.OK)
            {
                batch.Add(new List <string>()
                {
                    "123123123.djvu"
                });
            }
            Parallel.ForEach(batch, new ParallelOptions()
            {
                MaxDegreeOfParallelism = 3
            }, djvuBundle =>
            {
                Convert(djvuBundle.ToArray(), Path.Combine(Path.GetDirectoryName(djvuBundle.First()), "1.djvu"), 92);
            });
        }
Esempio n. 2
0
 internal bool Prepare()
 {
     if ((_config = Serializer.DeserializeItem <Config>(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase), "config.config").Replace("file:\\", ""))) == null)
     {
         _config = Config.GetDefaultConfig();
         Serializer.SerializeItem(_config, Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase), "config.config").Replace("file:\\", ""));
         return(false);
     }
     Directory.CreateDirectory(_config.InputPath);
     Directory.CreateDirectory(_config.LogPath);
     Directory.CreateDirectory(_config.OutputFolder);
     Directory.CreateDirectory(_config.UserLogFolder);
     _logger         = new FileLogger(_config.LogPath);
     _userLogger     = new FileLogger(_config.UserLogFolder);
     _filesInProcess = new List <string>();
     LogWriter.AddLogger(_logger, _config.LogLevel);
     LogWriter.AddLogger(_userLogger, LogDepth.UserLevel);
     try
     {
         _processedFiles = Serializer.DeserializeItem <List <string> >(_config.ProcessedCSVs);
         if (_processedFiles == null)
         {
             _processedFiles = new List <string>();
         }
         _converter = new CSVOperator();
         return(true);
     }
     catch (Exception e)
     {
         LogWriter.LogMessage(e.Message, LogDepth.UserLevel);
         LogWriter.LogMessage(e.StackTrace, LogDepth.Debug);
         return(false);
     }
 }
Esempio n. 3
0
        /// <summary>
        /// Shows the help contents to the console
        /// </summary>
        private static void ShowHelp()
        {
            ConsoleLoggerSettings settings = new ConsoleLoggerSettings()
            {
                LogLevel = LogMessageType.Verbose,
                DefaultBackgroundColor = Console.BackgroundColor,
                DefaultForegroundColor = Console.ForegroundColor,
                TimeStampOnNone        = false,
            };

            _logger.AddLogger(new ConsoleLogger(settings));

            _logger.ShowRawText(Properties.Resources.HelpContents);
        }
Esempio n. 4
0
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        private static void Main()
        {
            _logger = new LogWriter("File Cleanup Service");
            _logger.ShowRawText("File Cleanup Service started at " + DateTime.Now.ToString());

            // initialize the log file path
            string logFile = Path.GetFullPath(Properties.Settings.Default.LogFile);

            if (!Path.IsPathRooted(Properties.Settings.Default.LogFile))
            {
                logFile = Path.Combine(Path.GetDirectoryName(typeof(FileCleanupService).Assembly.Location), Properties.Settings.Default.LogFile);
            }

            // initialize the text logger
            TextFileLoggerSettings textLoggerSettings = new TextFileLoggerSettings()
            {
                LogLevel = LogMessageType.Verbose,
                ShowMessageTypePrefixes = true,
                TimeStampOnNone         = false,
                TimeStampOnError        = true,
                TimeStampOnInformation  = true,
                TimeStampOnWarning      = true,

                FilePath = logFile
            };

            _logger.AddLogger(new TextFileLogger(textLoggerSettings));
            _logger.ShowInformation("Log file set to " + logFile);

            // determine if service is being run in console mode
            bool consoleMode = false;

            string[] args = Environment.GetCommandLineArgs();
            if (args != null)
            {
                foreach (string arg in args)
                {
                    switch (arg.ToUpper())
                    {
                    case "-C":
                        consoleMode = true;
                        break;

                    case "-?":
                        ShowHelp();
                        return;
                    }
                }
            }

            // initialize console logger
            if (consoleMode)
            {
                // add console logger if running in console mode
                ConsoleLoggerSettings settings = new ConsoleLoggerSettings()
                {
                    LogLevel = LogMessageType.Verbose,
                    ShowMessageTypePrefixes = true,

                    DefaultBackgroundColor = Console.BackgroundColor,
                    DefaultForegroundColor = Console.ForegroundColor,
                    TimeStampOnNone        = false,

                    InformationBackgroundColor = ConsoleColor.Black,
                    InformationForegroundColor = ConsoleColor.Yellow,
                    TimeStampOnInformation     = true,

                    WarningBackgroundColor = ConsoleColor.Black,
                    WarningForegroundColor = ConsoleColor.Yellow,
                    TimeStampOnWarning     = true,

                    ErrorBackgroundColor = ConsoleColor.Black,
                    ErrorForegroundColor = ConsoleColor.Red,
                    TimeStampOnError     = true
                };
                _logger.AddLogger(new ConsoleLogger(settings));
            }

            // run in console mode
            if (consoleMode)
            {
                FileCleanupService svc = new FileCleanupService();
                svc.Debug_OnStart(args);

                Console.ReadKey();

                svc.Debug_OnStop();
            }
            else
            {
                ServiceBase.Run(new FileCleanupService());
            }
        }