//private readonly IRepositoryBulkReader BulkReader;
//private readonly Lazy<World>[] LazyWorlds = new Lazy<World>[512];
public Context(IObjectFactory factory, IDatabaseQueryManager manager)
{
var scope = factory.CreateScope(null);
scope.RegisterInterfaces(manager.StartQuery(false));
WorldRepository = scope.Resolve<IPersistableRepository<World>>();
FortuneRepository = scope.Resolve<IQueryableRepository<Fortune>>();
//BulkReader = scope.BulkRead(ChunkedMemoryStream.Static());
}
/// <summary>
/// Check for any data of specified type.
/// </summary>
/// <typeparam name="TValue">data type</typeparam>
/// <param name="repository">queryable repository</param>
/// <returns>items has been found</returns>
public static bool Exists <TValue>(this IQueryableRepository <TValue> repository)
where TValue : IDataSource
{
Contract.Requires(repository != null);
return(repository.Exists <TValue>(null));
}
/// <summary>
/// Search all data of specified type.
/// </summary>
/// <typeparam name="TValue">data type</typeparam>
/// <param name="repository">queryable repository</param>
/// <returns>found items</returns>
public static TValue[] Search <TValue>(this IQueryableRepository <TValue> repository)
where TValue : IDataSource
{
Contract.Requires(repository != null);
return(repository.Search <TValue>(null, null, null));
}
public FilesController(
IQueryableRepository <Models.FileInfo> filesRepository,
IBlobRepository blobRepository)
{
this.filesRepository = filesRepository;
this.blobRepository = blobRepository;
}
public CustomerController(ICustomerService customerService, IQueryableRepository <Customer> queryableRepository, IQueryableRepository <vwRP_StockCount> totalRowsRepository, IUserService userService)
{
_customerService = customerService;
_queryableRepository = queryableRepository;
_totalRowsRepository = totalRowsRepository;
_userService = userService;
}
public void test_fluent_delete_of_department_should_delete_the_underlying_employee()
{
//Arrange
ICommandRepository <Department> departmentCommandRepository = GetCommandRepositoryInstance <Department>();
ICommandRepository <Employee> employeeCommandRepository = GetCommandRepositoryInstance <Employee>();
IQueryableRepository <Employee> employeeQueryableRepository = GetQueryableRepositoryInstance <Employee>();
Department departmentFake = FakeData.GetDepartmentFake();
Employee employeeFake = FakeData.GetEmployeeFake();
employeeFake.EmployeeName = "XYZ";
employeeFake.DeptID = departmentFake.Id;
employeeFake.Department = departmentFake;
int employeesCount = 0;
//Action
//Employee insert will automatically insert the department object before inserting this employee object
//since department object is marked as required in the employee map.
// Should delete the employee object automatically since the map is defined so
// (WillCascadeOnDelete is set to true).
FluentRepoNamespace.FluentRepository
.SetUpCommandRepository(employeeCommandRepository, departmentCommandRepository)
.Insert(employeeFake)
.DeleteAsync(departmentFake)
.SetUpQueryRepository(employeeQueryableRepository)
.Query <Employee>(x => x, x => employeesCount = x.Count())
.ExecuteAsync(shouldAutomaticallyDisposeAllDisposables: true);
//Assert
employeesCount.Should().Be(0);
}
public EventsController(
IQueryableRepository <Entities.EventInfo> eventsRepository,
IHubContext <EventHub> eventHub)
{
this.eventsRepository = eventsRepository;
this.eventHub = eventHub;
}
private static void TestGroup <TEntity, TGroup>(
RhetosTestContainer container, IQueryableRepository <IEntity> entityRepository,
TGroup group, string format, string expectedCode)
where TEntity : class, IEntity, new()
{
var writeableRepository = (IWritableRepository <TEntity>)entityRepository;
Guid id = Guid.NewGuid();
dynamic entity = new TEntity();
entity.ID = id;
entity.Code = format;
try
{
entity.Grouping = group;
}
catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException)
{
entity.GroupingID = ((dynamic)group).ID;
}
writeableRepository.Insert((TEntity)entity);
var query = entityRepository.Query().Where(e => e.ID == id);
Console.WriteLine(query.GetType().FullName);
Console.WriteLine(query.Expression.ToString());
Console.WriteLine(query.ToString());
dynamic loaded = query.Single();
string generatedCode = loaded.Code;
Console.WriteLine(format + " => " + generatedCode);
Assert.AreEqual(expectedCode, generatedCode);
}
public static IFetchStrategy <TEntity, TId> Include <TEntity, TId>(this IQueryableRepository <TEntity, TId> repository, Expression <Func <TEntity, object> > selector)
where TEntity : IEntity <TId>
where TId : struct, IEquatable <TId>
{
var fs = new GenericFetchStrategy <TEntity, TId>(repository);
return(fs.ThenInclude(selector));
}
public static IQueryable <TSource> Find <TSource, TCondition>(
this IQueryableRepository <TSource> repository,
Expression <Func <TCondition, bool> > condition)
where TSource : TCondition
where TCondition : IDataSource
{
return(repository.Query(new SpecificationByExpression <TCondition>(condition)));
}
public void SetUp()
{
_productRepository = ContainerSpecification.Resolve<IQueryableRepository<Product>>();
_database = ContainerSpecification.Resolve<MongoDatabase>();
_collectionName = typeof (Product).Name.ToLower();
_collection = _database.GetCollection<Product>(_collectionName);
}
public BuyController(IBuyService buyService, IQueryableRepository <Buy> queryableRepository, IQueryableRepository <vwRP_StockCount> totalRowsRepository, IQueryableRepository <Gift> giftQueryableRepository, IQueryableRepository <User> userQueryableRepository)
{
_buyService = buyService;
_queryableRepository = queryableRepository;
_totalRowsRepository = totalRowsRepository;
_giftQueryableRepository = giftQueryableRepository;
_userQueryableRepository = userQueryableRepository;
}
public BuyUserController(IQueryableRepository <Gift> giftQueryableRepository, IQueryableRepository <Brand> brandQueryableRepository, IQueryableRepository <Category> categoryQueryableRepository, IGiftService giftService, IBuyService buyService, IQueryableRepository <User> userQueryableRepository)
{
_giftQueryableRepository = giftQueryableRepository;
_brandQueryableRepository = brandQueryableRepository;
_categoryQueryableRepository = categoryQueryableRepository;
_giftService = giftService;
_buyService = buyService;
_userQueryableRepository = userQueryableRepository;
}
public async Task test_sql_fluent_insert_multiple_employees_alongwith_department_with_explicit_transaction_scope_with_exception_thrown_in_between_should_rollback()
{
//Arrange
IUnitOfWork unitOfWorkWithExceptionToBeThrown = GetUnitOfWorkInstance(true);
ICommandRepository <Department> departmentCommandRepository = GetCommandRepositoryInstance <Department>();
ICommandRepository <Employee> employeeCommandRepository = GetCommandRepositoryInstance <Employee>();
IQueryableRepository <Department> departmentQueryableRepository = GetQueryableRepositoryInstance <Department>();
IQueryableRepository <Employee> employeeQueryableRepository = GetQueryableRepositoryInstance <Employee>();
Department departmentFake = FakeData.GetDepartmentFake();
Department departmentFake2 = FakeData.GetDepartmentFake(2);
Employee managerEmployeeFake = FakeData.GetEmployeeFake();
managerEmployeeFake.EmployeeName = "XYZ";
managerEmployeeFake.DeptID = departmentFake.Id;
managerEmployeeFake.Department = departmentFake;
Employee subEmployeeFake = FakeData.GetEmployeeFake(2);
subEmployeeFake.DeptID = departmentFake.Id;
subEmployeeFake.Department = departmentFake;
subEmployeeFake.ManagerId = managerEmployeeFake.Id;
subEmployeeFake.Manager = managerEmployeeFake;
int departmentsCount = 0;
int employeesCount = 0;
//Action
/// Order of operations of different instances of same type or different types needs to be handled at
/// the Business or Service Layer.
/// Order of deletion is important because of parent-child relationship.
FluentRepoNamespace.FluentRepository
.SetUpCommandRepository(employeeCommandRepository, departmentCommandRepository)
.Delete <Employee>(new List <Employee> {
subEmployeeFake, managerEmployeeFake
})
.Delete <Department>(new List <Department> {
departmentFake, departmentFake2
})
.Execute();
await FluentRepoNamespace.FluentRepository
.WithUnitOfWork(unitOfWorkWithExceptionToBeThrown)
.SetUpCommandRepository(employeeCommandRepository, departmentCommandRepository)
.InsertAsync <Employee>(new List <Employee> {
managerEmployeeFake, subEmployeeFake
})
.Insert(departmentFake2)
.SetUpQueryRepository(departmentQueryableRepository, employeeQueryableRepository)
.Query <Department>(x => x, x => departmentsCount = x.Count())
.Query <Employee>(x => x, x => employeesCount = x.Count())
.ExecuteAsync(shouldAutomaticallyDisposeAllDisposables: true);
//Assert
departmentsCount.Should().Be(0);
employeesCount.Should().Be(0);
}
public KnowledgeTestController(IKnowledgeTestService knowledgeTestService, IQueryableRepository <KnowledgeTest> queryableRepository, IQueryableRepository <vwRP_StockCount> totalRowsRepository, IQueryableRepository <Answer> answerQueryableRepository, IAnswerService answerService, IScoreService scoreService)
{
_knowledgeTestService = knowledgeTestService;
_queryableRepository = queryableRepository;
_totalRowsRepository = totalRowsRepository;
_answerQueryableRepository = answerQueryableRepository;
_answerService = answerService;
_scoreService = scoreService;
}
public AddressesController(
ILogger <AddressesController> logger,
IAddressValidator addressValidator,
IQueryableRepository <AddressInfo, string> repository)
{
_logger = logger;
_addressValidator = addressValidator;
_repository = repository;
}
//private readonly IRepositoryBulkReader BulkReader;
//private readonly Lazy<World>[] LazyWorlds = new Lazy<World>[512];
public Context(IObjectFactory factory, IDatabaseQueryManager manager)
{
var scope = factory.CreateScope(null);
scope.RegisterInterfaces(manager.StartQuery(false));
WorldRepository = scope.Resolve <IPersistableRepository <World> >();
FortuneRepository = scope.Resolve <IQueryableRepository <Fortune> >();
//BulkReader = scope.BulkRead(ChunkedMemoryStream.Static());
}
public BaseBatchSeedSelector(IQueryableRepository <TEntity> seedQueryableRepository, int batchSize, ILogger logger)
{
ContractUtility.Requires <ArgumentNullException>(seedQueryableRepository.IsNotNull(), "seedQueryableRepository cannot be null");
ContractUtility.Requires <ArgumentOutOfRangeException>(batchSize > 0, "batchSize should be greater than 0");
ContractUtility.Requires <ArgumentNullException>(logger.IsNotNull(), "logger cannot be null");
_seedQueryableRepository = seedQueryableRepository;
_batchSize = batchSize;
_logger = logger ?? LoggerFactory.GetLogger(LoggerType.Default);
}
public MockRepositories(IPrincipalHasRole[] principalRoles, IPrincipal[] principals, IRoleInheritsRole[] roleRoles, IPrincipalPermission[] principalPermissions, IRolePermission[] rolePermissions, IRole[] roles, ICommonClaim[] commonClaims)
{
principalRolesRepos = new MockPrincipalRoleRepos(principalRoles);
principalsRepos = CommonAuthorizationProviderTest.InitRepos(principals);
roleRolesRepos = InitRepos(roleRoles);
principalPermissionsRepos = InitRepos(principalPermissions);
rolePermissionsRepos = InitRepos(rolePermissions);
rolesRepos = InitRepos(roles);
commonClaimsRepos = InitRepos(commonClaims);
}
public static async Task <IReadOnlyCollection <T> > FindByListOfKeysAsync <T, TKey>(
this IQueryableRepository <T> source,
IEnumerable <TKey> keys,
CancellationToken cancellationToken = default) where T : IKey <TKey> where TKey : IEquatable <TKey>
{
cancellationToken.ThrowIfCancellationRequested();
return(await source.ProcessQueryAsync(
source.AsQueryable()
.Where(item => keys.Contains(item.Id)), cancellationToken));
}
public static IFluentQueryRepository SetUpQueryRepository <TEntity>(IQueryableRepository <TEntity> queryRepository)
where TEntity : class, IQueryableAggregateRoot
{
ContractUtility.Requires <ArgumentNullException>(queryRepository.IsNotNull(), "queryRepository instance cannot be null");
var queryRepositoryList = new List <dynamic> {
queryRepository
};
return(new FluentQueryRepository(null, queryRepositoryList, null));
}
public MasterFileService(IRepository <TEntity> service,
IQueryableRepository <TEntity> queryableService,
ITenantPersistenceService tenantPersistentService,
IBusinessRuleSet <TEntity> businessRuleSet = null)
{
Repository = service;
QueryableRepository = queryableService;
BusinessRuleSet = businessRuleSet;
TenantPersistenceService = tenantPersistentService;
}
//private readonly IServiceFactory _serviceFactory;
public AccountController(IUserService userService, IUserTypeService userTypeService, IQueryableRepository <User> queryableRepository, IQueryableRepository <vwRP_StockCount> totalRowsRepository, IQueryableRepository <Seller> sellerQueryableRepository
/* , IServiceFactory serviceFactory*/)
{
_userService = userService;
_userTypeService = userTypeService;
_queryableRepository = queryableRepository;
_totalRowsRepository = totalRowsRepository;
_sellerQueryableRepository = sellerQueryableRepository;
//_serviceFactory = serviceFactory;
}
public Context(IServiceProvider service)
{
Stream = ChunkedMemoryStream.Static();
Writer = Stream.GetWriter();
var dqm = service.Resolve<IDatabaseQueryManager>();
var factory = service.Resolve<IObjectFactory>().CreateInnerFactory();
factory.RegisterInterfaces(dqm.StartQuery(false));
WorldRepository = factory.Resolve<IPersistableRepository<World>>();
FortuneRepository = factory.Resolve<IQueryableRepository<Fortune>>();
BulkReader = factory.BulkRead(ChunkedMemoryStream.Static());
}
public SaleController(ISaleService saleService, IQueryableRepository <Sale> queryableRepository, IQueryableRepository <vwRP_StockCount> totalRowsRepository, IUserService userService, IProductService productService, IQueryableRepository <Product> productQueryableRepository, IQueryableRepository <User> userQueryableRepository, IScoreService scoreService)
{
_saleService = saleService;
_queryableRepository = queryableRepository;
_totalRowsRepository = totalRowsRepository;
_userService = userService;
_productService = productService;
_productQueryableRepository = productQueryableRepository;
_userQueryableRepository = userQueryableRepository;
_scoreService = scoreService;
}
public EntitiesController(
IEntitiesRepository entitiesRepository,
EntitiesDBContext dbContext,
IQueryableRepository <Entities.FileInfo> filesRepository,
IBlobRepository blobRepository)
{
this.entitiesRepository = entitiesRepository;
this.dbContext = dbContext;
this.filesRepository = filesRepository;
this.blobRepository = blobRepository;
}
public Context(IServiceProvider service)
{
Stream = ChunkedMemoryStream.Static();
Writer = Stream.GetWriter();
var dqm = service.Resolve <IDatabaseQueryManager>();
var factory = service.Resolve <IObjectFactory>().CreateInnerFactory();
factory.RegisterInterfaces(dqm.StartQuery(false));
WorldRepository = factory.Resolve <IPersistableRepository <World> >();
FortuneRepository = factory.Resolve <IQueryableRepository <Fortune> >();
BulkReader = factory.BulkRead(ChunkedMemoryStream.Static());
}
public void test_insert_multiple_employees_without_any_explicit_transaction_scope_should_be_saved()
{
//Arrange
using (ICommandRepository <Department> departmentCommandRepository = GetCommandRepositoryInstance <Department>())
using (ICommandRepository <Employee> employeeCommandRepository = GetCommandRepositoryInstance <Employee>())
using (IQueryableRepository <Department> departmentQueryableRepository = GetQueryableRepositoryInstance <Department>())
using (IQueryableRepository <Employee> employeeQueryableRepository = GetQueryableRepositoryInstance <Employee>())
{
//Arrange
Department departmentFake = FakeData.GetDepartmentFake();
Employee managerEmployeeFake = FakeData.GetEmployeeFake();
managerEmployeeFake.EmployeeName = "XYZ";
managerEmployeeFake.DeptID = departmentFake.Id;
managerEmployeeFake.Department = departmentFake;
Employee subEmployeeFake = FakeData.GetEmployeeFake(2);
subEmployeeFake.DeptID = departmentFake.Id;
subEmployeeFake.Department = departmentFake;
subEmployeeFake.ManagerId = managerEmployeeFake.Id;
subEmployeeFake.Manager = managerEmployeeFake;
//Action
//Considering cascading inserts, here the order in which the list is inserted with different employee
//objects is important. Since department object is defined as required in the EmployeMap class,
//Effort(just like EF) automatically inserts the department object before inserting the employee objects.
//But again in EmployeeMap class, Manager is marked as optional, so manager and the employees under him or her needs to
//be explicitly inserted in proper order.Also here, EF doesn't ensure that if managerEmployeeFake gets
//saved successfully and then subEmployeeFake doesn't get saved, then all the operations will be
//rolled back (at the DB level).
//And all these(inserting department object first, then manager object and then sub emloyee object), happens
// internally within the same transaction (just like EF6) and one doesn't need to use the UnitOfWork class
// (available in this project).
employeeCommandRepository.Insert(new List <Employee> {
managerEmployeeFake, subEmployeeFake
});
//Assert
departmentQueryableRepository.Count().Should().Be(1);
employeeQueryableRepository.Count().Should().Be(2);
employeeQueryableRepository.First().EmployeeName.Should().Be("XYZ");
employeeQueryableRepository.Single(x => x.EmployeeName == "Sandip").Id.Should().Be(2);
// LINQ to Entities doesn't support the method "Last" and so will throw an exception.That's one of
// the differences w.r.t LINQ to Objects.If tested with some mock(s) then the below code won't throw any
// exception since internally mocks uses LINQ to Objects (atleast as far as LINQ in general is concerned)
// and so true behaviour won't reflect using mocks.
Action action = () => employeeQueryableRepository.Last();
action.ShouldThrow <NotSupportedException>();
};
}
public QueueProcessor(
IMailService mailService,
IQueryableRepository <IMailMessage> repository,
IDataChangeNotification changeNotification)
{
Contract.Requires(mailService != null);
Contract.Requires(repository != null);
Contract.Requires(changeNotification != null);
this.MailService = mailService;
this.Repository = repository;
this.ChangeNotification = changeNotification;
}
public PrincipalWriter(
ILogProvider logProvider,
INamedPlugins <IRepository> repositories,
GenericRepository <IPrincipal> principalGenericRepository,
ISqlExecuter sqlExecuter,
ISqlUtility sqlUtility)
{
_logger = logProvider.GetLogger(GetType().Name);
_principalRepository = (IQueryableRepository <IPrincipal>)repositories.GetPlugin("Common.Principal");
_principalGenericRepository = principalGenericRepository;
_sqlExecuter = sqlExecuter;
_sqlUtility = sqlUtility;
}
public QueueProcessor(
IMailService mailService,
IQueryableRepository<IMailMessage> repository,
IDataChangeNotification changeNotification)
{
Contract.Requires(mailService != null);
Contract.Requires(repository != null);
Contract.Requires(changeNotification != null);
this.MailService = mailService;
this.Repository = repository;
this.ChangeNotification = changeNotification;
}
public LazyCache(
IQueryableRepository <TValue> repository,
IDataChangeNotification notifications)
{
Contract.Requires(repository != null);
Contract.Requires(notifications != null);
this.Repository = repository;
Subscription = notifications.Notifications.Subscribe(Synchronize);
Data = new Dictionary <string, TValue>();
Invalid = true;
}
public IFluentQueryRepository SetUpQueryRepository <TEntity>(IQueryableRepository <TEntity> queryRepository)
where TEntity : class, IQueryableAggregateRoot
{
ContractUtility.Requires <ArgumentNullException>(queryRepository.IsNotNull(), "queryRepository instance cannot be null");
string queryableRepositoryTypeName = typeof(IQueryableRepository <>).Name;
dynamic existingQueryRepository = _repositoriesList.SingleOrDefault(x => x != null && x.GetType().GetGenericTypeDefinition().GetInterface(queryableRepositoryTypeName) != null && x.GetType().GenericTypeArguments[0] == typeof(TEntity));
ContractUtility.Requires <ArgumentNullException>(existingQueryRepository == null, string.Format("Query Repository for {0} has already been set up", typeof(TEntity).Name));
if (_unitOfWorkData != null && _unitOfWorkData.UnitOfWork != null)
{
((dynamic)queryRepository).SetUnitOfWork(_unitOfWorkData.UnitOfWork);
}
_repositoriesList.Add(queryRepository);
return(new FluentQueryRepository(_unitOfWorkData, _repositoriesList, _operationsQueue));
}
public AuthorizationDataLoader(
ILogProvider logProvider,
INamedPlugins<IRepository> repositories,
Lazy<GenericRepository<IPrincipal>> principalGenericRepository)
{
_logger = logProvider.GetLogger(GetType().Name);
_principalRepository = (IQueryableRepository<IPrincipal>)repositories.GetPlugin("Common.Principal");
_principalGenericRepository = principalGenericRepository;
_principalRolesRepository = (IQueryableRepository<IPrincipalHasRole>)repositories.GetPlugin("Common.PrincipalHasRole");
_roleRolesRepository = (IQueryableRepository<IRoleInheritsRole>)repositories.GetPlugin("Common.RoleInheritsRole");
_principalPermissionRepository = (IQueryableRepository<IPrincipalPermission>)repositories.GetPlugin("Common.PrincipalPermission");
_rolePermissionRepository = (IQueryableRepository<IRolePermission>)repositories.GetPlugin("Common.RolePermission");
_roleRepository = (IQueryableRepository<IRole>)repositories.GetPlugin("Common.Role");
_claimRepository = (IQueryableRepository<ICommonClaim>)repositories.GetPlugin("Common.Claim");
}
public AuthorizationDataLoader(
ILogProvider logProvider,
INamedPlugins <IRepository> repositories,
Lazy <GenericRepository <IPrincipal> > principalGenericRepository)
{
_logger = logProvider.GetLogger(GetType().Name);
_principalRepository = (IQueryableRepository <IPrincipal>)repositories.GetPlugin("Common.Principal");
_principalGenericRepository = principalGenericRepository;
_principalRolesRepository = (IQueryableRepository <IPrincipalHasRole>)repositories.GetPlugin("Common.PrincipalHasRole");
_roleRolesRepository = (IQueryableRepository <IRoleInheritsRole>)repositories.GetPlugin("Common.RoleInheritsRole");
_principalPermissionRepository = (IQueryableRepository <IPrincipalPermission>)repositories.GetPlugin("Common.PrincipalPermission");
_rolePermissionRepository = (IQueryableRepository <IRolePermission>)repositories.GetPlugin("Common.RolePermission");
_roleRepository = (IQueryableRepository <IRole>)repositories.GetPlugin("Common.Role");
_claimRepository = (IQueryableRepository <ICommonClaim>)repositories.GetPlugin("Common.Claim");
}
public QueueProcessor(
IMailService mailService,
IQueryableRepository<IMailMessage> repository,
IDataChangeNotification changeNotification,
ILogFactory logFactory)
{
Contract.Requires(mailService != null);
Contract.Requires(repository != null);
Contract.Requires(changeNotification != null);
Contract.Requires(logFactory != null);
this.MailService = mailService;
this.Repository = repository;
this.ChangeNotification = changeNotification;
this.Logger = logFactory.Create("Mail Queue processor");
}
public KadaService(IServiceLocator locator)
{
this.Locator = locator;
this.Kade = locator.Resolve<IQueryableRepository<KadaIzvorPodataka>>();
}
public GetCustomersByPage(IQueryableRepository<Customer> custRepo)
{
_customerQueryableRepository = custRepo;
}