public Screenshot Create(string key, Screenshot instance)
{
ValidateInputs(() => _serviceInputValidator.ValidateAllPackageKeys(key, instance.PackageId, instance.PackageVersion));
Func <Screenshot> actionToExecute = () =>
{
_packageAuthenticator.EnsureKeyCanAccessPackage(key, instance.PackageId, instance.PackageVersion);
return(_screenshotRepository.Create(instance));
};
return(ExecuteAction(actionToExecute, "The Screenshot could not be created"));
}
public Package CreatePackage(string key, Stream packageFileStream, string fileExtension, bool isInPlaceUpdate, string externalPackageUri)
{
string tempPath = GenerateNewTempPath();
Package package;
try
{
package = ExtractPackage(packageFileStream, tempPath);
if (!_packageIdValidator.IsValidPackageId(package.Id))
{
throw new InvalidPackageIdException(package.Id);
}
_packageUriValidator.ValidatePackageUris(package);
_packageAuthenticator.EnsureKeyCanAccessPackage(key, package.Id, package.Version);
GenerateHash(tempPath, package);
if (string.IsNullOrWhiteSpace(package.Summary))
{
package.Summary = package.Description;
}
if (!isInPlaceUpdate)
{
CreateNewPackage(tempPath, package, externalPackageUri, fileExtension);
}
else
{
UpdatePackageInPlace(tempPath, package, externalPackageUri, fileExtension);
}
}
finally
{
_fileSystem.DeleteFileIfItExists(tempPath);
}
return(package);
}
public void Update(string key, string id, string version, Package instance)
{
Action validateInputsAction = () =>
{
_serviceInputValidator.ValidateAllPackageKeys(key, id, version);
_serviceInputValidator.ValidateKeysMatchInstance(id, version, instance);
};
ValidateInputs(validateInputsAction);
Action updateAction = () => {
_packageAuthenticator.EnsureKeyCanAccessPackage(key, id, version);
_packageUpdater.UpdateExistingPackage(instance);
};
ExecuteAction(updateAction, "The Package could not be updated");
}
public Package GetPackage(string key, string id, string version)
{
_packageAuthenticator.EnsureKeyCanAccessPackage(key, id, version);
IQueryable <Package> packages = _packageRepository.Collection.Include(p => p.Screenshots).Where(p => p.Id == id && p.Version == version);
if (!packages.Any())
{
throw new PackageDoesNotExistException(id, version);
}
if (packages.Count() > 1)
{
throw new WebFaultException <string>(string.Format("Duplicate Packages with ID '{0}' and Version '{1}' were found.", id, version),
HttpStatusCode.NotFound);
}
return(packages.Single());
}
public void PublishPackage(string key, string packageId, string packageVersion, PackageLogAction logActionForExistingPackage)
{
var packageLogAction = PackageLogAction.Create;
_packageAuthenticator.EnsureKeyCanAccessPackage(key, packageId, packageVersion);
Package package = _packageRepository.Collection
.Include(p => p.Dependencies)
.Include(p => p.Screenshots)
.SingleOrDefault(p => p.Id == packageId && p.Version == packageVersion);
if (package == null)
{
throw new PackageDoesNotExistException(packageId, packageVersion);
}
package.Published = _dateTime.UtcNow;
_packageRepository.Update(package);
var publishedPackage = _mapper.Map <Package, PublishedPackage>(package);
var existingPublishedPackageCount =
_publishedPackageRepository.Collection.Count(pp => pp.Id == packageId && pp.Version == packageVersion);
if (existingPublishedPackageCount > 0)
{
_publishedScreenshotRespository.DeleteMany(ps => ps.PublishedPackageId == packageId && ps.PublishedPackageVersion == packageVersion);
_publishedPackageRepository.DeleteMany(pp => pp.Id == packageId && pp.Version == packageVersion);
packageLogAction = logActionForExistingPackage;
}
if (!_publishedPackageRepository.Collection.Any(pp => pp.Id == publishedPackage.Id && pp.IsLatestVersion))
{
publishedPackage.IsLatestVersion = true;
}
else if (publishedPackage.IsLatestVersion)
{
_latestVersionUpdater.SetLatestVersionFlagsOfOtherVersionablesWithSameId(publishedPackage);
}
_publishedPackageRepository.Create(publishedPackage);
_packageLogEntryCreator.Create(packageId, packageVersion, packageLogAction);
}
public void UnpublishPackage(string key, string packageId, string packageVersion)
{
_packageAuthenticator.EnsureKeyCanAccessPackage(key, packageId, packageVersion);
Package package = _packageRepository.Collection.SingleOrDefault(p => p.Id == packageId && p.Version == packageVersion);
if (package == null)
{
throw new PackageDoesNotExistException(packageId, packageVersion);
}
PublishedPackage publishedPackage = _publishedPackageRepository.Collection.SingleOrDefault(p => p.Id == packageId && p.Version == packageVersion);
VerifyPackageIsInPublishedState(package, publishedPackage);
Unpublish(package, publishedPackage);
if (package.IsLatestVersion)
{
_packageRecommendedVersionManager.SetLatestVersionAsRecommended(packageId, false);
_publishedPackageRecommendedVersionManager.SetLatestVersionAsRecommended(packageId, true);
UnsetRecommendedVersion(package, publishedPackage);
}
_packageLogEntryCreator.Create(packageId, packageVersion, PackageLogAction.Unpublish);
}
