public BugzillaActionFactory(IBugzillaInfoStorageRepository bugzillaStorage, IStorageRepository repository,
		                             IUserMapper userMapper)
		{
			_bugzillaStorage = bugzillaStorage;
			_repository = repository;
			_userMapper = userMapper;
		}
		private WhenSenderAndProjectCompanyMatched(ParseNode clauseNode, IStorageRepository storage,
		                                           UserRepository userRepository)
		{
			_projectId = Int32.Parse(ClauseFactory.FindRecursive(TokenType.NUMBER, clauseNode).Token.Text);
			_storage = storage;
			_userRepository = userRepository;
		}
		public IVersionControlSystem Get(IStorageRepository profile)
		{
			var vcsArgs = new ExplicitArguments();
			vcsArgs.Set(profile.GetProfile<ISourceControlConnectionSettingsSource>());
			vcsArgs.Set(profile);
			return ObjectFactory.GetInstance<IVersionControlSystem>(vcsArgs);
		}
 public StorageController()
 {
     var config = Settings.StorageConfiguration;
     this.repository = new StorageRepository(config);
     this._tokenSerializer = new TokenSerializer();
     this._csvSerializer = new StorageCSVProcesser();
 }
 protected void SetUp()
 {
     //Configuration.Init();
     DbConfiguration config = new DbConfiguration();
     _connProvider = new ConnectionProvider(config);
     _storageRepo = new StorageRepository(_connProvider);
 }
        public void Init()
        {
            mock = new Mock<IStorageRepository>();

            bathRoomWithoutFurniture = new Room()
            {
                CreationDate = now,
                Name = "Bathroom",
                Furnitures = new Dictionary<string, int>()
            };

            mock.Setup(c => c.CreateRoom(bathRoomWithoutFurniture.Name, now)).Returns(bathRoomWithoutFurniture);
            mock.Setup(c => c.GetRoomByName(bathRoomWithoutFurniture.Name)).Returns(bathRoomWithoutFurniture);

            livingRoomWithFurniture = new Room
            {
                Name = "LivingRoom",
                CreationDate = now,
                Furnitures = (new List<Tuple<string, int>>
                {
                    new Tuple<string, int>("Table", 1),
                    new Tuple<string, int>("Chair", 2)
                }).ToDictionary(k => k.Item1, v => v.Item2)
            };

            mock.Setup(c => c.GetRoomByName("LivingRoom")).Returns(livingRoomWithFurniture);

            repository = mock.Object;
            service = new StorageService(repository);
        }
		public SeleniumResultsCommand(IStorageRepository storageRepository, ILocalBus localBus, ITestRunImportResultsReaderFactory resultsReaderFactory, IActivityLogger log)
		{
			_storageRepository = storageRepository;
			_localBus = localBus;
			_resultsReaderFactory = resultsReaderFactory;
			_log = log;
		}
		public GitVersionControlSystem(ISourceControlConnectionSettingsSource settings,
		                               ICheckConnectionErrorResolver errorResolver, IActivityLogger logger,
		                               IDiffProcessor diffProcessor, IStorageRepository profile)
			: base(settings, errorResolver, logger)
		{
			_diffProcessor = diffProcessor;
			_git = new GitClient(settings, profile.Get<GitRepositoryFolder>());
		}
 public ReleaseClassBookAppl(ITypeAdapter adapter, IProfessionalClassRepository classRepo, ISubscriptionRepository subscriptionRepo, IInventoryRepository inventoryRepo, IStorageRepository storageRepo)
 {
     _adapter = adapter;
     _classRepo = classRepo;
     _subscriptionRepo = subscriptionRepo;
     _inventoryRepo = inventoryRepo;
     _storageRepo = storageRepo;
 }
		public SyncNowCommand(IStorageRepository storageRepository, ILocalBus localBus, IStreamFactory streamFactory,
		                                      ITestRunImportResultsReaderFactory resultsReaderFactory)
		{
			_storageRepository = storageRepository;
			_localBus = localBus;
			_streamFactory = streamFactory;
			_resultsReaderFactory = resultsReaderFactory;
		}
		protected ThenClause(ParseNode clauseNode, ITpBus bus, IStorageRepository storage)
		{
			_bus = bus;
			_storage = storage;

			var projectIdNode = ClauseFactory.FindRecursive(TokenType.NUMBER, clauseNode);
			_projectId = Int32.Parse(projectIdNode.Token.Text);
		}
		protected VersionControlSystemProcessorBase(IRevisionIdComparer revisionComparer, IStorageRepository storage, ISourceControlConnectionSettingsSource settingsSource, IVersionControlSystem versionControlSystem, ILocalBus bus, IActivityLogger logger)
		{
			RevisionComparer = revisionComparer;
			Storage = storage;
			VersionControlSystem = versionControlSystem;
			Bus = bus;
			Logger = logger;
			StartRevision = revisionComparer.ConvertToRevisionId(settingsSource.StartRevision);
		}
