public ExternalAuthenticationGrant(
UserManager <TUser> userManager,
IProviderRepository providerRepository,
IFacebookAuthProvider facebookAuthProvider,
IGoogleAuthProvider googleAuthProvider,
ITwitterAuthProvider twitterAuthProvider,
ILinkedInAuthProvider linkeInAuthProvider,
INonEmailUserProcessor nonEmailUserProcessor,
IEmailUserProcessor emailUserProcessor
)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_providerRepository = providerRepository ?? throw new ArgumentNullException(nameof(providerRepository));
_facebookAuthProvider = facebookAuthProvider ?? throw new ArgumentNullException(nameof(facebookAuthProvider));
_googleAuthProvider = googleAuthProvider ?? throw new ArgumentNullException(nameof(googleAuthProvider));
_twitterAuthProvider = twitterAuthProvider ?? throw new ArgumentNullException(nameof(twitterAuthProvider));
_linkedAuthProvider = linkeInAuthProvider ?? throw new ArgumentNullException(nameof(linkeInAuthProvider));
_nonEmailUserProcessor = nonEmailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_emailUserProcessor = emailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_providers = new Dictionary <ProviderType, IExternalAuthProvider>
{
{ ProviderType.Facebook, _facebookAuthProvider },
{ ProviderType.Google, _googleAuthProvider },
{ ProviderType.Twitter, _twitterAuthProvider },
{ ProviderType.LinkedIn, _linkedAuthProvider }
};
}
public MessengerRepository(ILoggerService logger, FewaDbContext fewaDbContext, IHttpContextAccessor HttpContextAccessor, IProviderRepository providerRepository)
{
_logger = logger;
FewaDbContext = fewaDbContext;
accessor = HttpContextAccessor;
_providerRepository = providerRepository;
}
public DataService(IProviderRepository providerRepository, IBankAccountRepository accountRepository, IConfiguration configuration)
{
_configuration = configuration;
_providerRepository = providerRepository;
_accountRepository = accountRepository;
_client = new HttpClient();
}
public ExternalAuthenticationGrant(
UserManager <ApplicationUser> userManager,
IUnitOfWork <DatabaseContext> unitOfWork,
IExternalUserRepository externalUserRepository,
IProviderRepository providerRepository,
IFacebookAuthProvider facebookAuthProvider,
IGoogleAuthProvider googleAuthProvider,
ITwitterAuthProvider twitterAuthProvider,
ILinkedInAuthProvider linkeInAuthProvider,
INonEmailUserProcessor nonEmailUserProcessor,
IEmailUserProcessor emailUserProcessor
)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
_externalUserRepository = externalUserRepository ?? throw new ArgumentNullException(nameof(externalUserRepository));
_providerRepository = providerRepository ?? throw new ArgumentNullException(nameof(providerRepository));
_facebookAuthProvider = facebookAuthProvider ?? throw new ArgumentNullException(nameof(facebookAuthProvider));
_googleAuthProvider = googleAuthProvider ?? throw new ArgumentNullException(nameof(googleAuthProvider));
_twitterAuthProvider = twitterAuthProvider ?? throw new ArgumentNullException(nameof(twitterAuthProvider));
_linkedAuthProvider = linkeInAuthProvider ?? throw new ArgumentNullException(nameof(linkeInAuthProvider));
_nonEmailUserProcessor = nonEmailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_emailUserProcessor = emailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
providers = new Dictionary <ProviderType, IExternalAuthProvider>();
providers.Add(ProviderType.Facebook, _facebookAuthProvider);
providers.Add(ProviderType.Google, _googleAuthProvider);
providers.Add(ProviderType.Twitter, _twitterAuthProvider);
providers.Add(ProviderType.LinkedIn, _linkedAuthProvider);
}
public SystemController(IBankAccountRepository accountRepository, IProviderRepository providerRepository,
IInstitutionRepository institutionRepository)
{
_accountRepository = accountRepository;
_providerRepository = providerRepository;
_institutionRepository = institutionRepository;
}
public FacilityController(IFacilityRepository facilityRepository, IProviderRepository providerRepo, ILogger <FacilityController> logger)
{
_facilityRepository = facilityRepository ?? throw new ArgumentNullException(nameof(facilityRepository));
_providerRepo = providerRepo ?? throw new ArgumentException(nameof(providerRepo));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_logger.LogInformation($"Accessed FacilityController");
}
public MainViewModel(INavigationViewModel navigationViewModel,
IIndex <string, IDetailViewModel> detailViewModelCreator,
IEventAggregator eventAggregator,
IMessageDialogService messageDialogService,
IProviderRepository providerRepository)
{
_eventAggregator = eventAggregator;
_detailViewModelCreator = detailViewModelCreator;
_messageDialogService = messageDialogService;
_providerRepository = providerRepository;
DetailViewModels = new ObservableCollection <IDetailViewModel>();
_eventAggregator.GetEvent <OpenDetailViewEvent>()
.Subscribe(OnOpenDetailView);
_eventAggregator.GetEvent <AfterDetailDeletedEvent>()
.Subscribe(AfterDetailDeleted);
_eventAggregator.GetEvent <AfterDetailClosedEvent>()
.Subscribe(AfterDetailClosed);
CreateNewDetailCommand = new DelegateCommand <Type>(OnCreateNewDetailExecute);
OpenSingleDetailViewCommand = new DelegateCommand <Type>(OpenSingleDetailViewExecute);
ExportCommand = new DelegateCommand(OnExportExecute);
ImportCommand = new DelegateCommand(OnImportExecute);
AppExitCommand = new DelegateCommand(AppExitExecute);
NavigationViewModel = navigationViewModel;
}
public InMemoryApplicationCacheServiceTests()
{
_organizationRepository = Substitute.For <IOrganizationRepository>();
_providerRepository = Substitute.For <IProviderRepository>();
_sut = new InMemoryApplicationCacheService(_organizationRepository, _providerRepository);
}
public ProviderDocumentService(IProviderDocumentRepository repository, IProviderRepository providerRepository, Notification notification)
{
_repository = repository;
_storageService = new StorageService("schedule-core");
_providerRepository = providerRepository;
_notification = notification;
}
public ProviderDomainService(
IProviderValidation providerValidation,
IProviderRepository providerRepository)
{
this.providerValidation = providerValidation;
this.providerRepository = providerRepository;
}
// this is injecting the Interface in order for us to access the database
public CheckerClass(IPatientRepository patientRepo, IProviderRepository provRepo, IAppointmentRepository appointmentRepo)
{
//Making the local repository instance that we created equal to the overall repository that we are injecting so that its consistent.
_patientRepo = patientRepo;
_providerRepo = provRepo;
_appointmentRepo = appointmentRepo;
}
public IdamsSyncService(IIdamsEmailServiceWrapper idamsEmailServiceWrapper, IUserRepository userRepository, IProviderRepository providerRepository, ILog logger)
{
_idamsEmailServiceWrapper = idamsEmailServiceWrapper;
_userRepository = userRepository;
_providerRepository = providerRepository;
_logger = logger;
}
/// <summary>
/// Xunit Constructor
/// </summary>
/// <param name="IOfferRepository"></param>
/// <param name="IOfferAttributeRepository"></param>
/// <param name="IProviderRepository"></param>
/// <param name="IAttributeRepository"></param>
/// <param name="ILiveMatch"></param>
/// <param name="IRespondentCatalog"></param>
public OffersManager(
IOfferRepository IOfferRepository,
IOfferAttributeRepository IOfferAttributeRepository,
IProviderRepository IProviderRepository,
IAttributeRepository IAttributeRepository,
ILiveMatch ILiveMatch,
IRespondentCatalog IRespondentCatalog,
IQuotaExpressionRepository IQuotaExpressionRepository,
IQuotaMappingRepository IQuotaMappingRepository,
ISampleMappingRepository ISampleMappingRepository,
IGMIStudy IGMIStudy,
ISteamStudy ISteamStudy,
IQuotaLiveMatch IQuotaLiveMatch
)
{
//log = LoggerFactory.GetLogger("Xunit");
//detailedLog = LoggerFactory.GetLogger("Xunit");
this.xunit = true;
this.IOfferRepository = IOfferRepository;
this.IOfferAttributeRepository = IOfferAttributeRepository;
this.IProviderRepository = IProviderRepository;
this.IAttributeRepository = IAttributeRepository;
this.ILiveMatch = ILiveMatch;
this.IRespondentCatalog = IRespondentCatalog;
this.IQuotaExpressionRepository = IQuotaExpressionRepository;
this.IQuotaMappingRepository = IQuotaMappingRepository;
this.ISampleMappingRepository = ISampleMappingRepository;
this.IGMIStudy = IGMIStudy;
this.ISteamStudy = ISteamStudy;
this.IQuotaLiveMatch = IQuotaLiveMatch;
}
public ProviderService(IProviderRepository providerRepository, IOrganizationRepository organizationRepository, IGroupRepository groupRepository, IOptions <ConfigurationKeys> configurationKeys)
{
_providerRepository = providerRepository;
_organizationRepository = organizationRepository;
_groupRepository = groupRepository;
_configurationKeys = configurationKeys;
}
public OffersManager initOffersManager(
IOfferRepository IOfferRepository,
IOfferAttributeRepository IOfferAttributeRepository,
IProviderRepository IProviderRepository,
IAttributeRepository IAttributeRepository,
ILiveMatch ILiveMatch,
IRespondentCatalog IRespondentCatalog,
IQuotaExpressionRepository IQuotaExpressionRepository,
IQuotaMappingRepository IQuotaMappingRepository,
ISampleMappingRepository ISampleMappingRepository,
IGMIStudy IGMIStudy,
ISteamStudy ISteamStudy,
IQuotaLiveMatch IQuotaLiveMatch
)
{
OffersManager OffersManager = new OffersManager(
IOfferRepository,
IOfferAttributeRepository,
IProviderRepository,
IAttributeRepository,
ILiveMatch,
IRespondentCatalog,
IQuotaExpressionRepository,
IQuotaMappingRepository,
ISampleMappingRepository,
IGMIStudy,
ISteamStudy,
IQuotaLiveMatch);
return OffersManager;
}
static void Init(CommandLineOptions options)
{
_httpSpiExecutionContextManager = new HttpSpiExecutionContextManager();
_httpSpiExecutionContextManager.SetInternalRequestId(Guid.NewGuid());
_providerRepository = new TableProviderRepository(
new CacheConfiguration
{
TableStorageConnectionString = options.TableStorageConnectionString,
ProviderTableName = options.ProviderTableName,
},
_logger);
var translator = new TranslatorApiClient(
new AuthenticationConfiguration()
{
ClientId = options.ClientId,
ClientSecret = options.ClientSecret,
Resource = options.Resource,
TokenEndpoint = options.TokenEndpoint,
},
new RestClient(),
new CacheProvider(),
new TranslatorConfiguration
{
BaseUrl = options.TranslatorBaseUrl,
SubscriptionKey = options.TranslatorSubscriptionKey,
},
_logger,
_httpSpiExecutionContextManager);
_mapper = new PocoMapper(translator);
}
public ProviderAuthenticationHandler(IProviderRepository IProviderRepository, IPmp IPmp, ICSSProviders ICSSProviders)
{
this.xunit = true;
this.IProviderRepository = IProviderRepository;
this.IPmp = IPmp;
this.ICSSProviders = ICSSProviders;
}
public ProviderCourseImportService(
ICourseDirectoryService courseDirectoryService,
IProviderImportRepository providerImportRepository,
IProviderStandardImportRepository providerStandardImportRepository,
IProviderStandardLocationImportRepository providerStandardLocationImportRepository,
IStandardLocationImportRepository standardLocationImportRepository,
IProviderRepository providerRepository,
IProviderStandardRepository providerStandardRepository,
IProviderStandardLocationRepository providerStandardLocationRepository,
IStandardLocationRepository standardLocationRepository,
IImportAuditRepository importAuditRepository,
ILogger <ProviderCourseImportService> logger)
{
_courseDirectoryService = courseDirectoryService;
_providerImportRepository = providerImportRepository;
_providerStandardImportRepository = providerStandardImportRepository;
_providerStandardLocationImportRepository = providerStandardLocationImportRepository;
_standardLocationImportRepository = standardLocationImportRepository;
_providerRepository = providerRepository;
_providerStandardRepository = providerStandardRepository;
_providerStandardLocationRepository = providerStandardLocationRepository;
_standardLocationRepository = standardLocationRepository;
_importAuditRepository = importAuditRepository;
_logger = logger;
}
public void SetUp()
{
_liveSetting = new LiveSetting(_database.DatabasePath);
_userRepository = new UserRepository(_liveSetting);
_providerRepository = new ProviderRepository(_liveSetting);
_authService = new AuthService(_userRepository, _providerRepository, new PracticeRepository(_liveSetting), new DeviceRepository(_liveSetting), new UserSummaryRepository(_liveSetting));
}
public PracticeController(
ILogger <PracticeController> logger,
List <ProviderCabin> providerCabins,
WaitingRoom waitingroom,
IConfiguration configuration,
List <Provider> providers,
IHubContext <NotificationHub,
INotificationHub> notify,
IConfiguration config,
IPatientRepository patientRepository,
IProviderRepository providerRepository,
IWebHostEnvironment hostEnvironment,
FewaDbContext fewaDbContext,
IHttpContextAccessor HttpContextAccessor)
{
FewaDbContext = fewaDbContext;
_patientRepository = patientRepository;
_providers = providers;
Configuration = configuration;
_logger = logger;
_providerCabins = providerCabins;
_waitingroom = waitingroom;
_providerRepository = providerRepository;
idletime = Convert.ToInt32(configuration["IdleTime"]);
_notify = notify;
_config = config;
accessor = HttpContextAccessor;
_hostingEnvironment = hostEnvironment;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (productService != null)
{
productService.Dispose();
productService = null;
}
if (providerRepository != null)
{
providerRepository.Dispose();
providerRepository = null;
}
if (packagingRepository != null)
{
packagingRepository.Dispose();
packagingRepository = null;
}
if (currencyTypeRepository != null)
{
currencyTypeRepository.Dispose();
currencyTypeRepository = null;
}
if (productDocumentService != null)
{
productDocumentService.Dispose();
productDocumentService = null;
}
}
base.Dispose(disposing);
}
public FacebookAuthProvider(
IProviderRepository providerRepository,
HttpClient httpClient)
{
_providerRepository = providerRepository;
_httpClient = httpClient;
}
public ProviderValidation(
IEnumerable <PaymentProvider> paymentProviders,
IProviderRepository providerRepository)
{
this.paymentProviders = paymentProviders;
this.providerRepository = providerRepository;
}
public ProviderService(IProviderRepository providerRepository,
IAddressRepository addressRepository,
INotifier notifier) : base(notifier)
{
_providerRepository = providerRepository;
_addressRepository = addressRepository;
}
public ProviderService(IMapper mapper, IRequestData requestData, IProviderRepository providerRepository, IAttachmentRepository attachmentRepository, IStorageService storageService)
: base(mapper, requestData)
{
this.providerRepository = providerRepository;
this.attachmentRepository = attachmentRepository;
this.storageService = storageService;
}
/// <summary>
/// Create a new <see cref="SeasonRepository"/>.
/// </summary>
/// <param name="database">The database handle that will be used</param>
/// <param name="providers">A provider repository</param>
public SeasonRepository(DatabaseContext database,
IProviderRepository providers)
: base(database)
{
_database = database;
_providers = providers;
}
public ProjectProviderDataController(Orchestrator orchestrator, IProjectRepository projectsRepository, IProviderRepository providersRepository, IProviderDataRepository providerDataRepository)
{
this.orchestrator = orchestrator ?? throw new ArgumentNullException(nameof(orchestrator));
this.projectsRepository = projectsRepository ?? throw new ArgumentNullException(nameof(projectsRepository));
this.providersRepository = providersRepository ?? throw new ArgumentNullException(nameof(providersRepository));
this.providerDataRepository = providerDataRepository ?? throw new ArgumentNullException(nameof(providerDataRepository));
}
public ProviderService(IProviderRepository providerRepository, IProviderTagRepository providerTagRepository, ITagRepository tagRepository, IUnitOfWork unitOfWork)
{
this._providerRepository = providerRepository;
this._providerTagRepository = providerTagRepository;
this._tagRepository = tagRepository;
this._unitOfWork = unitOfWork;
}
public ProvidersController()
{
Context = AppService.Current.DataContextV2;
ProviderRepository = new ProviderRepository();
ProviderService = new ProviderService();
HoursRepository = new HoursRepo();
}
public When_ProviderQuarterlyUpdateEmailService_Is_Called_To_Send_Provider_Quarterly_Update_Emails_And_Status_Is_Processing(ProviderQuarterlyUpdateEmailFixture testFixture)
{
_emailService = Substitute.For <IEmailService>();
var messageQueueService = Substitute.For <IMessageQueueService>();
_providerRepository = Substitute.For <IProviderRepository>();
_providerRepository
.GetProvidersWithFundingAsync()
.Returns(new ValidProviderWithFundingDtoListBuilder().Build());
var backgroundProcessHistory = new BackgroundProcessHistoryBuilder().Build();
backgroundProcessHistory.Status = BackgroundProcessHistoryStatus.Processing.ToString();
_backgroundProcessHistoryRepository = Substitute.For <IRepository <BackgroundProcessHistory> >();
_backgroundProcessHistoryRepository
.GetSingleOrDefaultAsync(Arg.Any <Expression <Func <BackgroundProcessHistory, bool> > >())
.Returns(backgroundProcessHistory);
var providerQuarterlyUpdateEmailService = new Application.Services.ProviderQuarterlyUpdateEmailService(
testFixture.Logger,
_emailService,
_providerRepository, _backgroundProcessHistoryRepository,
messageQueueService, testFixture.DateTimeProvider);
_result = providerQuarterlyUpdateEmailService
.SendProviderQuarterlyUpdateEmailsAsync(1, "TestUser")
.GetAwaiter().GetResult();
}
public HomeController(IProviderRepository providerRepository,
ISearchRepository searchRepository, IMapper mapper)
{
_providerRepository = providerRepository;
_searchRepository = searchRepository;
_mapper = mapper;
}
public ProviderService(IProviderRepository providerRepository, IConsumerNotifier consumerNotifier,
ILogManager logManager)
{
_providerRepository = providerRepository;
_consumerNotifier = consumerNotifier;
_logger = logManager.GetClassLogger();
}
public ProviderService(
IProviderRepository providerRepository,
IMapper mapper)
: base(mapper)
{
_providerRepository = providerRepository;
}
public HttpResponseMessage initProviderAuthenticationHandler(IProviderRepository IProviderRepository, IPmp IPmp, ICSSProviders ICSSProviders, string ResponseFormat = null, string Authorization = null)
{
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/public");
var requestContext = new HttpRequestContext();
requestContext.Url = new System.Web.Http.Routing.UrlHelper();
requestContext.Url.Request = httpRequestMessage;
if (ResponseFormat != null)
requestContext.Url.Request.Headers.Add("Accept", "Application/Xml");
httpRequestMessage.Properties[HttpPropertyKeys.RequestContextKey] = requestContext;
httpRequestMessage.Properties.Add("requestId", new Guid());
if (Authorization != null)
httpRequestMessage.Headers.Add("Authorization", Authorization);
var handler = new ProviderAuthenticationHandler(IProviderRepository, IPmp, ICSSProviders)
{
InnerHandler = new ProviderAuthenticationHandler(IProviderRepository, IPmp, ICSSProviders)
};
var client = new HttpClient(handler);
return client.SendAsync(httpRequestMessage).Result;
}
public ProviderService(IProviderRepository providerRepository, IProfileService profileServce)
{
_providerRepository = providerRepository;
_profileServce = profileServce;
}
