MARKUS

using LiteDB;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net;

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");

            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)

        {

            bool result = false;

            try

            {

                var filename = $"{DateTime.Today.AddDays(-1).ToString("yyyyMMdd")}.db";

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

                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, 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 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, filePath);

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

                return reply;

            }

            catch (Exception)

            {

                throw;

            }

        }

        private async Task<string> FileSizeAsync(Uri _url, 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?filename={filePath}");

                return data;

            }

            catch (Exception)

            {

                throw;

            }

        }

    }

}