Compilation warns

src/isnd/Controllers/Packages/ApiIndex.cs

@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Linq;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.DataProtection;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NuGet.Versioning;
+using isnd.Data;
+using isnd.Entities;
+using Unleash;
+using isnd.Services;
+using isnd.ViewModels;
+using System.Threading.Tasks;
+using isnd.Interfaces;
+using isn.Abstract;
+
+namespace isnd.Controllers
+{
+    public partial class PackagesController : Controller
+    {
+        [HttpGet(_pkgRootPrefix + ApiConfig.Base)]
+        public IActionResult ApiIndex()
+        {
+            return Ok(new ApiIndexViewModel{ Version = PackageManager.BASE_API_LEVEL, Resources = _resources });
+        }
+    }
+        
+}

src/isnd/Controllers/Packages/AutoComplete.cs

@@ -0,0 +1,38 @@
+using isnd.Services;
+using isnd.Entities;
+using Microsoft.AspNetCore.Mvc;
+
+namespace isnd.Controllers
+{
+    public partial class PackagesController 
+    {
+        
+        // GET /autocomplete?id=isn.protocol&prerelease=true
+        [HttpGet(_pkgRootPrefix + ApiConfig.AutoComplete)]
+        public IActionResult AutoComplete(
+            string id,
+            string semVerLevel,
+            bool prerelease = false,
+            string packageType = null,
+            int skip = 0,
+            int take = 25)
+        {
+            CheckParams(take, semVerLevel);
+            if (ModelState.ErrorCount > 0) return BadRequest(ModelState);
+            
+            return Ok(_packageManager.AutoComplete(id,skip,take,prerelease,packageType));
+        }
+
+        protected void CheckParams(int take,string semVerLevel)
+        {
+            if (take > maxTake)
+            {
+                ModelState.AddModelError("take", "Maximum exceeded");
+            }
+            if (semVerLevel != PackageManager.BASE_API_LEVEL)
+            {
+                ModelState.AddModelError("semVerLevel", PackageManager.BASE_API_LEVEL + " expected");
+            }
+        }
+    }
+}

src/isnd/Controllers/Packages/Catalog.cs

@@ -0,0 +1,61 @@
+using System.Linq;
+using System.Threading.Tasks;
+using isnd.Data.Catalog;
+using isnd.Helpers;
+using isnd.Services;
+using isnd.Entities;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace isnd.Controllers
+{
+
+    public partial class PackagesController
+    {
+
+        // https://docs.microsoft.com/en-us/nuget/api/catalog-resource#versioning
+        [HttpGet(_pkgRootPrefix + ApiConfig.Catalog)]
+        public IActionResult CatalogIndex()
+        {
+            return Ok(PackageManager.CurrentCatalogIndex);
+        }
+        
+        [HttpGet(_pkgRootPrefix + ApiConfig.CatalogPage + "-{id}")]
+        public IActionResult Index(string id)
+        {
+            // https://docs.microsoft.com/en-us/nuget/api/catalog-resource#versioning
+            return Ok(PackageManager.CurrentCatalogPages[int.Parse(id)]);
+        }
+
+        [HttpGet(_pkgRootPrefix + ApiConfig.CatalogLeaf + "/{id}/{*lower}")]
+        public async Task<IActionResult> CatalogLeafAsync(string id, string lower)
+        {
+            string pkgType = ParamHelpers.Optional(ref lower);
+            var pkgVersion = await _dbContext.PackageVersions
+            .Include(v => v.LatestCommit)
+            .SingleOrDefaultAsync(
+                v => v.PackageId == id &&
+                v.FullString == lower &&
+                v.Type == pkgType
+            );
+            if (pkgVersion == null) return NotFound();
+
+            var pub = await _dbContext.Commits
+            .Include(c => c.Versions)
+            .OrderBy(c => c.CommitTimeStamp)
+            .SingleOrDefaultAsync
+            (
+                c => c.Action == PackageAction.PublishPackage
+                && c.Versions.Contains(pkgVersion)
+            );
+            return Ok(new CatalogLeaf
+            {
+                CommitId = id,
+                Id = pkgVersion.PackageId,
+                CommitTimeStamp = pkgVersion.LatestCommit.CommitTimeStamp
+
+            });
+        }
+
+    }
+}

src/isnd/Controllers/Packages/Ctor.cs

