using Microsoft.Extensions.Configuration;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using System;
using System.Threading.Tasks;

namespace SP.WebAPI.Services
{
	public interface IAzureBlobConnectionFactory
	{
		Task<CloudBlobContainer> GetBlobContainer();
	}

	public class AzureBlobConnectionFactory : IAzureBlobConnectionFactory
	{
		private readonly IConfiguration _configuration;
		private CloudBlobClient _blobClient;
		private CloudBlobContainer _blobContainer;

		public AzureBlobConnectionFactory(IConfiguration configuration)
		{
			_configuration = configuration;
		}

		public async Task<CloudBlobContainer> GetBlobContainer()
		{
			if (_blobContainer != null)
				return _blobContainer;

			var containerName = _configuration.GetValue<string>("ContainerName");
			if (string.IsNullOrWhiteSpace(containerName))
			{
				throw new ArgumentException("Configuration must contain ContainerName");
			}

			var blobClient = GetClient();

			_blobContainer = blobClient.GetContainerReference(containerName);
			if(await _blobContainer.CreateIfNotExistsAsync())
			{
				await _blobContainer.SetPermissionsAsync(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });
			}
			return _blobContainer;
		}

		private CloudBlobClient GetClient()
		{
			if (_blobClient != null)
				return _blobClient;

			var storageConnectionString = _configuration.GetValue<string>("StorageConnectionString");
			if(string.IsNullOrWhiteSpace(storageConnectionString))
			{
				throw new ArgumentException("Configuration must contain StorageConnectionString");
			}

			if(!CloudStorageAccount.TryParse(storageConnectionString, out CloudStorageAccount storageAccount))
			{
				throw new Exception("Could not create storage account with StorageConnectionString configuration");
			}

			_blobClient = storageAccount.CreateCloudBlobClient();
			return _blobClient;
		}
	}
}

using Microsoft.AspNetCore.Http;
using Microsoft.WindowsAzure.Storage.Blob;
using SP.Application.Exceptions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

namespace SP.WebAPI.Services
{
  public interface IAzureBlobService
  {
    Task<IEnumerable<Uri>> ListAsync();
    Task<string> UploadAsync(IFormFile file,string userId);
    Task DeleteAsync(string fileUri);
    Task DeleteAllAsync();
    Task<Stream> DownloadAsync(string filePath);
  }

  public class AzureBlobService : IAzureBlobService
  {
    private readonly IAzureBlobConnectionFactory _azureBlobConnectionFactory;

    public AzureBlobService(IAzureBlobConnectionFactory azureBlobConnectionFactory)
    {
      _azureBlobConnectionFactory = azureBlobConnectionFactory;
    }

    public async Task DeleteAllAsync()
    {
      var blobContainer = await _azureBlobConnectionFactory.GetBlobContainer();

      BlobContinuationToken blobContinuationToken = null;
      do
      {
        var response = await blobContainer.ListBlobsSegmentedAsync(blobContinuationToken);
        foreach (IListBlobItem blob in response.Results)
        {
          if (blob.GetType() == typeof(CloudBlockBlob))
            await ((CloudBlockBlob)blob).DeleteIfExistsAsync();
        }
        blobContinuationToken = response.ContinuationToken;
      } while (blobContinuationToken != null);
    }

    public async Task DeleteAsync(string fileUri)
    {
      var blobContainer = await _azureBlobConnectionFactory.GetBlobContainer();

      Uri uri = new Uri(fileUri);
      string filename = Path.GetFileName(uri.LocalPath);

      var blob = blobContainer.GetBlockBlobReference(filename);
      await blob.DeleteIfExistsAsync();
    }

    public async Task<IEnumerable<Uri>> ListAsync()
    {
      var blobContainer = await _azureBlobConnectionFactory.GetBlobContainer();
      var allBlobs = new List<Uri>();
      BlobContinuationToken blobContinuationToken = null;
      do
      {
        var response = await blobContainer.ListBlobsSegmentedAsync(blobContinuationToken);
        foreach (IListBlobItem blob in response.Results)
        {
          if (blob.GetType() == typeof(CloudBlockBlob))
            allBlobs.Add(blob.Uri);
        }
        blobContinuationToken = response.ContinuationToken;
      } while (blobContinuationToken != null);
      return allBlobs;
    }

    public async Task<string> UploadAsync(IFormFile file,string userId)
    {
      var blobContainer = await _azureBlobConnectionFactory.GetBlobContainer();

      var newFileFullPath = userId + "/" + GetRandomBlobName(file.FileName);

      var blob = blobContainer.GetBlockBlobReference(newFileFullPath);
      using (var stream = file.OpenReadStream())
      {
        await blob.UploadFromStreamAsync(stream);
      }

      return newFileFullPath;
    }

    private string GetRandomBlobName(string filename)
    {
      return string.Format("{0:10}_{1}_{2}", DateTime.Now.Ticks, Guid.NewGuid(), filename);
    }

    public async Task<Stream> DownloadAsync(string filePath)
    {
      MemoryStream ms = new MemoryStream();
      
      var blobContainer = await _azureBlobConnectionFactory.GetBlobContainer();

      var blob = blobContainer.GetBlockBlobReference(filePath);

      if (await blob.ExistsAsync())
      {
        await blob.DownloadToStreamAsync(ms);
        return ms;
      }
      else
      {
        throw new NotFoundException(nameof(AzureBlobService),"file is not exist" );
      }
    }
  }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using SP.WebAPI.Helpers;
using SP.WebAPI.Services;

namespace SP.WebAPI.Controllers
{
  [Route("files")]
  [ApiController]
  public class FilesController : ControllerBase
  {
    private readonly IAzureBlobService _azureBlobService;

    public FilesController(IAzureBlobService azureBlobService)
    {
      _azureBlobService = azureBlobService;
    }

    [HttpOptions]
    [ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
    public IActionResult Options()
    {
      Response.Headers.Add("Allow", "OPTIONS,POST");
      return Ok();
    }

    [HttpPost]
    public async Task<IActionResult> UploadFile([FromForm(Name = "file")] IFormFile file)
    {

      var userId = new Guid(User.Claims.FirstOrDefault(t => t.Type == "sub").Value).ToString(); //userid를 이용하여 폴더를 만든후 그 하위에 저장하기 위함.

      if (file == null)
      {
        return BadRequest("Could not upload files");
      }

      var newFileName = await _azureBlobService.UploadAsync(file, userId);
      
      var result = new
      {
        UploadFileName = newFileName
      };

      return new JsonResult(result); //생긴 파일명을 화면에 뿌려주기 위함.
    }

    [HttpGet]
    public async Task<IActionResult> DownloadFile(string fileName)
    {
      if (fileName == null)
      {
        return BadRequest("Missing fileName");
      }

      var stream = await _azureBlobService.DownloadAsync(fileName);
      
      if (stream == null)
        return NotFound();

      stream.Position = 0; //이거 안하면 500에러나거나 0k파일이 만들어짐

      return  File(stream, "application/octet-stream"); 

    }
  }
}