BeWoPlaner/Service/ServiceUtils/Update/UpdatePlanResponseBuilder.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 UpdatePlanResponseBuilder
    {
        private static UpdatePlanRequest _Request;
        private static UpdatePlanResponse _Response;

        private static string _Version;
        private static string _Tenant;

        public static void BuildResponse(UpdatePlanRequest request, string tenant, UpdatePlanResponse response)
        {
            _Response = response;

            _Tenant = tenant;
            _Request = request;

            ReadUpdateConfig(out string default_version, out string special_version);

            _Response.CurrentPackage = new UpdatePlanDC
            {
                DefaultVersion = default_version,
                TenantVersion = special_version
            };

            _Version = _Response.CurrentPackage.Version;

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

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

                CalcFilesToRequest();

                if (!_Request.ApplyFolderIsEmpty)
                    CalcFilesToDeleteInApply();

                if (!_Request.DownloadFolderIsEmpty)
                    CalcFilesToApplyInDownload();

                CalcDownloadSize();
            }
            catch(Exception e)
            {
                throw new HideClientUpdateException("Erstellprozess gescheitert", e);
            }            
        }

        private static void ReadUpdateConfig(out string default_version, out string special_version)
        {
            string path = GetUpdateConfigPath();

            try
            {
                var reader = new UpdateConfigReader(path, _Tenant);

                default_version = reader.GetDefaultVersion();
                special_version = reader.GetSpecificVersion();
            }
            catch(Exception e)
            {
                throw new HideClientUpdateException($"Konnte UpdateConfig File für \"{_Tenant}\" nicht lesen.", e);
            }
        }
        private static string GetUpdateConfigPath()
        {
            try
            {
                return ServerFilePaths.UpdateConfigPath;
            }
            catch (Exception e)
            {
                throw new HideClientUpdateException($"Konnte UpdateConfig Path für \"{_Tenant}\" nicht lesen.", e);
            }
        }

        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.GetSpecialTenantFolderPath(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;

            return false;
        }
    }
}