@@ -0,0 +1,53 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Linq;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.DataProtection;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using NuGet.Versioning;
+using isnd.Data;
+using isnd.Entities;
+using Unleash;
+using isnd.Services;
+using isnd.ViewModels;
+using System.Threading.Tasks;
+using isnd.Interfaces;
+using isn.Abstract;
+
+namespace isnd.Controllers
+{
+    [AllowAnonymous]
+    public partial class PackagesController : Controller
+    {
+        const int maxTake = 100;
+        private readonly Resource[] _resources;
+        private readonly ILogger<PackagesController> _logger;
+        private readonly IDataProtector _protector;
+
+        private readonly IsndSettings _isndSettings;
+        readonly ApplicationDbContext _dbContext;
+        private readonly IPackageManager _packageManager;
+        private readonly IUnleash _unleashĈlient;
+        const string _pkgRootPrefix = "~/";
+
+        public PackagesController(
+            ILoggerFactory loggerFactory,
+            IDataProtectionProvider provider,
+            IOptions<IsndSettings> isndOptions,
+            IUnleash unleashĈlient,
+            ApplicationDbContext dbContext,
+            IPackageManager pm)
+        {
+            _logger = loggerFactory.CreateLogger<PackagesController>();
+            _isndSettings = isndOptions.Value;
+            _protector = provider.CreateProtector(_isndSettings.ProtectionTitle);
+            _dbContext = dbContext;
+            _packageManager = pm;
+            _unleashĈlient = unleashĈlient;
+            _resources = _packageManager.GetResources(_unleashĈlient).ToArray();
+        }
+    }
+}

src/isnd/Controllers/Packages/Delete.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using isnd.Helpers;
+using isnd.Entities;
+using System.ComponentModel.DataAnnotations;
+using isnd.Attributes;
+namespace isnd.Controllers
+{
+    public partial class PackagesController
+    {
+        [HttpDelete(_pkgRootPrefix + ApiConfig.Delete + "/{id}/{*lower}")]
+        public async Task<IActionResult> Delete(
+           [FromRoute][SafeName][Required] string id, 
+           [FromRoute][SafeName][Required] string lower)
+        {
+            string pkgtype = ParamHelpers.Optional(ref lower);
+            var report = await _packageManager.DeletePackageAsync(id, lower, pkgtype);
+            return Ok(report);
+        }
+    }
+}

src/isnd/Controllers/Packages/Files.cs

@@ -0,0 +1,51 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using Microsoft.AspNetCore.Mvc;
+using isnd.Attributes;
+using isnd.Entities;
+namespace isnd.Controllers
+{
+
+    public partial class PackagesController
+    {
+        // Web get nupkg
+        [HttpGet(_pkgRootPrefix + ApiConfig.Get + "/{id}/{lower}/{idf}-{lowerf}.nupkg")]
+        public IActionResult GetPackage(
+           [FromRoute][SafeName][Required] string id, 
+           [FromRoute][SafeName][Required] string lower,
+            [FromRoute] string idf, [FromRoute] string lowerf)
+        {
+            var pkgpath = Path.Combine(_isndSettings.PackagesRootDir,
+            id, lower, $"{id}-{lower}.nupkg"
+            );
+
+            FileInfo pkgfi = new FileInfo(pkgpath);
+
+            if (!pkgfi.Exists)
+            {
+                return BadRequest("!pkgfi.Exists");
+            }
+            return File(pkgfi.OpenRead(), "application/zip; charset=binary");
+        }
+
+        // Web get spec
+        [HttpGet(_pkgRootPrefix + ApiConfig.Get + "/{id}/{lower}/{idf}-{lowerf}.nuspec")]
+        public IActionResult GetNuspec(
+            [FromRoute][SafeName][Required] string id,
+            [FromRoute][SafeName][Required] string lower,
+            [FromRoute][SafeName][Required] string idf,
+            [FromRoute][SafeName][Required] string lowerf)
+        {
+            var pkgpath = Path.Combine(_isndSettings.PackagesRootDir,
+            id, lower, $"{id}.nuspec");
+
+            FileInfo pkgfi = new FileInfo(pkgpath);
+            if (!pkgfi.Exists)
+            {
+                return BadRequest("!pkgfi.Exists");
+            }
+
+            return File(pkgfi.OpenRead(), "text/xml; charset=utf-8");
+        }
+    }
+}

src/isnd/Controllers/Packages/GetVersions.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Mvc;
+using NuGet.Versioning;
+using isnd.Entities;
+
+namespace isnd.Controllers
+{
+    public partial class PackagesController 
+    {
+        [HttpGet(_pkgRootPrefix + ApiConfig.Get + "/{id}/{lower}/index.json")]
+        public IActionResult GetVersions(
+            string id,
+            string lower,
+            bool prerelease = false,
+            string packageType = null,
+            int skip = 0,
+            int take = 25)
+        {
+            if (take > maxTake)
+            {
+                ModelState.AddModelError("take", "Maximum exceeded");
+            }
+            // NugetVersion
+            if (!NuGetVersion.TryParse(lower, out NuGetVersion parsedVersion))
+            {
+                ModelState.AddModelError("lower", "invalid version string");
+            }
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+            return Ok(new
+            {
+                versions = _packageManager.GetVersions(
+                    id, parsedVersion, prerelease, packageType, skip, take)
+            });
+        }
+    }
+}

