public ExplorerViewModel(IList<IConnection> connections,
IFilterManager filterManager,
IErrorHandler errorHandler)
{
this.filterManager = filterManager;
this.errorHandler = errorHandler;
IEnumerable<ConnectionViewModel> enumerable = from connection in connections
select new ConnectionViewModel(connection,filterManager,errorHandler);
this.connections = new ObservableCollection<ConnectionViewModel>(enumerable);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionBase"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The method binder.</param>
/// <param name="filters">The filters.</param>
protected ActionBase(IMethod method, IMessageBinder messageBinder, IFilterManager filters)
{
_method = method;
_messageBinder = messageBinder;
_filters = filters;
_requirements = _method.Info.GetParameters()
.Select(x => new RequiredParameter(x.Name, x.ParameterType))
.ToList();
}
public ConnectionViewModel(IConnection connection, IFilterManager filterManager, IErrorHandler errorHandler)
{
this.connection = connection;
this.filterManager = filterManager;
this.errorHandler = errorHandler;
this.disconnectCommand = new DisconnectCommand(this);
this.connectCommand = new ConnectCommand(this);
this.reloadCommand = new ReloadCommand(this);
this.defragmentCommand = new DefragmentCommand(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionCreationContext"/> class.
/// </summary>
/// <param name="serviceLocator">The service locator.</param>
/// <param name="methodFactory">The method factory.</param>
/// <param name="messageBinder">The message binder.</param>
/// <param name="conventionManager">The convention manager</param>
/// <param name="targetType">Type of the target.</param>
/// <param name="targetFilters">The target filters.</param>
/// <param name="method">The method.</param>
public ActionCreationContext(IServiceLocator serviceLocator, IMethodFactory methodFactory,
IMessageBinder messageBinder, IConventionManager conventionManager, Type targetType, IFilterManager targetFilters,
MethodInfo method)
{
ConventionManager = conventionManager;
ServiceLocator = serviceLocator;
MethodFactory = methodFactory;
MessageBinder = messageBinder;
TargetType = targetType;
TargetFilters = targetFilters;
Method = method;
}
public void TestInit()
{
_processRepository = Mock.Create<IProcessMetadataRepository>(Behavior.Loose);
_dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
_filterManager = Mock.Create<IFilterManager>(Behavior.Loose);
_filterMetadataFactory = Mock.Create<IFilterMetadataFactory>(Behavior.Loose);
_layoutManager = Mock.Create<ILayoutManager>(Behavior.Loose);
_layoutMetadataFactory = Mock.Create<ILayoutMetadataFactory>(Behavior.Loose);
_processMetadata = CreateProcess(ProcessName);
Mock.Arrange(() => _processMetadata.SupportsStates).Returns(true);
Mock.Arrange(() => _processRepository.GetProcessMetadata(ProcessName)).Returns(_processMetadata);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionHost"/> class.
/// </summary>
/// <param name="targetType">Type of the target.</param>
/// <param name="factory">The factory.</param>
/// <param name="serviceLocator">The container</param>
public ActionHost(Type targetType, IActionFactory factory, IServiceLocator serviceLocator)
{
_targetType = targetType;
_serviceLocator = serviceLocator;
AddMetadataFrom(targetType);
_filters = new FilterManager(_targetType, this, serviceLocator);
foreach(var action in factory.CreateFor(this))
{
_actions[action.Name] = action;
}
}
public void TestInit()
{
_dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
_filterManager = Mock.Create<IFilterManager>(Behavior.Loose);
_layoutManager = Mock.Create<ILayoutManager>(Behavior.Loose);
_searchUtils = Mock.Create<ISearchUtils>(Behavior.Loose);
_processMetadataRepository = Mock.Create<IProcessMetadataRepository>(Behavior.Loose);
_filterDescriptorFactory = Mock.Create<IFilterDescriptorFactory>(Behavior.Loose);
_metricsManager = Mock.Create<IMetricsManager>(Behavior.Loose);
_kpiManager = Mock.Create<IKPIManager>(Behavior.Loose);
_filterRepository = Mock.Create<IFilterRepository>(Behavior.Loose);
_processMetadata = Mock.Create<IProcessMetadata>(Behavior.Loose);
Mock.Arrange(() => _processMetadata.Name).Returns(ProcessName);
Mock.Arrange(() => _processMetadataRepository.GetProcessMetadata(ProcessName)).Returns(_processMetadata);
}
protected override void given_the_context_of()
{
method = Mock<IMethod>();
method.Stub(x => x.Info).Return(typeof(object).GetMethod("ToString")).Repeat.Any();
messageBinder = Mock<IMessageBinder>();
filterManager = Stub<IFilterManager>();
action = new AsynchronousAction(
Stub<IServiceLocator>(),
method,
messageBinder,
filterManager,
false
);
}
public DeleteModule(IRepository repo, IFilterManager filterManager)
{
_repo = repo;
_filterManager = filterManager;
Delete["DeleteCorporation/{id}"] = par =>
{
_repo.RemoveCorporation(par.id);
var objID = JsonConvert.SerializeObject(new { id = par.id });
return SetNancyResponse.NancyResponse(Nancy.HttpStatusCode.OK, "Ente cancellato correttamente - id = " + par.id, objID );
};
Post["DeleteCorporazione"] = _ =>
{
var corp = this.Bind<Corporation>();
_repo.RemoveCorporation(corp.Id.ToString());
return SetNancyResponse.NancyResponse(Nancy.HttpStatusCode.OK, "Ente cancellato correttamente - id = " + corp.Id.ToString(), corp.Id.ToString());
};
}
/// <summary>
/// Creates the action.
/// </summary>
/// <param name="targetType">Type of the target.</param>
/// <param name="targetFilters">The target filters.</param>
/// <param name="methodInfo">The method info.</param>
/// <returns>The action.</returns>
protected virtual IAction CreateAction(Type targetType, IFilterManager targetFilters, MethodInfo methodInfo)
{
var builder = methodInfo.GetAttributes<IActionFactory>(true)
.FirstOrDefault() ?? new ActionAttribute();
return builder.Create(
new ActionCreationContext(
serviceLocator,
methodFactory,
messageBinder,
conventionManager,
targetType,
targetFilters,
methodInfo
)
);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionLocationContext"/> class.
/// </summary>
/// <param name="serviceLocator">The service locator.</param>
/// <param name="targetType">Type of the target.</param>
/// <param name="targetFilters">The target filters.</param>
public ActionLocationContext(IServiceLocator serviceLocator, Type targetType, IFilterManager targetFilters)
{
ServiceLocator = serviceLocator;
TargetType = targetType;
TargetFilters = targetFilters;
}
private static async Task <SearchResult <IIndexEntity> > Search <T>(Models.DTO.Search search, string environment, IFilterManager fm, IAzureSearch <T> client, string minimumCriteria, string[] freetextFields)
where T : class, IIndexEntity
{
fm.Init(search.SearchQuery.Filters);
var selected = fm.GetSelectedFilters();
var query = search.SearchQuery.SearchTerm;
if (IsAllDigits(query))
{
query = RemoveWhiteSpaces(query);
}
var filters = CreateAndFilter(selected, minimumCriteria);
var result = await client.SearchWithFullResult(query, filters, true,
search.SearchParameters.OrderBy?.ToArray(), search.SearchParameters.NumberPerPage,
search.SearchParameters.GetSkipCount(),
searchFields : freetextFields);
var resultObject = new SearchResult <IIndexEntity>()
{
SearchParameters = search.SearchParameters,
Documents = result.Results.Select(x => x.Document)
};
resultObject.SearchParameters.TotalCount = (int)result.Count;
return(resultObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="BackgroundAction"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The message binder.</param>
/// <param name="filters">The filters.</param>
/// <param name="blockInteraction">if set to <c>true</c> [block interaction].</param>
public BackgroundAction(IMethod method, IMessageBinder messageBinder, IFilterManager filters, bool blockInteraction)
: base(method, messageBinder, filters)
{
_blockInteraction = blockInteraction;
}
public FilterCommand(IApiRetriever apiRetriever, IFilterManager filterManager)
{
_apiRetriever = apiRetriever;
_filterManager = filterManager;
}
public FiltersController(ILogger logger, IFilterManager filterManager, IDatamartManager datamartManager)
{
_logger = logger;
_filterManager = filterManager;
_datamartManager = datamartManager;
}
/// <summary>
/// Searches for a "CanExecute" method and add the Preview if found.
/// </summary>
/// <param name="manager">The manager.</param>
/// <param name="method">The method.</param>
protected void TryAddCanExecute(IFilterManager manager, IMethod method)
{
var found = method.GetMatchingMetadata<PreviewAttribute>()
.Where(x => x.MethodName == "Can" + method.Info.Name
);
if(found.Count() > 0) return;
var canExecute = method.Info.DeclaringType.GetMethod(
"Can" + method.Info.Name,
method.Info.GetParameters().Select(x => x.ParameterType).ToArray()
)
?? method.Info.DeclaringType.GetMethod("get_Can" + method.Info.Name);
if(canExecute != null)
manager.Add(new PreviewAttribute(_methodFactory.CreateFrom(canExecute)));
}
public FilterRepository(
IProcessMetadataRepository processRepository,
IDynamicTypeManager dynamicTypeManager,
IUtils utils,
IFilterManager filterManager)
{
if (processRepository == null)
throw new ArgumentNullException("processRepository");
if (dynamicTypeManager == null)
throw new ArgumentNullException("dynamicTypeManager");
if (utils == null)
throw new ArgumentNullException("utils");
if (filterManager == null)
throw new ArgumentNullException("filterManager");
_processRepository = processRepository;
_dynamicTypeManager = dynamicTypeManager;
_utils = utils;
_filterManager = filterManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="AsynchronousAction"/> class.
/// </summary>
/// <param name="serviceLocator">The service locator.</param>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The method binder.</param>
/// <param name="filters">The filters.</param>
/// <param name="blockInteraction">if set to <c>true</c> blocks interaction.</param>
public AsynchronousAction(IServiceLocator serviceLocator, IMethod method, IMessageBinder messageBinder, IFilterManager filters, bool blockInteraction)
: base(method, messageBinder, filters, blockInteraction)
{
this.serviceLocator = serviceLocator;
}
public void Save(string rank_filename, HoseiKind hosei_kind, int mylist_rate, IFilterManager filter)
{
StringBuilder buff_notfiltered = new StringBuilder();
StringBuilder buff_filtered = new StringBuilder();
int rank_notfiltered = 1;
int rank_filtered = 1;
for (int i = 0; i < video_list_.Count; ++i)
{
filter.DoEffect(video_list_[i]);
if (filter.IsThrough(video_list_[i]))
{
if (custom_format_.IsUsingCustomFormat())
{
buff_notfiltered.Append(custom_format_.VideoToString(video_list_[i], rank_notfiltered));
}
else
{
buff_notfiltered.Append(video_list_[i].ToStringWithRank(rank_notfiltered, hosei_kind, mylist_rate));
}
++rank_notfiltered;
buff_notfiltered.Append("\r\n");
}
else
{
if (custom_format_.IsUsingCustomFormat())
{
buff_filtered.Append(custom_format_.VideoToString(video_list_[i], rank_filtered));
}
else
{
buff_filtered.Append(video_list_[i].ToStringWithRank(rank_filtered, hosei_kind, mylist_rate));
}
++rank_filtered;
buff_filtered.Append("\r\n");
}
}
IJFile.Write(rank_filename, buff_notfiltered.ToString());
if (filter.IsOutputFilteredVideo())
{
string rank_str = buff_filtered.ToString();
if (rank_str != "")
{
IJFile.Write(Path.GetDirectoryName(rank_filename) + "\\" + Path.GetFileNameWithoutExtension(rank_filename) +
"_filter" + Path.GetExtension(rank_filename), rank_str);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AsynchronousAction"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The method binder.</param>
/// <param name="filters">The filters.</param>
/// <param name="blockInteraction">if set to <c>true</c> [block interaction].</param>
public AsynchronousAction(IMethod method, IMessageBinder messageBinder, IFilterManager filters, bool blockInteraction)
: base(method, messageBinder, filters)
{
_blockInteraction = blockInteraction;
}
/// <summary>
/// Initializes a new instance of the <see cref="SearchCommand"/> class.
/// </summary>
/// <param name="process">
/// The process metadata.
/// </param>
/// <param name="dynamicTypeManager">
/// The dynamic type manager.
/// </param>
/// <param name="filterManager">
/// The filter manager.
/// </param>
/// <param name="layoutManager">
/// The layout manager.
/// </param>
/// <param name="searchUtils">
/// The search utils.
/// </param>
/// <param name="filterDescriptorFactory">
/// The filter descriptor factory.
/// </param>
/// <param name="metricsManager">
/// The metrics manager.
/// </param>
/// <param name="kpiManager">
/// The KPI manager.
/// </param>
/// <param name="filterRepository">
/// The filter repository.
/// </param>
public SearchCommand(
IProcessMetadata process,
IDynamicTypeManager dynamicTypeManager,
IFilterManager filterManager,
ILayoutManager layoutManager,
ISearchUtils searchUtils,
IFilterDescriptorFactory filterDescriptorFactory,
IMetricsManager metricsManager,
IKPIManager kpiManager,
IFilterRepository filterRepository)
{
if (process == null)
throw new ArgumentNullException("process");
if (dynamicTypeManager == null)
throw new ArgumentNullException("dynamicTypeManager");
if (filterManager == null)
throw new ArgumentNullException("filterManager");
if (layoutManager == null)
throw new ArgumentNullException("layoutManager");
if (searchUtils == null)
throw new ArgumentNullException("searchUtils");
if (filterDescriptorFactory == null)
throw new ArgumentNullException("filterDescriptorFactory");
if (metricsManager == null)
throw new ArgumentNullException("metricsManager");
if (kpiManager == null)
throw new ArgumentNullException("kpiManager");
if (filterRepository == null)
throw new ArgumentNullException("filterRepository");
_dynamicTypeManager = dynamicTypeManager;
_filterManager = filterManager;
_layoutManager = layoutManager;
_searchUtils = searchUtils;
_filterDescriptorFactory = filterDescriptorFactory;
_metricsManager = metricsManager;
_kpiManager = kpiManager;
_filterRepository = filterRepository;
_process = process;
}
PreInitAsync(IConfigProvider configProvider, IDbProvider dbProvider, string baseDbPath,
IBlockTree blockTree, ITxPool txPool, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, IFilterStore filterStore, IFilterManager filterManager,
ITimestamper timestamper, IEthereumEcdsa ecdsa, IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore, IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager consumerChannelManager, INdmDataPublisher dataPublisher,
IGrpcServer grpcServer, bool enableUnsecuredDevWallet, IWebSocketsManager webSocketsManager,
ILogManager logManager, IBlockProcessor blockProcessor)
{
if (!(configProvider.GetConfig<INdmConfig>() is NdmConfig defaultConfig))
{
return default;
}
if (!defaultConfig.Enabled)
{
return default;
}
if (defaultConfig.StoreConfigInDatabase && string.IsNullOrWhiteSpace(defaultConfig.Id))
{
throw new ArgumentException("NDM config stored in database requires an id.", nameof(defaultConfig.Id));
}
IMongoProvider mongoProvider = null;
IConfigRepository configRepository = null;
IEthRequestRepository ethRequestRepository = null;
switch (defaultConfig.Persistence?.ToLowerInvariant())
{
case "mongo":
mongoProvider = new MongoProvider(configProvider.GetConfig<INdmMongoConfig>(), logManager);
var database = mongoProvider.GetDatabase();
configRepository = new ConfigMongoRepository(database);
ethRequestRepository = new EthRequestMongoRepository(database);
break;
default:
configRepository = new ConfigRocksRepository(dbProvider.ConfigsDb, new NdmConfigDecoder());
ethRequestRepository = new EthRequestRocksRepository(dbProvider.EthRequestsDb,
new EthRequestDecoder());
break;
}
var configManager = new ConfigManager(defaultConfig, configRepository);
var ndmConfig = await configManager.GetAsync(defaultConfig.Id);
if (ndmConfig is null)
{
ndmConfig = defaultConfig;
if (defaultConfig.StoreConfigInDatabase)
{
await configManager.UpdateAsync(ndmConfig);
}
}
var webSocketsModule = webSocketsManager.GetModule("ndm");
var notifier = new NdmNotifier(webSocketsModule);
var ethRequestService = new EthRequestService(ndmConfig.FaucetHost, logManager);
var services = _ndmModule.Init(new NdmRequiredServices(configProvider, configManager, ndmConfig,
baseDbPath, dbProvider, mongoProvider, logManager, blockTree, txPool, specProvider, receiptStorage,
filterStore, filterManager, wallet, timestamper, ecdsa, keyStore, rpcModuleProvider, jsonSerializer,
cryptoRandom, enode, consumerChannelManager, dataPublisher, grpcServer, ethRequestService, notifier,
enableUnsecuredDevWallet, blockProcessor));
var faucetAddress = string.IsNullOrWhiteSpace(ndmConfig.FaucetAddress)
? null
: new Address(ndmConfig.FaucetAddress);
var faucet = new NdmFaucet(services.CreatedServices.BlockchainBridge, ethRequestRepository, faucetAddress,
ndmConfig.FaucetWeiRequestMaxValue, ndmConfig.FaucetEthDailyRequestsTotalValue, ndmConfig.FaucetEnabled,
timestamper, wallet, logManager);
var consumerAddress = string.IsNullOrWhiteSpace(ndmConfig.ConsumerAddress)
? Address.Zero
: new Address(ndmConfig.ConsumerAddress);
var providerAddress = string.IsNullOrWhiteSpace(ndmConfig.ProviderAddress)
? Address.Zero
: new Address(ndmConfig.ProviderAddress);
var consumers = _ndmConsumersModule.Init(services);
return (ndmConfig, services, faucet, consumers.AccountService, consumers.ConsumerService, consumerAddress,
providerAddress);
}
public static IFilterManager GetFilterManager()
{
return(filterManager ?? (filterManager = new FilterManager.FilterManager()));
}
public virtual async Task <INdmCapabilityConnector> InitAsync(IConfigProvider configProvider,
IDbProvider dbProvider, string baseDbPath, IBlockTree blockTree, ITxPool txPool, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, IFilterStore filterStore, IFilterManager filterManager,
ITimestamper timestamper, IEthereumEcdsa ecdsa, IRpcModuleProvider rpcModuleProvider, IKeyStore keyStore,
IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager consumerChannelManager, INdmDataPublisher dataPublisher, IGrpcServer grpcServer,
INodeStatsManager nodeStatsManager, IProtocolsManager protocolsManager,
IProtocolValidator protocolValidator, IMessageSerializationService messageSerializationService,
bool enableUnsecuredDevWallet, IWebSocketsManager webSocketsManager, ILogManager logManager,
IBlockProcessor blockProcessor, IJsonRpcClientProxy jsonRpcClientProxy,
IEthJsonRpcClientProxy ethJsonRpcClientProxy, IHttpClient httpClient, IMonitoringService monitoringService)
{
var(config, services, faucet, ethRequestService, accountService, consumerService, consumerAddress,
providerAddress) = await PreInitAsync(configProvider, dbProvider, baseDbPath, blockTree, txPool,
specProvider, receiptStorage, wallet, filterStore, filterManager, timestamper, ecdsa, rpcModuleProvider,
keyStore, jsonSerializer, cryptoRandom, enode, consumerChannelManager, dataPublisher, grpcServer,
enableUnsecuredDevWallet, webSocketsManager, logManager, blockProcessor, jsonRpcClientProxy,
ethJsonRpcClientProxy, httpClient, monitoringService);
if (!config.Enabled)
{
return(default);
public SearchUtils(
IProcessMetadataRepository processMetadataRepository,
IDynamicTypeManager dynamicTypeManager,
IFilterManager filterManager,
IFilterMetadataFactory filterMetadataFactory,
ILayoutManager layoutManager,
ILayoutMetadataFactory layoutMetadataFactory)
{
if (processMetadataRepository == null)
throw new ArgumentNullException("processMetadataRepository");
if (dynamicTypeManager == null)
throw new ArgumentNullException("dynamicTypeManager");
if (filterManager == null)
throw new ArgumentNullException("filterManager");
if (filterMetadataFactory == null)
throw new ArgumentNullException("filterMetadataFactory");
if (layoutManager == null)
throw new ArgumentNullException("layoutManager");
if (layoutMetadataFactory == null)
throw new ArgumentNullException("layoutMetadataFactory");
_processMetadataRepository = processMetadataRepository;
_dynamicTypeManager = dynamicTypeManager;
_filterManager = filterManager;
_filterMetadataFactory = filterMetadataFactory;
_layoutManager = layoutManager;
_layoutMetadataFactory = layoutMetadataFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="SynchronousAction"/> class.
/// </summary>
/// <param name="serviceLocator">The service locator.</param>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The method binder.</param>
/// <param name="filters">The filters.</param>
/// <param name="blockInteraction">if set to <c>true</c> blocks interaction.</param>
public SynchronousAction(IServiceLocator serviceLocator, IMethod method, IMessageBinder messageBinder, IFilterManager filters, bool blockInteraction)
: base(method, messageBinder, filters, blockInteraction)
{
this.serviceLocator = serviceLocator;
}
/// <summary>
/// Initializes a new instance of the <see cref="SynchronousAction"/> class.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="messageBinder">The method binder.</param>
/// <param name="filters">The filters.</param>
public SynchronousAction(IMethod method, IMessageBinder messageBinder, IFilterManager filters)
: base(method, messageBinder, filters) {}
protected ConcreteContainer(IFilterManager manager, IRepository repository, DbDataReader r) : base(repository, r)
{
_manager = manager;
Operation = (FilterContainerOperation)Enum.Parse(typeof(FilterContainerOperation), r["Operation"].ToString());
}
protected ConcreteContainer(IFilterManager manager)
{
_manager = manager;
}
public FilterController(IFilterManager filterManager)
{
_filterManager = filterManager;
}
