MTWorkHR/MTWorkHR.Application/Services/Base/BlobFileService.cs

using AutoMapper;
using Azure.Storage.Blobs;
using Azure.Storage.Blobs.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.Logging;
using MTWorkHR.Application.Models;
using MTWorkHR.Application.Services.Interfaces;
using MTWorkHR.Core.Global;
using System.IO;
using System.Net.Http.Headers;

namespace MTWorkHR.Application.Services
{
    public class BlobFileService : IFileService
    {
       // private readonly AppSettingsConfiguration settings;
        private const string ContainerName = "blobcontainer";
        public const string SuccessMessageKey = "SuccessMessage";
        public const string ErrorMessageKey = "ErrorMessage";
        private readonly BlobServiceClient _blobServiceClient;
        private readonly BlobContainerClient _containerClient;
        private readonly ILogger<BlobFileService> _logger;

        public BlobFileService(BlobServiceClient blobServiceClient, ILogger<BlobFileService> logger)
        {
            _blobServiceClient = blobServiceClient;
            _containerClient = _blobServiceClient.GetBlobContainerClient(ContainerName);
            _containerClient.CreateIfNotExists();
            _logger = logger;
        }
        public async Task<AttachmentResponseDto> UploadFile(IFormFile file)
        {
            AttachmentResponseDto result = new AttachmentResponseDto();
            try
            {
                var blobClient = _containerClient.GetBlobClient(file.FileName);
                if (blobClient != null)
                {
                    var status = await blobClient.UploadAsync(file.OpenReadStream(), true);
                    //if(status.Value == "201")
                    result.FileName = file.FileName;
                    result.FilePath = blobClient.Uri.AbsoluteUri;
                    return result;
                }else
                    return result;
            }
            catch (Exception ex)
            {
                return result;
            }
        }
        public async Task<string> UploadFileCloud(AttachmentDto file)
        {
            try
            {
                var blobClient = _containerClient.GetBlobClient(file.FileName);
                if(blobClient != null)
                {
                    //var stream = file.FileData.OpenReadStream();
                    using (Stream fs = file.FileData.OpenReadStream())
                    {
                        var status = await blobClient.UploadAsync(fs, true);
                        fs.Position = 0;
                        using (BinaryReader br = new BinaryReader(fs))
                        {
                            byte[] bytes = br.ReadBytes((Int32)fs.Length);
                            var Headers = file.FileData.Headers;
                            file.Content = bytes;
                            file.ContentType = file.FileData.ContentType;
                            file.FilePath = blobClient.Uri.AbsoluteUri;
                        }
                    }
                    //if(status.Value == "201")
                    return blobClient.Uri.AbsoluteUri;
                }else
                    return "";

            }
            catch (Exception ex)
            {
                return "";
            }
        }
        public async Task<AttachmentResponseDto> UploadFile(byte[] pdfBytes, string fileName)
        {
            AttachmentResponseDto result = new AttachmentResponseDto();
            try
            {
                // Get a reference to the container
                //BlobContainerClient containerClient = _blobServiceClient.GetBlobContainerClient("Contracts");

                // Create the container if it doesn’t exist
                //containerClient.CreateIfNotExists();
                var blobClient = _containerClient.GetBlobClient(fileName);
                if (blobClient != null)
                {
                    using (MemoryStream uploadStream = new MemoryStream(pdfBytes))
                    {
                        _logger.LogInformation("1--Contract uploadStream length={0}", pdfBytes.Length);

                        var status = await blobClient.UploadAsync(uploadStream, overwrite: true);
                        _logger.LogInformation("2--Contract uploadStream Status={0}, uri={1}", status, blobClient.Uri.AbsoluteUri);

                    }
                    result.FileName = fileName;
                    result.FilePath = blobClient.Uri.AbsoluteUri;
                    _logger.LogInformation("3--Contract upload finish path={0}", blobClient.Uri.AbsoluteUri);
                    return result;
                }
                else
                {
                    _logger.LogInformation("BlobClient is null when upload file ={0}", fileName);
                    return result;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                return result;
            }
        }
        public async Task<BlobObject> Download(string url)
        {
            try
            {
                var fileName = new Uri(url).Segments.LastOrDefault();
                var blobClient = _containerClient.GetBlobClient(fileName);
                if(await blobClient.ExistsAsync())
                {
                    BlobDownloadResult content = await blobClient.DownloadContentAsync();
                    var downloadedData = content.Content.ToStream();
                    if (ImageExtensions.Contains(Path.GetExtension(fileName.ToUpperInvariant())))
                    {
                        var extension = Path.GetExtension(fileName);
                        return new BlobObject { Content = downloadedData, ContentType = "image/"+extension.Remove(0,1) };
                    }
                    else
                    {
                        return new BlobObject { Content = downloadedData, ContentType = content.Details.ContentType };
                    }
                }
                return null;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        public async Task<List<AttachmentResponseDto>> UploadFiles(List<IFormFile> files)
        {
            List<AttachmentResponseDto> msgs = new List<AttachmentResponseDto>();
            foreach (var formFile in files)
            {
                msgs.Add(await UploadFile(formFile));
            }
            return msgs;
        }
        public async Task<Tuple<bool, string>> UploadFile2(IFormFile file)
        {
            try
            {
                var blobClient = _containerClient.GetBlobClient(file.FileName);
                var status = await blobClient.UploadAsync(file.OpenReadStream(), true);
                return new Tuple<bool, string>(true, "");// = "File uploaded successfully.";
            }
            catch (Exception ex)
            {
                return new Tuple<bool, string>(false, ex.Message);
            }
        }
        public async Task<List<Tuple<bool, string>>> UploadFiles2(List<IFormFile> files)
        {
            List<Tuple<bool, string>> msgs = new List<Tuple<bool, string>>();
            foreach (var formFile in files)
            {
                msgs.Add( await UploadFile2(formFile));
            }
            return msgs;
        }

    
        
        public async Task<bool> Delete(string fileName)
        {
            try
            {
                var blobClient = _containerClient.GetBlobClient(fileName);
                await blobClient.DeleteIfExistsAsync();
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        public void CopyFileToCloud(ref List<AttachmentDto> attachments)
        {
            foreach(var attach in attachments)
            {
                if (attach.FileData != null)
                {
                    var resPath = UploadFileCloud(attach).Result;
                    //if (resPath != "")
                    //    attach.FilePath = resPath;
                }
                
            }
        }

        public bool CopyFileToActualFolder(string FileName)
        {
            throw new NotImplementedException();
        }

        public bool DeleteFileFromTempFolder(string FileName)
        {
            throw new NotImplementedException();
        }

        public string GetTempAttachmentPath()
        {
            throw new NotImplementedException();
        }

        public string GetActualAttachmentPath()
        {
            throw new NotImplementedException();
        }

        public Task<Tuple<MemoryStream, string, string>> GetFileDownloadInfo(string fileUrl)
        {
            throw new NotImplementedException();
        }

        public Task<bool> CopyFileToActualFolder(List<AttachmentDto> attachments)
        {
            throw new NotImplementedException();
        }


        string[] ImageExtensions = new string[]
           {
                ".JPEG"
                , ".JPG"
                , ".PNG"
              
           };
    }
}