protected override (int, IIncrementalSource <LiveInfoListItemViewModel>) GenerateIncrementalSource()
{
var query = LiveSearchOptionsQuery.Create(Keyword, SelectedLiveStatus.Value);
if (SelectedProviders.Any())
{
query.UseProviderTypes(SelectedProviders);
}
query.UseSortOrder(SelectedSearchSort.Value);
if (IsTagSearch.Value is true)
{
query.UseIsTagSearch(true);
}
if (IsTimeshiftAvairable.Value is true)
{
query.UseTimeshiftIsAvailable(true);
}
if (IsDisableGrouping.Value is true)
{
query.UseDisableGrouping(true);
}
if (IsHideMemberOnly.Value is true)
{
query.UseHideMemberOnly(true);
}
_query = query;
return(LiveSearchSource.OneTimeLoadCount, new LiveSearchSource(query, _reservation, SearchProvider, NiconicoSession, _nicoLiveCacheRepository));
}
public override bool ProcessRecordAsync()
{
SelectedProviders.ParallelForEach(provider => {
_providersProcessed.GetOrAdd(provider.ProviderName, () => false);
try {
if (Name.IsNullOrEmpty())
{
foreach (var pkg in ProcessProvider(provider))
{
if (IsPackageInVersionRange(pkg))
{
WriteObject(pkg);
}
}
}
else
{
foreach (var n in Name)
{
foreach (var pkg in ProcessNames(provider, n))
{
if (IsPackageInVersionRange(pkg))
{
WriteObject(pkg);
}
}
}
}
} catch (Exception e) {
e.Dump();
}
});
return(true);
}
public override bool ProcessRecordAsync()
{
if (IsPackageByObject)
{
return(UninstallPackages(InputObject));
}
// otherwise, it's just packages by name
_resultsPerName = new Dictionary <string, List <SoftwareIdentity> >();
SelectedProviders.ParallelForEach(provider => {
foreach (var n in Name)
{
var c = _resultsPerName.GetOrAdd(n, () => new List <SoftwareIdentity>());
foreach (var pkg in ProcessNames(provider, n))
{
lock (c) {
if (IsPackageInVersionRange(pkg))
{
c.Add(pkg);
}
}
}
}
});
return(true);
}
public override bool ProcessRecordAsync()
{
// keep track of what package names the user asked for.
if (!Name.IsNullOrEmpty())
{
foreach (var name in Name)
{
_namesProcessed.GetOrAdd(name, () => false);
}
}
var requests = (Name.IsNullOrEmpty() ?
// if the user didn't specify any names
SelectedProviders.Select(pv => new {
query = "?",
packages = pv.GetInstalledPackages("", this.ProviderSpecific(pv)).CancelWhen(_cancellationEvent.Token)
}) :
// if the user specified a name,
SelectedProviders.SelectMany(pv => {
// for a given provider, if we get an error, we want just that provider to stop.
var host = this.ProviderSpecific(pv);
return(Name.Select(name => new {
query = name,
packages = pv.GetInstalledPackages(name, host).CancelWhen(_cancellationEvent.Token)
}));
})).ToArray();
while (WaitForActivity(requests.Select(each => each.packages)))
{
// keep processing while any of the the queries is still going.
foreach (var result in requests.Where(each => each.packages.HasData))
{
// look only at requests that have data waiting.
foreach (var package in result.packages.GetConsumingEnumerable())
{
// process the results for that set.
if (IsPackageInVersionRange(package))
{
// it only counts if the package is in the range we're looking for.
// mark down that we found something for that query
_namesProcessed.AddOrSet(result.query, true);
ProcessPackage(result.query, package);
}
}
}
// just work with whatever is not yet consumed
requests = requests.FilterWithFinalizer(each => each.packages.IsConsumed, each => each.packages.Dispose()).ToArray();
}
return(true);
}
public override bool ProcessRecordAsync()
{
if (IsSourceByObject)
{
// we've already got the package source
UpdatePackageSource(InputObject);
return(true);
}
if (string.IsNullOrWhiteSpace(Name) && string.IsNullOrWhiteSpace(Location))
{
Error(Constants.Errors.NameOrLocationRequired);
return(false);
}
// otherwise, we're just changing a source by name
var prov = SelectedProviders.ToArray();
if (Stopping)
{
return(false);
}
if (prov.Length == 0)
{
if (ProviderName.IsNullOrEmpty() || string.IsNullOrWhiteSpace(ProviderName[0]))
{
return(Error(Constants.Errors.UnableToFindProviderForSource, Name ?? Location));
}
return(Error(Constants.Errors.UnknownProvider, ProviderName[0]));
}
if (prov.Length > 0)
{
var sources = prov.SelectMany(each => each.ResolvePackageSources(this.SuppressErrorsAndWarnings(IsProcessing)).Where(source => source.IsRegistered &&
(Name == null || source.Name.EqualsIgnoreCase(Name)) || (Location == null || source.Location.EqualsIgnoreCase(Location))).ToArray()).ToArray();
if (sources.Length == 0)
{
return(Error(Constants.Errors.SourceNotFound, Name));
}
if (sources.Length > 1)
{
return(Error(Constants.Errors.SourceFoundInMultipleProviders, Name, prov.Select(each => each.ProviderName).JoinWithComma()));
}
UpdatePackageSource(sources[0]);
}
return(true);
}
protected virtual void SearchForPackages()
{
try {
var providers = SelectedProviders.ToArray();
// filter the items into three types of searches
_names = CollectionExtensions.IsNullOrEmpty(Name) ? CollectionExtensions.SingleItemAsEnumerable(string.Empty) : Name.Where(each => !IsUri(each) && !IsFile(each)).ToArray();
foreach (var n in _names)
{
Debug("Calling SearchForPackages. Name='{0}'", n);
}
ProcessRequests(providers.Where(pv => string.Equals(pv.ProviderName, "bootstrap", StringComparison.OrdinalIgnoreCase)).ToArray());
ProcessRequests(providers.Where(pv => !string.Equals(pv.ProviderName, "bootstrap", StringComparison.OrdinalIgnoreCase)).ToArray());
} catch (Exception ex) {
Debug(ex.ToString());
}
}
public override bool ProcessRecordAsync()
{
// keep track of what package names the user asked for.
if (!Name.IsNullOrEmpty())
{
foreach (var name in Name)
{
_namesProcessed.GetOrAdd(name, () => false);
}
}
var requests = (Name.IsNullOrEmpty() ?
// if the user didn't specify any names
SelectedProviders.Select(pv => new {
query = "?",
packages = pv.GetInstalledPackages("", RequiredVersion, MinimumVersion, MaximumVersion, this.ProviderSpecific(pv)).CancelWhen(CancellationEvent.Token)
}) :
// if the user specified a name,
SelectedProviders.SelectMany(pv => {
// for a given provider, if we get an error, we want just that provider to stop.
var host = this.ProviderSpecific(pv);
return(Name.Select(name => new {
query = name,
packages = pv.GetInstalledPackages(name, RequiredVersion, MinimumVersion, MaximumVersion, host).CancelWhen(CancellationEvent.Token)
}));
})).ToArray();
var potentialPackagesToProcess = new System.Collections.ObjectModel.Collection <SoftwareIdentity>();
while (WaitForActivity(requests.Select(each => each.packages)))
{
// keep processing while any of the the queries is still going.
foreach (var result in requests.Where(each => each.packages.HasData))
{
// look only at requests that have data waiting.
foreach (var package in result.packages.GetConsumingEnumerable())
{
// process the results for that set.
if (IsPackageInVersionRange(package))
{
// it only counts if the package is in the range we're looking for.
// mark down that we found something for that query
_namesProcessed.AddOrSet(result.query, true);
potentialPackagesToProcess.Add(package);
}
}
}
// just work with whatever is not yet consumed
requests = requests.FilterWithFinalizer(each => each.packages.IsConsumed, each => each.packages.Dispose()).ToArray();
} // end of WaitForActivity()
// post processing the potential packages as we have to display only
// 1 package per name (note multiple versions of the same package may be installed)
// In general, it is good practice to show only the latest one.
foreach (var potentialPackage in from p in potentialPackagesToProcess
group p by p.Name
into grouping
select grouping.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).First()
)
{
ProcessPackage(potentialPackage.CanonicalId, potentialPackage);
}
return(true);
}
public override bool ProcessRecordAsync()
{
if (IsSourceByObject)
{
foreach (var source in InputObject)
{
if (Stopping)
{
return(false);
}
var provider = SelectProviders(source.ProviderName).FirstOrDefault();
if (provider == null)
{
if (string.IsNullOrWhiteSpace(source.ProviderName))
{
return(Error(Constants.Errors.UnableToFindProviderForSource, source.Name));
}
return(Error(Constants.Errors.UnknownProvider, source.ProviderName));
}
Unregister(source);
}
return(true);
}
if (string.IsNullOrWhiteSpace(Source) && string.IsNullOrWhiteSpace(Location))
{
Error(Constants.Errors.NameOrLocationRequired);
return(false);
}
// otherwise, we're just deleting a source by name
var prov = SelectedProviders.ToArray();
if (Stopping)
{
return(false);
}
if (prov.Length == 0)
{
if (ProviderName.IsNullOrEmpty() || string.IsNullOrWhiteSpace(ProviderName[0]))
{
return(Error(Constants.Errors.UnableToFindProviderForSource, Source ?? Location));
}
return(Error(Constants.Errors.UnknownProvider, ProviderName[0]));
}
if (prov.Length > 0)
{
var sources = prov.SelectMany(each => each.ResolvePackageSources(this.SuppressErrorsAndWarnings(IsProcessing)).Where(source => source.IsRegistered && (source.Name.EqualsIgnoreCase(Source) || source.Location.EqualsIgnoreCase(Source) || source.Location.EqualsIgnoreCase(Location))).ToArray()).ToArray();
if (sources.Length == 0)
{
return(Error(Constants.Errors.SourceNotFound, Source ?? Location));
}
if (sources.Length > 1)
{
return(Error(Constants.Errors.SourceFoundInMultipleProviders, Source ?? Location, prov.Select(each => each.ProviderName).JoinWithComma()));
}
return(Unregister(sources[0]));
}
return(true);
}
protected void SearchForPackages()
{
var providers = SelectedProviders.ToArray();
// filter the items into three types of searches
_names = Name.IsNullOrEmpty() ? string.Empty.SingleItemAsEnumerable() : Name.Where(each => !IsUri(each) && !IsFile(each)).ToArray();
var requests = SelectedProviders.SelectMany(pv => {
// for a given provider, if we get an error, we want just that provider to stop.
var host = this.ProviderSpecific(pv);
var a = _uris.Select(uri => new {
query = new List <string> {
uri.AbsolutePath
},
provider = pv,
packages = pv.FindPackageByUri(uri, host).CancelWhen(CancellationEvent.Token)
});
var b = _files.Keys.Where(file => pv.IsSupportedFile(_files[file].Item2)).Select(file => new {
query = _files[file].Item1,
provider = pv,
packages = pv.FindPackageByFile(file, host)
});
var c = _names.Select(name => new {
query = new List <string> {
name
},
provider = pv,
packages = pv.FindPackage(name, RequiredVersion, MinimumVersion, MaximumVersion, host)
});
return(a.Concat(b).Concat(c));
}).ToArray();
if (AllVersions || !SpecifiedMinimumOrMaximum)
{
// the user asked for every version or they didn't specify any version ranges
// either way, that means that we can just return everything that we're finding.
while (WaitForActivity(requests.Select(each => each.packages)))
{
// keep processing while any of the the queries is still going.
foreach (var result in requests.Where(each => each.packages.HasData))
{
// look only at requests that have data waiting.
foreach (var package in result.packages.GetConsumingEnumerable())
{
// process the results for that set.
ProcessPackage(result.provider, result.query, package);
}
}
// filter out whatever we're done with.
requests = requests.FilterWithFinalizer(each => each.packages.IsConsumed, each => each.packages.Dispose()).ToArray();
}
}
else
{
// now this is where it gets a bit funny.
// the user specified a min or max
// and so we have to only return the highest one in the set for a given package.
while (WaitForActivity(requests.Select(each => each.packages)))
{
// keep processing while any of the the queries is still going.
foreach (var perProvider in requests.GroupBy(each => each.provider))
{
foreach (var perQuery in perProvider.GroupBy(each => each.query))
{
if (perQuery.All(each => each.packages.IsCompleted && !each.packages.IsConsumed))
{
foreach (var pkg in from p in perQuery.SelectMany(each => each.packages.GetConsumingEnumerable())
group p by new { p.Name, p.Source }
// for a given name
into grouping
// get the latest version only
select grouping.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance).First())
{
ProcessPackage(perProvider.Key, perQuery.Key, pkg);
}
}
}
}
// filter out whatever we're done with.
requests = requests.FilterWithFinalizer(each => each.packages.IsConsumed, each => each.packages.Dispose()).ToArray();
}
}
// dispose of any requests that didn't get cleaned up earlier.
foreach (var i in requests)
{
i.packages.Dispose();
}
}
public override bool ProcessRecordAsync()
{
ValidateVersion(RequiredVersion);
ValidateVersion(MinimumVersion);
ValidateVersion(MaximumVersion);
// If AllVersions is specified, make sure other version parameters are not supplied
if (AllVersions.IsPresent)
{
if ((!string.IsNullOrWhiteSpace(RequiredVersion)) || (!string.IsNullOrWhiteSpace(MinimumVersion)) || (!string.IsNullOrWhiteSpace(MaximumVersion)))
{
Error(Constants.Errors.AllVersionsCannotBeUsedWithOtherVersionParameters);
}
}
// Cannot have Max/Min version parameters with RequiredVersion
if (RequiredVersion != null)
{
if ((!string.IsNullOrWhiteSpace(MaximumVersion)) || (!string.IsNullOrWhiteSpace(MinimumVersion)))
{
Error(Constants.Errors.VersionRangeAndRequiredVersionCannotBeSpecifiedTogether);
}
}
// keep track of what package names the user asked for.
if (!Name.IsNullOrEmpty())
{
foreach (var name in Name)
{
_namesProcessed.GetOrAdd(name, () => false);
}
}
var requests = (Name.IsNullOrEmpty() ?
// if the user didn't specify any names
SelectedProviders.Select(pv => new {
query = "?",
packages = pv.GetInstalledPackages("", RequiredVersion, MinimumVersion, MaximumVersion, this.ProviderSpecific(pv)).CancelWhen(CancellationEvent.Token)
}) :
// if the user specified a name,
SelectedProviders.SelectMany(pv => {
// for a given provider, if we get an error, we want just that provider to stop.
var host = this.ProviderSpecific(pv);
return(Name.Select(name => new {
query = name,
packages = pv.GetInstalledPackages(name, RequiredVersion, MinimumVersion, MaximumVersion, host).CancelWhen(CancellationEvent.Token)
}));
})).ToArray();
var potentialPackagesToProcess = new System.Collections.ObjectModel.Collection <SoftwareIdentity>();
while (WaitForActivity(requests.Select(each => each.packages)))
{
// keep processing while any of the the queries is still going.
foreach (var result in requests.Where(each => each.packages.HasData))
{
// look only at requests that have data waiting.
foreach (var package in result.packages.GetConsumingEnumerable())
{
// process the results for that set.
if (IsPackageInVersionRange(package))
{
// it only counts if the package is in the range we're looking for.
// mark down that we found something for that query
_namesProcessed.AddOrSet(result.query, true);
// If AllVersions is specified, process the package immediately
if (AllVersions)
{
// Process the package immediately if -AllVersions are required
ProcessPackage(package);
}
else
{
// Save to perform post-processing to eliminate duplicate versions and group by Name
potentialPackagesToProcess.Add(package);
}
}
}
}
// just work with whatever is not yet consumed
requests = requests.FilterWithFinalizer(each => each.packages.IsConsumed, each => each.packages.Dispose()).ToArray();
} // end of WaitForActivity()
// Peform post-processing only if -AllVersions is not specified
if (!AllVersions)
{
// post processing the potential packages as we have to display only
// 1 package per name (note multiple versions of the same package may be installed)
// In general, it is good practice to show only the latest one.
// However there are cases when the same package can be found by different providers. in that case, we will show
// the packages from different providers even through they have the same package name. This is important because uninstall-package
// inherts from get-package, so that when the first provider does not implement the uninstall-package(), such as Programs, others will
// perform the uninstall.
//grouping packages by package name first
var enumerablePotentialPackages = from p in potentialPackagesToProcess
group p by p.Name
into grouping
select grouping.OrderByDescending(pp => pp, SoftwareIdentityVersionComparer.Instance);
//each group of packages with the same name, return the first if the packages are from the same provider
foreach (var potentialPackage in enumerablePotentialPackages.Select(pp => (from p in pp
group p by p.ProviderName
into grouping
select grouping.OrderByDescending(each => each, SoftwareIdentityVersionComparer.Instance).First())).SelectMany(pkgs => pkgs.ToArray()))
{
ProcessPackage(potentialPackage);
}
}
return(true);
}
protected void SearchForPackages()
{
var providers = SelectedProviders.ToArray();
if (!Name.IsNullOrEmpty())
{
Name.ParallelForEach(name => {
var found = false;
if (Uri.IsWellFormedUriString(name, UriKind.Absolute))
{
// try everyone as via uri
var packageUri = new Uri(name, UriKind.Absolute);
if (!packageUri.IsFile)
{
providers.ParallelForEach(provider => {
try {
found = found | FindViaUri(provider, name, packageUri);
} catch (Exception e) {
e.Dump();
}
});
// we're done searching for this provider
return;
}
// file uris should be treated like files, not uris.
}
var files = FindFiles(name);
if (files.Any())
{
lock (_filesWithoutMatches) {
foreach (var file in files)
{
_filesWithoutMatches.Add(file, name);
}
}
// they specified something that looked kinda like a
// file path, and it actually matched some files on disk
// so we're going to assume that they meant to treat it
// as a file.
files.ParallelForEach(file => {
SelectProvidersSupportingFile(providers, file).ParallelForEach(pv => {
try {
FindViaFile(pv, name, file);
} catch (Exception e) {
e.Dump();
}
});
});
return;
}
_resultsPerName.GetOrAdd(name, null);
// it didn't match any files
// and it's not a uri of any kind
// so we'll just ask if there is a package by that name.
providers.ParallelForEach(provider => {
try {
#if DEEP_DEBUG
Console.WriteLine("Processing find via name [{0}]", provider.Name);
#endif
FindViaName(provider, name);
#if DEEP_DEBUG
Console.WriteLine("Done Processing find via name [{0}]", provider.Name);
#endif
} catch (Exception e) {
e.Dump();
}
});
});
}
else
{
providers.ParallelForEach(provider => {
try {
if (!FindViaName(provider, string.Empty))
{
// nothing found?
_providersNotFindingAnything.AddLocked(provider);
}
} catch (Exception e) {
e.Dump();
}
});
}
/*
* Parallel.ForEach(SelectedProviders, provider => {
* try {
* if (!Name.IsNullOrEmpty()) {
* foreach (var each in Name) {
* // check if the parameter is an uri
* if (FindViaUri(provider, each)) {
* continue;
* }
*
* // then if it's a file
* if (FindViaFile(provider, each)) {
* continue;
* }
*
* // otherwise, it's just a name
* FindViaName(provider, each);
* }
* return;
* }
*
* // no package name passed in.
* if (!FindViaName(provider, string.Empty)) {
* // nothing found?
* _providersNotFindingAnything.AddLocked(provider);
* }
* } catch (Exception e) {
* e.Dump();
* }
* });
*/
}
