protected void getAllUsers()
{
DataTable myDataTable = new DataTable();
AdminModule myAdminModule = new AdminModule();
myDataTable = myAdminModule.getAllUsers2().Copy();
myDataTable.Columns.Add("Warn", typeof(String));
myDataTable.Columns.Add("Ban", typeof(String));
UsersGridView.DataSource = myDataTable;
UsersGridView.DataBind();
formatGridView();
}
protected void search()
{
DataTable myDataTable = new DataTable();
AdminModule myAdminModule = new AdminModule();
//myDataTable = myAdminModule.getAllUsers();
if (KeywordBox.Text.Equals(""))
{
myDataTable = myAdminModule.getAllUsers2().Copy();
}
else
{
myDataTable = myAdminModule.searchUsers2(KeywordBox.Text).Copy();
}
myDataTable.Columns.Add("Warn", typeof(String));
myDataTable.Columns.Add("Ban", typeof(String));
UsersGridView.DataSource = myDataTable;
UsersGridView.DataBind();
formatGridView();
}
public virtual Task Execute(CancellationToken cancellationToken)
{
if (_api.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_api.RpcModuleProvider));
}
if (_api.TxPool == null)
{
throw new StepDependencyException(nameof(_api.TxPool));
}
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
if (_api.TxSender == null)
{
throw new StepDependencyException(nameof(_api.TxSender));
}
ILogger logger = _api.LogManager.GetClassLogger();
IJsonRpcConfig jsonRpcConfig = _api.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return(Task.CompletedTask);
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
if (logger.IsDebug)
{
logger.Debug($"Resolving CLI ({nameof(CliModuleLoader)})");
}
IInitConfig initConfig = _api.Config <IInitConfig>();
INdmConfig ndmConfig = _api.Config <INdmConfig>();
IJsonRpcConfig rpcConfig = _api.Config <IJsonRpcConfig>();
IBaselineConfig baselineConfig = _api.Config <IBaselineConfig>();
IVaultConfig vaultConfig = _api.Config <IVaultConfig>();
INetworkConfig networkConfig = _api.Config <INetworkConfig>();
if (ndmConfig.Enabled && !(_api.NdmInitializer is null) && ndmConfig.ProxyEnabled)
{
EthModuleProxyFactory proxyFactory = new EthModuleProxyFactory(_api.EthJsonRpcClientProxy, _api.Wallet);
_api.RpcModuleProvider.Register(new SingletonModulePool <IEthModule>(proxyFactory, true));
if (logger.IsInfo)
{
logger.Info("Enabled JSON RPC Proxy for NDM.");
}
}
else
{
// lets add threads to support parallel eth_getLogs
ThreadPool.GetMinThreads(out var workerThreads, out var completionPortThreads);
ThreadPool.SetMinThreads(workerThreads + Environment.ProcessorCount, completionPortThreads + Environment.ProcessorCount);
EthModuleFactory ethModuleFactory = new EthModuleFactory(
_api.DbProvider,
_api.TxPool,
_api.TxSender,
_api.Wallet,
_api.BlockTree,
_api.EthereumEcdsa,
_api.MainBlockProcessor,
_api.ReceiptFinder,
_api.SpecProvider,
rpcConfig,
_api.Config <ISyncConfig>(),
_api.BloomStorage,
_api.LogManager,
initConfig.IsMining);
_api.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(8, ethModuleFactory));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_api.DbProvider, _api.BlockTree, _api.RecoveryStep, _api.ReceiptFinder, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(2, proofModuleFactory));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(
_api.DbProvider,
_api.BlockTree,
rpcConfig,
_api.BlockValidator,
_api.RecoveryStep,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
new ReceiptMigration(_api),
_api.ConfigProvider,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(8, debugModuleFactory));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(_api.DbProvider, _api.BlockTree, rpcConfig, _api.RecoveryStep, _api.RewardCalculatorSource, _api.ReceiptStorage, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(8, traceModuleFactory));
PersonalModule personalModule = new PersonalModule(
_api.EthereumEcdsa,
_api.Wallet,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
AdminModule adminModule = new AdminModule(_api.BlockTree, networkConfig, _api.PeerManager, _api.StaticNodesManager, _api.Enode, initConfig.BaseDbPath);
_api.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
LogFinder logFinder = new LogFinder(
_api.BlockTree,
_api.ReceiptFinder,
_api.BloomStorage,
_api.LogManager,
new ReceiptsRecovery(),
1024);
if (baselineConfig.Enabled)
{
IDbProvider dbProvider = _api.DbProvider !;
IStateReader stateReader = new StateReader(dbProvider.StateDb, dbProvider.CodeDb, _api.LogManager);
BaselineModuleFactory baselineModuleFactory = new BaselineModuleFactory(
_api.TxSender,
stateReader,
logFinder,
_api.BlockTree,
_api.AbiEncoder,
_api.FileSystem,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IBaselineModule>(baselineModuleFactory, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Baseline RPC Module has been enabled");
}
}
TxPoolModule txPoolModule = new TxPoolModule(_api.BlockTree, _api.TxPoolInfoProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
if (vaultConfig.Enabled)
{
VaultService vaultService = new VaultService(vaultConfig, _api.LogManager);
VaultModule vaultModule = new VaultModule(vaultService, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IVaultModule>(vaultModule, true));
if (logger?.IsInfo ?? false)
{
logger !.Info($"Vault RPC Module has been enabled");
}
}
NetModule netModule = new NetModule(_api.LogManager, new NetBridge(_api.Enode, _api.SyncServer));
_api.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_api.EthereumEcdsa,
_api.TxPool,
_api.BlockTree,
_api.ReceiptFinder,
_api.Enode,
_api.EngineSignerStore,
_api.KeyStore,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
return(Task.CompletedTask);
}
/// <summary>
/// When Saleorder is set to waiting for order, generate InventoryItem for each item in the sale order
/// TransformInventoryRequest event is called to finalize the list of items.
/// </summary>
/// <param name="db"></param>
/// <param name="saleOrder"></param>
internal static void ProcessSaleOrderUpdate(NancyBlackDatabase db, SaleOrder saleOrder, bool replay, DateTime now)
{
if (replay == false)
{
now = DateTime.Now;
// only do when status is waiting for order
if (saleOrder.Status != SaleOrderStatus.WaitingForOrder)
{
return;
}
// if previous status is already waiting for order - do nothing
if (db.GetOlderVersions(saleOrder).First().Status == SaleOrderStatus.WaitingForOrder)
{
return;
}
}
var currentSite = AdminModule.ReadSiteSettings();
// NOTE: We can't run it again since it can alter the amount
// it is possible that admin may change amount in database
//// ensures that all logic of sale order has been ran
//saleOrder.UpdateSaleOrder(currentSite, db, false);
// ensure that no inventory inbound can be run
var totalDiscount = 0M;
var items = new List <InventoryItem>();
foreach (var item in saleOrder.ItemsDetail)
{
if (item.CurrentPrice < 0) // dont take negative prices (coupon)
{
totalDiscount += item.CurrentPrice * -1; // record the discount
continue;
}
// For each items in sale order, create an inventory item
for (int i = 0; i < (int)item.Attributes.Qty; i++)
{
var ivitm = new InventoryItem()
{
SaleOrderId = saleOrder.Id,
ProductId = item.Id,
RequestedDate = now,
IsFullfilled = false,
SellingPrice = item.CurrentPrice
};
items.Add(ivitm);
if (item.CurrentPrice != item.Price)
{
totalDiscount += item.Price - item.CurrentPrice;
}
}
}
// distribute discount into items which has actual sell price
var discountToDistribute = totalDiscount / items.Where(item => item.SellingPrice > 0).Count();
// discount is too great for some item, add it to the most expensive one
if (items.Where(item => discountToDistribute > item.SellingPrice).Count() > 0)
{
var item = items.OrderByDescending(i => i.SellingPrice).First();
item.SellingPrice -= totalDiscount;
if (currentSite.commerce.billing.vattype == "addvat")
{
item.SellingTax = item.SellingPrice * (100 + (int)currentSite.commerce.billing.vatpercent) / 100;
}
if (currentSite.commerce.billing.vattype == "includevat")
{
var priceWithoutTax = item.SellingPrice * 100 / (100 + (int)currentSite.commerce.billing.vatpercent);
item.SellingTax = item.SellingPrice - priceWithoutTax;
item.SellingPrice = priceWithoutTax;
}
}
else // distribute it to items
{
foreach (var item in items)
{
if (item.SellingPrice > 0)
{
item.SellingPrice -= discountToDistribute;
if (currentSite.commerce.billing.vattype == "addvat")
{
item.SellingTax = item.SellingPrice * (100 + (int)currentSite.commerce.billing.vatpercent) / 100;
}
if (currentSite.commerce.billing.vattype == "includevat")
{
var priceWithoutTax = item.SellingPrice * 100 / (100 + (int)currentSite.commerce.billing.vatpercent);
item.SellingTax = item.SellingPrice - priceWithoutTax;
item.SellingPrice = priceWithoutTax;
}
}
}
}
InventoryAdminModule.TransformInventoryRequest(db, saleOrder, items);
db.Transaction(() =>
{
// before inserting...
// if the inventory item for this sale order already fullfilled
// it will remain in inventory but sale order removed
// we will always create new inventory item for this sale order
// and clear out old ones
foreach (var item in db.Query <InventoryItem>().Where(ivt => ivt.SaleOrderId == saleOrder.Id).ToList())
{
if (item.IsFullfilled)
{
item.Note = "Sale Order Id was removed because sale order which created this item has status set to WaitingForOrder Again";
item.SaleOrderId = 0;
item.IsFullfilled = false;
db.UpsertRecord(item);
continue; // item already fullfilled, we leave it but remove sale order id
}
db.DeleteRecord(item);
}
foreach (var item in items)
{
db.UpsertRecord(item);
}
});
}
public virtual async Task Execute(CancellationToken cancellationToken)
{
if (_api.BlockTree == null)
{
throw new StepDependencyException(nameof(_api.BlockTree));
}
if (_api.ReceiptFinder == null)
{
throw new StepDependencyException(nameof(_api.ReceiptFinder));
}
if (_api.BloomStorage == null)
{
throw new StepDependencyException(nameof(_api.BloomStorage));
}
if (_api.LogManager == null)
{
throw new StepDependencyException(nameof(_api.LogManager));
}
IJsonRpcConfig jsonRpcConfig = _api.Config <IJsonRpcConfig>();
if (!jsonRpcConfig.Enabled)
{
return;
}
if (_api.RpcModuleProvider == null)
{
throw new StepDependencyException(nameof(_api.RpcModuleProvider));
}
if (_api.FileSystem == null)
{
throw new StepDependencyException(nameof(_api.FileSystem));
}
if (_api.TxPool == null)
{
throw new StepDependencyException(nameof(_api.TxPool));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
if (_api.SpecProvider == null)
{
throw new StepDependencyException(nameof(_api.SpecProvider));
}
if (_api.TxSender == null)
{
throw new StepDependencyException(nameof(_api.TxSender));
}
if (_api.StateReader == null)
{
throw new StepDependencyException(nameof(_api.StateReader));
}
if (_api.PeerManager == null)
{
throw new StepDependencyException(nameof(_api.PeerManager));
}
if (jsonRpcConfig.Enabled)
{
_api.RpcModuleProvider = new RpcModuleProvider(_api.FileSystem, jsonRpcConfig, _api.LogManager);
}
else
{
_api.RpcModuleProvider ??= NullModuleProvider.Instance;
}
// the following line needs to be called in order to make sure that the CLI library is referenced from runner and built alongside
ILogger logger = _api.LogManager.GetClassLogger();
IInitConfig initConfig = _api.Config <IInitConfig>();
IJsonRpcConfig rpcConfig = _api.Config <IJsonRpcConfig>();
INetworkConfig networkConfig = _api.Config <INetworkConfig>();
// lets add threads to support parallel eth_getLogs
ThreadPool.GetMinThreads(out int workerThreads, out int completionPortThreads);
ThreadPool.SetMinThreads(workerThreads + Environment.ProcessorCount, completionPortThreads + Environment.ProcessorCount);
EthModuleFactory ethModuleFactory = new EthModuleFactory(
_api.TxPool,
_api.TxSender,
_api.Wallet,
_api.BlockTree,
_api.Config <IJsonRpcConfig>(),
_api.LogManager,
_api.StateReader,
_api);
_api.RpcModuleProvider.Register(new BoundedModulePool <IEthModule>(ethModuleFactory, _cpuCount, rpcConfig.Timeout));
if (_api.DbProvider == null)
{
throw new StepDependencyException(nameof(_api.DbProvider));
}
if (_api.BlockPreprocessor == null)
{
throw new StepDependencyException(nameof(_api.BlockPreprocessor));
}
if (_api.BlockValidator == null)
{
throw new StepDependencyException(nameof(_api.BlockValidator));
}
if (_api.RewardCalculatorSource == null)
{
throw new StepDependencyException(nameof(_api.RewardCalculatorSource));
}
ProofModuleFactory proofModuleFactory = new ProofModuleFactory(_api.DbProvider, _api.BlockTree, _api.TrieStore, _api.BlockPreprocessor, _api.ReceiptFinder, _api.SpecProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IProofModule>(proofModuleFactory, 2, rpcConfig.Timeout));
DebugModuleFactory debugModuleFactory = new DebugModuleFactory(
_api.DbProvider,
_api.BlockTree,
rpcConfig,
_api.BlockValidator,
_api.BlockPreprocessor,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
new ReceiptMigration(_api),
_api.TrieStore,
_api.ConfigProvider,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <IDebugModule>(debugModuleFactory, _cpuCount, rpcConfig.Timeout));
TraceModuleFactory traceModuleFactory = new TraceModuleFactory(
_api.DbProvider,
_api.BlockTree,
_api.ReadOnlyTrieStore,
rpcConfig,
_api.BlockPreprocessor,
_api.RewardCalculatorSource,
_api.ReceiptStorage,
_api.SpecProvider,
_api.LogManager);
_api.RpcModuleProvider.Register(new BoundedModulePool <ITraceModule>(traceModuleFactory, _cpuCount, rpcConfig.Timeout));
if (_api.EthereumEcdsa == null)
{
throw new StepDependencyException(nameof(_api.EthereumEcdsa));
}
if (_api.Wallet == null)
{
throw new StepDependencyException(nameof(_api.Wallet));
}
PersonalModule personalModule = new PersonalModule(
_api.EthereumEcdsa,
_api.Wallet,
_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IPersonalModule>(personalModule, true));
if (_api.PeerManager == null)
{
throw new StepDependencyException(nameof(_api.PeerManager));
}
if (_api.StaticNodesManager == null)
{
throw new StepDependencyException(nameof(_api.StaticNodesManager));
}
if (_api.Enode == null)
{
throw new StepDependencyException(nameof(_api.Enode));
}
AdminModule adminModule = new AdminModule(
_api.BlockTree,
networkConfig,
_api.PeerManager,
_api.StaticNodesManager,
_api.Enode,
initConfig.BaseDbPath);
_api.RpcModuleProvider.Register(new SingletonModulePool <IAdminModule>(adminModule, true));
if (_api.TxPoolInfoProvider == null)
{
throw new StepDependencyException(nameof(_api.TxPoolInfoProvider));
}
TxPoolModule txPoolModule = new TxPoolModule(_api.BlockTree, _api.TxPoolInfoProvider, _api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <ITxPoolModule>(txPoolModule, true));
if (_api.SyncServer == null)
{
throw new StepDependencyException(nameof(_api.SyncServer));
}
if (_api.EngineSignerStore == null)
{
throw new StepDependencyException(nameof(_api.EngineSignerStore));
}
NetModule netModule = new NetModule(_api.LogManager, new NetBridge(_api.Enode, _api.SyncServer));
_api.RpcModuleProvider.Register(new SingletonModulePool <INetModule>(netModule, true));
ParityModule parityModule = new ParityModule(
_api.EthereumEcdsa,
_api.TxPool,
_api.BlockTree,
_api.ReceiptFinder,
_api.Enode,
_api.EngineSignerStore,
_api.KeyStore,
_api.LogManager,
_api.PeerManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IParityModule>(parityModule, true));
Web3Module web3Module = new Web3Module(_api.LogManager);
_api.RpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(web3Module, true));
foreach (INethermindPlugin plugin in _api.Plugins)
{
await plugin.InitRpcModules();
}
if (logger.IsDebug)
{
logger.Debug($"RPC modules : {string.Join(", ", _api.RpcModuleProvider.Enabled.OrderBy(x => x))}");
}
ThisNodeInfo.AddInfo("RPC modules :", $"{string.Join(", ", _api.RpcModuleProvider.Enabled.OrderBy(x => x))}");
}
public void Initialize(IPipelines piepeLinse, NancyContext ctx)
{
if (ctx.Request.Headers.UserAgent.Contains("facebookexternalhit/1.1"))
{
ctx.Request.Headers.Accept = new List <Tuple <string, decimal> >()
{
new Tuple <string, decimal>("text/html", 1)
};
ctx.Items["FBBot"] = true;
}
ctx.Items["Webp"] = ctx.Request.Headers.Accept.Any(a => a.Item1 == "image/webp");
ctx.Items["CurrentSite"] = AdminModule.ReadSiteSettings();
ctx.Items["SiteSettings"] = AdminModule.ReadSiteSettings();
ctx.Items["RootPath"] = BootStrapper.RootPath;
ctx.Items["IsAdmin"] = null;
NancyBlackDatabase db = null;
if (_FirstRun == true)
{
lock (BaseModule.GetLockObject("Request-FirstRun"))
{
// check again, other thread might done it
if (_FirstRun == false)
{
goto Skip;
}
_FirstRun = false;
// this will ensure DataType Factory only run once
db = NancyBlackDatabase.GetSiteDatabase(BootStrapper.RootPath, ctx);
GlobalVar.Default.Load(db);
ctx.Items["SiteDatabase"] = db; // other modules expected this
foreach (var item in _GlobalInitializes)
{
item.GlobalInitialize(ctx);
}
Skip:
;
}
}
if (db == null)
{
db = NancyBlackDatabase.GetSiteDatabase(BootStrapper.RootPath, ctx);
ctx.Items["SiteDatabase"] = db;
}
// Get Subsite Name if in main site will get null
string folder = Path.Combine(BootStrapper.RootPath, "Site", "SubSites");
if (Directory.Exists(folder))
{
var subSiteNames = from subDirectories in Directory.GetDirectories(folder) select Path.GetFileName(subDirectories);
var matchSubSiteName = (from subSite in subSiteNames where ctx.Request.Url.HostName.Contains(subSite) select subSite).FirstOrDefault();
ctx.Items[ContextItems.SubSite] = matchSubSiteName;
}
else
{
ctx.Items[ContextItems.SubSite] = null;
}
if (ctx.Request.Cookies.ContainsKey("userid") == false)
{
ctx.Items["userid"] = Guid.NewGuid().ToString();
}
else
{
ctx.Items["userid"] = ctx.Request.Cookies["userid"];
}
}
