/// <summary>
/// Get an IAggregateFluent of parents matching a supplied IAggregateFluent of children for this relationship.
/// </summary>
/// <typeparam name="TParent">The type of the parent Entity</typeparam>
/// <param name="children">An IAggregateFluent of children</param>
public IAggregateFluent <TParent> ParentsFluent <TParent>(IAggregateFluent <TChild> children) where TParent : Entity
{
if (typeof(TParent) == typeof(TChild))
{
throw new InvalidOperationException("Both parent and child types cannot be the same");
}
if (inverse)
{
return(children
.Lookup <TChild, JoinRecord, Joined <JoinRecord> >(
JoinCollection,
c => c.ID,
r => r.ParentID,
j => j.Results)
.ReplaceRoot(j => j.Results[0])
.Lookup <JoinRecord, TParent, Joined <TParent> >(
DB.Collection <TParent>(),
r => r.ChildID,
p => p.ID,
j => j.Results)
.ReplaceRoot(j => j.Results[0])
.Distinct());
}
else
{
return(children
.Lookup <TChild, JoinRecord, Joined <JoinRecord> >(
JoinCollection,
c => c.ID,
r => r.ChildID,
j => j.Results)
.ReplaceRoot(j => j.Results[0])
.Lookup <JoinRecord, TParent, Joined <TParent> >(
DB.Collection <TParent>(),
r => r.ParentID,
p => p.ID,
j => j.Results)
.ReplaceRoot(j => j.Results[0])
.Distinct());
}
}
/// <summary>
/// Get an IQueryable of parents matching a supplied IQueryable of children for this relationship.
/// </summary>
/// <typeparam name="TParent">The type of the parent Entity</typeparam>
/// <param name="children">An IQueryable of children</param>
/// <param name="options">An optional AggregateOptions object</param>
public IMongoQueryable <TParent> ParentsQueryable <TParent>(IMongoQueryable <TChild> children, AggregateOptions options = null) where TParent : Entity
{
if (typeof(TParent) == typeof(TChild))
{
throw new InvalidOperationException("Both parent and child types cannot be the same");
}
if (inverse)
{
return(children
.Join(
JoinQueryable(options),
c => c.ID,
j => j.ParentID,
(c, j) => j)
.Join(
DB.Collection <TParent>(),
j => j.ChildID,
p => p.ID,
(j, p) => p)
.Distinct());
}
else
{
return(children
.Join(
JoinQueryable(options),
c => c.ID,
j => j.ChildID,
(c, j) => j)
.Join(
DB.Collection <TParent>(),
j => j.ParentID,
p => p.ID,
(j, p) => p)
.Distinct());
}
}
/// <summary>
/// Run the update command in MongoDB.
/// </summary>
/// <param name="cancellation">An optional cancellation token</param>
public async Task <UpdateResult> ExecuteAsync(CancellationToken cancellation = default)
{
if (models.Count > 0)
{
var bulkWriteResult = await(
session == null
? DB.Collection <T>().BulkWriteAsync(models, null, cancellation)
: DB.Collection <T>().BulkWriteAsync(session, models, null, cancellation)
).ConfigureAwait(false);
models.Clear();
return(new UpdateResult.Acknowledged(bulkWriteResult.MatchedCount, bulkWriteResult.ModifiedCount, null));
}
else
{
if (filter == Builders <T> .Filter.Empty)
{
throw new ArgumentException("Please use Match() method first!");
}
if (defs.Count == 0)
{
throw new ArgumentException("Please use Modify() method first!");
}
if (stages.Count > 0)
{
throw new ArgumentException("Regular updates and Pipeline updates cannot be used together!");
}
if (ShouldSetModDate())
{
Modify(b => b.CurrentDate(Cache <T> .ModifiedOnPropName));
}
return(await UpdateAsync(filter, Builders <T> .Update.Combine(defs), options, session, cancellation).ConfigureAwait(false));
}
}
/// <summary> /// Gets the IMongoCollection for a given IEntity type. /// <para>TIP: Try never to use this unless really neccessary.</para> /// </summary> /// <typeparam name="T">Any class that implements IEntity</typeparam> public static IMongoCollection <T> Collection <T>(this T _) where T : IEntity => DB.Collection <T>();
/// <summary>
/// Gets the IMongoCollection for a given IEntity type.
/// <para>TIP: Try never to use this unless really neccessary.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
public static IMongoCollection <T> Collection <T>(this T entity) where T : IEntity
{
return(DB.Collection <T>(entity.Database()));
}
/// <summary>
/// An IQueryable collection of Entities.
/// </summary>
public static IMongoQueryable <T> Collection <T>(this T entity) where T : Entity
{
return(DB.Collection <T>());
}
private Task <UpdateResult> UpdateAsync(FilterDefinition <T> filter, UpdateDefinition <T> definition, UpdateOptions options, IClientSessionHandle session = null, CancellationToken cancellation = default)
{
return(session == null
? DB.Collection <T>().UpdateManyAsync(filter, definition, options, cancellation)
: DB.Collection <T>().UpdateManyAsync(session, filter, definition, options, cancellation));
}
/// <summary>
/// Gets the IMongoCollection for a given IEntity type.
/// <para>TIP: Try never to use this unless really neccessary.</para>
/// </summary>
/// <typeparam name="T">Any class that implements IEntity</typeparam>
public static IMongoCollection <T> Collection <T>(this T _) where T : IEntity
{
return(DB.Collection <T>());
}
/// <summary>
/// Fetches the actual entity this reference represents from the database.
/// </summary>
/// <returns>A Task containing the actual entity</returns>
async public Task <T> ToEntityAsync()
{
return(await DB.Collection <T>().SingleOrDefaultAsync(e => e.ID.Equals(ID)));
}
private Task CreateAsync(CreateIndexModel <T> model, CancellationToken cancellation = default)
{
return(DB.Collection <T>().Indexes.CreateOneAsync(model, cancellationToken: cancellation));
}
/// <summary>
/// Drops all indexes for this entity type
/// </summary>
/// <param name="cancellation">An optional cancellation token</param>
public async Task DropAllAsync(CancellationToken cancellation = default)
{
await DB.Collection <T>().Indexes.DropAllAsync(cancellation).ConfigureAwait(false);
}
/// <summary>
/// Drops an index by name for this entity type
/// </summary>
/// <param name="name">The name of the index to drop</param>
/// <param name="cancellation">An optional cancellation token</param>
public async Task DropAsync(string name, CancellationToken cancellation = default)
{
await DB.Collection <T>().Indexes.DropOneAsync(name, cancellation).ConfigureAwait(false);
}