public PoolConfigurator(
IPoolService poolService,
ILogger <PoolConfigurator> logger)
{
this.poolService = poolService;
this.logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Osma.Mobile.App.Services.AgentContextProvider" /> class.
/// </summary>
/// <param name="walletService">Wallet service.</param>
/// <param name="poolService">The pool service.</param>
/// <param name="provisioningService">The provisioning service.</param>
/// <param name="keyValueStoreService">Key value store.</param>
public AgentContextProvider(IWalletService walletService,
IPoolService poolService,
IProvisioningService provisioningService,
IKeyValueStoreService keyValueStoreService,
IEdgeClientService edgeClientService,
IConnectionService connectionService,
IMessageService messageService,
IWalletRecordService recordService
//IAgentProvider agentProvider
)
{
_poolService = poolService;
_provisioningService = provisioningService;
_walletService = walletService;
_keyValueStoreService = keyValueStoreService;
_edgeClientService = edgeClientService;
_connectionService = connectionService;
_messageService = messageService;
_recordService = recordService;
//_agentProvider = agentProvider;
if (_keyValueStoreService.KeyExists(AgentOptionsKey))
{
_options = _keyValueStoreService.GetData <AgentOptions>(AgentOptionsKey);
}
}
public ProfileController()
{
IValidationDictionary validationDictionary = new ModelStateWrapper(ModelState);
_service = new ProfileService(validationDictionary);
_sshService = new SshProfileService(validationDictionary);
_poolService = new PoolService(validationDictionary);
}
public CredOfferViewModel(IUserDialogs userDialogs,
INavigationService navigationService,
IAgentProvider agentProvider,
ICredentialService credentialService,
IMessageService messageService,
IPoolService poolService,
IWalletRecordService recordService,
IConnectionService connectionService,
IEventAggregator eventAggregator, CredentialRecord credentialOffer) :
base(nameof(CredOfferViewModel), userDialogs, navigationService)
{
_credentialOffer = credentialOffer;
_agentProvider = agentProvider;
_credentialService = credentialService;
_connectionService = connectionService;
_messageService = messageService;
_poolService = poolService;
_recordService = recordService;
_eventAggregator = eventAggregator;
Title = "Offer Detail";
CredentialName = ConvertNameFromeSchemaId(CredentialOffer.SchemaId);
if (_credentialOffer.CreatedAtUtc != null)
{
IssuedDate = (DateTime)_credentialOffer.CreatedAtUtc;
}
}
public void Initialize(IScoreUIControllerSettings settings, IPoolService poolService)
{
this.icons = new List <GameObject>();
this.poolService = poolService;
Messenger.AddListener <IGameStartModel>(Signals.UpdateAttackTries(), UpdateIcons);
}
// This allows you to despawn a clone via Component, with optional delay
public static void Despawn(this IPoolService pool, Component clone, float delay = 0.0f)
{
if (clone != null)
{
pool.Despawn(clone.gameObject, delay);
}
}
public CredentialTests()
{
var recordService = new DefaultWalletRecordService();
var ledgerService = new DefaultLedgerService();
_eventAggregator = new EventAggregator();
_poolService = new DefaultPoolService();
var routingMock = new Mock <IMessageService>();
routingMock.Setup(x =>
x.SendAsync(It.IsAny <Wallet>(), It.IsAny <IAgentMessage>(), It.IsAny <ConnectionRecord>(), It.IsAny <string>()))
.Callback((Wallet _, IAgentMessage content, ConnectionRecord __, string ___) =>
{
if (_routeMessage)
{
_messages.Add(content);
}
else
{
throw new AgentFrameworkException(ErrorCode.LedgerOperationRejected, "");
}
})
.Returns(Task.FromResult(false));
var provisioningMock = new Mock <IProvisioningService>();
provisioningMock.Setup(x => x.GetProvisioningAsync(It.IsAny <Wallet>()))
.Returns(Task.FromResult(new ProvisioningRecord
{
Endpoint = new AgentEndpoint {
Uri = MockEndpointUri
},
MasterSecretId = MasterSecretId,
TailsBaseUri = MockEndpointUri
}));
var tailsService = new DefaultTailsService(ledgerService);
_schemaService = new DefaultSchemaService(provisioningMock.Object, recordService, ledgerService, tailsService);
_connectionService = new DefaultConnectionService(
_eventAggregator,
recordService,
routingMock.Object,
provisioningMock.Object,
new Mock <ILogger <DefaultConnectionService> >().Object);
_credentialService = new DefaultCredentialService(
_eventAggregator,
routingMock.Object,
ledgerService,
_connectionService,
recordService,
_schemaService,
tailsService,
provisioningMock.Object,
new Mock <ILogger <DefaultCredentialService> >().Object);
}
public void Initialize(IWeaponControllerSettings settings, IPoolService weaponsPool)
{
this.weaponsPool = weaponsPool;
Messenger.AddListener(Signals.TargetReady(), OnStartGamePhase);
Messenger.AddListener(Signals.AttackSucces(), ShowWeapon);
Messenger.AddListener(Signals.TargetOut(), weaponsPool.Reset);
}
public PoolServiceTests()
{
_repository = Substitute.For<IPoolRepository>();
var unitOfWork = Substitute.For<IUnitOfWork>();
var logger = Substitute.For<ILogger>();
var activityHelperService = Substitute.For<IActivityHelperService>();
_service = new PoolService(_repository, unitOfWork, logger, activityHelperService);
}
public SchemaServiceTests()
{
var walletService = new DefaultWalletRecordService();
var ledgerService = new DefaultLedgerService();
var tailsService = new DefaultTailsService(ledgerService);
_poolService = new DefaultPoolService();
_schemaService = new DefaultSchemaService(walletService, ledgerService, tailsService);
}
public MobileAgentProvider(
IAgent agent,
IPoolService poolService,
IWalletService walletService)
{
_agent = agent;
_poolService = poolService;
_walletService = walletService;
}
public PoolConfigurationHostedService(
IOptions <PoolOptions> options,
IPoolService poolService,
ILogger <PoolConfigurationHostedService> logger)
{
_poolOptions = options.Value;
_poolService = poolService;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="PoolConfigurationService" /> class.
/// </summary>
/// <param name="options"></param>
/// <param name="poolService"></param>
/// <param name="logger"></param>
public PoolConfigurationService(
IOptions <AgentOptions> options,
IPoolService poolService,
ILogger <PoolConfigurationService> logger)
{
_agentOptions = options.Value;
_poolService = poolService;
_logger = logger;
}
public MessageRoutingSystemErrorService()
{
_ruleService = new RuleService();
_poolService = new PoolService();
_messagePoolService = new MessagePoolService();
_messageService = new MessageService();
_applicationService = new ApplicationService();
_machineService = new MachineService();
_priorityService = new PriorityService();
}
public SSHService(IValidationDictionary validationDictionary, ISSHRepository repository,
IPPPSecretService pppSecretService, IProfileService pppProfileService,
IPoolService poolService)
{
_validationDictionary = validationDictionary;
_repository = repository;
_pppSecretService = pppSecretService;
_pppProfileService = pppProfileService;
_poolService = poolService;
}
public MessageRoutingSystemErrorService(IRuleService ruleService, IPoolService poolService,
IMessagePoolService messagePoolService, IMessageService messageService,
IApplicationService applicationService, IMachineService machineService)
{
_ruleService = ruleService;
_poolService = poolService;
_messagePoolService = messagePoolService;
_messageService = messageService;
_applicationService = applicationService;
_machineService = machineService;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:AgentFramework.AspNetCore.Hosting.AgentHostedService"/> class.
/// </summary>
/// <param name="provisioningService">Provisioning service.</param>
/// <param name="provisioningConfiguration">Provisioning configuration.</param>
/// <param name="poolService">Pool service.</param>
/// <param name="poolOptions">Pool options.</param>
public ProvisioningHostedService(
ProvisioningConfiguration provisioningConfiguration,
IProvisioningService provisioningService,
IPoolService poolService,
IOptions <PoolOptions> poolOptions)
{
ProvisioningConfiguration = provisioningConfiguration;
_provisioningService = provisioningService;
_poolService = poolService;
_poolOptions = poolOptions.Value;
}
public SchemaServiceTests()
{
var walletService = new DefaultWalletRecordService();
var ledgerService = new DefaultLedgerService();
var tailsService = new DefaultTailsService(ledgerService);
var provisioningMock = new Mock <IProvisioningService>();
_poolService = new DefaultPoolService();
_schemaService = new DefaultSchemaService(provisioningMock.Object, walletService, ledgerService, tailsService);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultAgentProvider"/> class.
/// </summary>
/// <param name="agentOptions"></param>
/// <param name="defaultAgent">Default agent.</param>
/// <param name="walletService">Wallet service.</param>
/// <param name="poolService">Pool service.</param>
public DefaultAgentProvider(
IOptions <AgentOptions> agentOptions,
IAgent defaultAgent,
IWalletService walletService,
IPoolService poolService)
{
_agentOptions = agentOptions.Value;
_defaultAgent = defaultAgent;
_walletService = walletService;
_poolService = poolService;
}
public AgentBuilder(
IPoolService poolService,
IProvisioningService provisioningService,
IOptions <WalletOptions> walletOptions,
IOptions <PoolOptions> poolOptions)
{
_poolService = poolService;
_provisioningService = provisioningService;
_walletOptions = walletOptions.Value;
_poolOptions = poolOptions.Value;
}
/// <summary>
/// Default Agent Context Provider.
/// </summary>
/// <param name="walletOptions">The wallet options provider.</param>
/// <param name="poolOptions">The pool options provider/</param>
/// <param name="walletService">The wallet service.</param>
/// <param name="poolService">The pool service.</param>
public DefaultAgentContextProvider(IOptions <WalletOptions> walletOptions,
IOptions <PoolOptions> poolOptions,
IWalletService walletService,
IPoolService poolService)
{
_walletOptions = walletOptions.Value;
_poolOptions = poolOptions.Value;
_walletService = walletService;
_poolService = poolService;
}
public SovrinPaymentService(
IWalletRecordService recordService,
IPoolService poolService,
ILedgerService ledgerService,
IProvisioningService provisioningService,
ILogger <SovrinPaymentService> logger)
{
this.recordService = recordService;
this.poolService = poolService;
this.ledgerService = ledgerService;
this.provisioningService = provisioningService;
this.logger = logger;
}
public UserService(
IUserRepository userRepository,
IUnitOfWork unitOfWork,
IUserRoleRepository userRoleRepository,
IUserProfileRepository userProfileRepository,
IPoolService poolService
)
{
_userRepository = userRepository;
_unitOfWork = unitOfWork;
_userRoleRepository = userRoleRepository;
_userProfileRepository = userProfileRepository;
_poolService = poolService;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:IdentifyMe.App.Services.AgentContextProvider" /> class.
/// </summary>
/// <param name="walletService">Wallet service.</param>
/// <param name="poolService">The pool service.</param>
/// <param name="provisioningService">The provisioning service.</param>
/// <param name="keyValueStoreService">Key value store.</param>
public AgentContextProvider(IWalletService walletService,
IPoolService poolService,
IProvisioningService provisioningService,
IKeyValueStoreService keyValueStoreService)
{
_poolService = poolService;
_provisioningService = provisioningService;
_walletService = walletService;
_keyValueStoreService = keyValueStoreService;
if (_keyValueStoreService.KeyExists(AgentOptionsKey))
{
_options = _keyValueStoreService.GetData <AgentOptions>(AgentOptionsKey);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TxnAuthorAcceptanceService" /> class.
/// </summary>
/// <param name="hostApplicationLifetime"></param>
/// <param name="provisioningService"></param>
/// <param name="recordService"></param>
/// <param name="poolService"></param>
/// <param name="agentProvider"></param>
/// <param name="agentOptions"></param>
public TxnAuthorAcceptanceService(
IHostApplicationLifetime hostApplicationLifetime,
IProvisioningService provisioningService,
IWalletRecordService recordService,
IPoolService poolService,
IAgentProvider agentProvider,
IOptions <AgentOptions> agentOptions)
{
hostApplicationLifetime.ApplicationStarted.Register(AcceptTxnAuthorAgreement);
_provisioningService = provisioningService;
_recordService = recordService;
_poolService = poolService;
_agentProvider = agentProvider;
_agentOptions = agentOptions.Value;
}
public CredentialTests()
{
var messageSerializer = new DefaultMessageSerializer();
var recordService = new DefaultWalletRecordService();
var ledgerService = new DefaultLedgerService();
_poolService = new DefaultPoolService();
var routingMock = new Mock <IRouterService>();
routingMock.Setup(x => x.ForwardAsync(It.IsNotNull <IEnvelopeMessage>(), It.IsAny <AgentEndpoint>()))
.Callback((IEnvelopeMessage content, AgentEndpoint endpoint) => { _messages.Add(content); })
.Returns(Task.CompletedTask);
var provisioningMock = new Mock <IProvisioningService>();
provisioningMock.Setup(x => x.GetProvisioningAsync(It.IsAny <Wallet>()))
.Returns(Task.FromResult(new ProvisioningRecord
{
Endpoint = new AgentEndpoint {
Uri = MockEndpointUri
},
MasterSecretId = MasterSecretId,
TailsBaseUri = MockEndpointUri
}));
var tailsService = new DefaultTailsService(ledgerService);
_schemaService = new DefaultSchemaService(recordService, ledgerService, tailsService);
_connectionService = new DefaultConnectionService(
recordService,
routingMock.Object,
provisioningMock.Object,
messageSerializer,
new Mock <ILogger <DefaultConnectionService> >().Object);
_credentialService = new DefaultCredentialService(
routingMock.Object,
ledgerService,
_connectionService,
recordService,
messageSerializer,
_schemaService,
tailsService,
provisioningMock.Object,
new Mock <ILogger <DefaultCredentialService> >().Object);
}
public Estoria1Steps(ScenarioContext scenarioContext)
{
_scenarioContext = scenarioContext;
string dbName = Guid.NewGuid().ToString();
DbContextOptionsBuilder <LunchDbContext> contextOptionsBuilder = new DbContextOptionsBuilder <LunchDbContext>().UseInMemoryDatabase(dbName);
LunchDbContextInMemory dbContext = new LunchDbContextInMemory(contextOptionsBuilder.Options);
IRestaurantRepository restaurantRepository = new RestaurantRepository(dbContext);
IUserRepository userRepository = new UserRepository(dbContext);
IVoteRepository voteRepository = new VoteRepository(dbContext);
IPoolRepository poolRepository = new PoolRepository(dbContext);
restaurantAppService = new RestaurantService(restaurantRepository);
userAppService = new UserService(userRepository);
poolAppService = new PoolService(poolRepository, voteRepository, restaurantAppService, userAppService);
}
public PoolServiceTest()
{
string dbName = Guid.NewGuid().ToString();
DbContextOptionsBuilder <LunchDbContext> contextOptionsBuilder = new DbContextOptionsBuilder <LunchDbContext>().UseInMemoryDatabase(dbName);
dbContext = new LunchDbContextInMemory(contextOptionsBuilder.Options);
restaurantRepository = new RestaurantRepository(dbContext);
userRepository = new UserRepository(dbContext);
voteRepository = new VoteRepository(dbContext);
poolRepository = new PoolRepository(dbContext);
restaurantService = new RestaurantService(restaurantRepository);
userService = new UserService(userRepository);
poolService = new PoolService(poolRepository, voteRepository, restaurantService, userService);
CreateUsersAndRestaurants();
}
public AgentMiddleware(RequestDelegate next,
IWalletService walletService,
IPoolService poolService,
IMessageSerializer messageSerializer,
IConnectionService connectionService,
ICredentialService credentialService,
IProvisioningService provisioningService,
IOptions <WalletOptions> walletOptions,
IOptions <PoolOptions> poolOptions)
{
_next = next;
_walletService = walletService;
_poolService = poolService;
_messageSerializer = messageSerializer;
_connectionService = connectionService;
_credentialService = credentialService;
_provisioningService = provisioningService;
_poolOptions = poolOptions.Value;
_walletOptions = walletOptions.Value;
}
public WiftService(
ILogger logger,
IConfigurationRoot configuration,
IWiftWrapper wiftWrapper,
IPoolService poolService,
IDividendService dividendService,
IRunnerService runnerService,
IRaceService raceService,
IMeetingService meetingService
)
{
_logger = logger;
_config = configuration;
_wiftWrapper = wiftWrapper;
_poolService = poolService;
_dividendService = dividendService;
_runnerService = runnerService;
_raceService = raceService;
_meetingService = meetingService;
}
static void CallPoolService()
{
ChannelFactory <IPoolService> channelFactory =
new ChannelFactory <IPoolService>("poolservice");
IPoolService proxy = channelFactory.CreateChannel();
Console.WriteLine("Press <ENTER> to invoke the method which returns the object " +
"to the pool.");
Console.ReadLine();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(proxy.GetData());
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("Press <ENTER> to invoke the method which does not return " +
"the object to the pool.");
Console.ReadLine();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(proxy.GetDataNoPooling());
Console.ForegroundColor = ConsoleColor.Gray;
}
public void Initialize()
{
MockUow = new Mock<IMessageRoutingSystemUow>();
MockUow.Setup(x => x.Rules).Returns(MockRepoRule.Object);
MockUow.Setup(x => x.Pools).Returns(MockRepoPool.Object);
MockUow.Setup(x => x.Applications).Returns(MockRepoApplication.Object);
MockUow.Setup(x => x.ApplicationGroups).Returns(MockRepoApplicationGroup.Object);
MockUow.Setup(x => x.ApplicationGroupMaps).Returns(MockRepoApplicationGroupMap.Object);
MockUow.Setup(x => x.Machines).Returns(MockRepoMachine.Object);
MockUow.Setup(x => x.MachineGroups).Returns(MockRepoMachineGroup.Object);
MockUow.Setup(x => x.MachineGroupMaps).Returns(MockRepoMachineGroupMap.Object);
MockUow.Setup(x => x.MessagePools).Returns(MockRepoMessagePool.Object);
MockUow.Setup(x => x.Messages).Returns(MockRepoMessage.Object);
MockUow.Setup(x => x.Priorities).Returns(MockRepoPriority.Object);
RuleService = new RuleService(MockUow.Object);
PoolService = new PoolService(MockUow.Object);
ApplicationService = new ApplicationService(MockUow.Object);
MachineService = new MachineService(MockUow.Object);
MessagePoolService = new MessagePoolService(MockUow.Object);
MessageService = new MessageService(MockUow.Object);
PriorityService = new PriorityService(MockUow.Object);
}
public PoolController(IPoolService poolService)
{
this.poolService = poolService;
}
public PoolController(IPoolService poolService)
{
_poolService = poolService;
}
private void Awake()
{
_weaponPoolService = new PoolService(this, _gameControllerSettings.WeaponSettings.WeaponPrefab);
_uiPoolService = new PoolService(this, _scoreUIControllerSettings.IconPrefab as GameObject);
}
public void Setup()
{
this.TournamentService = new TournamentService();
this.PoolService = new PoolService();
}
public CandidatesController(ICandidateService candidateService, IPoolService poolService)
{
_candidateService = candidateService;
_poolService = poolService;
}
public static GameObject Spawn(this IPoolService pool, GameObject prefab, Vector3 position, Quaternion rotation)
{
return(pool.Spawn(prefab, position, rotation, null));
}
public PoolController()
{
IValidationDictionary validationDictionary = new ModelStateWrapper(ModelState);
_service = new PoolService(validationDictionary);
_sshService = new SshPoolService(validationDictionary, true);
}
public GroupService(IGroupRepository repository, IPoolService carPoolService)
{
groupRepository = repository;
poolService = carPoolService;
}
public HunterValidation(IPoolService poolService)
{
_poolService = poolService;
}
public ProfileService(IValidationDictionary validationDictionary)
{
_validationDictionary = validationDictionary;
_repository = new EntityProfileRepository();
_poolService = new PoolService(validationDictionary);
}
