/// <summary>
/// Ctor. Initializes a repository provider and the datacontextFactory to be used.
/// </summary>
/// <param name="repositoryProvider"></param>
/// <param name="dataContextFactory"></param>
public UnitOfWork(IRepositoryProvider repositoryProvider)
{
RepositoryProvider = repositoryProvider;
if (RepositoryProvider.DataContextFactory == null) {
RepositoryProvider.DataContextFactory = new DataContextFactory();
}
}
public HomeController(IRepositoryProvider repositories, IIssuesProvider issues, IHometasksProvider hometasks, ICouchProvider couchProvider)
{
_repositories = repositories;
_issues = issues;
_hometasks = hometasks;
_couchProvider = couchProvider;
}
public void Dispose()
{
if (RepositoryProvider != null)
{
RepositoryProvider.Dispose();
RepositoryProvider = null;
}
}
/// <summary>
/// A tracker to capture, store, and transmit events to a data channel.
/// </summary>
/// <param name="channel"> The channel used to store the data remotely. </param>
/// <param name="provider"> The repository used to store the data locally. </param>
/// <param name="elapsedTime"> The amount of time this tracker should have already been running. </param>
/// <param name="values"> The values to associate with this session. </param>
public static Tracker Start(IDataChannel channel, IRepositoryProvider provider, TimeSpan elapsedTime, params EventValue[] values)
{
var application = (Assembly.GetEntryAssembly() ?? Assembly.GetCallingAssembly()).GetName();
var tracker = new Tracker(channel, provider);
tracker.Start(application, elapsedTime, values);
return(tracker);
}
public Uow(IRepositoryProvider repositoryProvider)
{
CreateDbContext();
repositoryProvider.DbContext = DbContext;
RepositoryProvider = repositoryProvider;
}
public OrderProcessingUow(IRepositoryProvider repositoryProvider, DBConnectionString dbConnectionString)
{
_dbConnectionString = dbConnectionString;
CreateDbContext();
repositoryProvider.DbContext = DbContext;
RepositoryProvider = repositoryProvider;
}
public EditProjectPresenter(
Action <MessageType,
string> messageHandler,
Action <string, string> errorHandler,
IRepositoryProvider repositoryProvider)
: base(messageHandler, errorHandler, repositoryProvider)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ReadOnlyRepository{TModel,TEntity}"/> class.
/// </summary>
/// <param name="repositoryProvider">
/// The repository provider for this repository.
/// </param>
/// <param name="entityMapper">
/// The entity mapper.
/// </param>
public ReadOnlyRepository(
[NotNull] IRepositoryProvider repositoryProvider,
[NotNull] IEntityMapper entityMapper)
{
// The entity mapper, and its resolution context, is intended to last only for the lifetime of the repository.
this.EntityMapper = entityMapper ?? throw new ArgumentNullException(nameof(entityMapper));
this.RepositoryProvider = repositoryProvider ?? throw new ArgumentNullException(nameof(repositoryProvider));
}
internal MqttConnectedClient(IPacketChannelFactory channelFactory,
IProtocolFlowProvider flowProvider,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
MqttConfiguration configuration)
: base(channelFactory, flowProvider, repositoryProvider, packetIdProvider, configuration)
{
}
protected ProtocolFlowProvider(IMqttTopicEvaluator topicEvaluator,
IRepositoryProvider repositoryProvider,
MqttConfiguration configuration)
{
this.topicEvaluator = topicEvaluator;
this.repositoryProvider = repositoryProvider;
this.configuration = configuration;
}
public Section GetSectionForProviderGui(IRepositoryProvider provider)
{
Verify.Argument.IsNotNull(provider, nameof(provider));
var section = _providersSection.GetCreateSection(provider.Name);
return(section.GetCreateSection("Gui"));
}
public JetNettIntegrationTestingUnitOfWork(IRepositoryProvider repositoryProvider)
{
CreateDbContext();
repositoryProvider.DbContext = DbContext;
RepositoryProvider = repositoryProvider;
;
}
public void Dispose()
{
if (RepositoryProvider != null)
{
RepositoryProvider.Dispose();
RepositoryProvider = null;
}
}
/// <summary>
/// Constructeur.
/// </summary>
/// <param name="repositoriesConfiguration">Configuratrion des répertoires de données.</param>
/// <param name="repositoryService">Service de gestion des répertoires de données.</param>
public Repository(IRepositoriesConfiguration repositoriesConfiguration, IRepositoryService repositoryService)
{
// Recherche des informations de l'égrégat.
AggregateInfo aggregateInfo = repositoryService.GetInfo <AggregateT>();
// Récupération du fournisseur de données pour l'agrégat.
provider = repositoriesConfiguration.GetRepositoryProvider <AggregateT, IndexT>(aggregateInfo);
}
public AppEFUnitOfWork(IDataContext dataContext, IRepositoryProvider repositoryProvider)
{
_repositoryProvider = repositoryProvider;
_applicationDbContext = dataContext as ApplicationDbContext;
if (_applicationDbContext == null)
{
throw new NullReferenceException("No EF dbcontext found in UOW");
}
}
public RegistrationPresenter(IRegistrationView view, IRegistrationValidatorProvider provider, IRepositoryProvider <User> repositoryProvider)
{
this.provider = provider;
this.view = view;
this.repositoryProvider = repositoryProvider;
SubscribeToViewEvents();
SetUpView();
}
public MaterialsContextUow(
IList <DbContext> dbContexts,
IRepositoryProvider repositoryProvider)
{
_dbContexts = dbContexts;
ConfigureDbContexts();
_repositoryProvider = repositoryProvider;
_repositoryProvider.DbContext = _dbContexts[0];
}
public RepositoryGroupManager(
IFileRepository fileRepository,
IRepositoryProvider repositoryProvider,
IContinueEvent continueEvent)
{
_fileRepository = fileRepository;
_repositoryProvider = repositoryProvider;
_continueEvent = continueEvent;
}
public bool ProviderMatch(string url, out IRepositoryProvider provider) {
provider = null;
if (RepoRegex.IsMatch(url)) {
provider = new Provider();
return true;
}
return false;
}
/// <summary>
/// Populates the tree view.
/// </summary>
/// <param name="metadatas">The metadatas.</param>
private void PopulateTreeView(MetadataCollection metadatas)
{
lbConnected.Text = "[No remote repository]";
lbConnected.IsLink = false;
IRepositoryProvider p = RepositoryManager.Instance.GetMainRemoteProvider();
if (p != null)
{
lbConnected.Text = "Remote repository at " + p.Name;
lbConnected.IsLink = true;
lbConnected.Tag = p.Name;
}
// Racine
_treeCtrl.BeginUpdate();
_treeCtrl.Nodes.Clear();
try
{
TreeNode tvRoot = new TreeNode("Repository");
tvRoot.ImageIndex = tvRoot.SelectedImageIndex = 3;
_treeCtrl.Nodes.Add(tvRoot);
if (metadatas != null)
{
string currentDomain = CandleSettings.CurrentDomainId;
foreach (ComponentModelMetadata data in metadatas)
{
// Filtre sur les types
if (_filterType != null && data.ComponentType != _filterType)
{
continue;
}
// Filtre sur les noms
if (!String.IsNullOrEmpty(_filterName) && !Utils.StringStartsWith(data.Name, _filterName))
{
continue;
}
// Filtre sur le domaine
if (!String.IsNullOrEmpty(currentDomain) && data.Visibility != Visibility.Public &&
!Utils.StringStartsWith(data.Path, currentDomain))
{
continue;
}
PopulateNode(tvRoot, data);
}
tvRoot.Expand();
}
}
finally
{
_treeCtrl.EndUpdate();
btnRefresh.Enabled = true;
btnSelect.Enabled = true;
}
}
public Uow(IDbContext dbContext = null)
{
this.dbContext = dbContext;
ConfigureDbContext(this.dbContext);
var repositoryProvider = new RepositoryProvider(new RepositoryFactories());
repositoryProvider.dbContext = this.dbContext;
RepositoryProvider = repositoryProvider;
}
public CacheRepository(int blockSize, IRepositoryProvider repositoryProvider)
{
if (blockSize < 1)
{
throw new ArgumentOutOfRangeException("Block size must be greater than zero.");
}
_repositoryProvider = repositoryProvider ?? throw new ArgumentNullException(nameof(repositoryProvider));
_blockSize = blockSize;
}
public LinksController(
UserManager <ApplicationUser> userManager,
IRepositoryProvider repositoryProvider,
ILogger <LinksController> logger)
{
this.repository = repositoryProvider.GetRepository <TaggedLink>("links");
this.userManager = userManager;
this.logger = logger;
}
public CustomerServiceUOW(IRepositoryProvider repositoryProvider, ILogger <CustomerServiceUOW> logger)
{
if (repositoryProvider.DbContext == null)
{
throw new ArgumentNullException("dbContext is null");
}
this.RepositoryProvider = repositoryProvider;
_logger = logger;
}
public ViewProjectPresenter(
Action <MessageType, string> messageHandler,
Action <string, string> errorHandler,
IRepositoryProvider repositoryProvider)
: base(messageHandler, errorHandler, repositoryProvider)
{
_viewSprintPresenter = new ViewSprintPresenter(MessageHandler, ErrorHandler, RepositoryProvider);
_sprintReportPresenter = new SprintReportPresenter(MessageHandler, ErrorHandler, RepositoryProvider);
}
public VehicleActivityServiceUOW(IRepositoryProvider repositoryProvider, ILogger <VehicleActivityServiceUOW> logger)
{
if (repositoryProvider.DbContext == null)
{
throw new ArgumentNullException("dbContext is null"); /// if Database context not initalized Through Exception
}
this.RepositoryProvider = repositoryProvider;
_logger = logger;
}
/// <summary>
/// Chargement des metadata à partir du répertoire local et des serveurs distants
/// </summary>
/// <returns></returns>
internal MetadataCollection LoadAll()
{
if (_models != null)
{
return(this);
}
// Vérouillage
lock (_syncObject)
{
if (_models != null)
{
return(this);
}
ILogger logger = ServiceLocator.Instance.GetService <ILogger>();
// Lecture dans les référentiels - Local en premier
_models = new List <ComponentModelMetadata>();
// Local en premier
IRepositoryProvider localProvider = RepositoryManager.Instance.GetLocalProvider();
if (localProvider != null)
{
Merge(RepositoryLocation.Local, localProvider.GetAllMetadata());
}
// Puis les serveurs
foreach (IRepositoryProvider provider in RepositoryManager.Instance.GetRemoteProviders())
{
try
{
List <ComponentModelMetadata> list = provider.GetAllMetadata();
if (list != null)
{
// On met à jour l'url du serveur d'origine
list.ForEach(delegate(ComponentModelMetadata m) { m.ServerUrl = provider.Name; });
Merge(RepositoryLocation.Server, list);
}
}
catch (Exception ex)
{
if (logger != null)
{
logger.WriteError("GetMetadatas",
String.Format("Error when trying to retrieve the model list"), ex);
}
}
}
// Evénement fin de chargement
OnMetadataLoaded(new EventArgs());
}
return(this);
}
public UseCaseFactoryProvider(IRepositoryProvider repositoryProvider)
{
Person = new PersonUseCaseFactory(repositoryProvider);
Project = new ProjectUseCaseFactory(repositoryProvider);
Team = new TeamUseCaseFactory(repositoryProvider);
Meeting = new MeetingUseCaseFactory(repositoryProvider);
WorkTask = new WorkTaskUseCaseFactory(repositoryProvider);
Sprint = new SprintUseCaseFactory(repositoryProvider);
Document = new DocumentUseCaseFactory(repositoryProvider);
}
public ModernCmsUow(IRepositoryProvider repositoryProvider, IDbContext dbContext = null)
{
this.dbContext = dbContext;
ConfigureDbContext(this.dbContext);
repositoryProvider.dbContext = this.dbContext;
RepositoryProvider = repositoryProvider;
}
public AppUnitOfWork(IDataContext dbContext, IRepositoryProvider repositoryProvider)
{
_dbContext = dbContext as ApplicationDbContext;
if (_dbContext == null)
{
throw new ArgumentNullException(nameof(dbContext));
}
_repositoryProvider = repositoryProvider;
}
public DefaultRepositoryFacotry(
IEnumerable <IRepositoryProvider <TAggregateRoot, TKey> > repositoryProvider,
DomainMetadata domainMetadata
)
{
//if has more repository provider(ef core,dapper,ado).always choose last one.
_repositoryProvider = repositoryProvider.Last();
_aggregateRootDescriptors = domainMetadata.DomainObject.AggregateRoots;
}
protected UnitOfWork(IRepositoryProvider repositoryProvider, IEntityFrameworkDbContext dbContext)
{
//CreateDbContext();
RepositoryProvider = repositoryProvider;
repositoryProvider.DbContext = dbContext;
this.dbContext = dbContext;
PrepareDbContext();
}
/// <summary>
/// 初始化 <see cref="EntityRepository{TEntity}"/> 类的新实例。
/// </summary>
/// <param name="contextService"></param>
/// <param name="options"></param>
public EntityRepository(IContextService contextService, IRepositoryProvider <TEntity> repositoryProxy, EntityContextOptions options)
{
_contextService = contextService;
_repositoryProxy = repositoryProxy;
_options = options;
_provider = options.Provider;
EntityType = typeof(TEntity);
_subMgr = PersistentSubscribeManager.GetRequiredManager(contextService.ContextType);
}
public PresenterFactoryProvider(IRepositoryProvider repositoryProvider)
{
Meeting = new MeetingPresenterFactory(repositoryProvider);
Person = new PersonPresenterFactory(repositoryProvider);
Project = new ProjectPresenterFactory(repositoryProvider);
Sprint = new SprintPresenterFactory(repositoryProvider);
Team = new TeamPresenterFactory(repositoryProvider);
WorkTask = new WorkTaskPresenterFactory(repositoryProvider);
Document = new DocumentPresenterFactory(repositoryProvider);
}
/// <summary>
/// Création d'un nouveau domaine
/// </summary>
/// <param name="path"></param>
public void RemoveDomainPath(string path)
{
DomainManager.Instance.RemoveDomainPath(path);
IRepositoryProvider provider = _wsRepository;
if (provider != null)
{
provider.RemoveDomainPath(path);
}
}
public TaskBoardViewModel(IRepositoryProvider repositoryProvider, IEventAggregator bus, ICommandResolver commandResolver)
{
_repositoryProvider = repositoryProvider;
_bus = bus;
_commandResolver = commandResolver;
Tasks = new SortableReactiveCollection<TaskViewModel>();
Tasks.ItemChanged
.Throttle(TimeSpan.FromSeconds(5))
.Select(c => c.Sender)
.Where(c => _repository != null)
.Where(task => !task.IsEditing)
.SubscribeOn(RxApp.DeferredScheduler)
.Subscribe(_ => OnSaveAllTasks(null));
Tasks.ItemChanged
.Where(c => c.PropertyName == "IsSelected")
.SubscribeOn(RxApp.DeferredScheduler)
.Select(c => c.Sender)
.Subscribe(IsSelectedChanged);
Tasks.ItemChanged
.Where(c => c.PropertyName == "State")
.SubscribeOn(RxApp.DeferredScheduler)
.Select(c => c.Sender)
.Subscribe(StateChanged);
Tasks.ChangeTrackingEnabled = true;
_bus.ListenOnScheduler<DatabaseChanged>(OnDatabaseChanged);
_bus.ListenOnScheduler<CreateNewTask>(OnCreateNewTask);
_bus.ListenOnScheduler<CreateNewSubTask>(OnCreateNewSubTask);
_bus.ListenOnScheduler<SaveAllTasks>(OnSaveAllTasks);
_bus.ListenOnScheduler<ReloadAllTasks>(evt => Reload());
_bus.ListenOnScheduler<ReSort>(evt => Reorder());
_bus.ListenOnScheduler<CollapseAll>(evt => OnCollapseAll());
_bus.AddSource(Tasks.PropertyOnAnyChanged(vm => vm.State)
.Select(_ => new TaskStateChanged()));
DragCommand = new ReactiveCommand();
DragCommand.OfType<DragCommandArgs>().Subscribe(OnNext);
}
public StoreController(IRepositoryProvider repositoryProvider)
{
_repositoryProvider = repositoryProvider;
}
public NewsletterController(IRepositoryProvider repositoryProvider, IEmailService emailService, IMembershipProvider membershipProvider)
{
_repositoryProvider = repositoryProvider;
_emailService = emailService;
_membershipProvider = membershipProvider;
}
public SiteManagerWrapper(ISiteProvider siteProvider, IRepositoryProvider repositoryProvider)
: base(siteProvider, new RepositoryManager(repositoryProvider))
{
}
public TasksExporter(IDtoMapper mapper, IRepositoryProvider provider)
{
_mapper = mapper;
_provider = provider;
}
public Section GetSectionForProviderGui(IRepositoryProvider provider)
{
Verify.Argument.IsNotNull(provider, "provider");
var section = _providersSection.GetCreateSection(provider.Name);
return section.GetCreateSection("Gui");
}
public TasksImporter(IRepositoryProvider provider, IDtoMapper mapper)
{
_provider = provider;
_mapper = mapper;
}
public ForumController(IRepositoryProvider repositoryProvider, IMembershipProvider membershipProvider)
{
_repositoryProvider = repositoryProvider;
_membershipProvider = membershipProvider;
}
public RepositoryManager(IRepositoryProvider provider)
{
this.Provider = provider;
}
public void Setup() {
provider = new Provider();
files = provider.Download(Url);
}
public RepositoryProvider(IRepositoryProvider innerProvider)
{
inner = innerProvider;
}
public ArticleController(IRepositoryProvider repositoryProvider)
{
_repositoryProvider = repositoryProvider;
}
public void AssignToRepository(IRepositoryProvider repository)
{
this.FullPathInRepo = Path.Combine(repository.GetPathToRepository(), this.NameInRepo);
}
public CategoryController(IRepositoryProvider repositoryProvider)
{
_repositoryProvider = repositoryProvider;
}
public void Initialize()
{
factory = new RepositoryFactories();
provider = new RepositoryProvider(factory);
uow = new UnitOfWork(provider);
}
public DebugDumpImportantLinks(IRepositoryProvider provider, IDebugService debugService)
{
_provider = provider;
_debugService = debugService;
}
private void OnOrderEditViewModelClosed(object sender, EventArgs e)
{
var orderEditViewModel = sender as OrderEditViewModel;
if (orderEditViewModel != null && orderEditViewModel.ModalResult)
{
RepositoryProvider.Dispose();
RepositoryProvider = ServiceLocator.GetInstance<IRepositoryProvider>();
Search();
}
}
public EmailService(IRepositoryProvider repositoryProvider)
{
_repositoryProvider = repositoryProvider;
_logger = LogManager.GetLogger("DessertHouse");
}
