Implemented Queues and folder monitors.

BodyshopUploader/Utils/JobProcessingQueue.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using BodyshopUploader.Utils;
+using BodyshopUploader.Models;
+
+namespace BodyshopUploader.Utils
+{
+    public static class JobProcessingQueue
+    {
+        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
+        private static Queue<DTO_QueueItem> _jobs = new Queue<DTO_QueueItem>();
+        private static bool _delegateQueuedOrRunning = false;
+
+        public static void Enqueue(DTO_QueueItem item)
+        {
+            lock (_jobs)
+            {
+                //See if the job is already in the queue based on the file name. If it is, ignore it. 
+                if (!(_jobs.Any(_ => _.FilePath == item.FilePath)))
+                {
+                    logger.Debug("Adding job to the queue. | {0}", item.FilePath);
+                    _jobs.Enqueue(item);
+                    if (!_delegateQueuedOrRunning)
+                    {
+                        _delegateQueuedOrRunning = true;
+                        ThreadPool.UnsafeQueueUserWorkItem(ProcessQueuedItems, null);
+                    }
+                }
+                else
+                {
+                    logger.Debug("Ignoring job {0}, it's already in the queue.", item.FilePath);
+                }
+            }
+        }
+
+        private static void ProcessQueuedItems(object ignored)
+        {
+            while (true)
+            {
+                DTO_QueueItem item;
+                lock (_jobs)
+                {
+                    if (_jobs.Count == 0)
+                    {
+                        _delegateQueuedOrRunning = false;
+                        break;
+                    }
+                    //Only peek at the first item in the queue so that it does not get added again while it is still getting processed. 
+                    item = _jobs.Peek();
+                }
+
+                try
+                {
+                    Thread.Sleep(1000);//Allow a small amount of time to pass before processing the queue item so that any writes can finish. 
+
+                    DecodeQueueItemJob(item);
+
+                    UpsertQueueItem(item);
+                }
+                catch
+                {
+                    ThreadPool.UnsafeQueueUserWorkItem(ProcessQueuedItems, null);
+                    throw;
+                }
+            }
+        }
+
+        private static void DecodeQueueItemJob(DTO_QueueItem item)
+        {
+            //Process the job. 
+            logger.Info("Should process the job here. {0}", item.FilePath);
+        }
+
+        private static void UpsertQueueItem(DTO_QueueItem item)
+        {
+            //Save the job to the DB.
+            logger.Info("Should upsert the job graphqlly here. {0}", item.FilePath);
+
+            _jobs.Dequeue();
+        }
+
+        private static void MoveFile(string FullPath)
+        {
+            try
+            {
+                System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(FullPath) + @"\Processed\");
+                File.Move(FullPath, System.IO.Path.GetDirectoryName(FullPath) + @"\Processed\" + System.IO.Path.GetFileNameWithoutExtension(FullPath) + DateTime.Now.Ticks.ToString() + ".bak");
+
+            }
+            catch (Exception Ex)
+            {
+                logger.Error(Ex, "Can't move file {0} - it's gone!", FullPath);
+            }
+        }
+    }
+}