MARKUS

using LiteDB;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

using System.Text;

using System.Threading.Tasks;

namespace License.DB

{

    public class DataBase : iDatabase

    {

        const int initial = 10 * 8192;

        private readonly string ConnectionString;

        private readonly string DataBaseFoloder;

        private readonly string DataBaseFile;

        private readonly string LogConnectionString;

        private readonly string LogDataBaseFile;

        public DataBase()

        {

            DataBaseFoloder = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DataBase\\Active");

            if (!System.IO.Directory.Exists(DataBaseFoloder))

            {

                System.IO.Directory.CreateDirectory(DataBaseFoloder);

            }

            DataBaseFile = System.IO.Path.Combine(DataBaseFoloder, $"{DateTime.Today.ToString("yyyyMMdd")}.db");

            ConnectionString = $"Filename={DataBaseFile};Password=dof1073#;Connection=shared";

            LogDataBaseFile = System.IO.Path.Combine(DataBaseFoloder, "Log.db");

            LogConnectionString = $"Filename={LogDataBaseFile};Password=dof1073#;Connection=shared";

        }

        public void Active(string MachineName, string Process, string UserName, string license)

        {

            using (var db = new LiteDatabase(ConnectionString))

            {

                var collection = db.GetCollection<Active>("active");

                var items = collection.Query().Where(x => x.Process == Process && x.MachineName == MachineName && x.UserName == UserName).FirstOrDefault();

                System.Diagnostics.Debug.WriteLine("item : " + items?.UserName);

                System.Diagnostics.Debug.WriteLine(MachineName + " " + Process + "  " + UserName);

                if (items == null)

                {

                    collection.Insert(new DB.Active(UserName, MachineName, Process, DateTime.Now, DateTime.MinValue));

                }

                else

                {

                    items.UpdateTime = DateTime.Now;

                    collection.Update(items);

                }

            }

        }

        public async Task<bool> UploadAsync(Uri uri,string SiteName)

        {

            bool result = false;

            try

            {

                var databasedir = new DirectoryInfo(DataBaseFoloder);

                if(databasedir.EnumerateFiles().Count() > 0)

                {

                    var items = databasedir.GetFiles().Where(x=>x.Name != $"{DateTime.Today.ToString("yyyyMMdd")}.db")

                                            .Select(x => new { key = int.Parse(x.Name.Replace(".db", "")), fileName = x.Name})

                                            .OrderByDescending(x => x.key);

                    foreach (var item in items)

                    {

                        var fileSize = await FileSizeAsync(uri, SiteName, item.fileName);

                        if(int.Parse(fileSize) < 0)

                        {

                            var filepath = System.IO.Path.Combine(DataBaseFoloder, item.fileName);

                            var uploadFilename = await UploadFileAsync(uri, SiteName, filepath);

                        }

                        else

                        {

                            break;

                        }

                    }

                    //using (var db = new LiteDatabase(LogConnectionString))

                    //{

                    //    var collection = db.GetCollection<UploadItem>("Upload");

                    //    var items = collection.Query().Where(x => x.FileName == filename).FirstOrDefault();

                    //    if (items == null && File.Exists(filepath))

                    //    {

                    //        var uploadFilename = await UploadFileAsync(uri,SiteName, filepath);

                    //        var size = await FileSizeAsync(uri, filename);

                    //        var localfileLength = new System.IO.FileInfo(filepath).Length;

                    //        if (long.Parse(size) == localfileLength)

                    //        {

                    //            collection.Insert(new UploadItem(filename, localfileLength));

                    //            result = true;

                    //        }

                    //    }

                    //    else

                    //    {

                    //        result = true;

                    //    }

                    //}

                }

            }

            catch (Exception)

            {

                throw;

            }

            return result;

        }

        private async Task<string> UploadFileAsync(Uri _url,string SiteName, string filePath)

        {

            try

            {

                ServicePointManager.Expect100Continue = true;

                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

                WebClient client = new WebClient();

                client.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.BypassCache);

                client.Headers.Add("Cache-Control", "no-cache");

                client.Encoding = Encoding.UTF8;

                var result = await client.UploadFileTaskAsync($"{_url}/Site={SiteName}", filePath);

                string reply = System.Text.Encoding.UTF8.GetString(result);

                return reply;

            }

            catch (Exception)

            {

                throw;

            }

        }

        private async Task<string> FileSizeAsync(Uri _url, string SiteName, string filePath)

        {

            try

            {

                ServicePointManager.Expect100Continue = true;

                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

                WebClient client = new WebClient();

                client.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.BypassCache);

                client.Headers.Add("Cache-Control", "no-cache");

                client.Encoding = Encoding.UTF8;

                var data = await client.DownloadStringTaskAsync($"{_url}/FileInfo/Site={SiteName}&file={filePath}");

                return data;

            }

            catch (Exception)

            {

                throw;

            }

        }

        private async Task<string> FileListAsync(Uri _url, string SiteName)

        {

            try

            {

                return "";

            }

            catch (Exception)

            {

                throw;

            }

        }

    }

}