public RepositoryFile(IRepository repository, String path, RepositoryStatus contentsStatus, RepositoryStatus propertiesStatus) { if (path == null) throw new ArgumentNullException("path"); if (path.Trim().Length == 0) throw new ArgumentException("Path must be set to a valid path", "path"); if (path[path.Length-1] == '/') throw new ArgumentException("Path must be set to a file, not a directory", "path"); if (propertiesStatus == RepositoryStatus.Added || propertiesStatus == RepositoryStatus.Deleted) { throw new ArgumentException("Properties status cannot be set to Added or Deleted, use Updated", "propertiesStatus"); } this.contentsStatus = contentsStatus; this.propertiesStatus = propertiesStatus; this.repository = repository; SetPathRelatedFields(path); if (fileName.EndsWith(" ")) throw new ArgumentException("Filename cannot end with trailing spaces", "path"); if (fileName.StartsWith(" ")) throw new ArgumentException("Filename cannot begin with leading spaces", "path"); }
public ApplicationService(IRepository<Application> applicationRepository, IEventPublisher eventPublisher, ICacheManager cacheManager) { _applicationRepository = applicationRepository; _eventPublisher = eventPublisher; _cacheManager = cacheManager; }
public FaqHandler(IRepository<FaqPartRecord> repository) { Filters.Add(StorageFilter.For(repository)); OnRemoved<FaqPart>((context, part) => repository.Delete(part.Record)); OnIndexing<FaqPart>((context, contactPart) => context.DocumentIndex.Add("faq_question", contactPart.Question).Analyze().Store()); }
public TaskController(IRepository<Task> tasks) { if (tasks == null) throw new ArgumentNullException("tasks"); _tasks = tasks; }
public void Initialise() { _blogRepo = new SimpleRepository<Data.Blog>(new InMemoryRepositoryDataSource<Data.Blog>(new List<Data.Blog> { new Data.Blog { Id = 1, AuthoritiveUrl = "http://blog.test.con" } })); _templateRepo = new SimpleRepository<BlogTemplate>(new InMemoryRepositoryDataSource<BlogTemplate>()); _mockHttpContext = new Mock<IHttpContextService>(); _mockHttpContext.Setup(h => h.RequestUrl).Returns(new Uri("http://blog.test.con/blah")); }
public VendorAddressService( IRepository<VendorAddress> vendorAddressRepo, IEventPublisher eventPublisher) { _vendorAddressRepo = vendorAddressRepo; _eventPublisher = eventPublisher; }
public ProjectsService( IRepository<SoftwareProject> projectsRepo, IRepository<User> usersRepo) { this.projects = projectsRepo; this.users = usersRepo; }
/// <summary> /// Ctor /// </summary> /// <param name="sciRepository">Shopping cart repository</param> /// <param name="workContext">Work context</param> /// <param name="currencyService">Currency service</param> /// <param name="productService">Product settings</param> /// <param name="localizationService">Localization service</param> /// <param name="productAttributeParser">Product attribute parser</param> /// <param name="checkoutAttributeService">Checkout attribute service</param> /// <param name="checkoutAttributeParser">Checkout attribute parser</param> /// <param name="priceFormatter">Price formatter</param> /// <param name="customerService">Customer service</param> /// <param name="shoppingCartSettings">Shopping cart settings</param> /// <param name="eventPublisher">Event publisher</param> /// <param name="permissionService">Permission service</param> /// <param name="aclService">ACL service</param> public ShoppingCartService(IRepository<ShoppingCartItem> sciRepository, IWorkContext workContext, ICurrencyService currencyService, IProductService productService, ILocalizationService localizationService, IProductAttributeParser productAttributeParser, ICheckoutAttributeService checkoutAttributeService, ICheckoutAttributeParser checkoutAttributeParser, IPriceFormatter priceFormatter, ICustomerService customerService, ShoppingCartSettings shoppingCartSettings, IEventPublisher eventPublisher, IPermissionService permissionService, IAclService aclService) { this._sciRepository = sciRepository; this._workContext = workContext; this._currencyService = currencyService; this._productService = productService; this._localizationService = localizationService; this._productAttributeParser = productAttributeParser; this._checkoutAttributeService = checkoutAttributeService; this._checkoutAttributeParser = checkoutAttributeParser; this._priceFormatter = priceFormatter; this._customerService = customerService; this._shoppingCartSettings = shoppingCartSettings; this._eventPublisher = eventPublisher; this._permissionService = permissionService; this._aclService = aclService; }
public BodyPartHandler(IRepository<BodyPartRecord> bodyRepository) { Filters.Add(StorageFilter.For(bodyRepository)); OnIndexing<BodyPart>((context, bodyPart) => context.DocumentIndex .Add("body", bodyPart.Record.Text).RemoveTags().Analyze() .Add("format", bodyPart.Record.Format).Store()); }
protected override bool ExecuteWithData(string cmd, IRepository repo, Player player) { string[] cmdArray = cmd.Split(new[] { ' ' }, 2); string name = ""; if (cmdArray.GetUpperBound(0) >= 1) name = cmdArray[1].Trim(); GameObject target; switch (name.ToLower()) { case "here": case "": target = player.Location; break; default: target = queries.FindNearPlayer(repo, player, name); break; } if (target == null) { console.WriteLine(STR_NoSuchObject, name); return false; } formatters.OfType<LookFormatter>().First().Format(target); formatters.OfType<InventoryFormatter>().First().Format(target); return false; }
/// <summary> /// Ctor /// </summary> /// <param name="cacheManager">Cache manager</param> /// <param name="notificationRepository">Notification repository</param> /// <param name="eventPublisher">Event published</param> public NotificationService(ICacheManager cacheManager, IRepository<Notification> notificationRepository, ISignals signals) { _cacheManager = cacheManager; _notificationRepository = notificationRepository; _signals = signals; }
public PostPartHandler(IRepository<PostPartRecord> repository, IPostService postService, IThreadService threadService, IForumService forumService, IClock clock) { _postService = postService; _threadService = threadService; _forumService = forumService; _clock = clock; Filters.Add(StorageFilter.For(repository)); OnGetDisplayShape<PostPart>(SetModelProperties); OnGetEditorShape<PostPart>(SetModelProperties); OnUpdateEditorShape<PostPart>(SetModelProperties); OnCreated<PostPart>((context, part) => UpdateCounters(part)); OnPublished<PostPart>((context, part) => { UpdateCounters(part); UpdateThreadVersioningDates(part); }); OnUnpublished<PostPart>((context, part) => UpdateCounters(part)); OnVersioned<PostPart>((context, part, newVersionPart) => UpdateCounters(newVersionPart)); OnRemoved<PostPart>((context, part) => UpdateCounters(part)); OnRemoved<ThreadPart>((context, b) => _postService.Delete(context.ContentItem.As<ThreadPart>())); OnIndexing<PostPart>((context, postPart) => context.DocumentIndex .Add("body", postPart.Record.Text).RemoveTags().Analyze() .Add("format", postPart.Record.Format).Store()); }
/// <summary> /// Initializes a new instance of the <see cref="PredictiveModelService" /> class /// </summary> /// <param name="trainRepository">trainRepository parameter</param> /// <param name="waterdataRepository">waterdataRepository parameter</param> /// <param name="predictiveRepository">predictiveRepository parameter</param> /// <param name="vesselRepository">vesselRepository parameter</param> public PredictiveModelService(IRepository<train> trainRepository, IRepository<water_data> waterdataRepository, IPredictiveModelRepository predictiveRepository, IVesselRepository vesselRepository) { this.modifiedwaterdataRepository = waterdataRepository; this.predictiveRepository = predictiveRepository; this.modifiedTrainRepository = trainRepository; this.modifiedVesselRepository = vesselRepository; }
//private readonly ILifetimeScope container; public GenericCharacteristicService() { //this.container = AutofacHostFactory.Container; this.genericCharacteristicRepository = EngineContext.Current.Resolve<IRepository<GenericCharacteristic>>(); this.cacheManager = EngineContext.Current.Resolve<ICacheManager>(); }
public void Init(string email, IRepository repository) { if (!string.IsNullOrEmpty(email)) { User = repository.GetUser(email); } }
public ListsModule(IRepository db) : base("/pages/{pageid:guid}/lists") { this.RequiresAuthentication(); Post("/", args => { return db.CreateList(this.Bind<List>().SetDefaults<List>()); }); Get("/{id:guid}", args => { return db.ReadList(args.id); }); Put("/{id:guid}", args => { return db.UpdateList(this.Bind<List>().SetDefaults<List>()); }); Delete("/{id:guid}", args => { return db.DeleteList(args.id); }); Put("/updateorder", args => { var ordering = this.Bind<Ordering>(); db.UpdateListDisplayOrder(ordering); return true; }); }
public SecureLdapAuthenticationProvider(IConfigSectionProvider configSectionProvider, ILocalEducationAgencyContextProvider localEducationAgencyContextProvider, IRepository<LocalEducationAgency> localEducationAgencyRepository, IRepository<LocalEducationAgencyAuthentication> localEducationAgencyAuthenticationRepository) { this.configSectionProvider = configSectionProvider; this.localEducationAgencyContextProvider = localEducationAgencyContextProvider; _localEducationAgencyRepository = localEducationAgencyRepository; _localEducationAgencyAuthenticationRepository = localEducationAgencyAuthenticationRepository; }
public CampaignController( ICampaignService campaignService, ITShirtCostService tshirtService, IProductService productService, IPromotionService promotionService, IRepository<CurrencyRecord> currencyRepository, IWorkContextAccessor wca, INotifier notifier, IOrchardServices services, ICookieCultureService cookieCultureService, ICountryService countryService) { _currencyRepository = currencyRepository; Services = services; _tshirtService = tshirtService; _productService = productService; _campaignService = campaignService; _promotionService = promotionService; _wca = wca; _notifier = notifier; Logger = NullLogger.Instance; _cookieCultureService = cookieCultureService; //var culture = _wca.GetContext().CurrentCulture.Trim(); _cultureUsed = _wca.GetContext().CurrentCulture.Trim(); //cultureUsed = culture == "en-SG" ? "en-SG" : (culture == "id-ID" ? "id-ID" : "en-MY"); _countryService = countryService; }
public ApplyMaximumsTask(IRepository<AUMaxBidJobControlRecord> maxbidjobcontrolRepo, IRepository<AUMaxBidRecord> maxbidRepo, IRepository<AULotLastBidChangeRecord> lotlastbidchangeRepo, ILogger logger, IConsignorService consignorService, ICustomerService customerService, IQueuedEmailService queuedEmailService, IEmailAccountService emailAccountService, EmailAccountSettings emailAccountSettings, IAUCatalogService AUcatalogService, ILotService lotService) { //this._customerService = customerService; this._logger = logger; this._maxbidjobcontrolRepo = maxbidjobcontrolRepo; this._maxbidRepo = maxbidRepo; this._lotlastbidchangeRepo = lotlastbidchangeRepo; this._consignorService = consignorService; this._customerService = customerService; this._queuedEmailService = queuedEmailService; this._emailAccountService = emailAccountService; this._emailAccountSettings = emailAccountSettings; this._AUcatalogService = AUcatalogService; this._lotService = lotService; }
public void Init(IEnumerable<Type> dataMigrations) { var builder = new ContainerBuilder(); _folders = new StubFolders(); var contentDefinitionManager = new Mock<IContentDefinitionManager>().Object; builder.RegisterInstance(new ShellSettings { DataTablePrefix = "TEST_"}); builder.RegisterType<SqlServerDataServicesProvider>().As<IDataServicesProvider>(); builder.RegisterType<DataServicesProviderFactory>().As<IDataServicesProviderFactory>(); builder.RegisterType<NullInterpreter>().As<IDataMigrationInterpreter>(); builder.RegisterInstance(_folders).As<IExtensionFolders>(); builder.RegisterInstance(contentDefinitionManager).As<IContentDefinitionManager>(); builder.RegisterType<ExtensionManager>().As<IExtensionManager>(); builder.RegisterType<DataMigrationManager>().As<IDataMigrationManager>(); builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)); builder.RegisterType<StubCacheManager>().As<ICacheManager>(); builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>(); builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>(); _session = _sessionFactory.OpenSession(); builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>().As<ITransactionManager>(); foreach(var type in dataMigrations) { builder.RegisterType(type).As<IDataMigration>(); } _container = builder.Build(); _container.Resolve<IExtensionManager>(); _dataMigrationManager = _container.Resolve<IDataMigrationManager>(); _repository = _container.Resolve<IRepository<DataMigrationRecord>>(); _transactionManager = _container.Resolve<ITransactionManager>(); InitDb(); }
public TermsPartHandler( IContentDefinitionManager contentDefinitionManager, IRepository<TermsPartRecord> repository, ITaxonomyService taxonomyService, IContentManager contentManager, IProcessingEngine processingEngine, ShellSettings shellSettings, IShellDescriptorManager shellDescriptorManager) { _contentDefinitionManager = contentDefinitionManager; _contentManager = contentManager; Filters.Add(StorageFilter.For(repository)); OnPublished<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part)); OnUnpublished<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part)); OnRemoved<TermsPart>((context, part) => RecalculateCount(processingEngine, shellSettings, shellDescriptorManager, part)); // Tells how to load the field terms on demand, when a content item it loaded or when it has been created OnInitialized<TermsPart>((context, part) => InitializerTermsLoader(part)); OnLoading<TermsPart>((context, part) => InitializerTermsLoader(part)); OnUpdating<TermsPart>((context, part) => InitializerTermsLoader(part)); OnIndexing<TermsPart>( (context, part) => { foreach (var term in part.Terms) { var termContentItem = context.ContentManager.Get(term.TermRecord.Id); context.DocumentIndex.Add(term.Field, termContentItem.As<TitlePart>().Title).Analyze(); context.DocumentIndex.Add(term.Field + "-id", termContentItem.Id).Store(); // tag the current content item with all parent terms foreach (var parent in taxonomyService.GetParents(termContentItem.As<TermPart>())) { context.DocumentIndex.Add(term.Field + "-id", parent.Id).Store(); } } }); }
/// <summary> /// Ctor /// </summary> /// <param name="vendorRepository">Vendor repository</param> /// <param name="eventPublisher">Event published</param> public VendorService(IRepository<Vendor> vendorRepository, IEventPublisher eventPublisher, IRepository<Customer> customerRepository) { this._vendorRepository = vendorRepository; this._eventPublisher = eventPublisher; this._customerRepository = customerRepository; }
public ThreadServices( IRepository<Thread> threadRepository, IRepository<ThreadView> threadViewRepository, IRepository<Post> postRepository, IRepository<User> userRepository, IRepository<ThreadViewStamp> threadViewStampRepository, IRepository<Subscription> subscriptionRepository, IRepository<Attachment> attachmentRepository, PollServices pollServices, FileServices fileServices, ParseServices parseServices, RoleServices roleServices, IUnitOfWork unitOfWork) : base(unitOfWork) { _threadRepository = threadRepository; _threadViewRepository = threadViewRepository; _postRepository = postRepository; _userRepository = userRepository; _threadViewStampRepository = threadViewStampRepository; _subscriptionRepository = subscriptionRepository; _attachmentRepository = attachmentRepository; _pollServices = pollServices; _fileServices = fileServices; _parseServices = parseServices; _roleServices = roleServices; }
public Creator(IUnitOfWork unitOfWork, IRepository<Battle> repositoryOfBattle, IRepository<User> repositoryOfUser, IRepository<Team> repositoryOfTeam) { _unitOfWork = unitOfWork; _repositoryOfBattle = repositoryOfBattle; _repositoryOfUser = repositoryOfUser; _repositoryOfTeam = repositoryOfTeam; }
public CompilationsService(IRepositoryFactory repositoryFactory) { if(repositoryFactory == null) throw new ArgumentNullException(nameof(repositoryFactory)); _compilationRepository = repositoryFactory.CreateCompilationRepository(); }
public void Before_Each_Test() { console = MockRepository.GenerateMock<IConsoleFacade>(); repository = MockRepository.GenerateMock<IRepository<GameObject>>(); format = new Formatter(console, repository); cmd = new DescribeCommand(console, repository, format); }
public DefaultPageService(IRepository repository, IRedirectService redirectService, IUrlService urlService) { this.repository = repository; this.redirectService = redirectService; this.urlService = urlService; temporaryPageCache = new Dictionary<string, IPage>(); }
public PackageDataAggregateUpdater(IRepository<PackageDataAggregate> packageDataAggregateRepository, IRepository<PublishedPackage> publishedPackageRepository, IRepository<Package> packageRepository) { _packageDataAggregateRepository = packageDataAggregateRepository; _packageRepository = packageRepository; _publishedPackageRepository = publishedPackageRepository; }
public PostsController(IRepository<Post> postsRepository, IRepository<User> usersRepository, IRepository<Tag> tagsRepository, IRepository<Comment> commentsRepository) { this.postsRepository = postsRepository; this.usersRepository = usersRepository; this.tagsRepository = tagsRepository; this.commentsRepository = commentsRepository; }
public void SetUp() { _mockRepository = new MockRepository(); _tagRepository = _mockRepository.DynamicMock<IRepository<Tag>>(); _tagService = new TagService(_tagRepository); }
public static async Task TransactionWrapAsync(this IRepository repository, IsolationLevel isolationLevel, Func <Task> handler) { await repository.Transaction.TransactionWrapAsync(isolationLevel, handler); }
public RoleAppService(IRepository <Role> repository, RoleManager roleManager, UserManager userManager) : base(repository) { _roleManager = roleManager; _userManager = userManager; }
private static void AssertStatus(bool shouldIgnoreCase, FileStatus expectedFileStatus, IRepository repo, string path) { try { Assert.Equal(expectedFileStatus, repo.RetrieveStatus(path)); } catch (ArgumentException) { Assert.False(shouldIgnoreCase); } }
public MenuService(IRepository <Menu, int> menuRepository, IUnitOfWork unitOfWork) { _menuRepository = menuRepository; _unitOfWork = unitOfWork; }
public TagController(IRepository <Tag> tagRepo) { this.TagRepo = tagRepo; }
public StudentsRepository(IRepository<Students, string> repository) : base(repository) { }
public StudentService(IRepository <StudentInfo> studentRepository) { _studentRepository = studentRepository; }
public static void TransactionWrap(this IRepository repository, IsolationLevel isolationLevel, Action handler) { repository.Transaction.TransactionWrap(isolationLevel, handler); }
public static async Task SessionWrapAsync(this IRepository repository, RequestContext context, Func <Task> handler) { await repository.Session.SessionWrapAsync(context, handler); }
public static async Task TransactionWrapAsync(this IRepository repository, Func <Task> handler) { await repository.Transaction.TransactionWrapAsync(handler); }
public static void SessionWrap(this IRepository repository, RequestContext context, Action handler) { repository.Session.SessionWrap(context, handler); }
public static void TransactionWrap(this IRepository repository, Action handler) { repository.Transaction.TransactionWrap(handler); }
public RegionStateService(IRepository <RegionState> regionStateRepo, IMapper mapper) { this.regionStateRepo = regionStateRepo; _mapper = mapper; }
public static async Task SessionWrapAsync(this IRepository repository, Func <Task> handler) { await repository.Session.SessionWrapAsync(handler); }
public HRApprovalHistoryRepository(IRepository <HRApprovalHistory> repository, IUserResolverService UserResolverService) : base(repository, UserResolverService) { }
public static void SessionWrap(this IRepository repository, Action handler) { repository.Session.SessionWrap(handler); }
public UserService(IRepository <User> repository) : base(repository) { _repository = repository; }
/// public ProfessorController(IRepository repo, IMapper mapper) { _mapper = mapper; _repo = repo; }
public ReservationController(IRepository repo) => repository = repo;
public EnterpriseSiteAppService(IRepository<EnterpriseSite, Guid> repository) : base(repository) { LocalizationResource = typeof(SolutionResource); }
public Spartan_SettingsService(IDataProvider dataProvider, IDbContext dbContext, IRepository <Spartane.Core.Domain.Spartan_Settings.Spartan_Settings> Spartan_SettingsRepository) { this._dataProvider = dataProvider; this._dbContext = dbContext; this._Spartan_SettingsRepository = Spartan_SettingsRepository; }
public TopicManagementController(IRepository <Topic> topicRepo) { _topicRepo = topicRepo; }
public AppService(IRepository <T> repository) { Repository = repository; }
public UserAppService(IRepository <User, long> userRepository, IPermissionManager permissionManager) { _userRepository = userRepository; _permissionManager = permissionManager; }
public Open() { repos = new Repository(); }
public InquiryService(IRepository <Data.Models.Inquiry> inquiryRepository) { this._inquiryRepository = inquiryRepository; }
public ItemService(IRepository repository, DbContextFakeCms dbContext) { _repository = repository; _dbContext = dbContext; }
public Open(IRepository _repo) { repos = _repo; }
public PostController(IRepository <Post> postRepository, IRepository <User> userRepository) { _postRepository = postRepository; _userRepository = userRepository; }
public TournamentServices(IRepository <KadabraTournament> repository) { this.repository = repository; }