Beispiel #13
0
 public RouteProxy(DateTime date, IStorageRepository<RoutePoint> routesPointsRepository,
                   IStorageRepository<Order> ordersRepository,
                   IStorageRepository<OrderItem> orderItemsRepository)
     : base(date)
 {
     _routesPointsRepository = routesPointsRepository;
     _ordersRepository = ordersRepository;
     _orderItemsRepository = orderItemsRepository;
 }
 public InventoryAppl(ITypeAdapter adapter,
     IStorageRepository storage,
     IInventoryRepository inventory,
     ITextbookRepository textbook)
 {
     _adapter = adapter;
     _storageRepo = storage;
     _inventoryRepo = inventory;
     _textbookRepo = textbook;
 }
 public AddPresenter(IInventoryRepository inventoryRepository, IProductCategoryRepository categoryRepository, IStorageRepository storageRepository, IUnitOfMeasurementRepository measurementRepository, IProductRepository productRepository, IMerchandiseRepository merchandiseRepository, IStockMovementRepository stockMovementRepository)
 {
     _inventoryRepository = inventoryRepository;
     _categoryRepository = categoryRepository;
     _storageRepository = storageRepository;
     _measurementRepository = measurementRepository;
     _productRepository = productRepository;
     _merchandiseRepository = merchandiseRepository;
     _stockMovementRepository = stockMovementRepository;
 }
		private ThenCreateRequestClause(ParseNode clauseNode, ITpBus bus, IStorageRepository storage, bool isPrivate = false)
			: base(clauseNode, bus, storage)
		{
			var attachToRequestPart = ClauseFactory.FindRecursive(TokenType.AttachRequestToTeamPart, clauseNode.Parent);
			if (attachToRequestPart != null)
			{
				foreach (var squadIdNode in from node in attachToRequestPart.Nodes
				                            where node.Token.Type == TokenType.AttachRequestToTeamClause
				                            select ClauseFactory.FindRecursive(TokenType.NUMBER, node))
				{
					_squadId = System.Int32.Parse(squadIdNode.Token.Text);
					break;
				}
			}

			_isPrivate = isPrivate;
		}
		public UserMapper(IStorageRepository storageRepository, IActivityLogger logger)
		{
			_storageRepository = storageRepository;
			_logger = logger;
		}
		private ThenCreatePublicRequestClause(ParseNode clauseNode, ITpBus bus, IStorageRepository storage)
			: base(clauseNode, bus, storage)
		{
		}
 public ViewPresenter(IStorageRepository storageRepository)
 {
     _storageRepository = storageRepository;
 }
Beispiel #20
0
 public StorageApplicationService(IStorageRepository repository)
 {
     _repository = repository;
 }
Beispiel #21
0
 public ProductsController(IStorageRepository repo, IMapper mapper)
 {
     _mapper = mapper;
     _repo   = repo;
 }
        public FileSystemService(IFileSystemRepository <FileSystem> fileSyatemRepository, ITagRepository <Tag> tagRepository, IStorageRepository storageRepository)
        {
            _fileSystemRepository = fileSyatemRepository;
            _tagRepository        = tagRepository;

            _storageRepository = storageRepository;
        }
 private static void AssertUserExistInProfile(TestCaseTestPlanDTO testCaseTestPlanDto, IStorageRepository storageRepository)
 {
     storageRepository.Get <TestCaseTestPlanDTO>(testCaseTestPlanDto.ID.ToString()).SingleOrDefault().Should(Be.Not.Null);
 }
Beispiel #24
0
 public InitializeStorageCommandHandler(IStorageRepository storageRepository, IFileRepository fileRepository)
 {
     _storageRepository = storageRepository;
     _fileRepository    = fileRepository;
 }
