public AccountController(IUserService userService, ICryptographyService cryptographyService, IEmailService emailService, IImageService imageService)
{
_userService = userService;
_cryptographyService = cryptographyService;
_emailService = emailService;
_imageService = imageService;
}
public FreeToPlayPeriodPropertiesModelBinder(
IHeroRepository heroRepository,
ICryptographyService cryptographyService)
{
_heroRepository = heroRepository;
_cryptographyService = cryptographyService;
}
public UserService(IRepository<User> repository, IRepository<Role> roleRepository, IEmailService emailService, ICryptographyService cryptographyService)
{
_repository = repository;
_roleRepository = roleRepository;
_emailService = emailService;
_cryptographyService = cryptographyService;
}
public FreeToPlayPeriodController(
IHeroRepository heroRepository,
ICryptographyService cryptographyService)
{
_heroRepository = heroRepository;
_cryptographyService = cryptographyService;
}
public PackageService(
ICryptographyService cryptoSvc,
IEntityRepository<PackageRegistration> packageRegistrationRepo,
IEntityRepository<Package> packageRepo,
IEntityRepository<PackageStatistics> packageStatsRepo,
IPackageFileService packageFileSvc,
IEntityRepository<PackageOwnerRequest> packageOwnerRequestRepository,
IIndexingService indexingSvc,
IEntityRepository<PackageAuthor> packageAuthorRepo,
IEntityRepository<PackageFramework> packageFrameworksRepo,
IEntityRepository<PackageDependency> packageDependenciesRepo,
IEntityRepository<PackageFile> packageFilesRepo,
IMessageService messageSvc)
{
this.cryptoSvc = cryptoSvc;
this.packageRegistrationRepo = packageRegistrationRepo;
this.packageRepo = packageRepo;
this.packageStatsRepo = packageStatsRepo;
this.packageFileSvc = packageFileSvc;
this.packageOwnerRequestRepository = packageOwnerRequestRepository;
this.indexingSvc = indexingSvc;
this.packageAuthorRepo = packageAuthorRepo;
this.packageFrameworksRepo = packageFrameworksRepo;
this.packageDependenciesRepo = packageDependenciesRepo;
this.packageFilesRepo = packageFilesRepo;
this.messageSvc = messageSvc;
}
public HeroPropertiesModelBinder(
IHeroRepository heroRepository,
ICryptographyService cryptographyService)
{
_heroRepository = heroRepository;
_cryptographyService = cryptographyService;
}
public AccountCreator(IAuthorizationService authorizationService, IValidatorFactory validatorFactory, IAccountRepository accountRepository, ICryptographyService cryptographyService, IEmailService emailService, ISettingsProvider settingsProvider)
{
_authorizationService = authorizationService;
_validatorFactory = validatorFactory;
_accountRepository = accountRepository;
_cryptographyService = cryptographyService;
_emailService = emailService;
}
public AuthenticationController(IUserService userService,
ICryptographyService cryptographyService, IMediaService mediaService, MediaSettings mediaSettings)
{
_userService = userService;
_cryptographyService = cryptographyService;
_mediaService = mediaService;
_mediaSettings = mediaSettings;
}
public UserController(IUserService userService,ICryptographyService cryptographyService,IImageService imageService, IEmailService emailService,ISessionService sessionService)
{
_userService = userService;
_cryptographyService = cryptographyService;
_imageService = imageService;
_emailService = emailService;
_sessionService = sessionService;
}
public OAuthAuthenticationService(IUserService userService,
IUserRegistrationService userRegistrationService,
SecuritySettings securitySettings,
ICryptographyService cryptographyService,
HttpContextBase contextBase)
: base(userService, userRegistrationService, securitySettings, cryptographyService, contextBase)
{
_userService = userService;
}
public AddEditContactViewModel(IMessenger messenger, IDataAccessLayer database,
ICryptographyService cryptographyService)
{
_messenger = messenger;
_database = database;
_cryptographyService = cryptographyService;
_messenger.Register<AddEditContactConfirmMsg>(this, OnAddEditContactConfirmMsg);
}
public UserService(
IConfiguration config,
ICryptographyService cryptoService,
IEntityRepository<User> userRepository)
{
_config = config;
_cryptoService = cryptoService;
_userRepository = userRepository;
}
public UserService(
GallerySetting settings,
ICryptographyService cryptoService,
IEntityRepository<User> userRepository)
{
_settings = settings;
_cryptoService = cryptoService;
_userRepository = userRepository;
}
public UserService(
GallerySetting settings,
ICryptographyService cryptoSvc,
IEntityRepository<User> userRepo)
{
_settings = settings;
_cryptoSvc = cryptoSvc;
_userRepo = userRepo;
}
public UserService(
IConfiguration configuration,
ICryptographyService cryptoSvc,
IEntityRepository<User> userRepo)
{
this.configuration = configuration;
this.cryptoSvc = cryptoSvc;
this.userRepo = userRepo;
}
public UserService(
IConfiguration config,
ICryptographyService crypto,
IEntityRepository<User> userRepository) : this()
{
Config = config;
Crypto = crypto;
UserRepository = userRepository;
}
public AccountService(IAccountRepository accountRepository, IAuthorizationService authorizationService,
ICryptographyService cryptographyService, IEmailService emailService,
IValidatorFactory validatorFactory)
{
_accountRepository = accountRepository;
_authorizationService = authorizationService;
_cryptographyService = cryptographyService;
_emailService = emailService;
_validatorFactory = validatorFactory;
}
public AsyncWorkoutServices(Func<CancellationToken, Task<IEnumerable<string>>> workoutFactory, ICryptographyService cryptographyService)
{
if (workoutFactory == null)
throw new ArgumentNullException("workoutFactory");
if (cryptographyService == null)
throw new ArgumentNullException("cryptographyService");
_workoutFactory = workoutFactory;
CryptographyService = cryptographyService;
}
protected override void Context()
{
AuthorizationService = MockRepository.GenerateStub<IAuthorizationService>();
ValidatorFactory = MockRepository.GenerateStub<IValidatorFactory>();
AccountRepository = MockRepository.GenerateStub<IAccountRepository>();
CryptographyService = MockRepository.GenerateStub<ICryptographyService>();
EmailService = MockRepository.GenerateStub<IEmailService>();
SettingsProvider = MockRepository.GenerateStub<ISettingsProvider>();
AccountService = new AccountService(AccountRepository, AuthorizationService, CryptographyService,
EmailService, ValidatorFactory);
}
public UserController(IUserService userService, IRoleService roleService, UserSettings userSettings, SecuritySettings securitySettings, IUserRegistrationService userRegistrationService, ICryptographyService cryptographyService, IMediaService mediaService, MediaSettings mediaSettings)
{
_userService = userService;
_userSettings = userSettings;
_securitySettings = securitySettings;
_userRegistrationService = userRegistrationService;
_cryptographyService = cryptographyService;
_mediaService = mediaService;
_mediaSettings = mediaSettings;
_roleService = roleService;
}
public AuthenticationService(IUserService userService,
IUserRegistrationService userRegistrationService,
SecuritySettings securitySettings,
ICryptographyService cryptographyService, HttpContextBase contextBase)
{
_userService = userService;
_userRegistrationService = userRegistrationService;
_securitySettings = securitySettings;
_cryptographyService = cryptographyService;
_contextBase = contextBase;
}
internal HeroViewModel(Hero hero, ICryptographyService cryptographyService)
{
Id = cryptographyService.Encrypt(hero.Id);
Name = hero.Name;
FreeToPlayPeriods = hero
.FreeToPlayPeriods
.Select(ftpp => new FreeToPlayPeriodViewModel(ftpp, cryptographyService))
.ToArray();
Type = new HeroTypeViewModel(hero.Type, cryptographyService);
State = new HeroStateViewModel(hero.State, cryptographyService);
Created = hero.Created;
Price = hero.Price;
}
public PackagesController(
ICryptographyService cryptoSvc,
IPackageService packageSvc,
IPackageFileService packageFileRepo,
IUserService userSvc,
IMessageService messageService)
{
this.cryptoSvc = cryptoSvc;
this.packageSvc = packageSvc;
this.packageFileSvc = packageFileRepo;
this.userSvc = userSvc;
this.messageService = messageService;
}
public PackageService(
ICryptographyService cryptoSvc,
IEntityRepository<PackageRegistration> packageRegistrationRepo,
IEntityRepository<Package> packageRepo,
IEntityRepository<PackageStatistics> packageStatsRepo,
IPackageFileService packageFileSvc)
{
this.cryptoSvc = cryptoSvc;
this.packageRegistrationRepo = packageRegistrationRepo;
this.packageRepo = packageRepo;
this.packageStatsRepo = packageStatsRepo;
this.packageFileSvc = packageFileSvc;
}
public PackageService(
ICryptographyService cryptoService,
IEntityRepository<PackageRegistration> packageRegistrationRepository,
IEntityRepository<Package> packageRepository,
IEntityRepository<PackageStatistics> packageStatsRepository,
IEntityRepository<PackageOwnerRequest> packageOwnerRequestRepository,
IIndexingService indexingService)
{
_cryptoService = cryptoService;
_packageRegistrationRepository = packageRegistrationRepository;
_packageRepository = packageRepository;
_packageStatsRepository = packageStatsRepository;
_packageOwnerRequestRepository = packageOwnerRequestRepository;
_indexingService = indexingService;
}
public ShellViewModel(IFileService fileService, ICryptographyService cryptographyService)
{
_fileService = fileService;
_cryptographyService = cryptographyService;
SelectSourceFolderPathCommand = new DelegateCommand(SelectSourceFolderPath);
SelectOutputFolderPathCommand = new DelegateCommand(SelectOutputFolder);
PasswordChangedCommand = new DelegateCommand<PasswordBox>(PasswordChanged);
VerifyPasswordChangedCommand = new DelegateCommand<PasswordBox>(VerifyPasswordChanged);
ProcessCommand = new DelegateCommand(Process, CanExecuteEncrypt);
RemoveSelectedFilesCommand = new DelegateCommand(RemoveSelectedFiles);
FilesToBeProcessed = new ObservableCollection<FileViewModel>();
Mode = EncryptionMode.Encrypt;
}
public PackageService(
ICryptographyService cryptoSvc,
IEntityRepository<PackageRegistration> packageRegistrationRepo,
IEntityRepository<Package> packageRepo,
IEntityRepository<PackageStatistics> packageStatsRepo,
IPackageFileService packageFileSvc,
IEntityRepository<PackageOwnerRequest> packageOwnerRequestRepository,
IIndexingService indexingSvc)
{
this.cryptoSvc = cryptoSvc;
this.packageRegistrationRepo = packageRegistrationRepo;
this.packageRepo = packageRepo;
this.packageStatsRepo = packageStatsRepo;
this.packageFileSvc = packageFileSvc;
this.packageOwnerRequestRepository = packageOwnerRequestRepository;
this.indexingSvc = indexingSvc;
}
public PaymentController(IUserPaymentMethodService paymentMethodService,
IPaymentProcessingService paymentProcessingService,
ICryptographyService cryptographyService,
IVideoBattleService videoBattleService,
ISponsorService sponsorService,
ICreditService creditService,
PaymentSettings paymentSettings,
IPaymentTransactionService paymentTransactionService)
{
_paymentMethodService = paymentMethodService;
_paymentProcessingService = paymentProcessingService;
_cryptographyService = cryptographyService;
_videoBattleService = videoBattleService;
_sponsorService = sponsorService;
_creditService = creditService;
_paymentSettings = paymentSettings;
_paymentTransactionService = paymentTransactionService;
}
public MainViewModel(ICryptographyService cryptographyService, IMessenger messenger, IDataAccessLayer database,
IDropboxService dropboxService)
{
_cryptographyService = cryptographyService;
_messenger = messenger;
_database = database;
_dropboxService = dropboxService;
//register for messages
_messenger.Register<AssignNewKeysConfirmMsg>(this, OnAssignNewKeysConfirmMsg);
_messenger.Register<ExportPublicKeyConfirmMsg>(this, OnExportPublicKeyConfirmMsg);
_messenger.Register<ContactsViewClosedMsg>(this, OnContactsViewClosedMsg);
_messenger.Register<ChooseSourceConfirmMsg>(this, OnChooseSourceConfirmMsg);
_messenger.Register<ChooseTargetConfirmMsg>(this, OnChooseTargetConfirmMsg);
_messenger.Register<ContactSelectedMsg>(this, OnContactSelectedMsg);
_messenger.Register<ConnectDropboxViewClosedMsg>(this, OnConnectDropboxViewClosedMsg);
_messenger.Register<DropboxAccessTokenSavedMsg>(this, OnDropboxAccessTokenSavedMsg);
_messenger.Register<FileListViewClosedMsg>(this, OnFileListViewClosedMsg);
_messenger.Register<DropboxFileDownloadFinishedMsg>(this, OnDropboxFileDownloadFinishedMsg);
_messenger.Register<EncryptionSuccsessMsg>(this, OnEncryptionSuccsessMsg);
CheckDropboxAccess();
}
public DownloadService(ACEWebServiceDbContext context, ICryptographyService cryptoService, IOptions <AppSettings> settings)
{
_context = context;
_cryptoService = cryptoService;
_settings = settings.Value;
}
public UserService(IAuthenticationService authSerice, ICryptographyService cryptographyService, IDataProvider dataProvider)
{
_authenticationService = authSerice;
_dataProvider = dataProvider;
_cryptographyService = cryptographyService;
}
public BundleService(ILocalFileProvider localFileProvider, ILogger logger, ICryptographyService cryptographyService)
{
_localFileProvider = localFileProvider;
_logger = logger;
_cryptographyService = cryptographyService;
}
public GdprController(IConsentService consentService, IGdprModelFactory gdprModelFactory, IConsentGroupService consentGroupService, IModelMapper modelMapper, IConsentLogService consentLogService, ICryptographyService cryptographyService, IUserService userService)
{
_consentService = consentService;
_gdprModelFactory = gdprModelFactory;
_consentGroupService = consentGroupService;
_modelMapper = modelMapper;
_consentLogService = consentLogService;
_cryptographyService = cryptographyService;
_userService = userService;
}
public RegisterService(IRepository <User> userRepository, ICryptographyService cryptographyService)
{
this.userRepository = userRepository;
this.cryptographyService = cryptographyService;
}
public JwtFactory(IOptions <JwtIssuerOptions> jwtOptions, ICryptographyService cryptographyService)
{
_jwtOptions = jwtOptions.Value;
ThrowIfInvalidOptions(_jwtOptions);
_cryptographyService = cryptographyService;
}
public UserCodeService(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public CheckoutController(IPaymentProcessor paymentProcessor, IPaymentAccountant paymentAccountant, IModelMapper modelMapper, IAddressService addressService, ICartService cartService, IDataSerializer dataSerializer, IPluginAccountant pluginAccountant, IOrderService orderService, OrderSettings orderSettings, IRoleService roleService, IUserService userService, IProductService productService, IOrderAccountant orderAccountant, IDownloadService downloadService, ILogger logger, AffiliateSettings affiliateSettings, IStoreCreditService storeCreditService, IPriceAccountant priceAccountant, ICryptographyService cryptographyService)
{
_paymentProcessor = paymentProcessor;
_paymentAccountant = paymentAccountant;
_modelMapper = modelMapper;
_addressService = addressService;
_cartService = cartService;
_dataSerializer = dataSerializer;
_pluginAccountant = pluginAccountant;
_orderService = orderService;
_orderSettings = orderSettings;
_roleService = roleService;
_userService = userService;
_productService = productService;
_orderAccountant = orderAccountant;
_downloadService = downloadService;
_logger = logger;
_affiliateSettings = affiliateSettings;
_storeCreditService = storeCreditService;
_priceAccountant = priceAccountant;
_cryptographyService = cryptographyService;
}
public UserService(FlatFinderContext context, ICryptographyService cryptographyService, IHttpContextAccessor httpContextAccessor)
{
_context = context;
_cryptographyService = cryptographyService;
_httpContextAccessor = httpContextAccessor;
}
public AccountSettingsService(IUserAccountRepository userAccountRepository, IUserAccountSettingsRepository userAccountSettingRepository, ICryptographyService cryptographyService, IAuthenticationService authenticationService)
{
_userAccountRepository = userAccountRepository;
_userAccountSettingRepository = userAccountSettingRepository;
_cryptographyService = cryptographyService;
_authenticationService = authenticationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseController"/> class.
/// </summary>
/// <param name="cryptographyService">The cryptography service.</param>
public BaseController(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public CryptoServiceWrapper(ICryptographyService service, ICryptographyService sim)
{
cryptoService = service;
simulatedService = new CryptographySimulatedService();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="userService"></param>
/// <param name="membershipService"></param>
/// <param name="cryptographyService"></param>
public UsersController(IUserService userService, IMembershipService membershipService, ICryptographyService cryptographyService)
{
this.userService = userService;
this.membershipService = membershipService;
this.cryptographyService = cryptographyService;
}
/// <summary>
/// Initializes a new instance of the <see cref="CookieEncryptionHttpModule"/> class.
/// </summary>
/// <param name="cryptographyService">The cryptography service.</param>
public CookieEncryptionHttpModule(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public HexMD5CEncryptionService(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public NetworkRoamingService(ITaxiHailNetworkServiceClient taxiHailNetworkServiceClient, IServerSettings serverSettings, ICryptographyService cryptographyService)
{
_taxiHailNetworkServiceClient = taxiHailNetworkServiceClient;
_serverSettings = serverSettings;
_cryptographyService = cryptographyService;
}
public LoginViewModel(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public AuthService(IConfiguration configuration, IUsersRepository userRepository, ICryptographyService cryptographyService, IRelationshipsService relationshipsService)
{
_configuration = configuration;
_userRepository = userRepository;
_cryptographyService = cryptographyService;
_relationshipsService = relationshipsService;
}
/// <summary>
/// Initializes an instance of the <see cref="UserAuthenticationService"/> class.
/// </summary>
/// <param name="userDal"></param>
/// <param name="logger"></param>
/// <param name="cryptographyService"></param>
/// <param name="patientUserDal"></param>
public UserAuthenticationService(IUserDal userDal, ILogger <UserAuthenticationService> logger, ICryptographyService cryptographyService, IPatientUserDal patientUserDal)
{
_userDal = userDal ?? throw new ArgumentNullException(nameof(userDal));
_log = logger ?? throw new ArgumentNullException(nameof(logger));
_cryptographyService = cryptographyService ?? throw new ArgumentNullException(nameof(cryptographyService));
_patientUserDal = patientUserDal ?? throw new ArgumentNullException(nameof(patientUserDal));
}
public static BeaconBlock BuildEmptyBlock(IServiceProvider testServiceProvider, BeaconState state, Slot slot, BlsSignature randaoReveal)
{
//if (slot) is none
TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
SignatureDomains signatureDomains = testServiceProvider.GetService <IOptions <SignatureDomains> >().Value;
ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>();
BeaconChainUtility beaconChainUtility = testServiceProvider.GetService <BeaconChainUtility>();
BeaconStateAccessor beaconStateAccessor = testServiceProvider.GetService <BeaconStateAccessor>();
BeaconStateTransition beaconStateTransition = testServiceProvider.GetService <BeaconStateTransition>();
Eth1Data eth1Data = new Eth1Data(Root.Zero, state.Eth1DepositIndex, Bytes32.Zero);
Root stateRoot = !state.LatestBlockHeader.StateRoot.Equals(Root.Zero)
? state.LatestBlockHeader.StateRoot
: cryptographyService.HashTreeRoot(state);
BeaconBlockHeader previousBlockHeader = new BeaconBlockHeader(state.LatestBlockHeader.Slot,
state.LatestBlockHeader.ParentRoot, stateRoot, state.LatestBlockHeader.BodyRoot);
Root previousBlockHashTreeRoot = cryptographyService.HashTreeRoot(previousBlockHeader);
if (randaoReveal.Equals(BlsSignature.Zero))
{
Epoch blockEpoch = beaconChainUtility.ComputeEpochAtSlot(slot);
ValidatorIndex proposerIndex;
if (slot == state.Slot)
{
proposerIndex = beaconStateAccessor.GetBeaconProposerIndex(state);
}
else
{
Epoch stateEpoch = beaconChainUtility.ComputeEpochAtSlot(state.Slot);
if (blockEpoch > stateEpoch + 1)
{
Console.WriteLine("WARNING: Block slot (epoch {0}) far away from state (epoch {1}), and no proposer index manually given."
+ " Signing block is slow due to transition for proposer index calculation.", blockEpoch, stateEpoch);
}
// use stub state to get proposer index of future slot
BeaconState stubState = BeaconState.Clone(state);
beaconStateTransition.ProcessSlots(stubState, slot);
proposerIndex = beaconStateAccessor.GetBeaconProposerIndex(stubState);
}
byte[][] privateKeys = TestKeys.PrivateKeys(timeParameters).ToArray();
byte[] privateKey = privateKeys[(int)(ulong)proposerIndex];
Domain randaoDomain = beaconStateAccessor.GetDomain(state, signatureDomains.Randao, blockEpoch);
Root epochHashTreeRoot = cryptographyService.HashTreeRoot(blockEpoch);
Root randaoSigningRoot = beaconChainUtility.ComputeSigningRoot(epochHashTreeRoot, randaoDomain);
randaoReveal = TestSecurity.BlsSign(randaoSigningRoot, privateKey);
}
BeaconBlock emptyBlock = new BeaconBlock(slot,
previousBlockHashTreeRoot,
Root.Zero,
new BeaconBlockBody(
randaoReveal,
eth1Data,
new Bytes32(),
Array.Empty <ProposerSlashing>(),
Array.Empty <AttesterSlashing>(),
Array.Empty <Attestation>(),
Array.Empty <Deposit>(),
Array.Empty <SignedVoluntaryExit>()
));
return(emptyBlock);
}
public LoginViewModel(ICryptographyService cryptographyService)
{
_cryptographyService = cryptographyService;
}
public InstallController(IInstallationService installationService, IApplicationConfiguration applicationConfiguration, ICryptographyService cryptographyService)
{
_installationService = installationService;
_applicationConfiguration = applicationConfiguration;
_cryptographyService = cryptographyService;
}
public LoginService(IUnitOfWork unitOfWork, ICryptographyService cryptographyService)
{
this.unitOfWork = unitOfWork;
this.cryptographyService = cryptographyService;
}
public void Init(IUnityContainer container)
{
container.RegisterType <IUpdateOrderStatusJob>(
new TransientLifetimeManager(),
new InjectionFactory(c =>
{
var serverSettings = c.Resolve <IServerSettings>();
if (serverSettings.ServerData.IBS.FakeOrderStatusUpdate)
{
return(new UpdateOrderStatusJobStub(c.Resolve <IOrderDao>(), c.Resolve <IOrderStatusUpdateDao>(), c.Resolve <OrderStatusUpdater>()));
}
return(new UpdateOrderStatusJob(c.Resolve <IOrderDao>(), c.Resolve <IIBSServiceProvider>(), c.Resolve <IOrderStatusUpdateDao>(), c.Resolve <OrderStatusUpdater>(), c.Resolve <HoneyBadgerServiceClient>(), c.Resolve <IServerSettings>()));
}));
System.Data.Entity.Database.SetInitializer <BookingDbContext>(null);
container.RegisterType <ISmsService, TwilioService>();
container.RegisterInstance <IConfigurationDao>(new ConfigurationDao(() => container.Resolve <ConfigurationDbContext>()));
container.RegisterType <BookingDbContext>(new TransientLifetimeManager(),
new InjectionConstructor(
container.Resolve <ConnectionStringSettings>(Common.Module.MkConnectionString).ConnectionString));
container.RegisterInstance <IEmailSender>(new EmailSender(container.Resolve <IServerSettings>()));
container.RegisterInstance <ITemplateService>(new TemplateService(container.Resolve <IServerSettings>()));
container.RegisterInstance <IPushNotificationService>(new PushNotificationService(container.Resolve <IServerSettings>(), container.Resolve <ILogger>()));
container.RegisterInstance <IOrderDao>(new OrderDao(() => container.Resolve <BookingDbContext>(), container.Resolve <IServerSettings>()));
container.RegisterInstance <IReportDao>(new ReportDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IPromotionDao>(new PromotionDao(() => container.Resolve <BookingDbContext>(), container.Resolve <IClock>(), container.Resolve <IServerSettings>(), container.Resolve <IEventSourcedRepository <Promotion> >()));
container.RegisterType <INotificationService, NotificationService>(new ContainerControlledLifetimeManager(),
new InjectionFactory(c =>
{
ICryptographyService cryptographyService = null;
try
{
cryptographyService = c.Resolve <ICryptographyService>();
}
catch (Exception)
{
// nothing to do because ICryptographyService is considere
}
return(new NotificationService(() => container.Resolve <BookingDbContext>(),
container.Resolve <IPushNotificationService>(),
container.Resolve <ITemplateService>(),
container.Resolve <IEmailSender>(),
container.Resolve <IServerSettings>(),
container.Resolve <IConfigurationDao>(),
container.Resolve <IOrderDao>(),
container.Resolve <IAccountDao>(),
container.Resolve <IStaticMap>(),
container.Resolve <ISmsService>(),
container.Resolve <IGeocoding>(),
container.Resolve <ITaxiHailNetworkServiceClient>(),
container.Resolve <ILogger>(), cryptographyService));
}));
container.RegisterType <IPairingService>(new ContainerControlledLifetimeManager(),
new InjectionFactory(c => new PairingService(c.Resolve <ICommandBus>(), c.Resolve <IIbsOrderService>(), c.Resolve <IOrderDao>(), c.Resolve <IServerSettings>())));
container.RegisterType <IIbsCreateOrderService>(new ContainerControlledLifetimeManager(),
new InjectionFactory(c => new IbsCreateOrderService(c.Resolve <IServerSettings>(), c.Resolve <IVehicleTypeDao>(), c.Resolve <IAccountDao>(), c.Resolve <ILogger>(), c.Resolve <IIBSServiceProvider>(), c.Resolve <IUpdateOrderStatusJob>())));
container.RegisterInstance <IAddressDao>(new AddressDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IAccountDao>(new AccountDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IAccountNoteService>(new AccountNoteService(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IFeesDao>(new FeesDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IOrderStatusUpdateDao>(new OrderStatusUpdateDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IDefaultAddressDao>(new DefaultAddressDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <ITariffDao>(new TariffDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IRuleDao>(new RuleDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IOrderRatingsDao>(new OrderRatingsDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IRatingTypeDao>(new RatingTypeDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IPopularAddressDao>(new PopularAddressDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <ICreditCardDao>(new CreditCardDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IOrderPaymentDao>(new OrderPaymentDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IDeviceDao>(new DeviceDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <ICompanyDao>(new CompanyDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IAccountChargeDao>(new AccountChargeDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IVehicleTypeDao>(new VehicleTypeDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IAppStartUpLogDao>(new AppStartUpLogDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IPasswordService>(new PasswordService());
container.RegisterInstance <IRuleCalculator>(new RuleCalculator(container.Resolve <IRuleDao>(), container.Resolve <IServerSettings>()));
container.RegisterInstance <IOverduePaymentDao>(new OverduePaymentDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IOrderNotificationsDetailDao>(new OrderNotificationsDetailDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IBlackListEntryService>(new BlackListEntryService(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IConfigurationChangeService>(new ConfigurationChangeService(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IAirlineDao>(new AirlineDao(() => container.Resolve <BookingDbContext>()));
container.RegisterInstance <IPickupPointDao>(new PickupPointDao(() => container.Resolve <BookingDbContext>()));
RegisterMaps();
RegisterCommandHandlers(container);
RegisterEventHandlers(container);
container.RegisterType <IPayPalServiceFactory, PayPalServiceFactory>();
container.RegisterType <IPaymentService, PaymentService>();
container.RegisterType <IFeeService, FeeService>();
}
public AuthenticationController(IAppAuthenticationService appAuthenticationService, UserSettings userSettings, SecuritySettings securitySettings, IUserRegistrationService userRegistrationService, IRoleService roleService, IUserService userService, ICryptographyService cryptographyService, IUserCodeService userCodeService, IPreviousPasswordService previousPasswordService, IConsentService consentService, IGdprService gdprService, IGdprModelFactory gdprModelFactory, IInviteRequestService inviteRequestService, AffiliateSettings affiliateSettings)
{
_appAuthenticationService = appAuthenticationService;
_userSettings = userSettings;
_securitySettings = securitySettings;
_userRegistrationService = userRegistrationService;
_roleService = roleService;
_userService = userService;
_cryptographyService = cryptographyService;
_userCodeService = userCodeService;
_previousPasswordService = previousPasswordService;
_consentService = consentService;
_gdprService = gdprService;
_gdprModelFactory = gdprModelFactory;
_inviteRequestService = inviteRequestService;
_affiliateSettings = affiliateSettings;
}
public AsyncWorkoutServices(Func <CancellationToken, Task <IEnumerable <string> > > workoutFactory, ICryptographyService cryptographyService)
{
if (workoutFactory == null)
{
throw new ArgumentNullException("workoutFactory");
}
if (cryptographyService == null)
{
throw new ArgumentNullException("cryptographyService");
}
_workoutFactory = workoutFactory;
CryptographyService = cryptographyService;
}
public EncryptedPersister(ICryptographyService cryptographyService, IIOService ioService)
{
_cryptographyService = cryptographyService;
_ioService = ioService;
}
public async Task GenesisWithEmptyParametersTimeShouldReject()
{
// Arrange
IServiceProvider testServiceProvider = TestSystem.BuildTestServiceProvider();
ChainConstants chainConstants = testServiceProvider.GetService <ChainConstants>();
IOptionsMonitor <MiscellaneousParameters> miscellaneousParameterOptions =
testServiceProvider.GetService <IOptionsMonitor <MiscellaneousParameters> >();
IOptionsMonitor <GweiValues> gweiValueOptions =
testServiceProvider.GetService <IOptionsMonitor <GweiValues> >();
IOptionsMonitor <InitialValues> initialValueOptions =
testServiceProvider.GetService <IOptionsMonitor <InitialValues> >();
IOptionsMonitor <TimeParameters> timeParameterOptions =
testServiceProvider.GetService <IOptionsMonitor <TimeParameters> >();
IOptionsMonitor <StateListLengths> stateListLengthOptions =
testServiceProvider.GetService <IOptionsMonitor <StateListLengths> >();
IOptionsMonitor <RewardsAndPenalties> rewardsAndPenaltiesOptions =
testServiceProvider.GetService <IOptionsMonitor <RewardsAndPenalties> >();
IOptionsMonitor <MaxOperationsPerBlock> maxOperationsPerBlockOptions =
testServiceProvider.GetService <IOptionsMonitor <MaxOperationsPerBlock> >();
IOptionsMonitor <ForkChoiceConfiguration> forkChoiceConfigurationOptions =
testServiceProvider.GetService <IOptionsMonitor <ForkChoiceConfiguration> >();
IOptionsMonitor <SignatureDomains> signatureDomainOptions =
testServiceProvider.GetService <IOptionsMonitor <SignatureDomains> >();
IOptionsMonitor <InMemoryConfiguration> inMemoryConfigurationOptions =
testServiceProvider.GetService <IOptionsMonitor <InMemoryConfiguration> >();
miscellaneousParameterOptions.CurrentValue.MinimumGenesisActiveValidatorCount = 2;
LoggerFactory loggerFactory = new LoggerFactory(new[]
{
new ConsoleLoggerProvider(Core2.Configuration.Static.OptionsMonitor <ConsoleLoggerOptions>())
});
ICryptographyService cryptographyService = testServiceProvider.GetService <ICryptographyService>();
IDepositStore depositStore = new DepositStore(cryptographyService, chainConstants);
BeaconChainUtility beaconChainUtility = new BeaconChainUtility(
loggerFactory.CreateLogger <BeaconChainUtility>(),
chainConstants, miscellaneousParameterOptions, initialValueOptions, gweiValueOptions,
timeParameterOptions,
cryptographyService);
BeaconStateAccessor beaconStateAccessor = new BeaconStateAccessor(chainConstants,
miscellaneousParameterOptions, timeParameterOptions, stateListLengthOptions, signatureDomainOptions,
cryptographyService, beaconChainUtility);
BeaconStateMutator beaconStateMutator = new BeaconStateMutator(chainConstants, timeParameterOptions,
stateListLengthOptions, rewardsAndPenaltiesOptions,
beaconChainUtility, beaconStateAccessor);
BeaconStateTransition beaconStateTransition = new BeaconStateTransition(
loggerFactory.CreateLogger <BeaconStateTransition>(),
chainConstants, gweiValueOptions, timeParameterOptions, stateListLengthOptions,
rewardsAndPenaltiesOptions, maxOperationsPerBlockOptions, signatureDomainOptions,
cryptographyService, beaconChainUtility, beaconStateAccessor, beaconStateMutator, depositStore);
SimpleLatestMessageDrivenGreedyHeaviestObservedSubtree simpleLmdGhost =
new SimpleLatestMessageDrivenGreedyHeaviestObservedSubtree(
loggerFactory.CreateLogger <SimpleLatestMessageDrivenGreedyHeaviestObservedSubtree>(),
chainConstants, beaconChainUtility, beaconStateAccessor);
MemoryStore store = new MemoryStore(loggerFactory.CreateLogger <MemoryStore>(), inMemoryConfigurationOptions,
new DataDirectory("data"), Substitute.For <IFileSystem>(), simpleLmdGhost, new StoreAccessor());
ForkChoice forkChoice = new ForkChoice(loggerFactory.CreateLogger <ForkChoice>(),
chainConstants, miscellaneousParameterOptions, timeParameterOptions, maxOperationsPerBlockOptions,
forkChoiceConfigurationOptions, signatureDomainOptions,
cryptographyService, beaconChainUtility, beaconStateAccessor, beaconStateTransition);
GenesisChainStart genesisChainStart = new GenesisChainStart(loggerFactory.CreateLogger <GenesisChainStart>(),
chainConstants, miscellaneousParameterOptions, gweiValueOptions, initialValueOptions,
timeParameterOptions, stateListLengthOptions,
cryptographyService, store, beaconStateAccessor, beaconStateTransition, forkChoice, depositStore);
// Act
Bytes32 eth1BlockHash = Bytes32.Zero;
ulong eth1Timestamp = 106185600uL; // 1973-05-14
bool success = await genesisChainStart.TryGenesisAsync(eth1BlockHash, eth1Timestamp);
// Assert
success.ShouldBeFalse();
}
public EmailService(IDataRepository <EmailMessage> dataRepository, IEmailAccountService emailAccountService, ICryptographyService cryptographyService) : base(dataRepository)
{
_emailAccountService = emailAccountService;
_cryptographyService = cryptographyService;
}
public CustomerMapper(ICryptographyService cryptographyService) : base(cryptographyService)
{
}
public Application(IConfiguration configuration, IOptions <GravatarsConfiguration> gravatarsConfiguration, ILogger <Application> logger, IGraphAPIService fbClient, IDownloadService downloadService, ICryptographyService cryptographyService, IGoogleAdminService googleAdminClient)
{
_logger = logger;
_fbClient = fbClient;
_configuration = configuration;
_downloadService = downloadService;
_cryptographyService = cryptographyService;
_gravatarsConfiguration = gravatarsConfiguration.Value;
_googleAdminClient = googleAdminClient;
}
