Summary description for ServiceProvider
Beispiel #1
0
        public override void SetUp()
        {
            base.SetUp();

            var serviceProvider = new ServiceProvider();
            myWebScrapSC = serviceProvider.Browser();
        }
        /// <summary>
        /// Initializes a new instance of the ScriptSynthesizer class.
        /// </summary>
        /// <param name="serviceProvider">Service provider.</param>
        /// <param name="commonConfig">Common config of script synthesizer.</param>
        /// <param name="scriptFeatureImportConfig">Config of script feature import.</param>
        /// <param name="customizedFeaturePluginManager">Plugin manager of customized feature extraction.</param>
        public ScriptSynthesizer(ServiceProvider serviceProvider,
            ScriptSynthesizerCommonConfig commonConfig,
            ScriptFeatureImportConfig scriptFeatureImportConfig,
            CustomizedFeaturePluginManager customizedFeaturePluginManager)
        {
            if (serviceProvider == null)
            {
                throw new ArgumentNullException("serviceProvider");
            }

            // commonConfig can be null.
            // scriptFeatureImportConfig can be null.
            // customizedFeaturePluginManager can be null.
            _serviceProvider = serviceProvider;

            _scriptFeatureImportConfig = scriptFeatureImportConfig;

            if (commonConfig != null)
            {
                _logger = new TextLogger(commonConfig.TraceLogFile);
                _logger.Reset();
            }

            if (_scriptFeatureImportConfig != null)
            {
                _scriptFeatureImport = new ScriptFeatureImport(commonConfig,
                    _scriptFeatureImportConfig, _serviceProvider, _logger);
            }

            if (customizedFeaturePluginManager != null)
            {
                _customizedFeatureExtraction = new CustomizedFeatureExtraction(_serviceProvider,
                    customizedFeaturePluginManager);
            }
        }
        /// <summary>
        /// Initializes a new instance of the MixedVoiceSynthesizer class.
        /// </summary>
        /// <param name="donator">Service provider the donator.</param>
        /// <param name="receiver">Service provider the receiver.</param>
        /// <param name="config">Config object.</param>
        public MixedVoiceSynthesizer(ServiceProvider donator, ServiceProvider receiver,
            MixedVoiceSynthesizerConfig config)
        {
            if (donator == null)
            {
                throw new ArgumentNullException("donator");
            }

            if (receiver == null)
            {
                throw new ArgumentNullException("receiver");
            }

            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _donator = donator;
            _receiver = receiver;

            _config = config;

            _donator.Engine.AcousticProsodyTagger.Processed +=
                new EventHandler<TtsModuleEventArgs>(OnDonatorAcousticProcessed);

            _receiver.Engine.AcousticProsodyTagger.Processed +=
                new EventHandler<TtsModuleEventArgs>(OnReceiverAcousticProcessed);

            if (!string.IsNullOrEmpty(config.LogFile))
            {
                _logger = new TextLogger(config.LogFile);
                _logger.Reset();
            }
        }
Beispiel #4
0
        /*******************************************************************************/
        /*                                                                             */
        /*                            Конструктор                                      */
        public DMCC_service()
        {
            mPhones   = new DMCC_phone[mPHONES_MAX];

               mService  =null ;
               mConnected=false ;
        }
Beispiel #5
0
    public ServiceProvider[] ServiceProviders(string version)
    {

        ServiceProvider[] listServiceProviders = new ServiceProvider[1];

        ServiceProvider nikotelServiceProvider = new ServiceProvider();


        nikotelServiceProvider.Name = "nikotel - the voip network";
        nikotelServiceProvider.Description = "Visit www.nikotel.com";

        nikotelServiceProvider.IMServerAddress = "im.nikotel.com";
        nikotelServiceProvider.IMServerPort = 5222;

        nikotelServiceProvider.SIPProxyRealm = "nikotel.com";
        nikotelServiceProvider.SIPProxyAddress = "voip.nikotel.com";
        nikotelServiceProvider.SIPProxyPort = 5060;
        
        nikotelServiceProvider.VideoProxyAddress = "video.nikotel.com";
        nikotelServiceProvider.VideoProxyPort = 800;

        nikotelServiceProvider.SignupLink = "https://www.nikotel.com/nikotel-signup/nikotalk/register";

        listServiceProviders[0] = nikotelServiceProvider;

        return listServiceProviders;

    }
        public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
        {
            ConstructorInfo[] constructors = _descriptor.ImplementationType.GetTypeInfo()
                .DeclaredConstructors
                .Where(IsInjectable)
                .ToArray();

            // TODO: actual service-fulfillment constructor selection
            if (constructors.Length == 1)
            {
                ParameterInfo[] parameters = constructors[0].GetParameters();
                IServiceCallSite[] parameterCallSites = new IServiceCallSite[parameters.Length];
                for (var index = 0; index != parameters.Length; ++index)
                {
                    parameterCallSites[index] = provider.GetServiceCallSite(parameters[index].ParameterType, callSiteChain);

                    if (parameterCallSites[index] == null && parameters[index].HasDefaultValue)
                    {
                        parameterCallSites[index] = new ConstantCallSite(parameters[index].DefaultValue);
                    }
                    if (parameterCallSites[index] == null)
                    {
                        throw new InvalidOperationException(Resources.FormatCannotResolveService(
                                parameters[index].ParameterType,
                                _descriptor.ImplementationType));
                    }
                }
                return new ConstructorCallSite(constructors[0], parameterCallSites);
            }

            return new CreateInstanceCallSite(_descriptor);
        }