Beispiel #25
0
 public ViewPresenter(IMerchandiseRepository merchandiseRepository, IStorageRepository storageRepository)
 {
     _merchandiseRepository = merchandiseRepository;
     _storageRepository     = storageRepository;
 }
 public StorageController(IStorageRepository
                          storageRepository, DatabaseContext context) : base(storageRepository, context)
 {
     _storageRepository = storageRepository;
     _context           = context;
 }
 public GetDirectorySearchResultQueryHandler(IStorageRepository storageRepository)
 {
     _storageRepository = storageRepository;
 }
Beispiel #28
0
 public StorageService(IStorageRepository storageRepository)
 {
     _storageRepository = storageRepository;
 }
 public CustomerProxy(IStorageRepository<ShippingAddress> shippingAddressStorageRepository)
 {
     _shippingAddressStorageRepository = shippingAddressStorageRepository;
 }
Beispiel #30
0
 public UserService(IStorageRepository storage, IIdentityService identityService, IPasswordHashService passwordHashService)
 {
     _storage             = storage;
     _identityService     = identityService;
     _passwordHashService = passwordHashService;
 }
 public GitRevisionStorageRepository(IStorageRepository repository, IProfileCollectionReadonly profiles)
     : base(repository, profiles)
 {
 }
		public MessageUidRepository(IStorageRepository storageRepository)
		{
			_storageRepository = storageRepository;
		}
 public SeverityConverter(IStorageRepository storageRepository, IActivityLogger logger) : base(storageRepository, logger)
 {
 }
 public StorageService(IStorageRepository repository)
 {
     _repository = repository;
 }
Beispiel #35
0
 public AddBookCommandHandler(IStorageRepository storageRepository, IOptions <StorageConfig> storageOptions)
 {
     _storageRepository = storageRepository;
     _storageConfig     = storageOptions.Value;
 }
 public ViewPresenter(IProductRepository productRepository, IStorageRepository storageRepository)
 {
     _productRepository = productRepository;
     _storageRepository = storageRepository;
 }
Beispiel #37
0
 public CurrentProfileToSvnConnectionSettingsAdapter(IStorageRepository repository)
     : base(repository)
 {
 }
Beispiel #38
0
 public ProductProxy(IStorageRepository<ProductsUnitOfMeasure> productsUnitsOfMeasureRepository)
 {
     _productsUnitsOfMeasureRepository = productsUnitsOfMeasureRepository;
 }
Beispiel #39
0
 public CreateTasksForNewUserStoryHandler(ICommandBus bus, IStorageRepository storage)
 {
     _bus     = bus;
     _storage = storage;
     _profile = _storage.GetProfile <TaskCreatorProfile>();
 }
		private static void AssertUserExistInProfile(TestCaseTestPlanDTO testCaseTestPlanDto, IStorageRepository storageRepository)
		{
			storageRepository.Get<TestCaseTestPlanDTO>(testCaseTestPlanDto.ID.ToString()).SingleOrDefault().Should(Be.Not.Null);
		}
		public RuleParser(IStorageRepository storageRepository, IActivityLogger log)
		{
			_storageRepository = storageRepository;
			_log = log;
		}
 public MWLController(IStorageRepository storageRepository) {
     if (storageRepository == null) throw new ArgumentNullException(nameof(storageRepository));
     this._storageRepository = storageRepository;
 }
Beispiel #43
0
 protected GuessConverterBase(IStorageRepository storageRepository, IActivityLogger logger)
 {
     _storageRepository = storageRepository;
     _logger            = logger;
 }
		public BugzillaService(IStorageRepository storageRepository)
		{
			_storageRepository = storageRepository;
			_bugzillaProfile = _storageRepository.GetProfile<BugzillaProfile>();
		}
		public ThirdPartyFieldsMapper(IStorageRepository storageRepository)
		{
			_storageRepository = storageRepository;
		}
Beispiel #46
0
 public ViewDetailPresenter(IStorageRepository storageRepository, IStockMovementRepository movementRepository)
 {
     _storageRepository  = storageRepository;
     _movementRepository = movementRepository;
 }
 public AccountController(IStorageRepository repository)
 {
     this.repository = repository;
 }
 public AddPresenter(IStockMovementRepository movementRepository, IInventoryRepository inventoryRepository, IStorageRepository storageRepository)
 {
     _movementRepository = movementRepository;
     _inventoryRepository = inventoryRepository;
     _storageRepository = storageRepository;
 }
Beispiel #49
0
 public StorageController(IStorageRepository repository, IMapper mapper)
 {
     this.repository = repository;
     this.mapper     = mapper;
 }