src/isnd/Controllers/Packages/Put.cs

@@ -0,0 +1,218 @@
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.DataProtection;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using NuGet.Packaging.Core;
+using NuGet.Versioning;
+using isnd.Data;
+using isnd.Helpers;
+using isnd.Entities;
+using Microsoft.AspNetCore.Http;
+using isnd.Data.Catalog;
+
+namespace isnd.Controllers
+{
+
+    public partial class PackagesController
+    {
+
+        [HttpPut(_pkgRootPrefix + ApiConfig.Publish)]
+        public async Task<IActionResult> Put()
+        {
+            try
+            {
+                var clientVersionId = Request.Headers["X-NuGet-Client-Version"];
+                string apiKey = Request.Headers["X-NuGet-ApiKey"][0];
+                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.LogError("403 : no api-key");
+                    return Unauthorized();
+                }
+                Commit commit = new Commit
+                {
+                    Action = PackageAction.PublishPackage,
+                    TimeStamp = DateTime.Now
+                };
+                _dbContext.Commits.Add(commit);
+
+                foreach (IFormFile file in Request.Form.Files)
+                {
+                    string initpath = Path.Combine(Environment.GetEnvironmentVariable("TEMP") ??
+                    Environment.GetEnvironmentVariable("TMP") ?? "/tmp",
+                     $"isn-{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 ZipArchive(fw);
+
+                        var nuspec = archive.Entries.FirstOrDefault(e => e.FullName.EndsWith(".nuspec"));
+                        if (nuspec == null) return BadRequest(new { error = "no nuspec from archive" });
+                        string pkgpath;
+                        NuGetVersion version;
+                        string pkgid;
+                        string fullpath;
+
+                        using (var specstr = nuspec.Open())
+                        {
+                            NuspecCoreReader reader = new NuspecCoreReader(specstr);
+
+                            string pkgdesc = reader.GetDescription();
+                            var types = reader.GetPackageTypes();
+                            pkgid = reader.GetId();
+                            version = reader.GetVersion();
+
+                            string pkgidpath = Path.Combine(_isndSettings.PackagesRootDir,
+                                pkgid);
+                            pkgpath = Path.Combine(pkgidpath, version.ToFullString());
+                            string name = $"{pkgid}-{version}.nupkg";
+                            fullpath = Path.Combine(pkgpath, name);
+
+                            var destpkgiddir = new DirectoryInfo(pkgidpath);
+                            Package package = _dbContext.Packages.SingleOrDefault(p => p.Id == pkgid);
+                            if (package != null)
+                            {
+                                if (package.OwnerId != apikey.UserId)
+                                {
+                                    return new ForbidResult();
+                                }
+                                package.Description = pkgdesc;
+                            }
+                            else
+                            {
+                                package = new Package
+                                {
+                                    Id = pkgid,
+                                    Description = pkgdesc,
+                                    OwnerId = apikey.UserId,
+                                    LatestVersion = commit
+                                };
+                                _dbContext.Packages.Add(package);
+                            }
+                            if (!destpkgiddir.Exists) destpkgiddir.Create();
+
+                            var source = new FileInfo(initpath);
+                            var dest = new FileInfo(fullpath);
+                            var destdir = new DirectoryInfo(dest.DirectoryName);
+                            if (dest.Exists)
+                            {
+                                // La version existe sur le disque,
+                                // mais si elle ne l'est pas en base de donnéés,
+                                // on remplace la version sur disque.
+                                var pkgv = _dbContext.PackageVersions.Where(
+                                    v => v.PackageId == package.Id 
+                                );
+                                
+                                if (pkgv !=null && pkgv.Count()==0) 
+                                {
+                                    dest.Delete();
+                                }
+                                else {
+                                    ViewData["msg"] = "existant";
+                                    ViewData["ecode"] = 1;
+                                    _logger.LogWarning("400 : existant");
+                                    return base.BadRequest(new { error = ModelState });
+                                }
+                            }
+                            {
+                                if (!destdir.Exists) destdir.Create();
+                                source.MoveTo(fullpath);
+                                files.Add(name);
+                                string fullstringversion = version.ToFullString();
+                                var pkgvers = _dbContext.PackageVersions.Where
+                                (v => v.PackageId == package.Id && v.FullString == fullstringversion);
+                                if (pkgvers.Count() > 0)
+                                {
+                                    foreach (var v in pkgvers.ToArray())
+                                        _dbContext.PackageVersions.Remove(v);
+                                }
+                                // FIXME default type or null
+                                if (types==null || types.Count==0)
+                                _dbContext.PackageVersions.Add
+                                (new PackageVersion{
+
+                                        Package = package,
+                                        Major = version.Major,
+                                        Minor = version.Minor,
+                                        Patch = version.Patch,
+                                        IsPrerelease = version.IsPrerelease,
+                                        FullString = version.ToFullString(),
+                                        Type = null,
+                                        LatestCommit = commit
+                                });
+                                else
+                                foreach (var type in types)
+                                {
+                                    var pkgver = new PackageVersion
+                                    {
+                                        Package = package,
+                                        Major = version.Major,
+                                        Minor = version.Minor,
+                                        Patch = version.Patch,
+                                        IsPrerelease = version.IsPrerelease,
+                                        FullString = version.ToFullString(),
+                                        Type = type.Name,
+                                        LatestCommit = commit
+                                    };
+                                    _dbContext.PackageVersions.Add(pkgver);
+                                }
+
+                                await _dbContext.SaveChangesAsync();
+                                _packageManager.ÛpdateCatalogFor(commit);
+
+                                _logger.LogInformation($"new package : {nuspec.Name}");
+                            }
+                        }
+                        using (var shacrypto = System.Security.Cryptography.SHA512.Create())
+                        {
+                            using (var stream = System.IO.File.OpenRead(fullpath))
+                            {
+                                var hash = shacrypto.ComputeHash(stream);
+                                var shafullname = fullpath + ".sha512";
+                                var hashtext = Convert.ToBase64String(hash);
+                                var hashtextbytes = Encoding.ASCII.GetBytes(hashtext);
+
+                                using (var shafile = System.IO.File.OpenWrite(shafullname))
+                                {
+                                    shafile.Write(hashtextbytes, 0, hashtextbytes.Length);
+                                }
+                            }
+                        }
+                        string nuspecfullpath = Path.Combine(pkgpath, pkgid + ".nuspec");
+                        FileInfo nfpi = new FileInfo(nuspecfullpath);
+
+                        if (nfpi.Exists)
+                           nfpi.Delete();
+                        nuspec.ExtractToFile(nuspecfullpath);
+                    }
+
+                }
+                return Ok(ViewData);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message);
+                _logger.LogError("Stack Trace: " + ex.StackTrace);
+                return new ObjectResult(new { ViewData, ex.Message })
+                { StatusCode = 500 };
+            }
+        }
+    }
+}

