BeWoPlaner/Service/ServiceUtils/Update/UpdatePlanResponseHelper.cs

using BeWo.Service.ServiceUtils.Paths;
using BS.SharedLauncher.DataContract;
using BS.SharedLauncher.Enums;
using BS.SharedLauncher.Exceptions;
using BS.SharedLauncher.Extensions;
using BS.SharedLauncher.Information;
using BS.SharedLauncher.Logic;
using BS.SharedLauncher.Update;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BeWo.Service.ServiceUtils.Update
{
    public static class UpdatePlanResponseHelper
    {
        private static UpdatePlanRequest _Request;
        private static UpdatePlanResponse _Response;

        private static string _Version;
        private static string _Tenant;
        
        public static UpdatePlanResponse GetUpdatePlanResponse(UpdatePlanRequest request, string tenant)
        {
            var (default_version, tenant_version) = UpdateConfigReader.GetDefaultTenantVersion(tenant);
            _Version = UpdateConfigReader.GetValidVersion(default_version, tenant_version);

            _Tenant = tenant;
            _Request = request;
            _Response = new UpdatePlanResponse
            {
                CurrentPackage = new UpdatePlanDC
                {
                    DefaultVersion = default_version,
                    TenantVersion = tenant_version
                }
            };

            // Lädt komplettes Paket ohne Hash
            CalcFullPackage();

            // Lade Hash Werte
            _Response.CurrentPackage.LoadHash();

            CalcFilesToRequest();

            if (!_Request.ApplyFolderIsEmpty)
                CalcFilesToDeleteInApply();

            if (!_Request.DownloadFolderIsEmpty)
                CalcFilesToApplyInDownload();

            CalcDownloadSize();

            _Response.HasToDo = _Response.HasToDo();

            return _Response;
        }

        private static void CalcFullPackage()
        {
            // Setze Basis 
            _Response.CurrentPackage.InitFiles(getVersionDefaultFiles(_Version));

            // Überschreibe mit Version-Tenant Daten
            _Response.CurrentPackage.OverrideOrAddFiles(getVersionTenantFiles(_Version, _Tenant));

            // Überschreibe mit Special-Tenant Daten
            _Response.CurrentPackage.OverrideOrAddFiles(getSpecialTenantFiles(_Tenant));
        }

        private static void CalcFilesToRequest()
        {
            foreach (var file in _Response.CurrentPackage.Files)
            {
                // Bereits installiert
                if (_Request.ApplyPackage?.ContainsPlanerFileWithHash(file) ?? false)
                    continue;

                // Bereits heruntergeladen
                if (_Request.DownloadedFiles?.ContainsPlanerFileWithHash(file) ?? false)
                    continue;

                if (_Response.FilesToRequest is null)
                    _Response.FilesToRequest = new List<UpdateFileDC>();

                _Response.FilesToRequest.Add(file);
            }
        }

        private static void CalcFilesToDeleteInApply()
        {
            foreach (var file in _Request.ApplyPackage.Files)
            {
                // Datei wird gebraucht
                if (_Response.CurrentPackage.ContainsPlanerFile(file))
                    continue;
                
                if (_Response.FilesToDeleteInApply is null)
                    _Response.FilesToDeleteInApply = new List<UpdateFileDC>();

                _Response.FilesToDeleteInApply.Add(file);
            }
        }

        private static void CalcFilesToApplyInDownload()
        {
            foreach (var file in _Request.DownloadedFiles)
            {
                // Datei wird gebraucht
                if (!_Response.CurrentPackage.ContainsPlanerFile(file))
                    continue;

                if (_Response.FilesToApply is null)
                    _Response.FilesToApply = new List<UpdateFileDC>();

                _Response.FilesToApply.Add(file);
            }
        }

        private static void CalcDownloadSize()
        {
            if (_Response.FilesToRequest is null || !_Response.FilesToRequest.Any())
                return;

            long count = 0;
            foreach (var file in _Response.FilesToRequest)
            {
                var fi = new FileInfo(file.AbsolutePath);

                count += fi.Length;
            }

            _Response.DownloadSize = count;
        }

        private static List<UpdateFileDC> getVersionDefaultFiles(string version) => getPlanerFiles(ServerFilePaths.GetVersionDefaultFolderPath(version), UpdateFileSource.VersionDefault, false);
        private static List<UpdateFileDC> getVersionTenantFiles(string version, string tenant) => getPlanerFiles(ServerFilePaths.GetVersionTenantFolderPath(version, tenant), UpdateFileSource.VersionTenant, true);
        private static List<UpdateFileDC> getSpecialTenantFiles(string tenant) => getPlanerFiles(ServerFilePaths.GetOverrideTenantFolderPath(tenant), UpdateFileSource.OverrideTenant, true);

        private static List<UpdateFileDC> getPlanerFiles(string path, UpdateFileSource source, bool ignoreOnError)
        {
            if (!Directory.Exists(path)) {
                if (ignoreOnError)
                    return new List<UpdateFileDC>();
                else
                    throw new ServerConfigException($"{path} konnte nicht gefunden werden");
            }
            var res = FileController.GetPlanerFiles(path, true, ignorePlanerFile);

            res.ForEach(x => x.Source = source);

            return res;
        }

        private static bool ignorePlanerFile(UpdateFileDC update)
        {
            if (update.GetExtensionType() == ".xml")
                return true;

            if (update.GetExtensionType() == ".pdb")
                return true;

            return false;
        }
    }
}