Beispiel #7
0
    protected void allowAccessButton_Click(object sender, EventArgs e)
    {
        if (this.AuthorizationSecret != OAuthAuthorizationSecToken.Value) {
            throw new ArgumentException(); // probably someone trying to hack in.
        }
        this.AuthorizationSecret = null; // clear one time use secret
        var pending = Global.PendingOAuthAuthorization;
        Global.AuthorizePendingRequestToken();
        multiView.ActiveViewIndex = 1;

        ServiceProvider sp = new ServiceProvider(Constants.SelfDescription, Global.TokenManager);
        var response = sp.PrepareAuthorizationResponse(pending);
        if (response != null) {
            sp.Channel.Send(response);
        } else {
            if (pending.IsUnsafeRequest) {
                verifierMultiView.ActiveViewIndex = 1;
            } else {
                string verifier = ServiceProvider.CreateVerificationCode(VerificationCodeFormat.AlphaNumericNoLookAlikes, 10);
                verificationCodeLabel.Text = verifier;
                ITokenContainingMessage requestTokenMessage = pending;
                var requestToken = Global.TokenManager.GetRequestToken(requestTokenMessage.Token);
                requestToken.VerificationCode = verifier;
                Global.TokenManager.UpdateToken(requestToken);
            }
        }
    }
        /// <summary>
        /// Initializes a new instance of the CustomizedFeatureExtraction class.
        /// </summary>
        /// <param name="serviceProvider">Service provider.</param>
        /// <param name="customizedFeaturePluginManager">Plugin manager.</param>
        public CustomizedFeatureExtraction(ServiceProvider serviceProvider,
            CustomizedFeaturePluginManager customizedFeaturePluginManager)
        {
            if (serviceProvider == null)
            {
                throw new ArgumentNullException("serviceProvider");
            }

            if (customizedFeaturePluginManager == null)
            {
                throw new ArgumentNullException("customizedFeaturePluginManager");
            }

            _customizedFeaturePluginManager = customizedFeaturePluginManager;

            List<PluginInfo> pluginInfos = _customizedFeaturePluginManager.GetPlugins(
                CustomizedFeaturePluginManager.AttachBeforeExtraction);
            if (pluginInfos != null)
            {
                _utteranceExtenders = UtteranceExtenderFinder.LoadUtteranceExtenders(pluginInfos);
            }

            _serviceProvider = serviceProvider;

            _serviceProvider.Engine.AcousticProsodyTagger.Processing += new EventHandler<TtsModuleEventArgs>(OnAcousticProcessing);
        }
Beispiel #9
0
 public void TestServiceCreatorCallback()
 {
   ServiceProvider provider = new ServiceProvider();
   provider.Add<ILog>(new ServiceCreatorCallback<ILog>(ServiceRequested));
   ILog log = provider.Get<ILog>();
   Assert.IsNotNull(log);
 }
Beispiel #10
0
        protected internal SignInPage(PhoneApplicationPage page)
            : base(page)
        {
            SignIn = new SimpleActionCommand(_ => SelectServiceProvider.Execute(ClientData.VidyanoServiceProvider));
            RetryConnect = new SimpleActionCommand(async _ =>
            {
                if (State == SignInPageState.NoInternet)
                    await Connect();
            });
            SelectServiceProvider = new SimpleActionCommand(provider =>
            {
                selectedProvider = (ServiceProvider)provider;
                promptServiceProviderWaiter.Set();
            });

            Page.BackKeyPress += (_, e) =>
            {
                promptServiceProviderWaiter.Set();
                if (oauthBrowserWaiter != null)
                    oauthBrowserWaiter.Set();

                if (ClientData != null && !String.IsNullOrEmpty(ClientData.DefaultUserName))
                    e.Cancel = true;
            };
        }
Beispiel #11
0
 public void TestAddDuplicateService2()
 {
   ServiceProvider provider = new ServiceProvider();
   provider.Add<ILog>(new ServiceCreatorCallback<ILog>(ServiceRequested));
   ILog log1 = new NoLog();
   provider.Add<ILog>(log1);
 }
Beispiel #12
0
        public string GetAllResultsAsJSON(ServiceProvider serviceProvider, string apiKey, string apiPwd)
        {
            if (serviceProvider == ServiceProvider.CoulombChargePoint)
            {
                //Coulomb notes: logdata.endTime field in Reference.cs autocreated as DateTime but needs to be serialized as string as value is often 24:00, change property type to string
                OCM.Import.NetworkServices.ThirdPartyServices.Coulomb.coulombservicesClient svc = new Import.NetworkServices.ThirdPartyServices.Coulomb.coulombservicesClient();
                svc.ClientCredentials.UserName.UserName = apiKey;
                svc.ClientCredentials.UserName.Password = apiPwd;

                string output = "";
                OCM.Import.NetworkServices.ThirdPartyServices.Coulomb.logdata[] stationData = { new OCM.Import.NetworkServices.ThirdPartyServices.Coulomb.logdata() { } };
                string result = svc.getAllUSStations(new OCM.Import.NetworkServices.ThirdPartyServices.Coulomb.stationSearchRequest()
                {
                   // Geo = new Import.NetworkServices.ThirdPartyServices.Coulomb.stationSearchRequestGeo { lat = "38.5846", @long = "-121.4961" },
                    Country = "USA",
                    Proximity = 50000,
                    postalCode = "95816"
                },
                out output, out stationData);

                JavaScriptSerializer js = new JavaScriptSerializer();
                js.MaxJsonLength = 10000000;
                string outputJS = js.Serialize(stationData);
                System.Diagnostics.Debug.WriteLine("<json>"+outputJS+"</json>");
                return outputJS;
            }
            return null;
        }
        public PropertiesEditorLauncher(ServiceProvider serviceProvider)
        {
            if (serviceProvider == null)
                throw new ArgumentNullException("serviceProvider");

            this.serviceProvider = serviceProvider;
        }
Beispiel #14
0
 public void TestAddDuplicateService1()
 {
   ServiceProvider provider = new ServiceProvider();
   ILog log1 = new NoLog();
   ILog log2 = new NoLog();
   provider.Add<ILog>(log1);
   provider.Add<ILog>(log2);
 }
Beispiel #15
0
        static Engine()
        {
            Status = EngineStatus.Stopped;

            // The service provider is always there so that
            // it can be mocked during unit tests.
            ServiceProvider = new ServiceProvider();
        }
 public void doWork()
 {
     ServiceProvider service;
     if((provider == null) || !provider.TryGetTarget(out service)){
         service = new ServiceProvider();
         provider = new WeakReference<ServiceProvider>(service); // !!!!! podem evitar instanciar uma nova WeakReference fazendo o SetTarget(T)
     }
     service.doWork();
 }
 public IServiceCallSite CreateCallSite(ServiceProvider provider, ISet<Type> callSiteChain)
 {
     var list = new List<IServiceCallSite>();
     for (var service = _serviceEntry.First; service != null; service = service.Next)
     {
         list.Add(provider.GetResolveCallSite(service, callSiteChain));
     }
     return new CallSite(_itemType, list.ToArray());
 }
 public object Invoke(ServiceProvider provider)
 {
     var array = Array.CreateInstance(_itemType, _serviceCallSites.Length);
     for (var index = 0; index < _serviceCallSites.Length; index++)
     {
         array.SetValue(_serviceCallSites[index].Invoke(provider), index);
     }
     return array;
 }
        public void Setup()
        {
            serviceProvider = new ServiceProvider();

            if (serviceProvider.ServiceExist(TEMP_SERVICE_NAME))
            {
                serviceProvider.UnInstall(TEMP_SERVICE_NAME);
            }
        }
