monorepo/LCU.API.Internal.FileOperations/LCU.Api.Internal.FileOperations/Services/FileActionServices/UnzipFileService.cs

using System;
using System.Collections.Generic;
using System.IO.Compression;
using System.IO;
using Newtonsoft.Json;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.FileOperationsModels.Shared;
using LCU.Api.Internal.FileOperations.Validations;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
namespace LCU.Api.Internal.FileOperations.Services.FileActionServices;

public class UnzipFileService : FileActionService, IFileActionService, IActionService<UnzipFileRequest>
{
	public UnzipFileService(ServicesFactoryConfiguration servicesFactoryConfiguration)
        : base(servicesFactoryConfiguration)
	{
	}

	public RequestResponse ExecuteAction(QueueRequest queueRequest)
    {
        var requestResponse = new RequestResponse();
        try
        {
            var unzipRequest = JsonConvert.DeserializeObject<UnzipFileRequest>(queueRequest.Request);
            var requests = BuildFileList(unzipRequest);
            requestResponse = FileValidation.ValidateIfAnyRequest(requests, unzipRequest.FormattedSourceDirectoryPath, requestResponse);           

            foreach (var request in requests)
            {
                var temporaryRequestResponse = PerformRequest(request);
                if (!temporaryRequestResponse.IsSuccessful)
                {
                    requestResponse.IsSuccessful = temporaryRequestResponse.IsSuccessful;
                    requestResponse.MessageStack.AddRange(temporaryRequestResponse.MessageStack);
                }
            }

            requestResponse.ReturnResponse = unzipRequest;
            return requestResponse;
        }
        catch (Exception exception)
        {
            return RequestResponseHelper.ExceptionUpdateRequestResponse(requestResponse,
                                                                   queueRequest.FileOperationType,
                                                                   exception.Message);
        }
    }

    public RequestResponse PerformRequest(UnzipFileRequest request)
    {
        return OperationService.PerformOperation(request, IsRequestValid, UnzipFile);
    }

    private void UnzipFile(UnzipFileRequest request)
    {
        try
        {
            var destination = request.FormattedDestinationPath;
            if (request.UseZipFileNameAsFinalDestination)
            {
                destination = Path.GetDirectoryName(request.DestinationPathZipFileNameWithoutZip);
                if (destination.Length > 0)
                {
                    Directory.CreateDirectory(destination);
                }
            }

            ZipFile.ExtractToDirectory(request.SourceFilePath, destination);

            if (request.IgnoreFileNameSubFolderAsDestination) 
            {
                MoveFromChildFolder(destination, request);
            }
        }
        catch (Exception exception)
        {
            throw new Exception($"Exception thrown while trying to ExecuteRequestAction. " +
                                $"Request: {JsonConvert.SerializeObject(request)}" +
                                $"ExceptionMessage: {exception.Message}");
        }
    }

    private void MoveFromChildFolder(string destination, UnzipFileRequest request)
    {
        var recursionDepth = request.MaxFileDepth;
        var currentDepth = 0;
        var currentFilePath = destination;

        RecursiveFolderSearch(destination, recursionDepth, currentFilePath,currentDepth);
    }

    public void RecursiveFolderSearch(string destination, int recursionDepth, string currentFilePath, int currentDepth)
    {
        if (currentDepth>recursionDepth)
        {
            return;
        }

        var folders = Directory.EnumerateDirectories(currentFilePath);
        foreach (var folder in folders)
        {
            RecursiveFolderSearch(destination, recursionDepth, folder, currentDepth + 1);
            var childFiles = Directory.EnumerateFiles(folder);

            foreach (var file in childFiles)
            {
                var fileName = file[(file.LastIndexOf("\\") + 1)..];
                File.Move(file, destination + "\\" + fileName);
            }
            Directory.Delete(folder);
        }
    }

    public RequestResponse PreQueueValidation(UnzipFileRequest originalRequest)
    {
        var requestResponse = new RequestResponse();
        var requestList = BuildFileList(originalRequest);
        requestResponse = FileValidation.ValidateIfAnyRequest(requestList, originalRequest.FormattedSourceDirectoryPath, requestResponse);
        foreach (var request in requestList)
        {
            requestResponse = IsRequestValid(request, requestResponse);
        }

        return requestResponse;
    }

    public List<UnzipFileRequest> BuildFileList(UnzipFileRequest originalRequest)
    {
        var nameList = RegexNameHandler.BuildFileList(originalRequest.FormattedSourceDirectoryPath,
                                                      originalRequest.FinalZipFileName,
                                                      originalRequest.FileNameSetting);
        var requests = new List<UnzipFileRequest>();

        foreach (var name in nameList)
        {
            var newRequest = Clone.DeepClone(originalRequest);
            newRequest.ZipFileName = name;

            requests.Add(newRequest);
        }

        return requests;
    }

    public RequestResponse IsRequestValid(UnzipFileRequest fileRequest, RequestResponse requestResponse)
    {
        requestResponse = DirectoryValidation.ValidateDirectoryExists(fileRequest.FormattedSourceDirectoryPath, requestResponse);
        requestResponse = FileValidation.ValidateFileExists(fileRequest.SourceFilePath, requestResponse);
        requestResponse = DirectoryValidation.ValidateDirectoryExists(fileRequest.FormattedDestinationPath, requestResponse);
        return requestResponse;
    }
}