public void EventProcessingDelay()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
var watch = Stopwatch.StartNew();
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.EventProcessingDelay = 250;
tracker.Start();
tracker.Wait(x => x.EventProcessorRunning);
actual.Wait(x => x.Count == 1);
Thread.Sleep(50);
tracker.AddEvent("Event");
actual.Wait(x => x.Count == 2);
}
watch.Stop();
Console.WriteLine(watch.Elapsed.TotalMilliseconds);
Assert.IsTrue(watch.Elapsed.TotalMilliseconds > 250);
Assert.IsTrue(watch.Elapsed.TotalMilliseconds < 1000);
actual.Wait(x => x.Count == 2);
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("Event", actual[1].Name);
Assert.AreEqual(0, actual[1].ElapsedTime.TotalMilliseconds);
}
public TestActivateItems(UITests uiTests, MemoryDataExportRepository repo)
{
_uiTests = uiTests;
Results = new TestActivateItemsResults();
GlobalErrorCheckNotifier = new ToMemoryCheckNotifier();
RepositoryLocator = new RepositoryProvider(repo);
RefreshBus = new RefreshBus();
//don't load the comment store for every single test
if (_commentStore == null)
{
_commentStore = new CommentStore();
_commentStore.ReadComments(TestContext.CurrentContext.TestDirectory);
}
CommentStore = _commentStore;
CoreChildProvider = new DataExportChildProvider(RepositoryLocator, null, Results);
CoreIconProvider = new DataExportIconProvider(RepositoryLocator, null);
FavouritesProvider = new FavouritesProvider(this, repo.CatalogueRepository);
_problemProviders = new List <IProblemProvider>(new IProblemProvider[]
{
new CatalogueProblemProvider(),
new DataExportProblemProvider()
});
PluginUserInterfaces = new List <IPluginUserInterface>();
}
public async Task <IActionResult> TrackWallet(
string cryptoCode,
[ModelBinder(BinderType = typeof(DerivationStrategyModelBinder))]
DerivationStrategyBase derivationScheme,
[ModelBinder(BinderType = typeof(BitcoinAddressModelBinder))]
BitcoinAddress address)
{
TrackedSource trackedSource = GetTrackedSource(derivationScheme, address);
if (trackedSource == null)
{
return(NotFound());
}
var network = GetNetwork(cryptoCode, false);
if (trackedSource is DerivationSchemeTrackedSource dts)
{
foreach (var feature in Enum.GetValues(typeof(DerivationFeature)).Cast <DerivationFeature>())
{
await RepositoryProvider.GetRepository(network).GenerateAddresses(dts.DerivationStrategy, feature, new GenerateAddressQuery(minAddresses: 3, null));
}
foreach (var feature in Enum.GetValues(typeof(DerivationFeature)).Cast <DerivationFeature>())
{
_ = AddressPoolService.GenerateAddresses(network, dts.DerivationStrategy, feature);
}
}
else if (trackedSource is IDestination ats)
{
await RepositoryProvider.GetRepository(network).Track(ats);
}
return(Ok());
}
static void Main(string[] args)
{
var details = new Details();
var books = details.FindBookByIsbn("1451648553");
Database.SetInitializer(
new DropCreateDatabaseAlways<ReadgressDbContext>());
//Database.SetInitializer<ReadgressDbContext>(null);
var factories = new RepositoryFactories();
var repoistoryProvider = new RepositoryProvider(factories);
//var readgressUow = new ReadgressUow(repoistoryProvider);
using (var context = new ReadgressUow(repoistoryProvider))
//using (var context = new ReadgressDbContext())
{
//var progess = context.Progresses.GetById(1);
//progess.Bookmarks.Add(new Bookmark() { PageNumber = 30, CreatedOn = DateTime.Now });
//context.Progresses.Update(progess);
//context.Commit();
var reader = context.Readers.GetAll().First();
var progress = context.Progresses.GetByReaderId(1);
var bookmark = context.Bookmarks.GetAll();
Console.WriteLine(reader.FullName);
}
Console.WriteLine("Done");
}
public void WithOldSessions()
{
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var channel = new Mock <IDataChannel>();
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
TestHelper.Directory.SafeCreate();
var session = TestHelper.CreateSession();
using (var repository = provider.OpenRepository(session.SessionId.ToString()))
{
repository.WriteAndSave(session);
}
using (Tracker.Start(channel.Object, provider))
{
Thread.Sleep(500);
}
Assert.AreEqual(2, actual.Count);
session.Id = actual[1].Id;
TestHelper.AreEqual(session, actual[1]);
}
public void Edit(Language language)
{
RepositoryProvider.Do(repo =>
{
repo.Edit(language);
});
}
public TopicsController()
{
var rf = new RepositoryFactories();
var rp = new RepositoryProvider(rf);
uow = new DTUoW(rp);
}
public async Task <IActionResult> GetStatus(string cryptoCode)
{
var network = GetNetwork(cryptoCode, false);
var waiter = Waiters.GetWaiter(network);
var chain = ChainProvider.GetChain(network);
var repo = RepositoryProvider.GetRepository(network);
var now = DateTimeOffset.UtcNow;
var location = waiter.GetLocation();
var blockchainInfoAsync = waiter.RPCAvailable ? waiter.RPC.GetBlockchainInfoAsyncEx() : null;
var networkInfoAsync = waiter.RPCAvailable ? waiter.RPC.GetNetworkInfoAsync() : null;
await repo.Ping();
var pingAfter = DateTimeOffset.UtcNow;
GetBlockchainInfoResponse blockchainInfo = blockchainInfoAsync == null ? null : await blockchainInfoAsync;
GetNetworkInfoResponse networkInfo = networkInfoAsync == null ? null : await networkInfoAsync;
var status = new StatusResult()
{
NetworkType = network.NBitcoinNetwork.NetworkType,
CryptoCode = network.CryptoCode,
Version = typeof(MainController).GetTypeInfo().Assembly.GetCustomAttribute <AssemblyFileVersionAttribute>().Version,
SupportedCryptoCodes = Waiters.All().Select(w => w.Network.CryptoCode).ToArray(),
RepositoryPingTime = (pingAfter - now).TotalSeconds,
IsFullySynched = true
};
if (status.RepositoryPingTime > 30)
{
Logs.Explorer.LogWarning($"Repository ping exceeded 30 seconds ({(int)status.RepositoryPingTime}), please report the issue to NBXplorer developers");
}
if (blockchainInfo != null)
{
status.BitcoinStatus = new BitcoinStatus()
{
IsSynched = !waiter.IsSynchingCore(blockchainInfo),
Blocks = (int)blockchainInfo.Blocks,
Headers = (int)blockchainInfo.Headers,
VerificationProgress = blockchainInfo.VerificationProgress,
MinRelayTxFee = new FeeRate(Money.Coins((decimal)networkInfo.relayfee), 1000),
IncrementalRelayFee = new FeeRate(Money.Coins((decimal)networkInfo.incrementalfee), 1000),
Capabilities = new NodeCapabilities()
{
CanScanTxoutSet = waiter.RPC.Capabilities.SupportScanUTXOSet,
CanSupportSegwit = waiter.RPC.Capabilities.SupportSegwit
}
};
status.IsFullySynched &= status.BitcoinStatus.IsSynched;
}
status.ChainHeight = chain.Height;
status.SyncHeight = location == null ? (int?)null : chain.FindFork(location).Height;
status.IsFullySynched &= blockchainInfo != null &&
waiter.State == BitcoinDWaiterState.Ready &&
status.SyncHeight.HasValue &&
blockchainInfo.Headers - status.SyncHeight.Value < 3;
return(Json(status));
}
public void WithOldSessionsWithConnectionIssues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
TestHelper.Directory.SafeCreate();
var expected = new List <Event>();
var session = TestHelper.CreateSession();
using (var repository = provider.OpenRepository(session.SessionId.ToString()))
{
repository.WriteAndSave(session);
}
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(events =>
{
var list = events.ToList();
if (list.Any(x => x.UniqueId == session.SessionId))
{
throw new Exception("Unable to connect to the remote server");
}
expected.AddRange(list);
});
using (Tracker.Start(channel.Object, provider))
{
Thread.Sleep(1000);
}
Assert.AreEqual(1, expected.Count);
Assert.AreEqual(EventType.Session, expected[0].Type);
}
public ExpensesUow(RepositoryProvider repositoryProvider)
{
CreateDbContext();
repositoryProvider.DbContext = DbContext;
RepositoryProvider = repositoryProvider;
}
private void MakeLogin()
{
try
{
using (StartOperation())
{
User user = RepositoryProvider.GetRepository <User>().GetAll()
.FirstOrDefault(u => u.Login == Login);
if (user == null || !PasswordManager.ValidatePassword(Password, user.Password))
{
ErrorMessage = "Incorrect login or password.";
}
else
{
var mainViewModel = ServiceLocator.GetInstance <MainViewModel>();
mainViewModel.InitializeAsync(user.Id);
mainViewModel.Show();
Close(true);
}
}
}
catch (Exception exc)
{
ErrorMessage = "Can't connect to database. Try again.";
Debug.WriteLine(exc.ExpandToString());
}
}
public RepositoryTheoryCommand(IMethodInfo method, RepositoryProvider provider)
: base(method)
{
_provider = provider;
DisplayName = string.Format(
"{0} - DatabaseProvider: {1}", DisplayName, _provider);
}
private static Dictionary <string, Route> ComposeRoutes()
{
using (var context = new RepositoryProvider())
{
var routeEntities = context.TreeNodeRepository.GetEntities().Select(r => new
{
url = r.Url,
id = r.Id,
name = r.Name
})
.ToList();
foreach (var route in routeEntities)
{
_routes.Add(route.name, new Route(route.url, new RouteValueDictionary()
{
{ _controller, DefaultController },
{ _action, DefaultAction },
{ _id, route.id }
},
new MvcRouteHandler()));
}
}
return(_routes);
}
public void SessionValues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var events = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => events.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start();
}
Assert.AreEqual(1, events.Count);
Assert.AreEqual(0, events[0].ElapsedTime.Ticks);
}
var expected = new[]
{
".NET Framework Version", "Amount Of Memory", "Application Bitness", "Application Name",
"Application Version", "Bloodhound Version", "Machine ID", "Machine Name", "Machine User Name",
"Number Of Processors", "Operating System Bitness", "Operating System Name", "Operating System Service Pack",
"Operating System Version", "Screen Resolution", "Storage Available Space", "Storage Total Space"
};
var actual = events[0].Values.Select(x => x.Name).OrderBy(x => x).ToArray();
TestHelper.AreEqual(expected, actual);
}
public void StartWithElapsedTime()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
var elapsedTime = TimeSpan.FromTicks(5465421643);
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start(elapsedTime);
}
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(elapsedTime, actual[0].ElapsedTime);
Assert.AreEqual(elapsedTime, actual[0].CompletedOn - actual[0].CreatedOn);
}
var applicationName = actual[0].Values.First(x => x.Name == "Application Name");
Assert.AreEqual("Bloodhound.IntegrationTests", applicationName.Value);
}
void Start()
{
Logger.SetProvider(new UnityLogger());
repositoryProvider = new RepositoryProvider();
serviceProvider = new ServiceProvider();
actionsProvider = new ActionsProvider();
//RepositoryProvider.WordsRepository.Add(new Word("alfa"));
//RepositoryProvider.WordsRepository.Add(new Word("beta"));
//RepositoryProvider.WordsRepository.Add(new Word("gamma"));
//RepositoryProvider.WordsRepository.Add(new Word("delta"));
//RepositoryProvider.WordsRepository.Add(new Word("epsilon"));
RepositoryProvider.WordsRepository.Add(new Word("rayo"));
RepositoryProvider.WordsRepository.Add(new Word("finanzas"));
RepositoryProvider.WordsRepository.Add(new Word("marciano"));
RepositoryProvider.WordsRepository.Add(new Word("critico"));
RepositoryProvider.WordsRepository.Add(new Word("norte"));
RepositoryProvider.WordsRepository.Add(new Word("arena"));
RepositoryProvider.WordsRepository.Add(new Word("egipto"));
RepositoryProvider.WordsRepository.Add(new Word("auto"));
RepositoryProvider.WordsRepository.Add(new Word("dinosaurio"));
ActionsProvider.ClickLetterAction.OnWinGame += WinGame;
ActionsProvider.GenerateNewGameAction.OnGameReset += NewGame;
ActionsProvider.GenerateNewGameAction.Execute(12, 12, 5);
letterGridWidget.Load();
resetGameWidget.Load();
winPopUpWidget.Load();
NewGame();
}
public void Exception()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (var tracker = Tracker.Start(channel.Object, provider))
{
tracker.AddException(new Exception("Boom"));
}
Assert.IsTrue(actual.Wait(x => x.Count == 2));
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("Exception", actual[1].Name);
Assert.AreEqual(0, actual[1].ElapsedTime.TotalMilliseconds);
var actualValues = actual[1].Values;
Assert.AreEqual(2, actualValues.Count);
}
public async Task <IActionResult> GetTransaction(
[ModelBinder(BinderType = typeof(UInt256ModelBinding))]
uint256 txId,
bool includeTransaction = true,
string cryptoCode = null)
{
var network = GetNetwork(cryptoCode, false);
var chain = this.ChainProvider.GetChain(network);
var result = await RepositoryProvider.GetRepository(network).GetSavedTransactions(txId);
if (result.Length == 0)
{
var waiter = Waiters.GetWaiter(cryptoCode);
if (waiter.RPCAvailable &&
waiter.HasTxIndex &&
await waiter.RPC.TryGetRawTransaction(txId) is Repository.SavedTransaction savedTransaction)
{
result = new[] { savedTransaction };
}
else
{
return(NotFound());
}
}
var tx = Utils.ToTransactionResult(chain, result);
if (!includeTransaction)
{
tx.Transaction = null;
}
return(Json(tx));
}
public IList <Guid> GetRoleIds(Guid userId)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
return(new List <Guid>());
}
/// <summary>
/// Service for handling on-chain balance
/// </summary>
/// <param name="keysRepository"></param>
/// <param name="nbXplorerClientProvider"></param>
public WalletService(IKeysRepository keysRepository, INBXplorerClientProvider nbXplorerClientProvider, ILogger <WalletService> logger, RepositoryProvider repositoryProvider)
{
_keysRepository = keysRepository;
_nbXplorerClientProvider = nbXplorerClientProvider;
_logger = logger;
_repositoryProvider = repositoryProvider;
}
public void Edit(Actor actor)
{
RepositoryProvider.Do(repo =>
{
repo.Edit(actor);
});
}
public void StartWithElapsedTimeAndCustomValues()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var actual = new List <Event>();
var elapsedTime = TimeSpan.FromTicks(413124564);
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(x => actual.AddRange(x));
using (TestHelper.CreateDataContext())
{
using (var tracker = new Tracker(channel.Object, provider))
{
tracker.Start(elapsedTime, new EventValue("Foo", "Bar"));
}
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(elapsedTime, actual[0].ElapsedTime);
Assert.AreEqual(18, actual[0].Values.Count);
var eventValue = actual[0].Values.FirstOrDefault(x => x.Name == "Foo");
Assert.IsNotNull(eventValue);
Assert.AreEqual("Foo", eventValue.Name);
Assert.AreEqual("Bar", eventValue.Value);
}
var applicationName = actual[0].Values.First(x => x.Name == "Application Name");
Assert.AreEqual("Bloodhound.IntegrationTests", applicationName.Value);
}
public void Remove(int id)
{
RepositoryProvider.Do(repo =>
{
repo.Remove <Actor>(id);
});
}
public void TimedEventCompleteShouldOnlyFireOnce()
{
var channel = new Mock <IDataChannel>();
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
var count = 0;
channel.Setup(x => x.WriteEvents(It.IsAny <IEnumerable <Event> >()))
.Callback <IEnumerable <Event> >(events => count += events.Count());
using (var tracker = Tracker.Start(channel.Object, provider))
{
var timedEvent = tracker.StartEvent("TimedEvent");
timedEvent.Complete();
// Change unique ID so the repository would create a new event.
// Should not be added because complete should only fire once.
timedEvent.UniqueId = Guid.NewGuid();
timedEvent.Complete();
timedEvent.UniqueId = Guid.NewGuid();
timedEvent.Complete();
}
// Should only be two events.
Assert.AreEqual(2, count);
}
public Order SaveOrder(int branchId, int customerId, int employeeId, List <OrderedBookDescription> orderedBooks)
{
var order = new Order
{
Customer = RepositoryProvider.GetRepository <Customer>().Find(customerId),
EmployeeId = employeeId,
Date = DateTime.Now,
OrderedBooks = new List <OrderedBook>(orderedBooks.Count)
};
var bookAmountRepository = RepositoryProvider.GetRepository <BookAmount>();
foreach (var orderedBook in orderedBooks)
{
var bookAmount = bookAmountRepository.GetAll(ba => ba.Book)
.Where(ba => ba.BookId == orderedBook.BookId)
.First(ba => ba.BranchId == branchId);
bookAmount.Amount -= orderedBook.Amount;
order.OrderedBooks.Add(new OrderedBook
{
BookId = bookAmount.Book.Id,
Price = bookAmount.Book.Price,
Amount = orderedBook.Amount
});
}
RepositoryProvider.GetRepository <Order>().Add(order);
RepositoryProvider.SaveChanges();
return(order);
}
public void TimedEventWithTimedChild()
{
var channel = new WebDataChannel("http://localhost");
var provider = new RepositoryProvider(TestHelper.Directory, TimeSpan.FromDays(1), 10000);
using (var context = TestHelper.CreateDataContext())
{
using (var tracker = Tracker.Start(channel, provider))
{
var timedEvent = tracker.StartEvent("TimedEvent");
var childTimedEvent = timedEvent.StartEvent("ChildEvent");
Thread.Sleep(250);
childTimedEvent.Complete();
Thread.Sleep(250);
timedEvent.Complete();
}
Assert.IsTrue(context.Wait(x => x.Events.Count() == 3, 5000));
var actual = context.Events.ToList();
Assert.AreEqual(3, actual.Count);
Assert.AreEqual("Session", actual[0].Name);
Assert.AreEqual("TimedEvent", actual[1].Name);
Assert.IsTrue(actual[1].ElapsedTime.TotalMilliseconds > 500);
Assert.IsTrue(actual[1].ElapsedTime.TotalMilliseconds < 550);
Assert.AreEqual("ChildEvent", actual[2].Name);
Assert.IsTrue(actual[2].ElapsedTime.TotalMilliseconds > 250);
Assert.IsTrue(actual[2].ElapsedTime.TotalMilliseconds < 300);
}
}
private async Task UpdatePSBTCore(UpdatePSBTRequest update, NBXplorerNetwork network)
{
var repo = RepositoryProvider.GetRepository(network);
var rpc = Waiters.GetWaiter(network);
await UpdateInputsUTXO(update, repo, rpc);
if (update.DerivationScheme is DerivationStrategyBase)
{
foreach (var extpub in update.DerivationScheme.GetExtPubKeys().Select(e => e.GetWif(network.NBitcoinNetwork)))
{
update.PSBT.GlobalXPubs.AddOrReplace(extpub, new RootedKeyPath(extpub, new KeyPath()));
}
await UpdateHDKeyPathsWitnessAndRedeem(update, repo);
}
foreach (var input in update.PSBT.Inputs)
{
input.TrySlimUTXO();
}
if (update.RebaseKeyPaths != null)
{
foreach (var rebase in update.RebaseKeyPaths)
{
var rootedKeyPath = rebase.GetRootedKeyPath();
if (rootedKeyPath == null)
{
throw new NBXplorerException(new NBXplorerError(400, "missing-parameter", "rebaseKeyPaths[].rootedKeyPath is missing"));
}
update.PSBT.RebaseKeyPaths(rebase.AccountKey, rootedKeyPath);
}
}
}
private static void WriterOnDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var worker = (BackgroundWorker)sender;
var server = ConfigurationManager.AppSettings["Server"];
var client = new WebDataChannel(server);
var provider = new RepositoryProvider(Directory, TimeSpan.FromMinutes(1), 1000);
var random = new Random(Guid.NewGuid().GetHashCode());
var count = 0;
while (!worker.CancellationPending)
{
using (var tracker = new Tracker(client, provider))
{
worker.ReportProgress(1, $"Starting writer {count++} ...");
tracker.Start(new EventValue("Count", count));
decimal eventCount = random.Next(10, 1000);
for (var i = 1; i <= eventCount; i++)
{
var item = tracker.StartEvent($"Event{i}");
var itemDelay = random.Next(1, 100);
worker.ReportProgress((int)(i / eventCount * 100), $"{i} of {eventCount}");
item.Values.Add(new EventValue("Delay", itemDelay));
Thread.Sleep(itemDelay);
item.Complete();
}
}
}
}
public RepositoryTheoryCommand(IMethodInfo method, RepositoryProvider provider)
:base(method)
{
_provider = provider;
DisplayName = string.Format(
"{0} - DatabaseProvider: {1}", DisplayName, _provider);
}
public void Add(Language language)
{
RepositoryProvider.Do(repo =>
{
repo.Add(language);
});
}
public async Task <KeyPathInformation> GetUnusedAddress(
string cryptoCode,
[ModelBinder(BinderType = typeof(DestinationModelBinder))]
DerivationStrategyBase strategy, DerivationFeature feature = DerivationFeature.Deposit, int skip = 0, bool reserve = false)
{
if (strategy == null)
{
throw new ArgumentNullException(nameof(strategy));
}
var network = GetNetwork(cryptoCode);
var repository = RepositoryProvider.GetRepository(network);
try
{
var result = await repository.GetUnused(strategy, feature, skip, reserve);
if (result == null)
{
throw new NBXplorerError(404, "strategy-not-found", $"This strategy is not tracked, or you tried to skip too much unused addresses").AsException();
}
return(result);
}
catch (NotSupportedException)
{
throw new NBXplorerError(400, "derivation-not-supported", $"The derivation scheme {feature} is not supported").AsException();
}
}
public void Add(Actor actor)
{
RepositoryProvider.Do(repo =>
{
repo.Add(actor);
});
}
public static IUnitOfWork Create()
{
var factories = new RepositoryFactories();
var provider = new RepositoryProvider(factories);
IUnitOfWork uow = new UnitOfWork(provider);
return uow;
}
/// <summary>
/// Constructor. It creates a dbContext Factory and initializes the database.
/// </summary>
public UnitOfWorkFixture()
{
_contextFactory = new DataContextFactory();
_contextFactory.Get().Database.Initialize(false);
IRepositoryProvider provider = new RepositoryProvider(new RepositoryFactories());
provider.DataContextFactory = _contextFactory;
_unitOfWork = new UnitOfWork(provider);
}
public override void Init(RepositoryProvider provider)
{
if (provider == RepositoryProvider.DataService)
{
ServManager.InitService();
}
base.Init(provider);
}
public override void Init(RepositoryProvider provider)
{
if (provider == RepositoryProvider.DataService)
{
_Service = new TestDataService(typeof(TestDSCatalogService));
}
base.Init(provider);
}
public override void Init(RepositoryProvider provider)
{
if (provider == RepositoryProvider.DataService)
{
_service = new TestDataService(typeof(TestDSDynamicContentService));
}
base.Init(provider);
}
public DTView()
{
InitializeComponent();
var rf = new RepositoryFactories();
var rp = new RepositoryProvider(rf);
var uow = new DTUoW(rp);
DataContext = new DTViewModel(uow);
}
public void Test1()
{
RepositoryProvider repository = new RepositoryProvider();
repository.Add(contentRepository);
var item = repository.Get(contentRepository);
Assert.AreEqual(contentRepository.Name, item.Name);
Assert.AreEqual(contentRepository.DisplayName, item.DisplayName);
repository.Remove(item);
}
/// <summary>Create <see cref="GuiProvider"/>.</summary>
/// <param name="repositoryProvider">Git repository provider.</param>
public GuiProvider(RepositoryProvider repositoryProvider)
{
Verify.Argument.IsNotNull(repositoryProvider, "repositoryProvider");
_repositoryProvider = repositoryProvider;
_mainToolbar = new GitToolbar(this);
_viewFactories = new ViewFactoriesCollection(this);
_statusbar = new Statusbar(this);
_menus = new MainGitMenus(this);
_notifications = new Notifications(this);
}
public void Db_context_save_changes_is_called_on_commit()
{
var mockContext = new Mock<JetNettApiDbContext>();
var repoFactories = new RepositoryFactories();
var repoProvider = new RepositoryProvider(null);
var uow = new JetNettApiUow(repoProvider, mockContext.Object);
uow.Commit();
mockContext.Verify(x => x.SaveChanges());
}
public ResourcePublisher(RepositoryProvider publicationTarget, IPsCmdletLogger logger, string pluginFolder)
{
this.publicationTarget = publicationTarget;
this.logger = logger;
logger.Log("Loading plugins from " + pluginFolder);
Assembly.LoadFrom(Path.Combine(pluginFolder, "umbraco.courier.providers.dll"));
Assembly.LoadFrom(Path.Combine(pluginFolder, "umbraco.courier.dataresolvers.dll"));
Context.Current.BaseDirectory = Directory.GetCurrentDirectory();
Context.Current.HasHttpContext = false;
logger.Log("Current directory set to " + Directory.GetCurrentDirectory());
}
public UserIdentificationDialog(IWorkingEnvironment environment, Repository repository)
{
Verify.Argument.IsNotNull(environment, "environment");
_environment = environment;
_repository = repository;
_repositoryProvider = environment.GetRepositoryProvider<RepositoryProvider>();
InitializeComponent();
Text = Resources.StrUserIdentification;
_lblUser.Text = Resources.StrUsername.AddColon();
_lblEmail.Text = Resources.StrEmail.AddColon();
_lblUseThisUserNameAndEmail.Text = Resources.StrsUseThisUserNameAndEmail.AddColon();
_radSetUserGlobally.Text = Resources.StrsForCurrentWindowsUser;
_radSetUserForRepositoryOnly.Text = Resources.StrsForCurrentRepositoryOnly;
if(repository != null)
{
var userName = repository.Configuration.TryGetParameter(GitConstants.UserNameParameter);
if(userName != null)
{
_txtUsername.Text = _oldUserName = userName.Value;
}
else
{
_txtUsername.Text = Environment.UserName;
}
var userEmail = repository.Configuration.TryGetParameter(GitConstants.UserEmailParameter);
if(userEmail != null)
{
_txtEmail.Text = _oldUserEmail = userEmail.Value;
}
else
{
_txtEmail.Text = string.Format("{0}@{1}", Environment.UserName, Environment.UserDomainName);
}
}
else
{
_radSetUserForRepositoryOnly.Enabled = false;
}
GitterApplication.FontManager.InputFont.Apply(_txtUsername, _txtEmail);
}
internal SessionData(User loggingUser)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
UserId = loggingUser.PersonId;
Username = loggingUser.UserName;
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
var personInfo = unitofWork.RepositoryAsync<Person>()
.Query(m => m.PersonId == loggingUser.PersonId)
.Select()
.FirstOrDefault();
if (personInfo != null)
{
FirstName = personInfo.FullName;
Email = personInfo.Email;
ImageUrl = personInfo.ImageUrl;
ImageCoverUrl = personInfo.ImageCoverUrl;
}
IsAuthenticated = true;
Saved = false;
}
public TopicsController()
{
var rf = new RepositoryFactories();
var rp = new RepositoryProvider(rf);
uow = new DTUoW(rp);
}
public override void Init(RepositoryProvider provider)
{
//Fake call to init repositories
_appConfigRepository = AppConfigRepository;
_storeRepository = StoreRepository;
base.Init(provider);
}
public override bool ChangePassword(string username, string oldPassword, string newPassword)
{
oldPassword = oldPassword.Trim();
if (!SecurityUtility.IsPasswordValid(newPassword))
{
return false;
}
var user = SecurityUtility.GetUserByUsername(username);
if (user == null)
{
return false;
}
var feedbackMessage = new System.Text.StringBuilder();
if (user.Password != oldPassword && user.Password != Cryptography.EncryptPassword(oldPassword, user.Salt))
{
return false;
}
user.Password = Cryptography.EncryptPassword(newPassword, user.Salt);
IRepositoryProvider _repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), _repositoryProvider);
unitofWork.Repository<Domain.Entity.User>().Update(user);
var ret = unitofWork.SaveChanges();
return ret > 0;
}
public bool IsMemberOfRole(Guid userId, Guid roleId)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
// var user = unitofWork.RepositoryAsync<RolePerson>().Query(rp => rp.PersonId == userId && rp.RoleId == roleId).Select();
return true;
}
private User GetUserWithDomain(string username, string domain)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
var user = unitofWork.RepositoryAsync<User>()
.Query(
m => string.Compare(m.UserName, username, StringComparison.InvariantCultureIgnoreCase) == 0 &&
string.Compare(m.Domain, domain, StringComparison.InvariantCultureIgnoreCase) == 0
)
.Select()
.FirstOrDefault();
return user;
}
public void UpdateUserInformation(User loggingUser)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
unitofWork.RepositoryAsync<User>().Update(loggingUser);
unitofWork.SaveChanges();
}
public virtual void Init(RepositoryProvider provider)
{
_provider = provider;
}
public IList<Guid> GetRoleIds(Guid userId)
{
IRepositoryProvider repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), repositoryProvider);
return new List<Guid>();
}
//public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
//{
// throw new NotImplementedException();
//}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
#region Check valid username
if (!SecurityUtility.IsUsernameValid(username))
{
status = MembershipCreateStatus.InvalidUserName;
return null;
}
#endregion
#region Check for valid PersonId
string _username = username;
string _domain = string.Empty;
try
{
if (SecurityUtility.UsernameContainsDomain(username))
{
_username = SecurityUtility.ExtractUsername(username);
_domain = SecurityUtility.ExtractDomain(username);
}
}
catch
{
// Username was flagged as having a domain attached, but the extraction failed for unknown reason
status = MembershipCreateStatus.InvalidUserName;
return null;
}
Guid personId;
bool locked = false;
try
{
if (providerUserKey != null && providerUserKey.ToString().Length >= 32)
{
personId = new Guid(providerUserKey.ToString().Substring(0, 32));
locked = ValueUtilities.GetBoolean(providerUserKey.ToString().Substring(32), false);
}
else if (providerUserKey == null || providerUserKey.ToString().Length == 0)
{
personId = Guid.Empty;
}
else
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return null;
}
}
catch
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return null;
}
#endregion
#region Test for valid email
//if ((RequiresUniqueEmail || EnablePasswordRetrieval || EnablePasswordReset) && !password.Equals(SOCIAL_LOGIN_DEFAULT_PASSWORD))
//{
// if (email == null || EmailUtilities.ValidateEmailAddress(email) == false)
// {
// status = MembershipCreateStatus.InvalidEmail;
// return null;
// }
//}
#endregion
#region Test for valid password
if (!SecurityUtility.IsPasswordValid(password))
{
status = MembershipCreateStatus.InvalidPassword;
return null;
}
#endregion
IRepositoryProvider _repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), _repositoryProvider);
#region Check for unique username
Domain.Entity.User user = unitofWork.Repository<User>().Query(u => String.Compare(u.UserName, username, StringComparison.InvariantCultureIgnoreCase) == 0).Select().FirstOrDefault();
if (user != null)
{
status = MembershipCreateStatus.DuplicateUserName;
return null;
}
#endregion
#region Test for valid question/answer
if (RequiresQuestionAndAnswer)
{
if (passwordQuestion == null || passwordQuestion.Length > 200 || passwordQuestion.Length < 1)
{
status = MembershipCreateStatus.InvalidQuestion;
return null;
}
if (passwordAnswer == null || passwordAnswer.Length > 200 || passwordAnswer.Length < 1)
{
status = MembershipCreateStatus.InvalidAnswer;
return null;
}
}
#endregion
DateTime dt = DateTime.Now;
user = new User
{
UserName = _username,
CreationDate = dt,
Domain = _domain,
PersonId = personId,
Locked = locked,
FailedLoginTimes = 0,
CurrentLanguage = System.Threading.Thread.CurrentThread.CurrentCulture.ToString()
};
user.Password = Cryptography.EncryptPassword(password, user.Salt);
try
{
unitofWork.RepositoryAsync<Domain.Entity.User>().Insert(user);
unitofWork.SaveChanges();
}
catch
{
status = MembershipCreateStatus.UserRejected;
// Log.Debug(this, string.Format("Create new user: {0} - failed", identity.Username));
return null;
}
status = MembershipCreateStatus.Success;
//Log.Debug(this, string.Format("Create new user: {0} - successfully", identity.Username));
return new MembershipUser(_providerName, username, providerUserKey, email, passwordQuestion, "", isApproved, false, dt, dt, dt, dt, DateTime.MinValue);
}
public VariantAttribute(RepositoryProvider provider)
{
RepositoryProvider = provider;
}
public override void Init(RepositoryProvider provider)
{
//Fake call to init repositories
_appConfigRepository = AppConfigRepository;
_storeRepository = StoreRepository;
SiteMaps.Loader = new Mock<ISiteMapLoader>().Object;
base.Init(provider);
}