Beispiel #20
0
 public AdalClient(
     AppConfig appConfig, 
     CredentialType credentialType, 
     IServiceInfoProvider serviceProvider = null)
     : base(appConfig, credentialType, serviceProvider)
 {
     appConfig.ServiceResource = Constants.Authentication.GraphServiceUrl;
     serviceProvider = new ServiceProvider();
     this.ServiceInformation = _serviceInfoProvider.CreateServiceInfo(appConfig, credentialType).Result;
 }
Beispiel #21
0
        private static IDocumentBrowser CreateEnhancedDocumentBrowser( ServiceProvider serviceProvider )
        {
            var navigator = new CachingNavigator(
                new Navigator(),
                new DocumentCache() );

            var browser = new DocumentBrowser( navigator );

            return browser;
        }
Beispiel #22
0
        public override void TearDown()
        {
            Interpreter.Context.TomScripting.Dispose();
            myServiceProvider.Reset();

            myInterpreter = null;
            myServiceProvider = null;
            myDataAccess = null;

            base.TearDown();
        }
Beispiel #23
0
 public object Create(ServiceProvider provider)
 {
     if (_descriptor.ImplementationInstance != null)
     {
         return _descriptor.ImplementationInstance;
     }
     else
     {
         return ActivatorUtilities.CreateInstance(provider, _descriptor.ImplementationType);
     }
 }
Beispiel #24
0
 /// <include file='doc\CodeWindowManager.uex' path='docs/doc[@for="DocumentProperties.DocumentProperties"]/*' />
 protected DocumentProperties(CodeWindowManager mgr) {
     this.mgr = mgr;
     this.visible = true;
     if (mgr != null) {
         IOleServiceProvider sp = mgr.CodeWindow as IOleServiceProvider;
         if (sp != null) {
             ServiceProvider site = new ServiceProvider(sp);
             this.tracker = site.GetService(typeof(SVsTrackSelectionEx)) as IVsTrackSelectionEx;
         }
     }
 }
Beispiel #25
0
        private static IDocumentBrowser CreateLegacyDocumentBrowser( ServiceProvider serviceProvider )
        {
            var browser = new LegacyDocumentBrowser();
            browser.Init( serviceProvider );

            browser.DownloadController.Options = BrowserOptions.NoActiveXDownload |
                BrowserOptions.NoBehaviors | BrowserOptions.NoJava | BrowserOptions.NoScripts |
                BrowserOptions.Utf8;

            return browser;
        }
 public object Create(ServiceProvider provider)
 {
     var list = new List<object>();
     for (var service = _serviceEntry.First; service != null; service = service.Next)
     {
         list.Add(provider.ResolveService(service));
     }
     var array = Array.CreateInstance(_itemType, list.Count);
     Array.Copy(list.ToArray(), array, list.Count);
     return array;
 }
Beispiel #27
0
        protected SelectionListener(ServiceProvider serviceProvider)
        {
            this.serviceProvider = serviceProvider;
            this.monSel = serviceProvider.GetService(typeof(SVsShellMonitorSelection)) as IVsMonitorSelection;

            Debug.Assert(this.monSel != null, "Could not get the IVsMonitorSelection object from the services exposed by this project");

            if (this.monSel == null)
            {
                throw new InvalidOperationException();
            }
        }
        protected ProjectDocumentsListener(ServiceProvider serviceProvider)
        {
            this.serviceProvider = serviceProvider;
            this.projectDocTracker = serviceProvider.GetService(typeof(SVsTrackProjectDocuments)) as IVsTrackProjectDocuments2;

            Debug.Assert(this.projectDocTracker != null, "Could not get the IVsTrackProjectDocuments2 object from the services exposed by this project");

            if (this.projectDocTracker == null)
            {
                throw new InvalidOperationException();
            }
        }
 public ServiceChannel[] GetChannels()
 {
     List<ServiceChannel> list = new List<ServiceChannel>();
     foreach (var type in Builder.EntityTypes)
     {
         Type instance = typeof(CacheEntityQueryable<>).MakeGenericType(new Type[] { type });
         Type contract = typeof(ICacheEntityQueryable<>).MakeGenericType(new Type[] { type });
         ServiceProvider provider = new ServiceProvider(instance, contract);
         ServiceChannel channel = new ServiceChannel("Comboost_EntityChannel_" + type.Name, provider, DataFormatter);
         list.Add(channel);
     }
     return list.ToArray();
 }
        public void CreateCallSite_CreatesInstanceCallSite_IfTypeHasDefaultOrPublicParameterlessConstructor(Type type)
        {
            // Arrange
            var descriptor = new ServiceDescriptor(type, type, ServiceLifetime.Transient);
            var service = new Service(descriptor);
            var serviceProvider = new ServiceProvider(new[] { descriptor });

            // Act
            var callSite = service.CreateCallSite(serviceProvider, new HashSet<Type>());

            // Assert
            Assert.IsType<CreateInstanceCallSite>(callSite);
        }
 public virtual int SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp)
 {
     _serviceProvider = new ServiceProvider(psp);
     return(VSConstants.S_OK);
 }
