public ConnectionLocator()
{
account_manager = DBusUtility.GetProxy <IAccountManager> (bus, Constants.ACCOUNTMANAGER_IFACE,
Constants.ACCOUNTMANAGER_PATH);
Initialize ();
}
// private UserInfo userInfo = new UserInfo();
public AuthorityManager()
{
//
//TODO: 在此处添加构造函数逻辑
//
//TcpClientChannel channel = new TcpClientChannel();
//ChannelServices.RegisterChannel(channel, false);
//string strRBPCServiceURL = ConfigurationManager.AppSettings["RBPC.Service.url"].ToString();
//string strRBPCServicePort = ConfigurationManager.AppSettings["RBPC.Service.port"].ToString();
string strRBPCServiceURL = ConfigurationManager.AppSettings["RBPCServiceAddress"].ToString();
string strRBPCServicePort = ConfigurationManager.AppSettings["RBPCServicePort"].ToString();
//string tcpChannel = "tcp://" + strRBPCServiceURL + ":" + strRBPCServicePort + "/";
string strAccountMgrURL = "tcp://" + strRBPCServiceURL + ":" + strRBPCServicePort + "/IAccountManager";
log.Debug("*-*-strAccountMgrURL=" + strAccountMgrURL);
string strPermissionMgrURL = "tcp://" + strRBPCServiceURL + ":" + strRBPCServicePort + "/IPermissionManager";
log.Debug("*-*-strPermissionMgrURL=" + strPermissionMgrURL);
string strRoleMgrURL = "tcp://" + strRBPCServiceURL + ":" + strRBPCServicePort + "/IRoleManager";
log.Debug("*-*-strRoleMgrURL=" + strRoleMgrURL);
string strSecurityMgrURL = "tcp://" + strRBPCServiceURL + ":" + strRBPCServicePort + "/ISecurityManager";
log.Debug("*-*-strSecurityMgrURL=" + strSecurityMgrURL);
accountMgr = (IAccountManager)Activator.GetObject(typeof(IAccountManager), strAccountMgrURL);
permissionMgr = (IPermissionManager)Activator.GetObject(typeof(IPermissionManager), strPermissionMgrURL);
roleMgr = (IRoleManager)Activator.GetObject(typeof(IRoleManager), strRoleMgrURL);
securityMgr = (ISecurityManager)Activator.GetObject(typeof(ISecurityManager), strSecurityMgrURL);
application = System.Configuration.ConfigurationManager.AppSettings.Get("RBPCApplication").ToString();
}
public BlockUserTask(IMessageHandler consumeHandler, IMessageHandler publishHandler, string publishRoutingKey, IFeedBackDataManager feedBackManager, IAccountManager accountManager, IBlackListDataManager blackListDataManager)
: base(consumeHandler, publishHandler, publishRoutingKey)
{
_feedBackManager = feedBackManager;
_accountManager = accountManager;
_blackListDataManager = blackListDataManager;
}
public CustomerOperationProvider(IAccountManager accountManager)
{
_accountManager = accountManager;
var config = new CustomerOperationServiceConfiguration(_accountManager);
_customerOperationServiceClient = config.CustomerOperationServiceClient;
}
public DefaultCallBuilder(ICallManagerInternal callManager, IAccountManager accountManager)
{
Helper.GuardNotNull(callManager);
Helper.GuardNotNull(accountManager);
_callManager = callManager;
_accountManager = accountManager;
}
/// <summary> 根据 <see cref="ILogin.Id"/> 检查 <see cref="ILogin"/> 是否可以被删除. </summary>
/// <returns> 可以被删除时返回 <c>true</c>, 否则返回 <c>false</c>. </returns>
public static LoginRemovableResult Check(IAccountManager accountManager, Guid loginId)
{
if (accountManager == null) throw new ArgumentNullException("accountManager");
var login = LoginExistsResult.Check(accountManager, loginId).ThrowIfFailed().Login;
return Check(accountManager, login);
}
public AccountController(IAccountManager logicManager)
{
if (logicManager == null)
{
throw new ArgumentNullException("logicManager");
}
LogicManager = logicManager;
}
public CustomerOperationServiceConfiguration(IAccountManager accountManager)
{
_accountManager = accountManager;
BasicHttpBinding httpBinding = new BasicHttpBinding();
CustomerOperationServiceClient =
new CustomerOperationServiceClient(httpBinding, EndPoints.CustomerOperation);
}
public Checker(ICaptchaService captchaService, IProxyManager proxyManager, IAccountManager accountManager)
{
_captchaService = captchaService;
_proxyManager = proxyManager;
_accountManager = accountManager;
_logger = ServiceLocator.Current.GetInstance<ILogger>();
_eventAggregator = ServiceLocator.Current.GetInstance<IEventAggregator>();
}
internal AdminService(IAccountManager adminManager, IAccountManager userManager)
: base(adminManager)
{
// todo1[ak] check args
//_adminManager = adminManager;
_userManager = userManager;
}
public AuthorityManager()
{
permissionManager = RBPCAgent.getRBPCManager<IPermissionManager>();
securityManager = RBPCAgent.getRBPCManager<ISecurityManager>();
roleManager = RBPCAgent.getRBPCManager<IRoleManager>();
accountManager = RBPCAgent.getRBPCManager<IAccountManager>();
appName = ConfigurationManager.AppSettings["RBPCApplication"].ToString();
}
public AccountController(ISecurityUserService securityUserService, IMenuService menuService,
IAccountManager accountManager, IPresetService presetService, IUnitOfWorkFactory unitOfWorkFactory)
{
_securityUserService = securityUserService;
_menuService = menuService;
_accountManager = accountManager;
_presetService = presetService;
_unitOfWorkFactory = unitOfWorkFactory;
}
public AccountPickerViewModel(IServiceProvider serviceProvider, string hostId)
{
this.hostId = hostId;
this.authenticationManager = (IAzureAuthenticationManager)serviceProvider.GetService(typeof(IAzureAuthenticationManager));
this.authenticationManager.SubscriptionsChanged += this.OnSubscriptionsChanged;
this.accountManager = (IAccountManager)serviceProvider.GetService(typeof(SVsAccountManager));
}
public AccountApiController(ISecureDataFormat<AuthenticationTicket> accessTokenFormat, IAccountManager accountManager, IAuthenticationManager authenticationManager, AppUserManager appUserManager)
{
AccessTokenFormat = accessTokenFormat;
AccountManager = accountManager;
AccountManager.AuthenticationManager = authenticationManager;
AccountManager.UserManager = appUserManager;
AccountManager.UrlManager = Url;
AccountManager.StartupPublicClientId = Startup.PublicClientId;
}
public AuthController(ISessionProvider<AefSession> sessionProvider,
IOptions<JwtBearerOptions> bearerOptions,
SigningCredentials signingCredentials,
IAccountManager accountManager)
:base(sessionProvider)
{
this.m_BearerOptions = bearerOptions.Value;
this.m_SigningCredentials = signingCredentials;
this.m_AccountManager = accountManager;
}
public PaymentRound(IPersistedBlock block, IStorageLayer storageLayer, IAccountManager accountManager)
{
Block = block;
_storageLayer = storageLayer;
_accountManager = accountManager;
Payments = new List<IPayment>();
_shares = _storageLayer.GetShares(Block); // load the shares for the round.
CalculatePayments(); // calculate the per-user payments.
}
/// <summary> 根据 <see cref="ILogin.Id"/> 返回是否存在相应的 <see cref="ILogin"/>. </summary>
/// <returns> 存在时返回 <c>true</c>, 不存在时返回 <c>false</c>. </returns>
public static LoginExistsResult Check(IAccountManager accountManager, Guid loginId)
{
ILogin login = accountManager.FindLogin(loginId);
if (login == null)
{
var message = String.Format("Invalid loginId Id [{0}].", loginId);
return new LoginExistsResult(false, message, null);
}
return new LoginExistsResult(true, null, login);
}
public AuthController(ISessionScopeFactory sessionScopeFactory,
IOptions<OAuthBearerAuthenticationOptions> bearerOptions,
SigningCredentials signingCredentials,
IAccountManager accountManager)
:base(sessionScopeFactory)
{
//this.m_BearerOptions = bearerOptions.Options;
this.m_SigningCredentials = signingCredentials;
this.m_AccountManager = accountManager;
this.m_SessionScopeFactory = sessionScopeFactory;
}
public DefaultCallBuilder(Call call, ICallManagerInternal callManager, IAccountManager accountManager, UaConfig uaConfig)
{
Helper.GuardNotNull(callManager);
Helper.GuardNotNull(accountManager);
Helper.GuardNotNull(call);
Helper.GuardNotNull(uaConfig);
_call = call;
_callManager = callManager;
_accountManager = accountManager;
_uaConfig = uaConfig;
}
public Account ToAccount(IAccountManager manager)
{
return new DefaultAccount(manager)
{
AccountName = this.AccountName,
Alias = this.Alias,
BatchServiceUrl = this.BatchServiceUrl,
SecureKey = this.SecureKey,
UniqueIdentifier = this.UniqueIdentifier
};
}
public List<Account> GetAccountCollection(IAccountManager parentAccountManager)
{
List<Account> results = new List<Account>();
foreach (SerializableAccount serializableAccount in Accounts)
{
results.Add(serializableAccount.CreateAccountFromSerialization(parentAccountManager));
}
return results;
}
public void SetUp()
{
// Configure Spring programmatically
NamespaceParserRegistry.RegisterParser(typeof(DatabaseNamespaceParser));
NamespaceParserRegistry.RegisterParser(typeof(TxNamespaceParser));
NamespaceParserRegistry.RegisterParser(typeof(AopNamespaceParser));
IApplicationContext context = CreateContextFromXml();
IDictionary<string, IAccountManager> dict = context.GetObjects<IAccountManager>();
accountManager = context["accountManager"] as IAccountManager;
CleanDb(context);
}
public BlockAccounter(IPoolConfig poolConfig, IObjectFactory objectFactory, IStorageLayer storageLayer, IAccountManager accountManager)
{
_objectFactory = objectFactory;
_storageLayer = storageLayer;
_accountManager = accountManager;
_logger = Log.ForContext<BlockAccounter>().ForContext("Component", poolConfig.Coin.Name);
if (!poolConfig.Payments.Enabled) // make sure payments are enabled.
return;
Active = true;
}
public void SetManagers(IImManager imManager, ICallManager callManager,
IAccountManager accountManager, IMediaManager mediaManager)
{
Helper.GuardNotNull(imManager);
Helper.GuardNotNull(callManager);
Helper.GuardNotNull(accountManager);
Helper.GuardNotNull(mediaManager);
ImManager = imManager;
CallManager = callManager;
AccountManager = accountManager;
MediaManager = mediaManager;
}
/// <summary> 返回 <see cref="IAccount"/> 的 <see cref="IAccount.Password"/> 是否可以为 <c>null</c>. </summary>
/// <returns> 可以为 <c>null</c> 时返回 <c>true</c>, 否则返回 <c>false</c>. </returns>
public static PasswordMayEmptyResult Check(IAccountManager accountManager, IAccount account)
{
if (accountManager == null) throw new ArgumentNullException("accountManager");
if (account == null) throw new ArgumentNullException("account");
if (account.Logins.Any() == false)
{
var message = String.Format("The password is required for user [{0}][{1}] without external logins.",
account.Id, account.Name);
return new PasswordMayEmptyResult(false, message, account);
}
return new PasswordMayEmptyResult(true, null, account);
}
public TaskController(ISessionScopeFactory sessionScopeFactory, ITaskManager taskManager
, IPartakerManager partakerManager, IAccountManager accountManager,
IStaffManager staffManager)
{
if (sessionScopeFactory == null) throw new ArgumentException("sessionScopeFactory");
if (taskManager == null) throw new ArgumentException("TaskManager");
m_SessionScopeFactory = sessionScopeFactory;
m_TaskManager = taskManager;
m_PartakerManager = partakerManager;
m_AccountManager = accountManager;
m_StaffManager = staffManager;
}
public DelightService()
{
IoCBootstrapper.Boot();
_accountManager = ObjectFactory.GetInstance<IAccountManager>();
_categoryManager = ObjectFactory.GetInstance<ICategoryManager>();
_productManager = ObjectFactory.GetInstance<IProductManager>();
_userGroupManager = ObjectFactory.GetInstance<IUserGroupManager>();
_voteManager = ObjectFactory.GetInstance<IVoteManager>();
_userManager = ObjectFactory.GetInstance<IUserManager>();
_sessionManager = ObjectFactory.GetInstance<ISessionManager>();
_messageManager = ObjectFactory.GetInstance<IMessageManager>();
}
public UserController(IAccountManager logicManager, ISecurityConfiguration securityConfiguration)
{
if (logicManager == null)
{
throw new ArgumentNullException("logicManager");
}
if (securityConfiguration == null)
{
throw new ArgumentNullException("securityConfiguration");
}
LogicManager = logicManager;
SecurityConfiguration = securityConfiguration;
}
public IPaymentProcessor GetPaymentProcessor(IPoolConfig poolConfig, IStorageLayer storageLayer, IDaemonClient daemonClient,
IAccountManager accountManager)
{
var @params = new NamedParameterOverloads
{
{ "poolConfig", poolConfig },
{ "storageLayer", storageLayer },
{ "daemonClient", daemonClient },
{ "accountManager", accountManager },
};
return(_applicationContext.Container.Resolve <IPaymentProcessor>(@params));
}
public OrdersController(
IAccountManager accountManager,
IProfileManager profileManager,
IOrderManager orderManager,
ITaskManager taskManager,
ITagManager tagManager)
{
_accountManager = accountManager ?? throw new ArgumentNullException(nameof(accountManager));
_profileManager = profileManager ?? throw new ArgumentNullException(nameof(profileManager));
_taskManager = taskManager ?? throw new ArgumentNullException(nameof(taskManager));
_orderManager = orderManager ?? throw new ArgumentNullException(nameof(orderManager));
_tagManager = tagManager ?? throw new ArgumentNullException(nameof(tagManager));
}
public BillingRepository(
IPaymentManager paymentManager,
ICartManager cartManager,
ICatalogRepository catalogRepository,
IAccountManager accountManager,
ICartModelBuilder cartModelBuilder,
IEntityMapper entityMapper,
IStorefrontContext storefrontContext,
IVisitorContext visitorContext)
: base(cartManager, catalogRepository, accountManager, cartModelBuilder, entityMapper, storefrontContext, visitorContext)
{
this.PaymentManager = paymentManager;
}
public CheckoutRepository(
IOrderManager orderManager,
ICartManager cartManager,
ICatalogRepository catalogRepository,
IAccountManager accountManager,
ICartModelBuilder cartModelBuilder,
IEntityMapper entityMapper,
IStorefrontContext storefrontContext,
IVisitorContext visitorContext)
: base(cartManager, catalogRepository, accountManager, cartModelBuilder, entityMapper, storefrontContext, visitorContext)
{
this.OrderManager = orderManager;
}
/// <summary> 根据 <see cref="IAccount.Name"/> 检查是否<b>不</b>存在相应的 <see cref="IAccount"/>. </summary>
public static AccountNotExistsResult Check(IAccountManager accountManager, String accountName)
{
if (accountManager == null) throw new ArgumentNullException("accountManager");
if (String.IsNullOrEmpty(accountName)) throw new ArgumentNullException("accountName");
IAccount account = accountManager.FindAccountByName(accountName);
if (account != null)
{
var message = String.Format("Account for name [{0}] exists.", accountName);
return new AccountNotExistsResult(false, message, account);
}
return new AccountNotExistsResult(true, null, null);
}
public AuthController(
IAccountManager accountManager,
IEmailSender emailSender,
IdentityDbContext context,
IEventBus eventBus,
IMapper mapper)
{
_mapper = mapper;
_context = context;
_emailSender = emailSender;
_accountManager = accountManager;
_eventBus = eventBus;
}
public AccountController
(
ILoggingService <AccountController> logger,
IAccountManager accountManager,
IEncryptionService encryptionService,
IDateTimeService dateTimeService
)
{
_logger = logger;
_accountManager = accountManager;
_encryptionService = encryptionService;
_dateTimeService = dateTimeService;
}
public UserController(
IStorage <Account> users,
IStorage <Statistics> statisticsStorage,
IAccountManager accountManager,
ILogger <UserController> logger,
IRoomCoordinator roomCoordinator
)
{
_accountStorage = users;
_statisticsStorage = statisticsStorage;
_accountManager = accountManager;
_logger = logger;
}
public AccountController(IAccountManager accountManager, IMapper mapper, IEmailSender emailSender,
IConfiguration configuration, IFilesUploader filesUploader, IDatabase database, IAuthService authService)
{
this.accountManager = accountManager;
this.mapper = mapper;
this.emailSender = emailSender;
this.filesUploader = filesUploader;
this.database = database;
this.authService = authService;
this.Configuration = configuration;
this.filesUploader.PreparePathAndUrl("users");
}
public UserController(IAccountManager logicManager, ISecurityConfiguration securityConfiguration)
{
if (logicManager == null)
{
throw new ArgumentNullException("logicManager");
}
if (securityConfiguration == null)
{
throw new ArgumentNullException("securityConfiguration");
}
LogicManager = logicManager;
SecurityConfiguration = securityConfiguration;
}
/// <summary>
///
/// </summary>
/// <param name="identityOptions"></param>
/// <param name="signInManager"></param>
/// <param name="userManager"></param>
/// <param name="accountManager"></param>
/// <param name="authenticationService"></param>
public AuthenticationController(
IOptions <IdentityOptions> identityOptions,
SignInManager <ApplicationUser> signInManager,
UserManager <ApplicationUser> userManager,
IAccountManager accountManager,
AuthenticationService authenticationService)
{
_identityOptions = identityOptions;
_signInManager = signInManager;
_userManager = userManager;
_accountManager = accountManager;
_authenticationService = authenticationService;
}
private void button2_Click(object sender, EventArgs e)
{
IQueryManager iqm = ManagerFactory.getQueryManager("QUeryManagerImpl");
IAccountManager iam = ManagerFactory.getAccountManager("AccountManagerImpl");
string username = Username.Text.Trim();
User user = iqm.queryUser(username);
//修改
user.Tele = Tele.Text;
user.Email = Email.Text;
iam.modifyUser(username, user);
MessageBox.Show("修改成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public AccountController(IAccountManager accountManager,
IAuthorizationService authorizationService,
UserManager <TraisiUser> userManager,
IUnitOfWork unitOfWork, IMailgunMailer emailer, IConfiguration configuration, IStringLocalizer <AccountController> localizer)
{
_accountManager = accountManager;
_authorizationService = authorizationService;
_unitOfWork = unitOfWork;
_emailer = emailer;
_configuration = configuration;
_localizer = localizer;
_userManager = userManager;
}
public ShoppingCartController(
IMapper mapper,
IUnitOfWork unitOfWork,
ILogger <ShoppingCartController> logger,
IEmailSender emailSender,
IAccountManager accountManager)
{
_mapper = mapper;
_unitOfWork = unitOfWork;
_logger = logger;
_emailSender = emailSender;
_accountManager = accountManager;
}
public CatalogRepository(
[NotNull] IAccountManager accountManager,
[NotNull] IContactFactory contactFactory,
[NotNull] ICartManager cartManager,
[NotNull] ICatalogManager catalogManager,
[NotNull] IInventoryManager inventoryManager,
[NotNull] IPricingManager pricingManager)
: base(accountManager, contactFactory)
{
_cartManager = cartManager;
_catalogManager = catalogManager;
_inventoryManager = inventoryManager;
_pricingManager = pricingManager;
}
private async Task EnsureRoleAsync(IAccountManager accountManager, string roleName, string description, string[] claims)
{
if ((await accountManager.GetRoleByNameAsync(roleName)) == null)
{
ApplicationRole applicationRole = new ApplicationRole(roleName, description);
(bool Succeeded, string[] Errors)result = await accountManager.CreateRoleAsync(applicationRole, claims);
if (!result.Succeeded)
{
throw new Exception($"Seeding \"{description}\" role failed. Errors: {string.Join(Environment.NewLine, result.Errors)}");
}
}
}
public AccountServiceTests()
{
this.fixture = new Fixture();
this.accountManager = Substitute.For <IAccountManager>();
this.mapper = Substitute.For <IAccountMapper>();
this.storefrontContext = Substitute.For <IStorefrontContext>();
this.storefrontContext.ShopName.Returns(this.fixture.Create <string>());
this.service = Substitute.For <AccountService>(
this.accountManager,
this.mapper,
this.storefrontContext);
}
public BlockAccounter(IPoolConfig poolConfig, IObjectFactory objectFactory, IStorageLayer storageLayer, IAccountManager accountManager)
{
_objectFactory = objectFactory;
_storageLayer = storageLayer;
_accountManager = accountManager;
_logger = Log.ForContext <BlockAccounter>().ForContext("Component", poolConfig.Coin.Name);
if (!poolConfig.Payments.Enabled) // make sure payments are enabled.
{
return;
}
Active = true;
}
/// <summary> 根据 <see cref="ILogin.Provider"/> 与 <see cref="ILogin.ProviderKey"/> 返回是否存在相应的 <see cref="ILogin"/>. </summary>
/// <returns> 存在时返回 <c>true</c>, 不存在时返回 <c>false</c>. </returns>
public static LoginExistsResult Check(IAccountManager accountManager, String provider, String providerKey)
{
if (accountManager == null) throw new ArgumentNullException("accountManager");
if (String.IsNullOrEmpty(provider)) throw new ArgumentNullException("provider");
if (String.IsNullOrEmpty(providerKey)) throw new ArgumentNullException("providerKey");
ILogin login = accountManager.FindLogin(provider, providerKey);
if (login == null)
{
var message = String.Format("Invalid login for provider [{0}] with Key [{1}].", provider, providerKey);
return new LoginExistsResult(false, message, null);
}
return new LoginExistsResult(true, null, login);
}
/// <summary>
///
/// </summary>
/// <param name="userManager"></param>
public SAML2AuthorizationHandler(UserManager <TraisiUser> userManager,
AuthenticationService authenticationService,
IAccountManager accountManager,
IUnitOfWork unitofWork,
IConfiguration configuration)
{
this._userManager = userManager;
this._authenticationService = authenticationService;
this._accountManager = accountManager;
this._unitOfWork = unitofWork;
this._configuration = configuration;
this.Initialize();
}
public DefaultAccount CreateAccountFromSerialization(IAccountManager parentAccountManager)
{
DefaultAccount account = new DefaultAccount(parentAccountManager)
{
AccountName = this.AccountName,
Alias = this.Alias,
BatchServiceUrl = this.BatchServiceUrl,
Key = this.Key,
SecureKey = this.SecureKey,
UniqueIdentifier = this.UniqueIdentifier
};
return(account);
}
//[Route("Identity/Account/Login")]
//public IActionResult LoginRedirect(string ReturnUrl)
//{
// return Redirect("/Account/Login?ReturnUrl=" + ReturnUrl);
//}
public AccountController(SignInManager <User> signInManager,
RoleManager <Role> roleManager,
UserManager <User> userManager,
IAccountManager accountManager,
IMapper mapper,
IHttpContextAccessor contextAccessor)
{
_accountManager = accountManager;
_mapper = mapper;
_signInManager = signInManager;
_roleManager = roleManager;
_userManager = userManager;
_contextAccessor = contextAccessor;
}
public override void OnTick(params Tick[] t)
{
channel.HandleNextTick(t[0]);
foreach (var indicator in indicatorList)
{
indicator.Value.HandleNextTick(t[0]);
}
if (prevTick != null)
{
if (IAccountManager.ExistsLongPositionForSymbol(t[0].Symbol))
{
if (indicatorList["EMA"][0] < channel.LOW(0))
{
IAccountManager.ClosePosition(t[0].Symbol);
}
}
if (IAccountManager.ExistsShortPositionForSymbol(t[0].Symbol))
{
if (indicatorList["EMA"][0] > channel.HI(0))
{
IAccountManager.ClosePosition(t[0].Symbol);
}
}
//Volatility high
if (indicatorList["HVOL"][0] > 40)
{
if (!IAccountManager.ExistsPositionForSymbol(t[0].Symbol))
{
if (indicatorList["EMA"][0] > channel.HI(0) && indicatorList["EMA"][1] < channel.HI(1))
{
IAccountManager.PlaceMarketOrder(t[1].Symbol, 10000, Position.PositionSide.Long, STOPLEVEL);
}
}
if (!IAccountManager.ExistsPositionForSymbol(t[0].Symbol))
{
if (indicatorList["EMA"][0] < channel.LOW(0) && indicatorList["EMA"][1] > channel.LOW(1))
{
IAccountManager.PlaceMarketOrder(t[1].Symbol, 10000, Position.PositionSide.Short, STOPLEVEL);
}
}
}
}
prevTick = t[0];
}
private PositionsViewModel GetVm(
IMarketDataManager marketDataManager = null,
IPositionManager positionManager = null,
IContractManager contractManager = null,
ITradeRecordingService tradeRecordingService = null)
{
var manager = marketDataManager ?? Substitute.For <IMarketDataManager>();
_accountManager = Substitute.For <IAccountManager>();
if (positionManager == null)
{
positionManager = Substitute.For <IPositionManager>();
positionManager.RequestOpenOrdersAsync().Returns(Task.FromResult(new List <OpenOrderEventArgs>()));
}
if (contractManager == null)
{
contractManager = Substitute.For <IContractManager>();
contractManager.RequestDetailsAsync(Arg.Any <Contract>()).Returns(Task.FromResult(new List <ContractDetails>()));
}
var queueProcessor = Substitute.For <IQueueProcessor>();
queueProcessor
.When(x => x.Enqueue(Arg.Any <Action>()))
.Do(x =>
{
var action = x.Arg <Action>();
action.Invoke();
});
var dispatcherHelper = Substitute.For <IDispatcherHelper>();
dispatcherHelper
.When(x => x.InvokeOnUiThread(Arg.Any <Action>()))
.Do(x =>
{
var action = x.Arg <Action>();
action.Invoke();
});
if (tradeRecordingService == null)
{
tradeRecordingService = Substitute.For <ITradeRecordingService>();
}
return(new PositionsViewModel(dispatcherHelper, manager, _accountManager, positionManager, contractManager, queueProcessor, tradeRecordingService));
}
public CartController(
IAccountManager accountManager,
IContactFactory contactFactory,
IGiftCardRepository gitCardRepository,
ICatalogRepository catalogRepository,
ICartRepository cartRepository,
ILogger logger)
: base(accountManager, contactFactory)
{
ContactFactory = contactFactory;
_catalogRepository = catalogRepository;
_giftCardRepository = gitCardRepository;
_cartRepository = cartRepository;
_logger = logger;
}
public AccountController(IAccountManager accountManager,
IJwtFactory jwtFactory,
IOptions <JwtIssuerOptions> jwtOptions,
ICustomLogger logger)
{
_accountManager = accountManager;
_jwtFactory = jwtFactory;
_jwtOptions = jwtOptions.Value;
_logger = logger;
_serializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented
};
}
public AccountController(
UserManager <ApplicationUser> userManager,
RoleManager <ApplicationRole> roleManager,
SignInManager <ApplicationUser> signInManager,
IAccountManager accountManager,
IPasswordHasher <ApplicationUser> passwordHasher,
IOptions <AppConfiguration> appConfiguration)
{
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_accountManager = accountManager;
_passwordHasher = passwordHasher;
_appConfiguration = appConfiguration;
}
public MainViewModel(IAccountManager accountManager,
IExtendedNavigationService navigationService,
ILocaleManager localeManager,
IDialogService dialogService)
{
this.accountManager = accountManager;
this.navigationService = navigationService;
this.localeManager = localeManager;
this.dialogService = dialogService;
OnLoadCommand = new RelayCommand(OnLoadCommandProcessor);
LogoutCommand = new RelayCommand(LogoutCommandProcessor);
ShowTransactionsCommand = new RelayCommand(ShowTransactionsCommandProcessor);
NewTransactionCommand = new RelayCommand(NewTransactionCommandProcessor);
}
public AuthorizationController(
IOptions <IdentityOptions> identityOptions,
SignInManager <ApplicationUser> signInManager,
UserManager <ApplicationUser> userManager,
IAccountManager accountManager,
IDatabaseInitializer databaseInitializer,
ILogger <AuthorizationController> logger)
{
_identityOptions = identityOptions;
_signInManager = signInManager;
_userManager = userManager;
_accountManager = accountManager;
_databaseInitializer = databaseInitializer;
_logger = logger;
}
public PortfolioOrchestrator(
IPortfolioManager portfolioManager,
IMarketWorkTimeService marketWorkTimeService,
IMarketDataProviderQueryable marketDataProviderQueryable,
IMarketDataService marketDataService,
IStrategyService strategyService,
IAccountManager accountManager)
{
_portfolioManager = portfolioManager;
_marketWorkTimeService = marketWorkTimeService;
_marketDataProviderQueryable = marketDataProviderQueryable;
_marketDataService = marketDataService;
_strategyService = strategyService;
_accountManager = accountManager;
}
public AccountController(
IRestrictedAccountManager accountManager,
IAccountManager unrestrictedAccountManager,
IAuthorizationService authorizationService,
IClaimsService claimsService,
ITenantEntityAccessChecker accessChecker,
AutoMapperConfig autoMapperConfig)
{
_accountManager = accountManager;
_unrestrictedAccountManager = unrestrictedAccountManager;
_authorizationService = authorizationService;
_accessChecker = accessChecker;
_claimsService = claimsService;
_mapper = autoMapperConfig.CreateMapper();
}
/// <summary>
/// Initializes a new instance of the <see cref="LoyaltyController" /> class.
/// </summary>
/// <param name="loyaltyProgramManager">The loyalty program manager.</param>
/// <param name="cartManager">The cart manager.</param>
/// <param name="accountManager">The account manager.</param>
/// <param name="contactFactory">The contact factory.</param>
/// <param name="logger">The logger.</param>
public LoyaltyController(
[NotNull] ILoyaltyProgramManager loyaltyProgramManager,
[NotNull] ICartManager cartManager,
[NotNull] IAccountManager accountManager,
[NotNull] IContactFactory contactFactory,
[NotNull] ILogger logger)
: base(accountManager, contactFactory)
{
Assert.ArgumentNotNull(loyaltyProgramManager, "loyaltyProgramManager");
Assert.ArgumentNotNull(cartManager, "cartManager");
Assert.ArgumentNotNull(contactFactory, "contactFactory");
this._loyaltyProgramManager = loyaltyProgramManager;
_logger = logger;
}
