QueryContinuation <IEnumerable <IPackageSearchMetadata> > GetPackageQuery(string searchTerm)
{
if (PackageManager == null)
{
return(null);
}
var selectedRepository = SelectedRepository;
var allowPrereleaseVersions = AllowPrereleaseVersions;
var updateFeed = getUpdateFeed();
if (selectedRepository == null)
{
var repositories = PackageManager.SourceRepositoryProvider.GetRepositories();
var packageQueries = repositories.Select(repository => GetPackageQuery(repository, searchTerm, allowPrereleaseVersions, updateFeed)).ToList();
if (packageQueries.Count == 1)
{
return(packageQueries[0]);
}
else
{
return(AggregateQuery.Create(packageQueries, results => results.SelectMany(xs => xs)));
}
}
return(GetPackageQuery(selectedRepository, searchTerm, allowPrereleaseVersions, updateFeed));
}
public IAggregateState FindById(DomainContext session, AggregateQuery aggregateQuery)
{
//ignoring Aggregate Version
var db = session.Set <Pizzeria.PizzeriaState>();
var aggregate = db.Include(nameof(Pizzeria.PizzeriaState.Orders))
.Single(p => p.Id == aggregateQuery.Id);
return(aggregate);
}
/// <inheritdoc />
public IAggregator Create(
IEnumerable <string> resultSetFieldNames,
string requestedQueryName,
AggregateQuery aggregateQuery)
{
Aggregator toReturn = new Aggregator(
resultSetFieldNames,
this.aggregationFieldsCache,
requestedQueryName,
aggregateQuery);
return(toReturn);
}
/// <summary>
/// Initialises a new instance of the <see cref="Aggregator" /> class.
/// </summary>
/// <param name="resultSetFieldNames">
/// A set of field names, obtained from the result set itself, upfront.
/// </param>
/// <param name="aggregationFieldsCache">
/// An instance of <see cref="AggregationFieldsCache" />.
/// </param>
/// <param name="requestedQueryName">
/// The name of the originally requested query.
/// </param>
/// <param name="aggregateQuery">
/// An instance of <see cref="AggregateQuery" />.
/// </param>
public Aggregator(
IEnumerable <string> resultSetFieldNames,
AggregationFieldsCache aggregationFieldsCache,
string requestedQueryName,
AggregateQuery aggregateQuery)
{
this.resultSetFieldNames = resultSetFieldNames;
this.aggregationFieldsCache = aggregationFieldsCache;
this.requestedQueryName = requestedQueryName;
this.aggregateQuery = aggregateQuery;
this.aggregateTotal = 0;
}
public void AggregateQueryConcatenatesIndividualQueriesIfNoOrderingButSequenceIsInvalid()
{
// Arrange
IEnumerable <IQueryable <string> > sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
GetInvalidSequence("B"),
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery <string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: false);
// Assert
ExceptionAssert.Throws <Exception>(() => aggregateQuery.ToArray(), "Bad sequence");
}
public void CountDoesNotThrowIfForInvalidRepositoriesIfFlagIsSet()
{
// Arrange
IEnumerable <IQueryable <string> > sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
GetInvalidSequence("B"),
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery <string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: true).OrderBy(c => c);
// Assert
Assert.Equal(6, aggregateQuery.Count());
}
public void AggregateQueryConcatenatesIndividualQueriesIfNoOrderingButSequenceIsInvalid()
{
// Arrange
IEnumerable<IQueryable<string>> sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
GetInvalidSequence("B"),
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery<string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: false);
// Assert
ExceptionAssert.Throws<Exception>(() => aggregateQuery.ToArray(), "Bad sequence");
}
public void CountDoesNotThrowIfForInvalidRepositoriesIfFlagIsSet()
{
// Arrange
IEnumerable<IQueryable<string>> sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
GetInvalidSequence("B"),
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery<string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: true).OrderBy(c => c);
// Assert
Assert.Equal(6, aggregateQuery.Count());
}
public void AggregateQueryConcatenatesIndividualQueriesIfNoOrderingIsAvailable()
{
// Arrange
IEnumerable <IQueryable <string> > sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery <string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: false);
// Assert
Assert.Equal(
new[] { "0C", "1C", "2C", "0A", "1A", "2A" },
aggregateQuery.ToArray()
);
}
public void AggregateQueryConcatenatesIndividualQueriesIfNoOrderingIsAvailable()
{
// Arrange
IEnumerable<IQueryable<string>> sources = new[] {
Enumerable.Range(0, 3).Select(i => i + "C").AsQueryable(),
Enumerable.Range(0, 3).Select(i => i + "A").AsQueryable(),
};
// Act
var aggregateQuery = new AggregateQuery<string>(sources, StringComparer.Ordinal, NullLogger.Instance, ignoreFailures: false);
// Assert
Assert.Equal(
new[] { "0C", "1C", "2C", "0A", "1A", "2A" },
aggregateQuery.ToArray()
);
}
public IAggregateState FindById(DomainContext session, Type stateType, AggregateQuery aggregateQuery)
{
var db = session.Set(stateType);
if (aggregateQuery.Version.HasValue)
{
var specificStateQuery = db.Where("Id.Equals(@0) AND Version = @1", aggregateQuery.Id, aggregateQuery.Version);
var specificState = specificStateQuery.Provider.Execute(
Expression.Call(
typeof(Queryable), "SingleOrDefault",
new Type[] { specificStateQuery.ElementType },
specificStateQuery.Expression));
return((IAggregateState)specificState);
}
var state = db.Find(aggregateQuery.Id);
return((IAggregateState)state);
}
protected override object OnExecute(TCommand command)
{
TAggregate aggregate = null;
using (var session = this.RepositoryFactory.OpenSession())
{
var aggregateId = this.GetAggregateId(command);
var aggregateVersion = this.GetAggregateVersion(command);
if (aggregateVersion.HasValue)
{
aggregate = session.GetById <TAggregate>(AggregateQuery.GetLatest(aggregateId, aggregateVersion.Value));
}
else
{
aggregate = session.GetById <TAggregate>(aggregateId);
}
this.Manipulate(aggregate, command);
session.CommitChanges();
return(aggregate.Id);
}
}
TAggregate IDefaultAggregateFinder <DomainContext> .FindById <TAggregate>(DomainContext session, AggregateQuery aggregateQuery)
{
var db = session.Set <TAggregate>();
if (aggregateQuery.Version.HasValue)
{
var specific = db.Where(a => a.Id == aggregateQuery.Id && a.Version == aggregateQuery.Version).SingleOrDefault();
return(specific);
}
var aggregate = db.Find(aggregateQuery.Id);
return(aggregate);
}