Beispiel #32
0
        public static int Main(string[] args)
        {
            RegisterBlipTypes();
            if (ServiceProvider == null)
            {
                ServiceProvider = GetServiceProvider();
            }

            return(CLI.HandleErrors(() =>
            {
                var app = CLI.Parser();

                app.ExecutableName(typeof(Program).GetTypeInfo().Assembly.GetName().Name);
                app.FromAssembly(typeof(Program).GetTypeInfo().Assembly);
                app.HelpText("BLiP Command Line Interface");

                _verbose = app.Switch("v").Alias("verbose").HelpText("Enable verbose output.");
                _force = app.Switch("force").HelpText("Enable force operation.");

                var pingHandler = new PingHandler();
                var pingCommand = app.Command("ping");
                pingHandler.Node = pingCommand.Parameter <string>("n").Alias("node").HelpText("Node to ping");
                pingCommand.HelpText("Ping a specific bot (node)");
                pingCommand.Handler(pingHandler.Run);

                var nlpImportHandler = new NLPImportHandler();
                var nlpImportCommand = app.Command("nlp-import");
                nlpImportHandler.Node = nlpImportCommand.Parameter <string>("n").Alias("node").HelpText("Node to receive the data");
                nlpImportHandler.Authorization = nlpImportCommand.Parameter <string>("a").Alias("authorization").HelpText("Node Authorization to receive the data");
                nlpImportHandler.EntitiesFilePath = nlpImportCommand.Parameter <string>("ep").Alias("entities").HelpText("Path to entities file in CSV format");
                nlpImportHandler.IntentsFilePath = nlpImportCommand.Parameter <string>("ip").Alias("intents").HelpText("Path to intents file in CSV format");
                nlpImportHandler.AnswersFilePath = nlpImportCommand.Parameter <string>("ap").Alias("answers").HelpText("Path to answers file in CSV format");
                nlpImportCommand.HelpText("Import intents and entities to a specific bot (node)");
                nlpImportCommand.Handler(nlpImportHandler.Run);

                var copyHandler = ServiceProvider.GetService <CopyHandler>();
                var copyCommand = app.Command("copy");
                copyHandler.From = copyCommand.Parameter <string>("f").Alias("from").HelpText("Node (bot) source.");
                copyHandler.To = copyCommand.Parameter <string>("t").Alias("to").HelpText("Node (bot) target");
                copyHandler.FromAuthorization = copyCommand.Parameter <string>("fa").Alias("fromAuthorization").HelpText("Authorization key of source bot");
                copyHandler.ToAuthorization = copyCommand.Parameter <string>("ta").Alias("toAuthorization").HelpText("Authorization key of target bot");
                copyHandler.Contents = copyCommand.Parameter <List <BucketNamespace> >("c").Alias("contents").HelpText($"Define which contents will be copied. Examples: '{copyHandler.GetTypesListAsString<BucketNamespace>()}'").ParseUsing(copyHandler.CustomNamespaceParser);
                copyHandler.Verbose = _verbose;
                copyHandler.Force = _force;
                copyCommand.HelpText("Copy data from source bot (node) to target bot (node)");
                copyCommand.Handler(copyHandler.Run);

                var saveNodeHandler = new SaveNodeHandler();
                var saveNodeCommand = app.Command("saveNode");
                saveNodeHandler.Node = saveNodeCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) to be saved");
                saveNodeHandler.AccessKey = saveNodeCommand.Parameter <string>("k").Alias("accessKey").HelpText("Node accessKey");
                saveNodeHandler.Authorization = saveNodeCommand.Parameter <string>("a").Alias("authorization").HelpText("Node authoriaztion header");
                saveNodeCommand.HelpText("Save a node (bot) to be used next");
                saveNodeCommand.Handler(saveNodeHandler.Run);

                var formatKeyHandler = new FormatKeyHandler();
                var formatKeyCommand = app.Command("formatKey").Alias("fk");
                formatKeyHandler.Identifier = formatKeyCommand.Parameter <string>("i").Alias("identifier").HelpText("Bot identifier").Required();
                formatKeyHandler.AccessKey = formatKeyCommand.Parameter <string>("k").Alias("accessKey").HelpText("Bot accessKey");
                formatKeyHandler.Authorization = formatKeyCommand.Parameter <string>("a").Alias("authorization").HelpText("Bot authoriaztion header");
                formatKeyCommand.HelpText("Show all valid keys for a bot");
                formatKeyCommand.Handler(formatKeyHandler.Run);

                var nlpAnalyseHandler = ServiceProvider.GetService <NLPAnalyseHandler>();
                var nlpAnalyseCommand = app.Command("nlp-analyse").Alias("analyse");
                nlpAnalyseHandler.Input = nlpAnalyseCommand.Parameter <string>("i").Alias("input").HelpText("Input to be analysed. Works with a single phrase or with a text file (new line separator).");
                nlpAnalyseHandler.Authorization = nlpAnalyseCommand.Parameter <string>("a").Alias("authorization").HelpText("Bot authorization key");
                nlpAnalyseHandler.ReportOutput = nlpAnalyseCommand.Parameter <string>("o").Alias("report").Alias("output").HelpText("Report's file fullname (path + name)");
                nlpAnalyseHandler.Force = _force;
                nlpAnalyseHandler.Verbose = _verbose;
                nlpAnalyseCommand.HelpText("Analyse some text or file using a bot IA model");
                nlpAnalyseCommand.Handler(nlpAnalyseHandler.Run);

                var exportHandler = ServiceProvider.GetService <ExportHandler>();
                var exportCommand = app.Command("export").Alias("get");
                exportHandler.Node = exportCommand.Parameter <string>("n").Alias("node").HelpText("Node (bot) source");
                exportHandler.Authorization = exportCommand.Parameter <string>("a").Alias("authorization").HelpText("Authorization key of source bot");
                exportHandler.OutputFilePath = exportCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path. Please use a full path.");
                exportHandler.Model = exportCommand.Parameter <ExportModel>("m").Alias("model").HelpText($"Model to be exported. Examples: \'{exportHandler.GetTypesListAsString<ExportModel>()}\'").ParseUsing(exportHandler.CustomParser);
                exportHandler.Verbose = _verbose;
                exportHandler.Excel = exportCommand.Parameter <string>("x").Alias("excel").HelpText("Export content in a excel file. Please specify the file name (without extension)");
                exportCommand.HelpText("Export some BLiP model");
                exportCommand.Handler(exportHandler.Run);

                var compareHandler = ServiceProvider.GetService <NLPCompareHandler>();
                var compareCommand = app.Command("comp").Alias("compare");
                compareHandler.Authorization1 = compareCommand.Parameter <string>("a1").Alias("authorization1").Alias("first").HelpText("Authorization key of first bot");
                compareHandler.Bot1Path = compareCommand.Parameter <string>("p1").Alias("path1").Alias("firstpath").HelpText("Path of first bot containing exported model");
                compareHandler.Authorization2 = compareCommand.Parameter <string>("a2").Alias("authorization2").Alias("second").HelpText("Authorization key of second bot");
                compareHandler.Bot2Path = compareCommand.Parameter <string>("p2").Alias("path2").Alias("secondpath").HelpText("Path of second bot containing exported model");
                compareHandler.OutputFilePath = compareCommand.Parameter <string>("o").Alias("output").Alias("path").HelpText("Output file path");
                compareHandler.Method = compareCommand.Parameter <ComparisonMethod>("m").Alias("method").HelpText("Comparison method (exact, levenshtein)").ParseUsing(compareHandler.CustomMethodParser);
                compareHandler.Verbose = _verbose;
                compareCommand.HelpText("Compare two knowledgebases");
                compareCommand.Handler(compareHandler.Run);

                app.HelpCommand();
                return app.Parse(args).Run();
            }));
        }
        public virtual async Task ProcessEventsAsync(PartitionContext context, IEnumerable <EventData> messages)
        {
            var       eventDataList = new List <EventData>();
            EventData lastEventData = null;

            if (ConsumerConfiguration.ConsumeDelayInSeconds == null)
            {
                lastEventData = messages.LastOrDefault();
                eventDataList = messages.ToList();
            }
            else
            {
                foreach (var eventData in messages)
                {
                    if (ConsumerConfiguration.ConsumeDelayInSeconds != null && eventData.SystemProperties.EnqueuedTimeUtc <= DateTime.UtcNow.AddSeconds(ConsumerConfiguration.ConsumeDelayInSeconds.Value * (-1)))
                    {
                        lastEventData = eventData;
                        eventDataList.Add(eventData);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (lastEventData != null)
            {
                try
                {
                    bool sucess = await ProcessEventDataList(context, eventDataList);

                    if (sucess)
                    {
                        await context.CheckpointAsync(lastEventData);
                    }
                    else if (!sucess && !string.IsNullOrWhiteSpace(ConsumerConfiguration.ProducerName))
                    {
                        var sendToShuntList = new List <EventData>();
                        var sendToRetryList = new List <EventData>();
                        IEventHubProducerService eventHubProducerService = ServiceProvider.GetService <IEventHubProducerService>();

                        foreach (var eventData in eventDataList)
                        {
                            if (eventData.HasIsOkProperty())
                            {
                                eventData.RemoveSendToShuntProperty().RemoveIsOkProperty().RemoveRetryProperty();
                                continue;
                            }

                            int incrementedRetryProperty = eventData.IncrementRetryProperty();
                            if (!string.IsNullOrWhiteSpace(ConsumerConfiguration.Shunt?.ProducerName) &&
                                (eventData.HasSendToShuntProperty() ||
                                 (ConsumerConfiguration.Shunt.MaxRetry > 0 && incrementedRetryProperty > ConsumerConfiguration.Shunt.MaxRetry))
                                )
                            {
                                eventData.RemoveSendToShuntProperty().RemoveIsOkProperty().RemoveRetryProperty();
                                sendToShuntList.Add(eventData);
                            }
                            else
                            {
                                sendToRetryList.Add(eventData);
                            }
                        }
                        if (sendToShuntList.Any())
                        {
                            await eventHubProducerService.SendEventDataAsync(ConsumerConfiguration.Shunt.ProducerName, sendToShuntList);
                        }
                        if (sendToRetryList.Any())
                        {
                            await eventHubProducerService.SendEventDataAsync(ConsumerConfiguration.ProducerName, sendToRetryList);
                        }

                        await context.CheckpointAsync(lastEventData);
                    }
                }
                catch (Exception ex)
                {
                    IEventProcessorFactory eventProcessorFactory = null;

                    try
                    {
                        await Task.Run(() =>
                                       new ExecuteAsync(1, 1000, async() =>
                        {
                            IEventHubConsumerService eventHubConsumerService = ServiceProvider.GetService <IEventHubConsumerService>();

                            eventProcessorFactory = await eventHubConsumerService.UnregisterEventMessageConsumerAsync(ConsumerConfiguration.Name);

                            Thread.Sleep(10000);

                            await eventHubConsumerService.RegisterEventMessageConsumerAsync(ConsumerConfiguration.Name, eventProcessorFactory);
                        }).Do(true));
                    }
                    catch (Exception ex2)
                    {
                        if (ServiceProvider != null)
                        {
                            IEventHubConsumerService eventHubConsumerService = ServiceProvider.GetService <IEventHubConsumerService>();

                            if (eventProcessorFactory != null)
                            {
                                await eventHubConsumerService.RegisterEventMessageConsumerAsync(ConsumerConfiguration.Name, eventProcessorFactory);
                            }
                        }
                    }
                }
            }
        }
Beispiel #34
0
 public EmployeeTest()
 {
     _notificationHandler = ServiceProvider.GetRequiredService <INotificationHandler>();
 }
        public virtual async Task DisposeAsync()
        {
            await ServiceProvider.DisposeAsync();

            Dispose();
        }
Beispiel #36
0
        public async Task FutureEpochValidatorDuty()
        {
            // Arrange
            IServiceCollection testServiceCollection = TestSystem.BuildTestServiceCollection(useStore: true);

            testServiceCollection.AddSingleton <IHostEnvironment>(Substitute.For <IHostEnvironment>());
            ServiceProvider testServiceProvider = testServiceCollection.BuildServiceProvider();
            BeaconState     state      = TestState.PrepareTestState(testServiceProvider);
            ForkChoice      forkChoice = testServiceProvider.GetService <ForkChoice>();
            // Get genesis store initialise MemoryStoreProvider with the state
            IStore store = forkChoice.GetGenesisStore(state);

            // Move forward time
            TimeParameters timeParameters = testServiceProvider.GetService <IOptions <TimeParameters> >().Value;
            ulong          time           = state.GenesisTime + 1;
            ulong          nextSlotTime   = state.GenesisTime + timeParameters.SecondsPerSlot;
            // half way through epoch 4
            ulong futureEpoch = 4uL;
            ulong slots       = futureEpoch * timeParameters.SlotsPerEpoch + timeParameters.SlotsPerEpoch / 2;

            for (ulong slot = 1; slot < slots; slot++)
            {
                while (time < nextSlotTime)
                {
                    forkChoice.OnTick(store, time);
                    time++;
                }
                forkChoice.OnTick(store, time);
                time++;
//                Hash32 head = await forkChoice.GetHeadAsync(store);
//                store.TryGetBlockState(head, out BeaconState headState);
                BeaconState headState = state;
                BeaconBlock block     = TestBlock.BuildEmptyBlockForNextSlot(testServiceProvider, headState, signed: true);
                TestState.StateTransitionAndSignBlock(testServiceProvider, headState, block);
                forkChoice.OnBlock(store, block);
                nextSlotTime = nextSlotTime + timeParameters.SecondsPerSlot;
            }
            // halfway through slot
            ulong futureTime = nextSlotTime + timeParameters.SecondsPerSlot / 2;

            while (time < futureTime)
            {
                forkChoice.OnTick(store, time);
                time++;
            }

            Console.WriteLine("");
            Console.WriteLine("***** State advanced to epoch {0}, slot {1}, time {2}, ready to start tests *****", futureEpoch, state.Slot, store.Time);
            Console.WriteLine("");

            List <object?[]> data = FutureEpochValidatorDutyData().ToList();

            for (int dataIndex = 0; dataIndex < data.Count; dataIndex++)
            {
                object?[] dataRow           = data[dataIndex];
                string    publicKey         = (string)dataRow[0] !;
                ulong     epoch             = (ulong)dataRow[1] !;
                bool      success           = (bool)dataRow[2] !;
                ulong     attestationSlot   = (ulong)dataRow[3] !;
                ulong     attestationShard  = (ulong)dataRow[4] !;
                ulong?    blockProposalSlot = (ulong?)dataRow[5];

                Console.WriteLine("** Test {0}, public key {1}, epoch {2}", dataIndex, publicKey, epoch);

                // Act
                ValidatorAssignments validatorAssignments = testServiceProvider.GetService <ValidatorAssignments>();
                BlsPublicKey         validatorPublicKey   = new BlsPublicKey(publicKey);
                Epoch targetEpoch = new Epoch(epoch);

                // failure expected
                if (!success)
                {
                    Should.Throw <Exception>(async() =>
                    {
                        ValidatorDuty validatorDuty =
                            await validatorAssignments.GetValidatorDutyAsync(validatorPublicKey, targetEpoch);
                        Console.WriteLine(
                            "Validator {0}, epoch {1}: attestation slot {2}, shard {3}, proposal slot {4}",
                            validatorPublicKey, targetEpoch, validatorDuty.AttestationSlot,
                            (ulong)validatorDuty.AttestationShard, validatorDuty.BlockProposalSlot);
                    }, $"Test {dataIndex}, public key {validatorPublicKey}, epoch {targetEpoch}");
                    continue;
                }

                ValidatorDuty validatorDuty =
                    await validatorAssignments.GetValidatorDutyAsync(validatorPublicKey, targetEpoch);

                Console.WriteLine("Validator {0}, epoch {1}: attestation slot {2}, shard {3}, proposal slot {4}",
                                  validatorPublicKey, targetEpoch, validatorDuty.AttestationSlot,
                                  (ulong)validatorDuty.AttestationShard, validatorDuty.BlockProposalSlot);

                // Assert
                validatorDuty.ValidatorPublicKey.ShouldBe(validatorPublicKey, $"Test {dataIndex}, public key {validatorPublicKey}, epoch {targetEpoch}");

                Slot expectedBlockProposalSlot =
                    blockProposalSlot.HasValue ? new Slot(blockProposalSlot.Value) : Slot.None;
                Slot  expectedAttestationSlot  = new Slot(attestationSlot);
                Shard expectedAttestationShard = new Shard(attestationShard);

                validatorDuty.BlockProposalSlot.ShouldBe(expectedBlockProposalSlot, $"Test {dataIndex}, public key {validatorPublicKey}, epoch {targetEpoch}");
                validatorDuty.AttestationSlot.ShouldBe(expectedAttestationSlot, $"Test {dataIndex}, public key {validatorPublicKey}, epoch {targetEpoch}");
                validatorDuty.AttestationShard.ShouldBe(expectedAttestationShard, $"Test {dataIndex}, public key {validatorPublicKey}, epoch {targetEpoch}");
            }
        }
Beispiel #37
0
        public void ReportIAmDead()
        {
            var limit = ServiceProvider.GetService<IActivationLimit>();

            limit?.ReportIAmDead();
        }
        private void OnStartup(object sender, StartupEventArgs e)
        {
            var mainView = ServiceProvider.GetService <MainView>();

            mainView.Show();
        }
Beispiel #39
0
        public void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
        {
            try {
                Directory.Delete(replacementsDictionary["$destinationdirectory$"]);
                Directory.Delete(replacementsDictionary["$solutiondirectory$"]);
            } catch {
                // If it fails (doesn't exist/contains files/read-only), let the directory stay.
            }

            var oleProvider = automationObject as Microsoft.VisualStudio.OLE.Interop.IServiceProvider;

            if (oleProvider == null)
            {
                MessageBox.Show("Unable to start wizard: no automation object available.", "Visual Studio");
                throw new WizardBackoutException();
            }

            using (var serviceProvider = new ServiceProvider(oleProvider)) {
                int hr = EnsurePythonPackageLoaded(serviceProvider);
                if (ErrorHandler.Failed(hr))
                {
                    MessageBox.Show(string.Format("Unable to start wizard: failed to load Python support Package (0x{0:X08})", hr), "Visual Studio");
                    throw new WizardBackoutException();
                }

                // Cookiecutter is installed by default, but can be deselected/uninstalled separately from Python component
                hr = EnsureCookiecutterPackageLoaded(serviceProvider);
                if (ErrorHandler.Failed(hr))
                {
                    var dlg = new TaskDialog(serviceProvider)
                    {
                        Title             = Strings.ProductTitle,
                        MainInstruction   = Strings.CookiecutterComponentRequired,
                        Content           = Strings.CookiecutterComponentInstallInstructions,
                        AllowCancellation = true
                    };
                    dlg.Buttons.Add(TaskDialogButton.Cancel);
                    var download = new TaskDialogButton(Strings.DownloadAndInstall);
                    dlg.Buttons.Insert(0, download);

                    if (dlg.ShowModal() == download)
                    {
                        InstallTools(serviceProvider);
                        throw new WizardCancelledException();
                    }
                }

                var uiShell = (IVsUIShell)serviceProvider.GetService(typeof(SVsUIShell));

                string projName  = replacementsDictionary["$projectname$"];
                string directory = Path.GetDirectoryName(replacementsDictionary["$destinationdirectory$"]);

                var wizardData  = replacementsDictionary["$wizarddata$"];
                var templateUri = Resolve(new Uri(wizardData));

                object inObj = projName + "|" + directory + "|" + templateUri.ToString();
                var    guid  = GuidList.guidCookiecutterCmdSet;
                uiShell.PostExecCommand(ref guid, cmdidNewProjectFromTemplate, 0, ref inObj);
            }
            throw new WizardCancelledException();
        }
Beispiel #40
0
 public GetAllOwnedTokensTests(TestFixture aTestFixture)
 {
     ServiceProvider = aTestFixture.ServiceProvider;
     Mediator        = ServiceProvider.GetService <IMediator>();
     Herc1155        = ServiceProvider.GetService <Herc1155Instance>();
 }
        public void MyTestInitialize()
        {
            this.target = new LawEnforcementProviderQueryLogics();

            this.contact = new Contact
            {
                Email    = "*****@*****.**",
                ID       = 1,
                Website  = "www.test.org",
                Phone    = "9373608284",
                HelpLine = "9373608888"
            };
            this.state = new State {
                Abbreviation = "OH", CountryID = 1, FullName = "Ohio", ID = 1
            };

            this.location1 = new Location
            {
                City            = "testville 1",
                ContactID       = 1,
                Contact         = this.contact,
                ContactPersonID = 1,
                ID                = 1,
                Display           = true,
                Zip               = "45344",
                Street            = "Test way 1",
                State             = this.state,
                StateID           = this.state.ID,
                ProviderCoverages = new List <ProviderCoverage> {
                    new ProviderCoverage {
                        AreaID = 1, LocationID = 1
                    }
                }
            };
            this.location2 = new Location
            {
                City            = "testville 2",
                ContactID       = 2,
                Contact         = this.contact,
                ContactPersonID = 2,
                ID                = 2,
                Display           = true,
                Zip               = "45344",
                Street            = "Test way 2",
                State             = this.state,
                StateID           = this.state.ID,
                ProviderCoverages = new List <ProviderCoverage> {
                    new ProviderCoverage {
                        AreaID = 2, LocationID = 2
                    }
                }
            };

            this.locations = new List <Location> {
                this.location1, this.location2
            };

            this.websiteAddress1 = string.Format(
                "{0}, {1}, {2}, {3}",
                this.location1.Street,
                this.location1.City,
                this.location1.State.Abbreviation,
                this.location1.Zip);

            this.websiteAddress2 = string.Format(
                "{0}, {1}, {2}, {3}",
                this.location2.Street,
                this.location2.City,
                this.location2.State.Abbreviation,
                this.location2.Zip);

            var providerService11 = new ProviderService {
                ID = 1, ProviderID = 1, ServiceID = 1
            };
            var providerService12 = new ProviderService {
                ID = 2, ProviderID = 1, ServiceID = 2
            };
            var providerService13 = new ProviderService {
                ID = 3, ProviderID = 1, ServiceID = 3
            };

            var providerService21 = new ProviderService {
                ID = 1, ProviderID = 2, ServiceID = 1
            };
            var providerService22 = new ProviderService {
                ID = 2, ProviderID = 2, ServiceID = 2
            };
            var providerService23 = new ProviderService {
                ID = 3, ProviderID = 2, ServiceID = 3
            };

            this.providerServices1 = new List <ProviderService>
            {
                providerService11,
                providerService12,
                providerService13,
            };

            this.providerServices2 = new List <ProviderService>
            {
                providerService21,
                providerService22,
                providerService23
            };

            this.serviceProvider1 = new ServiceProvider
            {
                Description      = "Test description for test 1",
                ID               = 1,
                ServiceTypes     = 2,
                DisplayRank      = 1,
                ProviderName     = "Test 1",
                Locations        = this.locations,
                ProviderServices = this.providerServices1
            };
            this.serviceProvider2 = new ServiceProvider
            {
                Description      = "Test description for test 2",
                ID               = 2,
                ServiceTypes     = 2,
                DisplayRank      = 2,
                ProviderName     = "Test 2",
                Locations        = this.locations,
                ProviderServices = this.providerServices2
            };

            this.serviceProviderList = new List <ServiceProvider> {
                this.serviceProvider1, this.serviceProvider2
            };
        }
Beispiel #42
0
        /// <summary>
        /// 获取指定实体类所属的上下文类型
        /// </summary>
        /// <param name="entityType">实体类型</param>
        /// <returns>上下文类型</returns>
        public Type GetDbContextType(Type entityType)
        {
            IEntityManager entityManager = ServiceProvider.GetService <IEntityManager>();

            return(entityManager.GetDbContextTypeForEntity(entityType));
        }
Beispiel #43
0
 public LinkMenuBase(IGitHubServiceProvider serviceProvider)
     : base(serviceProvider)
 {
     usageTracker = new Lazy <IUsageTracker>(() => ServiceProvider.TryGetService <IUsageTracker>());
 }
 /// <summary>
 /// Creates the object instances for the types contained in the types collection.
 /// </summary>
 /// <returns>A list of objects of type <typeparamref name="TResolved"/>.</returns>
 protected virtual IEnumerable <TResolved> CreateInstances()
 {
     return(ServiceProvider.CreateInstances <TResolved>(InstanceTypes, Logger));
 }
Beispiel #45
0
        private void OnValidEvaluate(object sender, EvaluateInternalEventArgs evaluateInternalEventArgs)
        {
            var loadCarrierReceiptRepo = ServiceProvider.GetService <IRepository <Olma.LoadCarrierReceipt> >();

            Context.LoadCarrierReceipt = loadCarrierReceiptRepo.GetById <Olma.LoadCarrierReceipt, Contracts.Models.LoadCarrierReceipt>(Context.LoadCarrierReceiptId);
        }
 /// <summary>
 /// Locate and return service type
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <returns></returns>
 public T GetService <T>() => ServiceProvider.GetService <T>();
Beispiel #47
0
 private ParentObserver(Element view)
 {
     _view   = ServiceProvider.WeakReferenceFactory(view);
     _parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
     view.PropertyChanged += OnPropertyChanged;
 }
 /// <summary>
 /// Managed objects
 /// </summary>
 public void Dispose()
 {
     ServiceProvider.Dispose();
     ServiceCollection.Clear();
 }
Beispiel #49
0
 public OAuthHandler()
 {
     m_Provider = new ServiceProvider();
 }
 /// <summary>
 /// Used for initialization of the editor in the environment
 /// </summary>
 /// <param name="psp">
 /// pointer to the service provider. Can be used to obtain instances of other interfaces
 /// </param>
 /// <returns>
 /// The <see cref="int"/>.
 /// </returns>
 public int SetSite(IOleServiceProvider psp)
 {
     this.vsServiceProvider = new ServiceProvider(psp);
     return(VSConstants.S_OK);
 }
Beispiel #51
0
 public App()
 {
     serviceProvider = ConfigureServices(new ServiceCollection()).BuildServiceProvider();
     SetupExceptionHandling();
 }
 public CurrentTenant_Tests()
 {
     _currentTenant = ServiceProvider.GetRequiredService <ICurrentTenant>();
 }
 private ParentObserver(Element view)
 {
     _view   = ServiceProvider.WeakReferenceFactory(view, true);
     _parent = ServiceProvider.WeakReferenceFactory(FindParent(view), true);
     view.PropertyChanged += OnPropertyChanged;
 }
 public StartupFixture()
 {
     services = CreateContainer();
     Provider = services.BuildServiceProvider();
     Provider.GetRequiredService <IHostedService>().StartAsync(default).Wait();
Beispiel #55
0
 internal void SetProvider(ServiceProvider provider)
 {
     base.Provider = provider;
 }
 public ComplexTypeJsonIntegrationTest(StartupFixture fix)
 {
     fixture  = fix;
     provider = fixture.Provider;
 }
Beispiel #57
0
        /// <summary>
        /// Find the OSLC Creation Factory URL for a given OSLC resource type.  If no resource type is given, returns
        /// the default Creation Factory, if it exists.
        /// </summary>
        /// <param name="serviceProviderUrl"></param>
        /// <param name="oslcDomain"></param>
        /// <param name="oslcResourceType">the resource type of the desired query capability.   This may differ from the OSLC artifact type.</param>
        /// <returns>URL of requested Creation Factory or null if not found.</returns>
        public string LookupCreationFactory(string serviceProviderUrl, string oslcDomain, string oslcResourceType)
        {
            CreationFactory defaultCreationFactory = null;
            CreationFactory firstCreationFactory   = null;

            HttpResponseMessage response = GetResource(serviceProviderUrl, OSLCConstants.CT_RDF);

            if (response.StatusCode != HttpStatusCode.OK)
            {
                throw new ResourceNotFoundException(serviceProviderUrl, "CreationFactory");
            }

            ServiceProvider serviceProvider = response.Content.ReadAsAsync <ServiceProvider>(formatters).Result;

            if (serviceProvider != null)
            {
                foreach (Service service in serviceProvider.GetServices())
                {
                    Uri domain = service.GetDomain();
                    if (domain != null && domain.ToString().Equals(oslcDomain))
                    {
                        CreationFactory [] creationFactories = service.GetCreationFactories();
                        if (creationFactories != null && creationFactories.Length > 0)
                        {
                            firstCreationFactory = creationFactories[0];
                            foreach (CreationFactory creationFactory in creationFactories)
                            {
                                foreach (Uri resourceType in creationFactory.GetResourceTypes())
                                {
                                    //return as soon as domain + resource type are matched
                                    if (resourceType.ToString() != null && resourceType.ToString().Equals(oslcResourceType))
                                    {
                                        return(creationFactory.GetCreation().ToString());
                                    }
                                }
                                //Check if this is the default factory
                                foreach (Uri usage in creationFactory.GetUsages())
                                {
                                    if (usage.ToString() != null && usage.ToString().Equals(OSLCConstants.USAGE_DEFAULT_URI))
                                    {
                                        defaultCreationFactory = creationFactory;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            //If we reached this point, there was no resource type match
            if (defaultCreationFactory != null)
            {
                //return default, if present
                return(defaultCreationFactory.GetCreation().ToString());
            }
            else if (firstCreationFactory != null && firstCreationFactory.GetResourceTypes().Length == 0)
            {
                //return the first for the domain, if present
                return(firstCreationFactory.GetCreation().ToString());
            }

            throw new ResourceNotFoundException(serviceProviderUrl, "CreationFactory");
        }
 public virtual async Task InitializeAsync()
 {
     var startupRunner = ServiceProvider.GetRequiredService <IStartupRunner>();
     await startupRunner.StartupAsync();
 }
Beispiel #59
0
        internal SqlServerFhirStorageTestsFixture(int maximumSupportedSchemaVersion, string databaseName)
        {
            var initialConnectionString = Environment.GetEnvironmentVariable("SqlServer:ConnectionString") ?? LocalConnectionString;

            _maximumSupportedSchemaVersion = maximumSupportedSchemaVersion;
            _databaseName        = databaseName;
            TestConnectionString = new SqlConnectionStringBuilder(initialConnectionString)
            {
                InitialCatalog = _databaseName
            }.ToString();

            var schemaOptions = new SqlServerSchemaOptions {
                AutomaticUpdatesEnabled = true
            };
            var config = new SqlServerDataStoreConfiguration {
                ConnectionString = TestConnectionString, Initialize = true, SchemaOptions = schemaOptions
            };

            var schemaInformation  = new SchemaInformation(SchemaVersionConstants.Min, maximumSupportedSchemaVersion);
            var scriptProvider     = new ScriptProvider <SchemaVersion>();
            var baseScriptProvider = new BaseScriptProvider();
            var mediator           = Substitute.For <IMediator>();

            var sqlConnectionFactory = new DefaultSqlConnectionFactory(config);
            var schemaUpgradeRunner  = new SchemaUpgradeRunner(scriptProvider, baseScriptProvider, mediator, NullLogger <SchemaUpgradeRunner> .Instance, sqlConnectionFactory);

            _schemaInitializer = new SchemaInitializer(config, schemaUpgradeRunner, schemaInformation, sqlConnectionFactory, NullLogger <SchemaInitializer> .Instance);

            var searchParameterDefinitionManager = new SearchParameterDefinitionManager(ModelInfoProvider.Instance);

            _filebasedSearchParameterStatusDataStore = new FilebasedSearchParameterStatusDataStore(searchParameterDefinitionManager, ModelInfoProvider.Instance);

            var securityConfiguration = new SecurityConfiguration {
                PrincipalClaims = { "oid" }
            };

            var sqlServerFhirModel = new SqlServerFhirModel(
                config,
                schemaInformation,
                searchParameterDefinitionManager,
                () => _filebasedSearchParameterStatusDataStore,
                Options.Create(securityConfiguration),
                NullLogger <SqlServerFhirModel> .Instance);

            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSqlServerTableRowParameterGenerators();
            serviceCollection.AddSingleton(sqlServerFhirModel);

            ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();

            var upsertResourceTvpGeneratorV6      = serviceProvider.GetRequiredService <V6.UpsertResourceTvpGenerator <ResourceMetadata> >();
            var upsertResourceTvpGeneratorVLatest = serviceProvider.GetRequiredService <VLatest.UpsertResourceTvpGenerator <ResourceMetadata> >();
            var upsertSearchParamsTvpGenerator    = serviceProvider.GetRequiredService <VLatest.UpsertSearchParamsTvpGenerator <List <ResourceSearchParameterStatus> > >();

            var searchParameterToSearchValueTypeMap = new SearchParameterToSearchValueTypeMap();

            SqlTransactionHandler       = new SqlTransactionHandler();
            SqlConnectionWrapperFactory = new SqlConnectionWrapperFactory(SqlTransactionHandler, new SqlCommandWrapperFactory(), sqlConnectionFactory);

            SqlServerSearchParameterStatusDataStore = new SqlServerSearchParameterStatusDataStore(
                () => SqlConnectionWrapperFactory.CreateMockScope(),
                upsertSearchParamsTvpGenerator,
                () => _filebasedSearchParameterStatusDataStore,
                schemaInformation);

            FhirDataStore = new SqlServerFhirDataStore(config, sqlServerFhirModel, searchParameterToSearchValueTypeMap, upsertResourceTvpGeneratorV6, upsertResourceTvpGeneratorVLatest, Options.Create(new CoreFeatureConfiguration()), SqlConnectionWrapperFactory, NullLogger <SqlServerFhirDataStore> .Instance, schemaInformation);

            _fhirOperationDataStore = new SqlServerFhirOperationDataStore(SqlConnectionWrapperFactory, NullLogger <SqlServerFhirOperationDataStore> .Instance);

            _testHelper = new SqlServerFhirStorageTestHelper(initialConnectionString, MasterDatabaseName, searchParameterDefinitionManager, sqlServerFhirModel, sqlConnectionFactory);
        }
Beispiel #60
0
        protected CoinbaseClientTestsBase(CoinbaseApiFixture apiFixture, ITestOutputHelper output)
        {
            Logger = new LoggerConfiguration().WriteTo.TestOutput(output).CreateLogger();

            ServiceProvider = apiFixture.ServiceProvider;
        }