isn/src/nuget-host/Controllers/PackagesController.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using NuGet.Packaging;
using NuGet.Packaging.Core;
using nuget_host.Data;
using nuget_host.Entities;
using nuget_host.Helpers;

namespace nuget_host.Controllers
{

    [AllowAnonymous]
    public class PackagesController : Controller
    {
        private readonly ILogger<PackagesController> logger;
        private readonly IDataProtector protector;

        private readonly NugetSettings nugetSettings;
        ApplicationDbContext dbContext;

        public PackagesController(
            ILoggerFactory loggerFactory,
            IDataProtectionProvider provider,
            IOptions<NugetSettings> nugetOptions,
            ApplicationDbContext dbContext)
        {
            logger = loggerFactory.CreateLogger<PackagesController>();
            nugetSettings = nugetOptions.Value;
            protector = provider.CreateProtector(nugetSettings.ProtectionTitle);
            this.dbContext = dbContext;
        }

        [HttpPut("packages")]
        public async Task<IActionResult> Put()
        {
            string path = null;

            var clientVersionId = Request.Headers["X-NuGet-Client-Version"];
            var apiKey = Request.Headers["X-NuGet-ApiKey"];
            ViewData["versionId"] = typeof(PackagesController).Assembly.FullName;
            var files = new List<string>();
            ViewData["files"] = files;

            var clearkey = protector.Unprotect(apiKey);
            var apikey = dbContext.ApiKeys.SingleOrDefault(k => k.Id == clearkey);
            if (apikey == null)
            {
                logger.LogInformation("403 : no api-key");
                return Unauthorized();
            }

            foreach (var file in Request.Form.Files)
            {
                try
                {
                    files.Add(file.Name);
                    string initpath = Path.Combine(Environment.GetEnvironmentVariable("TEMP"),
                     $"nuget_host-{Guid.NewGuid()}.nupkg");

                    using (FileStream fw = new FileStream(initpath, FileMode.Create))
                    {
                        file.CopyTo(fw);
                    }

                    using (FileStream fw = new FileStream(initpath, FileMode.Open))
                    {
                        var archive = new System.IO.Compression.ZipArchive(fw);

                        foreach (var entry in archive.Entries)
                        {
                            if (entry.FullName.EndsWith(".nuspec"))
                            {
                                // var entry = archive.GetEntry(filename);
                                var specstr = entry.Open();
                                NuGet.Packaging.Core.NuspecCoreReader reader = new NuspecCoreReader(specstr);

                                string pkgdesc = reader.GetDescription();
                                string pkgid = reader.GetId();
                                var version = reader.GetVersion();

                                path = Path.Combine(nugetSettings.PackagesRootDir,
                                Path.Combine(pkgid,
                                Path.Combine(version.Version.ToString()),
                                    $"{pkgid}-{version}.nupkg"));

                                var source = new FileInfo(initpath);
                                var dest = new FileInfo(path);
                                var destdir = new DirectoryInfo(dest.DirectoryName);
                                if (dest.Exists)
                                {
                                    ViewData["error"] = "existe déjà";
                                    logger.LogInformation("400 : existe déjà");
                                    return BadRequest(ViewData);
                                }

                                if (!destdir.Exists)
                                {
                                    destdir.Create();
                                    source.MoveTo(path);
                                    var newpkg = new Package
                                    {
                                        Id = pkgid,
                                        Description = pkgdesc,
                                        OwnerId = apikey.UserId
                                    };
                                    dbContext.Packages.Add(newpkg);

                                    var newversion = new PackageVersion
                                    {
                                        Package = newpkg,
                                        Major = version.Major,
                                        Minor = version.Minor,
                                        Patch = version.Patch,
                                        IsPrerelease = version.IsPrerelease,
                                        FullString = version.ToFullString()
                                    };
                                    dbContext.PackageVersions.Add(newversion);

                                    await dbContext.SaveChangesAsync();
                                    logger.LogInformation($"new package : {entry.Name}");
                                }
                                else
                                {
                                    var pkg = dbContext.Packages.SingleOrDefault(p => p.Id == pkgid);
                                    if (pkg == null)
                                    {
                                        // TODO Choose an app policy to take ownership
                                        // and populate db with zip info
                                        // from either existing package on disk,
                                        // or from request
                                        logger.LogError("Package directory exists, but don't have any owner");
                                        throw new NotImplementedException();

                                        Package newpkgfromdisk = new Package{
                                            Id = pkgid,
                                            Description = pkgdesc,
                                            OwnerId = apikey.UserId
                                        };
                                        dbContext.Packages.Add(newpkgfromdisk);
                                        var newversionfromdisk = new PackageVersion
                                        {
                                            Package = newpkgfromdisk,
                                            Major = version.Major,
                                            Minor = version.Minor,
                                            Patch = version.Patch,
                                            IsPrerelease = version.IsPrerelease,
                                            FullString = version.ToFullString()
                                        };
                                        dbContext.PackageVersions.Add(newversionfromdisk);
                                        await dbContext.SaveChangesAsync();
                                        logger.LogInformation($"new package : {entry.Name}");
                                    

                                    }

                                    if (apikey.UserId != pkg.OwnerId)
                                    {
                                        logger.LogInformation("403 : not owner");
                                        return Unauthorized();
                                    }

                                    var newversion = new PackageVersion
                                    {
                                        PackageId = pkg.Id,
                                        Major = version.Major,
                                        Minor = version.Minor,
                                        Patch = version.Patch,
                                        IsPrerelease = version.IsPrerelease,
                                        FullString = version.ToFullString()
                                    };
                                    dbContext.PackageVersions.Add(newversion);

                                    await dbContext.SaveChangesAsync();
                                    logger.LogInformation($"new version : {entry.Name}");
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError($"400 en traitant {file.Name}:");
                    logger.LogError(ex.Message);
                    throw;
                }
            }
            return Ok(ViewData);
        }

        [HttpGet("packages/{spec}")]
        public IActionResult Index(string spec)
        {
            if (string.IsNullOrEmpty(spec))
            {
                ViewData["warn"] = "no spec";
            }
            else
            {
                ViewData["spec"] = spec;
                // TODO Assert valid sem ver spec
                var filelst = new DirectoryInfo(nugetSettings.PackagesRootDir);
                var fi = new FileInfo(spec);
                var lst = filelst.GetDirectories(spec);
                ViewData["lst"] = lst.Select(entry => entry.Name);
            }
            return Ok(ViewData);
        }



        [Authorize]
        [HttpGet("api/get-key/{*apikey}")]
        public IActionResult GetApiKey(string apiKey)
        {
            return Ok(protector.Protect(apiKey));
        }
    }
}