public async Task <HttpResponseMessage> PackagesUninstall(string fqn)
        {
            HttpResponseMessage retVal;

            if (string.IsNullOrEmpty(fqn))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("fqn", "The specified Fully Qualified Name is null or empty.").Result, JsonFormatter());
            }
            else
            {
                IPackage findResult = await PackageManager.FindPackageAsync(fqn);

                if (findResult != default(IPackage))
                {
                    IResult uninstallResult = await PackageManager.UninstallPackageAsync(findResult);

                    if (uninstallResult.ResultCode != ResultCode.Failure)
                    {
                        retVal = Request.CreateResponse(HttpStatusCode.NoContent);
                    }
                    else
                    {
                        HttpErrorResult result = new HttpErrorResult($"Failed to uninstall Package '{fqn}'.", uninstallResult);
                        retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, result, JsonFormatter());
                    }
                }
                else
                {
                    retVal = Request.CreateResponse(HttpStatusCode.NotFound);
                }
            }

            return(retVal);
        }
        public async Task <HttpResponseMessage> PackageArchivesAdd([FromBody] string data)
        {
            HttpResponseMessage retVal;

            byte[] decodedData = GetBytesFromBase64String(data);

            if (data.Length == 0)
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("data", "The data is of zero length.").Result, JsonFormatter());
            }
            else if (decodedData == default(byte[]))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("data", "The data is not a valid base 64 encoded string.").Result, JsonFormatter());
            }
            else
            {
                IResult <IPackageArchive> addResult = await PackageManager.AddPackageArchiveAsync(decodedData);

                if (addResult.ResultCode != ResultCode.Failure)
                {
                    retVal = Request.CreateResponse(HttpStatusCode.Created, addResult.ReturnValue, JsonFormatter());
                }
                else
                {
                    HttpErrorResult err = new HttpErrorResult("Failed to create a Package Archive from the specified data.", addResult);
                    retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, err, JsonFormatter());
                }
            }

            return(retVal);
        }
        public async Task <HttpResponseMessage> PackagesInstall(string fqn, [FromBody] PackageInstallationOptions options)
        {
            HttpResponseMessage retVal;
            ParameterValidator  validator = new ParameterValidator(ModelState);

            if (string.IsNullOrEmpty(fqn))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("fqn", "The specified Fully Qualified Name is null or empty.").Result, JsonFormatter());
            }
            else if (!validator.IsValid)
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, validator.Result);
            }
            else
            {
                IPackageArchive findResult = await PackageManager.FindPackageArchiveAsync(fqn);

                if (findResult != default(IPackageArchive))
                {
                    PackageInstallationOptions installOptions = new PackageInstallationOptions()
                    {
                        Overwrite        = options.Overwrite,
                        SkipVerification = options.SkipVerification,
                        PublicKey        = options.PublicKey,
                    };

                    IResult <IPackage> installResult = await PackageManager.InstallPackageAsync(findResult, installOptions);

                    if (installResult.ResultCode != ResultCode.Failure)
                    {
                        retVal = Request.CreateResponse(HttpStatusCode.OK, installResult.ReturnValue, JsonFormatter());
                    }
                    else
                    {
                        HttpErrorResult result = new HttpErrorResult($"Failed to install Package '{fqn}'.", installResult);
                        retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, result, JsonFormatter());
                    }
                }
                else
                {
                    retVal = Request.CreateResponse(HttpStatusCode.NotFound);
                }
            }

            return(retVal);
        }
        public async Task <HttpResponseMessage> PackagesGet(bool?scan = false)
        {
            if ((bool)scan)
            {
                IResult scanResult = await PackageManager.ScanPackagesAsync();

                if (scanResult.ResultCode == ResultCode.Failure)
                {
                    HttpErrorResult err = new HttpErrorResult("Failed to refresh Package list from disk", scanResult);
                    return(Request.CreateResponse(HttpStatusCode.InternalServerError, err, JsonFormatter()));
                }
            }

            IReadOnlyList <PackageSummaryData> packages = PackageManager.Packages.Select(p => new PackageSummaryData(p)).ToList().AsReadOnly();

            return(Request.CreateResponse(HttpStatusCode.OK, packages, JsonFormatter()));
        }
        public async Task <HttpResponseMessage> PackageArchivesGetFqnVerification(string fqn, string publicKey = default(string))
        {
            HttpResponseMessage retVal;

            if (string.IsNullOrEmpty(fqn))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("fqn", "The specified Fully Qualified Name is null or empty.").Result, JsonFormatter());
            }
            else if (publicKey != default(string) && !new Regex(PackagingConstants.KeyRegEx).IsMatch(publicKey))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("publicKey", "The specified PGP public key is not a valid key.").Result, JsonFormatter());
            }
            else
            {
                IPackageArchive findResult = await PackageManager.FindPackageArchiveAsync(fqn);

                if (findResult != default(IPackageArchive))
                {
                    IResult <bool> verifyResult = await PackageManager.VerifyPackageArchiveAsync(findResult);

                    if (verifyResult.ResultCode != ResultCode.Failure)
                    {
                        retVal = Request.CreateResponse(HttpStatusCode.OK, new PackageArchiveVerificationData(verifyResult), JsonFormatter());
                    }
                    else
                    {
                        HttpErrorResult result = new HttpErrorResult($"Failed to verify Package Archive '{fqn}'.", verifyResult);
                        retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, result, JsonFormatter());
                    }
                }
                else
                {
                    retVal = Request.CreateResponse(HttpStatusCode.NotFound);
                }
            }

            return(retVal);
        }
        public async Task <HttpResponseMessage> PackageArchivesGetFqnFile(string fqn)
        {
            HttpResponseMessage retVal;

            if (string.IsNullOrEmpty(fqn))
            {
                retVal = Request.CreateResponse(HttpStatusCode.BadRequest, new ParameterValidator().AddError("fqn", "The specified Fully Qualified Name is null or empty.").Result, JsonFormatter());
            }
            else
            {
                IPackageArchive findResult = await PackageManager.FindPackageArchiveAsync(fqn);

                if (findResult != default(IPackageArchive))
                {
                    IResult <byte[]> readResult = await PackageManager.FetchPackageArchiveAsync(findResult);

                    if (readResult.ResultCode != ResultCode.Failure)
                    {
                        retVal         = Request.CreateResponse(HttpStatusCode.OK);
                        retVal.Content = new ByteArrayContent(readResult.ReturnValue);
                        retVal.Content.Headers.ContentDisposition          = new ContentDispositionHeaderValue("attachment");
                        retVal.Content.Headers.ContentDisposition.FileName = Path.GetFileName(findResult.FileName);
                    }
                    else
                    {
                        HttpErrorResult result = new HttpErrorResult($"Failed to retrieve contents of Package Archive '{fqn}'.", readResult);
                        retVal = Request.CreateResponse(HttpStatusCode.InternalServerError, result, JsonFormatter());
                    }
                }
                else
                {
                    retVal = Request.CreateResponse(HttpStatusCode.NotFound);
                }
            }

            return(retVal);
        }