public RootFolderService(IBasicRepository<RootFolder> rootFolderRepository,
IDiskProvider diskProvider,
ISeriesRepository seriesRepository,
IConfigService configService)
{
_rootFolderRepository = rootFolderRepository;
_diskProvider = diskProvider;
_seriesRepository = seriesRepository;
_configService = configService;
}
public static async Task EnsureCollectionLoadedAsync <TEntity, TKey, TProperty>(
this IBasicRepository <TEntity, TKey> repository,
TEntity entity,
Expression <Func <TEntity, IEnumerable <TProperty> > > propertyExpression,
CancellationToken cancellationToken = default
)
where TEntity : class, IEntity <TKey>
where TProperty : class
{
var repo = ProxyHelper.UnProxy(repository) as ISupportsExplicitLoading <TEntity, TKey>;
if (repo != null)
{
await repo.EnsureCollectionLoadedAsync(entity, propertyExpression, cancellationToken).ConfigureAwait(false);
}
}
private static async Task HardDeleteWithUnitOfWorkAsync <TEntity>(
IBasicRepository <TEntity> repository,
TEntity entity,
bool autoSave,
CancellationToken cancellationToken, IUnitOfWork currentUow
)
where TEntity : class, IEntity, ISoftDelete
{
var hardDeleteEntities = (HashSet <IEntity>)currentUow.Items.GetOrAdd(
UnitOfWorkItemNames.HardDeletedEntities,
() => new HashSet <IEntity>()
);
hardDeleteEntities.Add(entity);
await repository.DeleteAsync(entity, autoSave, cancellationToken);
}
public BaseQueryType(IBasicRepository <TSet> repo, ISessionWrapper session)
{
Field(
type: typeof(TSetType),
name: nameof(repo.QueryData),
description: SystemCP.DESC_QueryData,
arguments: new QueryArguments(new QueryArgument <ListGraphType <IdGraphType> > {
Name = SystemCP.KeyVal, Description = SystemCP.DESC_KeyVal
}, new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = SystemCP.JWT, Description = SystemCP.DESC_JWT
}),
resolve: context =>
{
object[] keyVal = (context.GetArgument <object>(SystemCP.KeyVal) as List <object>).ToArray();
if (!BaseOperateComm <TSet> .CheckAuthority(context, session, repo, FuncAction.Query, keyVal))
{
return(default);
private static IUnitOfWorkManager GetUnitOfWorkManager<TEntity>(
this IBasicRepository<TEntity> repository,
[CallerMemberName] string callingMethodName = nameof(GetUnitOfWorkManager)
)
where TEntity : class, IEntity
{
if (ProxyHelper.UnProxy(repository) is not IUnitOfWorkManagerAccessor unitOfWorkManagerAccessor)
{
throw new AbpException($"The given repository (of type {repository.GetType().AssemblyQualifiedName}) should implement the " +
$"{typeof(IUnitOfWorkManagerAccessor).AssemblyQualifiedName} interface in order to invoke the {callingMethodName} method!");
}
if (unitOfWorkManagerAccessor.UnitOfWorkManager == null)
{
throw new AbpException($"{nameof(unitOfWorkManagerAccessor.UnitOfWorkManager)} property of the given {nameof(repository)} object is null!");
}
return unitOfWorkManagerAccessor.UnitOfWorkManager;
}
public SongsController(IFreeSql fsql,
GuidRepository <Song> repos1,
GuidRepository <xxxx> repos2,
DefaultRepository <Song, int> repos11,
DefaultRepository <xxxx, int> repos21,
BaseRepository <Song> repos3, BaseRepository <Song, int> repos4,
IBasicRepository <Song> repos31, IBasicRepository <Song, int> repos41,
IReadOnlyRepository <Song> repos311, IReadOnlyRepository <Song, int> repos411
)
{
_songRepository = repos4;
//test code
var curd1 = fsql.GetRepository <Song, int>();
var curd2 = fsql.GetRepository <Song, string>();
var curd3 = fsql.GetRepository <Song, Guid>();
var curd4 = fsql.GetGuidRepository <Song>();
}
public async static Task HardDeleteAsync<TEntity>(
this IBasicRepository<TEntity> repository,
IEnumerable<TEntity> entities,
bool autoSave = false,
CancellationToken cancellationToken = default
)
where TEntity : class, IEntity, ISoftDelete
{
var uowManager = repository.GetUnitOfWorkManager();
if (uowManager.Current == null)
{
using (var uow = uowManager.Begin())
{
await HardDeleteWithUnitOfWorkAsync(repository, entities, autoSave, cancellationToken, uowManager.Current);
await uow.CompleteAsync(cancellationToken);
}
}
else
{
await HardDeleteWithUnitOfWorkAsync(repository, entities, autoSave, cancellationToken, uowManager.Current);
}
}
public Transaction_Tests()
{
_personRepository = GetRequiredService <IBasicRepository <Person, Guid> >();
_unitOfWorkManager = GetRequiredService <IUnitOfWorkManager>();
}
public Transaction_Tests()
{
_personRepository = ServiceProvider.GetRequiredService <IBasicRepository <Person, Guid> >();
_bookRepository = ServiceProvider.GetRequiredService <IBasicRepository <BookInSecondDbContext, Guid> >();
_unitOfWorkManager = ServiceProvider.GetRequiredService <IUnitOfWorkManager>();
}
/// <summary>
/// Creates a new instance of the <see cref="QueryController"/>.
/// </summary>
/// <param name="repository">The <see cref="IBasicRepository{Employee}"/> repository to use.</param>
/// <param name="serviceProvider">The <see cref="IServiceProvider"/> for dependency resolution.</param>
public QueryController(IBasicRepository <Employee> repository, IServiceProvider serviceProvider)
{
_repository = repository;
_serviceProvider = serviceProvider;
}
public static IEnumerable <TParent> LoadSubtype <TParent, TChild>(this IEnumerable <TParent> parents, Func <TParent, int> foreignKeySelector, IBasicRepository <TChild> childRepository)
where TChild : ModelBase, new()
where TParent : RestResource
{
var parentList = parents.Where(p => foreignKeySelector(p) != 0).ToList();
if (!parentList.Any())
{
return(parents);
}
var ids = parentList.Select(foreignKeySelector).Distinct();
var childDictionary = childRepository.Get(ids).ToDictionary(child => child.Id, child => child);
var childSetter = GetChildSetter <TParent, TChild>();
foreach (var episode in parentList)
{
childSetter.Invoke(episode, new object[] { childDictionary[foreignKeySelector(episode)] });
}
return(parents);
}
internal static TEntity FoundEntity <TEntity>(this IBasicRepository <TEntity, Guid> repo) where TEntity : BaseEntity
{
return(repo.FoundEntity(Guid.NewGuid()));
}
public CalculationController(IBasicRepository <Calculation> repository, IServiceProvider serviceProvider)
{
_repository = repository;
_serviceProvider = serviceProvider;
}
public static IMongoDbRepository <TEntity, TKey> ToMongoDbRepository <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
var mongoDbRepository = repository as IMongoDbRepository <TEntity, TKey>;
if (mongoDbRepository == null)
{
throw new ArgumentException("Given repository does not implement " + typeof(IMongoDbRepository <TEntity, TKey>).AssemblyQualifiedName, nameof(repository));
}
return(mongoDbRepository);
}
public static Task <IMemoryDatabase> GetDatabaseAsync <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToMemoryDbRepository().GetDatabaseAsync());
}
public NamingConfigService(IBasicRepository<NamingConfig> repository)
{
_repository = repository;
}
public static Task <IMongoCollection <TEntity> > GetCollectionAsync <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToMongoDbRepository().GetCollectionAsync());
}
public BasicViewModel(IBasicRepository repository) : base(repository)
{
}
/// <summary>
/// Creates a new instance of the <see cref="QueryController"/>.
/// </summary>
/// <param name="repo">The <see cref="IBasicRepository{Contact}"/> repo to use.</param>
/// <param name="provider">The <see cref="IServiceProvider"/> for dependency resolution.</param>
public QueryController(IBasicRepository <Contact> repo,
IServiceProvider provider)
{
_repo = repo;
_serviceProvider = provider;
}
public CreateCalculationTests(IBasicRepository <Calculation> calculationRepository, UnitOfWork <FilippSystemContext, Calculation> unitOfWork)
{
_contextOptions = new DbContextOptionsBuilder <FilippSystemContext>()
.UseSqlite("Filename=Calculation-Test.db").Options;
_unitOfWork = unitOfWork;
}
public static IMongoDatabase GetDatabase <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToMongoDbRepository().Database);
}
public TestDataBuilder(IBasicRepository <Person, Guid> personRepository)
{
_personRepository = personRepository;
}
public static IMongoCollection <TEntity> GetCollection <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToMongoDbRepository().Collection);
}
public BaseSchema(IBasicRepository <TSet> repo, ISessionWrapper session) : base()
{
Query = LibData.Build <TQuery>()(new object[] { repo, session }) as IObjectGraphType;
}
public static Task <IMongoQueryable <TEntity> > GetMongoQueryableAsync <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToMongoDbRepository().GetMongoQueryableAsync());
}
public FunnyController(IBasicRepository repository)
{
_repo = repository;
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="repository"></param>
/// <returns></returns>
public static DbContext GetDbContext <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
return(repository.ToEfCoreRepository().DbContext);
}
public DbContext_Replace_Tests()
{
_dummyRepository = ServiceProvider.GetRequiredService <IBasicRepository <ThirdDbContextDummyEntity, Guid> >();
_unitOfWorkManager = ServiceProvider.GetRequiredService <IUnitOfWorkManager>();
}
public SecondContextTestDataBuilder(IBasicRepository <BookInSecondDbContext, Guid> bookRepository, IGuidGenerator guidGenerator)
{
_bookRepository = bookRepository;
_guidGenerator = guidGenerator;
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <param name="repository"></param>
/// <returns></returns>
public static IEfCoreRepository <TEntity, TKey> ToEfCoreRepository <TEntity, TKey>(this IBasicRepository <TEntity, TKey> repository)
where TEntity : class, IEntity <TKey>
{
if (!(repository is IEfCoreRepository <TEntity, TKey> efCoreRepository))
{
throw new ArgumentException("Given repository does not implement " + typeof(IEfCoreRepository <TEntity, TKey>).AssemblyQualifiedName, nameof(repository));
}
return(efCoreRepository);
}
public NewsController(IBasicRepository repo)
{
_repo = repo;
}
public BasicService(IBasicRepository <T> repository)
{
_repo = repository;
}
