BeWoPlaner/Service/ServiceImplementations/DownloadBeWoServiceImp.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;

using System.ServiceModel;
using System.Xml;
using BeWo.Data;
using BeWo.Service.ServiceContracts;
using BeWo.Service.ServiceUtils.Update;
using BS.SharedLauncher.DataContract;
using BS.SharedLauncher.Enums;
using BS.SharedLauncher.Update;

namespace BeWo.Service.ServiceImplementations
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
    public class DownloadBeWoServiceImp : IDownloadBeWoService
    {
        public UpdateConfigHelper UpdateConfigHelper { get; set; }
        
        public string Tenant => MultitenancyOperationContextExt.Current.Tenant;
        
        public DownloadPlanerResponseDC Download2(DownloadPlanerRequestDC request)
        {
            try
            {
                PlanerRoot root = new PlanerRoot();

                UpdateConfigHelper = new UpdateConfigHelper(UpdatePathHelper.VersionConfigPath(), Tenant);

                root.DefaultVersion = UpdateConfigHelper.LoadDefaultVersion();
                root.TenantVersion = UpdateConfigHelper.LoadSpecificVersion();

                string version = root.CurrentVersion;

                // Setze Basis 
                root.InitPlanerFiles(GetVersionDefaultFiles(version));

                // Überschreibe mit Version-Tenant Daten
                root.UpdatePlanerFiles(GetVersionTenantFiles(version, Tenant));

                // Überschreibe mit Special-Tenant Daten
                root.UpdatePlanerFiles(GetSpecialTenantFiles(Tenant));
                
                if (true || request.VersionXML is null)
                    return Install(root);

                return Update(root, request.VersionXML);
            }
            catch (Exception e)
            {
                throw Core.Utils.CreateBeWoFaultException(e);
            }
        }

        private List<PlanerFile> GetVersionDefaultFiles(string version) => GetPlanerFiles(UpdatePathHelper.VersionDefaultPath(version), PlanerUpdateSource.VersionDefault);
        private List<PlanerFile> GetVersionTenantFiles(string version, string tenant) => GetPlanerFiles(UpdatePathHelper.VersionTenantPath(version, tenant), PlanerUpdateSource.VersionTenant);
        private List<PlanerFile> GetSpecialTenantFiles(string tenant) => GetPlanerFiles(UpdatePathHelper.SpecialTenantPath(tenant), PlanerUpdateSource.SpecialTenant);

        private List<PlanerFile> GetPlanerFiles(string path, PlanerUpdateSource source)
        {
            var res = new List<PlanerFile>();

            if (!Directory.Exists(path))
                return res;

            // Sollte der Path ohne / enden, wird der unterordner mit angegeben 
            // Deshalb manuell hinzufügen, falls nicht vorhanden
            if (!path.EndsWith(Path.DirectorySeparatorChar.ToString()))
                path += Path.DirectorySeparatorChar;

            GetPlanerFilesRecursive(new DirectoryInfo(path), path, source, ref res);
            return res;
        }
        private void GetPlanerFilesRecursive(DirectoryInfo directoryInfo, string relativeTo, PlanerUpdateSource source, ref List<PlanerFile> files)
        {
            foreach (var item in directoryInfo.GetDirectories())
            {
                GetPlanerFilesRecursive(item, relativeTo, source, ref files);
            }

            foreach (var item in directoryInfo.GetFiles())
            {
                var file = new PlanerFile(item, relativeTo, source);
                
                files.Add(file);
            }
        }

        private DownloadPlanerResponseDC Install(PlanerRoot root)
        {
            var res = new DownloadPlanerResponseDC();

            res.VersionXML = root.GetVersionXml(Tenant);
            res.Data = root.GetData();

            return res;
        }

        private DownloadPlanerResponseDC Update(PlanerRoot newestVersion, string versionxml)
        {
            return null;
        }

        //public BeWoProgramPackageDC Update(BeWoProgramPackageDC current)
        //{
        //    try
        //    {
        //        DirectoryInfo dirUpdateRoot = new DirectoryInfo(ConfigurationManager.AppSettings.Get("UpdateRootPath"));

        //        var newest = GetNewestVersionSet(dirUpdateRoot, MultitenancyOperationContextExt.Current.Tenant);

        //        var res = CreateUpdatePackage(current, newest);

        //        res.toLoad = "BeWoPlaner.dll";

        //        return res;
        //    }
        //    catch (Exception e)
        //    {
        //        throw Core.Utils.CreateBeWoFaultException(e);
        //    }
        //}
        //private BeWoProgramPackageDC GetNewestVersionSet(DirectoryInfo dirUpdateRoot, string tenant)
        //{
        //    var res = new BeWoProgramPackageDC();
        //    var dirTenant = dirUpdateRoot.GetDirectories().FirstOrDefault(dict => dict.Name == tenant);

        //    var filesRoot = dirUpdateRoot.GetFiles().Select(file => new BeWoProgramFileDC(file));

        //    if (dirUpdateRoot is null)
        //        throw new Exception("Couldn't find update root path for launcher updates");

        //    res.Files.AddRange(filesRoot);

        //    if (dirTenant is null)
        //        return res;

        //    foreach (var newFile in dirTenant.GetFiles().Select(file => new BeWoProgramFileDC(file)))
        //    {
        //        var search = res.Files.FirstOrDefault(x => x.FileName == newFile.FileName);

        //        if (search is null)
        //        {
        //            res.Files.Add(newFile);
        //        }
        //        else
        //        {
        //            res.Files.Remove(search);
        //            res.Files.Add(newFile);
        //        }
        //    }

        //    return res;
        //}
        //private BeWoProgramPackageDC CreateUpdatePackage(BeWoProgramPackageDC oldSet, BeWoProgramPackageDC newSet)
        //{
        //    var res = new BeWoProgramPackageDC();

        //    if (!(oldSet is null))
        //        res.Files.AddRange(oldSet.Files);

        //    foreach (var newFile in newSet.Files)
        //    {

        //        var oldFile = res.Files.FirstOrDefault(x => x.FileName == newFile.FileName);

        //        if (oldFile is null)
        //        {
        //            newFile.FileData = File.ReadAllBytes(newFile.FullPath);
        //            newFile.ToDo = FileToDo.Add;

        //            res.Files.Add(newFile);
        //        }
        //        else
        //        {
        //            if (oldFile.FileVersion is null || newFile.FileVersion is null)
        //            {
        //                oldFile.FileVersion = newFile.FileVersion;
        //                oldFile.FileData = File.ReadAllBytes(newFile.FullPath);
        //                oldFile.ToDo = FileToDo.Update;
        //            }
        //            else
        //            {
        //                if (oldFile.FileVersion == newFile.FileVersion)
        //                {
        //                    if (oldFile.Checksum != newFile.Checksum)
        //                    {
        //                        oldFile.FileData = File.ReadAllBytes(newFile.FullPath);
        //                        oldFile.ToDo = FileToDo.Update;
        //                    }
        //                    else
        //                    {
        //                        oldFile.ToDo = FileToDo.Nuthing;
        //                    }
        //                }
        //                else
        //                {
        //                    oldFile.FileVersion = newFile.FileVersion;
        //                    oldFile.FileData = File.ReadAllBytes(newFile.FullPath);
        //                    oldFile.ToDo = FileToDo.Update;
        //                }
        //            }
        //        }
        //    }

        //    foreach (var oldFile in oldSet.Files)
        //    {
        //        var newFile = newSet.Files.FirstOrDefault(x => x.FileName == oldFile.FileName);

        //        if (newFile is default(BeWoProgramFileDC))
        //        {
        //            oldFile.ToDo = FileToDo.Remove;
        //        }
        //    }

        //    return res;
        //}
    }
}