src/isnd/Controllers/Packages/Search.cs

@@ -0,0 +1,29 @@
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using isnd.Entities;
+
+namespace isnd.Controllers
+{
+
+    public partial class PackagesController
+    {
+
+// GET {@id}?q={QUERY}&skip={SKIP}&take={TAKE}&prerelease={PRERELEASE}&semVerLevel={SEMVERLEVEL}&packageType={PACKAGETYPE}
+        [HttpGet(_pkgRootPrefix + ApiConfig.Search)]
+        public async Task<IActionResult> Search(
+            
+            string q,
+            int skip = 0,
+            int take = 25,
+            bool prerelease = false,
+            string semVerLevel = null,
+            string packageType = null
+        )
+        {
+
+            throw new NotImplementedException();
+        }
+    }
+}

src/isnd/Controllers/Packages/WebViews.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using isnd.ViewModels;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace isnd.Controllers
+{
+
+    public partial class PackagesController
+    {
+        // Web search
+        public async Task<IActionResult> Index(PackageIndexViewModel model)
+        {
+            var applicationDbContext = _dbContext.Packages.Include(p => p.Versions).Where(
+                p => (  model.Prerelease || p.Versions.Any(v => !v.IsPrerelease))
+            && ((model.Query == null) || p.Id.StartsWith(model.Query)));
+            model.Data = await applicationDbContext.ToArrayAsync();
+            return View(model);
+        }
+        
+        public async Task<IActionResult> Details(string pkgid)
+        {
+            if (pkgid == null)
+            {
+                return NotFound();
+            }
+
+            var packageVersion = _dbContext.PackageVersions
+                .Include(p => p.Package)
+                .Where(m => m.PackageId == pkgid)
+                .OrderByDescending(p => p)
+                ;
+
+            if (packageVersion == null)
+            {
+                return NotFound();
+            }
+            bool results = await packageVersion.AnyAsync();
+            var latest = await packageVersion.FirstAsync();
+
+            return View("Details", new PackageDetailViewModel
+            {
+                latest = latest,
+                pkgid = pkgid,
+                totalHits = packageVersion.Count(),
+                data = packageVersion.Take(10).ToArray()
+            });
+
+        }
+    }
+
+}