private async Task <ILibraryOperationResult> DeleteLibraryFilesAsync(ILibraryInstallationState state,
Func <IEnumerable <string>, Task <bool> > deleteFilesFunction,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
string libraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(state.Name, state.Version, state.ProviderId);
try
{
IProvider provider = _dependencies.GetProvider(state.ProviderId);
ILibraryOperationResult updatedStateResult = await provider.UpdateStateAsync(state, CancellationToken.None).ConfigureAwait(false);
if (updatedStateResult.Success)
{
List <string> filesToDelete = new List <string>();
state = updatedStateResult.InstallationState;
foreach (string file in state.Files)
{
var url = new Uri(file, UriKind.RelativeOrAbsolute);
if (!url.IsAbsoluteUri)
{
string relativePath = Path.Combine(state.DestinationPath, file).Replace('\\', '/');
filesToDelete.Add(relativePath);
}
}
bool success = true;
if (deleteFilesFunction != null)
{
success = await deleteFilesFunction.Invoke(filesToDelete).ConfigureAwait(false);
}
if (success)
{
return(LibraryOperationResult.FromSuccess(updatedStateResult.InstallationState));
}
else
{
return(LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(libraryId)));
}
}
return(updatedStateResult);
}
catch (OperationCanceledException)
{
return(LibraryOperationResult.FromCancelled(state));
}
catch (Exception)
{
return(LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(libraryId)));
}
}
/// <summary>
/// Generates a single ILibraryOperationResult with a collection of IErros based on the collection of FileConflict
/// </summary>
/// <param name="fileConflicts"></param>
/// <returns></returns>
private static ILibraryOperationResult GetConflictErrors(IEnumerable <FileConflict> fileConflicts)
{
if (fileConflicts.Any())
{
var errors = new List <IError>();
foreach (FileConflict conflictingLibraryGroup in fileConflicts)
{
errors.Add(PredefinedErrors.ConflictingFilesInManifest(conflictingLibraryGroup.File, conflictingLibraryGroup.Libraries.Select(l => l.Name).ToList()));
}
return(new LibraryOperationResult(errors.ToArray()));
}
return(LibraryOperationResult.FromSuccess(null));
}
/// <summary>
/// Validates <see cref="ILibraryInstallationState"/>
/// </summary>
/// <param name="state">The <see cref="ILibraryInstallationState"/> to validate.</param>
/// <param name="provider">The <see cref="IProvider"/> used to validate <see cref="ILibraryInstallationState"/></param>
/// <returns><see cref="ILibraryOperationResult"/> with the result of the validation</returns>
public static async Task <ILibraryOperationResult> IsValidAsync(this ILibraryInstallationState state, IProvider provider)
{
if (state == null)
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.UnknownError() }));
}
if (provider == null)
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.ProviderUnknown(provider.Id) }));
}
if (string.IsNullOrEmpty(state.Name))
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.LibraryIdIsUndefined() }));
}
ILibraryCatalog catalog = provider.GetCatalog();
try
{
await catalog.GetLibraryAsync(state.Name, state.Version, CancellationToken.None).ConfigureAwait(false);
}
catch
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.UnableToResolveSource(state.Name, state.Version, provider.Id) }));
}
if (string.IsNullOrEmpty(state.DestinationPath))
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.PathIsUndefined() }));
}
if (state.DestinationPath.IndexOfAny(Path.GetInvalidPathChars()) >= 0)
{
return(new LibraryOperationResult(state, new[] { PredefinedErrors.DestinationPathHasInvalidCharacters(state.DestinationPath) }));
}
return(LibraryOperationResult.FromSuccess(state));
}
/// <summary>
/// Validates the values of each Library property and returns a collection of ILibraryOperationResult for each of them
/// </summary>
/// <param name="libraries"></param>
/// <param name="dependencies"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private static async Task <IEnumerable <ILibraryOperationResult> > ValidatePropertiesAsync(IEnumerable <ILibraryInstallationState> libraries, IDependencies dependencies, CancellationToken cancellationToken)
{
var validationStatus = new List <ILibraryOperationResult>();
foreach (ILibraryInstallationState library in libraries)
{
cancellationToken.ThrowIfCancellationRequested();
ILibraryOperationResult result = await library.IsValidAsync(dependencies).ConfigureAwait(false);
if (!result.Success)
{
validationStatus.Add(result);
}
else
{
validationStatus.Add(LibraryOperationResult.FromSuccess(library));
}
}
return(validationStatus);
}
