private void DataGrid_AddingNewItem_1(object sender, AddingNewItemEventArgs e) { e.NewItem = new RelationAccountNumber() { UserId = ServiceResolver.GetService <IUserProvider>().GetUserId() }; }
private void Run(string[] args) { var serviceResolver = new ServiceResolver(); var logger = serviceResolver.GetService <ILogger>(); if (args.Length == 0) { Console.WriteLine("Usage: MBBSDatabase [view|convert] [files]"); } var convert = (args[0] == "convert"); foreach (string s in args.Skip(1)) { BtrieveFile file = new BtrieveFile(); try { file.LoadFile(logger, s); if (convert) { using var processor = new BtrieveFileProcessor(); processor.CreateSqliteDB(Path.ChangeExtension(s, ".DB"), file); } } catch (Exception e) { logger.Error(e, $"Failed to load Btrieve file {s}: {e.Message}\n{e.StackTrace}"); } } }
private void ResetCategoriesLinkPercentages(Relation entity) { double totalPercentage = entity.CategoryLinks.Sum(b => b.Percentage); if (totalPercentage < 100) { CategoryRelationLink categoryTransactionLink = new CategoryRelationLink(); categoryTransactionLink.Percentage = 100 - totalPercentage; categoryTransactionLink.Relation = entity; categoryTransactionLink.RelationID = entity.ID; categoryTransactionLink.UserId = ServiceResolver.GetService <IUserProvider>().GetUserId(); entity.CategoryLinks.Add(categoryTransactionLink); } else if (totalPercentage > 100) { double hasToBeLess = totalPercentage - 100; var link = entity.CategoryLinks.Last(); while (link != null && entity.CategoryLinks.Sum(b => b.Percentage) > 100) { if (hasToBeLess > link.Percentage) { hasToBeLess -= link.Percentage; link.Percentage = 0; } else { link.Percentage -= hasToBeLess; } link = entity.CategoryLinks.Skip(entity.CategoryLinks.IndexOf(link) - 1).FirstOrDefault(); } } }
public static IAppBuilder UseDomainAssemblyResolver( this IAppBuilder app) { if (app == null) { throw new ArgumentNullException(nameof(app)); } var domainAssemblyResolver = ServiceResolver.GetService <DomainAssemblyResolver>(); if (domainAssemblyResolver == null) { throw new InvalidOperationException( "Serive collection could not resolve FolderWatchdog instance, Please configure service at Startup"); } OwinContext owinContext = new OwinContext(app.Properties); CancellationToken cancellationToken = owinContext.Get <CancellationToken>("host.OnAppDisposing"); if (cancellationToken == new CancellationToken()) { cancellationToken = owinContext.Get <CancellationToken>("server.OnDispose"); } if (cancellationToken == new CancellationToken()) { throw new InvalidOperationException("Current OWIN environment does not contain an instance of the `CancellationToken` class neither under `host.OnAppDisposing`, nor `server.OnDispose` key.\r\nPlease use another OWIN host or create an instance of the `DomainAssemblyResolver` class manually."); } cancellationToken.Register(new Action(domainAssemblyResolver.Dispose)); domainAssemblyResolver.Start(); return(app); }
/// <summary> /// Creates a new instance of <see cref="IMessagingBus"/>. /// </summary> /// <returns> /// The created instance of <see cref="IMessagingBus"/> /// </returns> public IMessagingBus BuildSubscribers() { IMessagingConfig config = CreateConfig(); config.Validate(); ILoggerFactory loggerFactory = ServicesBuilder?.LoggerFactory?.Invoke() ?? ServiceResolver.ResolveService <ILoggerFactory>(); JustSayingBus bus = CreateBus(config, loggerFactory); JustSayingFluently fluent = CreateFluent(bus, loggerFactory); if (ServicesBuilder?.NamingStrategy != null) { fluent.WithNamingStrategy(ServicesBuilder.NamingStrategy); } if (ServicesBuilder?.MessageContextAccessor != null) { fluent.WithMessageContextAccessor(ServicesBuilder.MessageContextAccessor()); } if (SubscriptionBuilder != null) { SubscriptionBuilder.Configure(fluent); } return(bus); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ServiceResolver serviceResolver) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.UseEndpoints(endpoints => { // endpoints.MapGet("/", async context => { await context.Response.WriteAsync("Hello World!"); }); endpoints.MapGet("/create", new HomeController(serviceResolver).CreatePostEntry); endpoints.MapGet("/", new HomeController(serviceResolver).GetAllPosts); endpoints.MapPost("/home/create_post", new HomeController(serviceResolver).CreatePostEntry); endpoints.MapPost("/edit_post/{.}", new HomeController(serviceResolver).EditPost); endpoints.MapGet("/edit_post/{.}", new HomeController(serviceResolver).EditPost); endpoints.MapPost("/remove_post/{.}", new HomeController(serviceResolver).RemovePost); endpoints.MapGet("/show_comments/{.}", new HomeController(serviceResolver).ShowComments); endpoints.MapGet("/create_comment/{.}", new HomeController(serviceResolver).CreateComment); endpoints.MapPost("/create_comment/{.}", new HomeController(serviceResolver).CreateComment); endpoints.MapGet("/edit_comment/{.}", new HomeController(serviceResolver).EditComment); endpoints.MapPost("/edit_comment/{.}", new HomeController(serviceResolver).EditComment); }); }
public virtual void OnInitialize() { //Registrazione della sessione di default SessionFactory.RegisterDefaultDataSession <MockDataSession <TScenario, TransientScenarioOption <TScenario> > >(); //Registrazione dei servizi ServiceResolver.Register <IIdentityClient, MockIdentityClient>(); ServiceResolver.Register <ICaptchaValidatorService, MockCaptchaValidatorService>(); ServiceResolver.Register <ISemperPrecisMemoryCache, SemperPrecisMemoryCache>(); //Creazione del controller dichiarato Controller = new TApiController(); Scenario = Controller.DataSession.GetScenario <TScenario>(); //Recupero l'utente da usare nel testa var defaultShooterIdentity = GetIdentityUser(); if (defaultShooterIdentity == null) { throw new InvalidProgramException("Shooter for identity is invalid"); } //Inizializzazione del controller context e impostazione dell'identity UpdateIdentityUser(defaultShooterIdentity); }
public void ResolvedServiceGetResponseEncoder() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); EncodingLookupResult result = service.GetResponseEncoder("gzip"); Assert.IsNotNull(result); Assert.AreEqual(EncodingType.Empty, result.EncodingType); Assert.AreEqual(new IdentityEncoding(), result.Encoding); result = service.GetResponseEncoder("gzip, *"); Assert.IsNotNull(result); Assert.AreEqual(EncodingType.Empty, result.EncodingType); Assert.AreEqual(new IdentityEncoding(), result.Encoding); services.WithHostEncoding(new GzipDeflateEncoding()); service = new ServiceResolver(services).Find(MethodType.Post, "foo"); result = service.GetResponseEncoder("gzip, *"); Assert.IsNotNull(result); Assert.AreEqual(EncodingType.Parse("gzip"), result.EncodingType); Assert.AreEqual(new GzipDeflateEncoding(), result.Encoding); result = service.GetResponseEncoder("gzip;q=0"); Assert.IsNotNull(result); Assert.AreEqual(EncodingType.Empty, result.EncodingType); Assert.AreEqual(new IdentityEncoding(), result.Encoding); }
IActor IStewardManager.GetActor(IStewardDialogContext context, IConversationData conversationData) { if (conversationData.IsHandled()) { return(new WatsonActor(context, conversationData)); } if (conversationData.IsAskingForOwner()) { return(new OwnerServiceActor(context , conversationData , ServiceResolver.Get <ISettings>() , ServiceResolver.Get <ILogManager>().GetLogger(typeof(OwnerServiceActor)))); } if (conversationData.IsAskingForServiceCloudCase()) { return(new ServiceCloudCaseActor(context , conversationData , ServiceResolver.Get <ISettings>() , ServiceResolver.Get <ILogManager>().GetLogger(typeof(ServiceCloudCaseActor)))); } return(new QnAMakerActor(context)); }
public async Task <IActionResult> Update([FromBody] TestModel model) { var testService = new ServiceResolver().Resolve <ITestService>(new TestServiceDefinition()); var created = await testService.UpdateAsync(model); return(Ok(created)); }
public async Task CacheLoad() { TestingResourcesHelper.PreapareTestingDirectory(ServiceResolver.GetService <IAppConfigurationService>()); TestingResourcesHelper.InjectCachedQueriesData(ServiceResolver.GetService <IAppConfigurationService>()); var storageService = ServiceResolver.GetService <IStorageService>(); storageService.Load(); var queryCacheService = ServiceResolver.GetService <IQueryCacheService>() as AOEMatchDataProvider.Services.Default.QueryCacheService; //cast to specified service to get access for internal fields/methods queryCacheService.Load(); Assert.IsTrue(queryCacheService.Queries.CachedQueries.ContainsKey(productRequest), "Cache should exists"); //CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(5000); //var requestResponseWrapper = await queryCacheService.GetOrUpdate(productRequest, cancellationTokenSource.Token, DateTime.UtcNow.AddDays(1)); //if (!requestResponseWrapper.IsSuccess) // Assert.Fail("Request failed"); //Assert.IsTrue(queryCacheService.Queries.CachedQueries.ContainsKey(productRequest), "Cache exists"); }
async Task <QnaMakerResult> IQnAMakerService.SearchKbAsync(string question) { var kbId = settings[QnAMakerKnowledgeBaseId]; var subscriptionKey = settings[QnAMakerSubscriptionKey]; var endpoint = settings[QnAMakerEndPoint]; //Build the URI var uri = new UriBuilder($"{endpoint}/knowledgebases/{kbId}/generateAnswer").Uri; var postBody = JsonConvert.SerializeObject(new QnaMakerQuestion { Question = question }); string responseString; log.Debug($"postBody : {postBody}"); //Send the POST request using (var client = ServiceResolver.Get <IWebClient>()) { client.Headers.Add("Content-Type", "application/json"); client.Headers.Add("Ocp-Apim-Subscription-Key", subscriptionKey); responseString = await client.UploadStringTaskAsync(uri, postBody); } log.Debug($"responseString : {responseString}"); var result = ConvertResponseFromJson(responseString); return(result); }
public async Task SampleRequestCache() { TestingResourcesHelper.PreapareTestingDirectory(ServiceResolver.GetService <IAppConfigurationService>()); var requestTestingService = ServiceResolver.GetService <IRequestService>() as RequestTestingService; //return match in progress requestTestingService.AddTestingRule( new System.Text.RegularExpressions.Regex("https://reqres.in/api/products/3"), RequestTestingService.RequestTestingServiceMode.ReturnPredefinedResult, new RequestResponseWrapper() { ResponseContent = TestingResourcesHelper.GetApiResoponses("Product3.json"), IsSuccess = true }); var queryCacheService = ServiceResolver.GetService <IQueryCacheService>() as AOEMatchDataProvider.Services.Default.QueryCacheService; //cast to specified service to get access for internal props queryCacheService.Load(); CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(timeout); var requestResponseWrapper = await queryCacheService.GetOrUpdate(productRequest, cancellationTokenSource.Token, DateTime.UtcNow.AddYears(1000)); if (!requestResponseWrapper.IsSuccess) { Assert.Fail("Request failed"); } Assert.IsTrue(queryCacheService.Queries.CachedQueries.ContainsKey(productRequest), "Cache should exists"); var requestResponseWrapperFromCache = await queryCacheService.GetOrUpdate(productRequest, cancellationTokenSource.Token, DateTime.UtcNow.AddYears(1000)); Assert.AreEqual(requestResponseWrapper, requestResponseWrapperFromCache); }
static void Main(string[] args) { ServiceResolver resolver = new ServiceResolver(); resolver.ServiceFound += new Network.ZeroConf.ObjectEvent <Network.ZeroConf.IService>(resolver_ServiceFound); resolver.Resolve("urn:schemas-upnp-org:service:ContentDirectory:1"); //resolver.Resolve("upnp:rootdevice"); //resolver.Resolve("urn:schemas-upnp-org:service:RenderingControl:1"); //IPEndPoint server = new IPEndPoint(IPAddress.Parse("192.168.1.13"), 2869); //Browse browse = new Browse("http://192.168.1.13:2869/upnphost/udhisapi.dll?control=uuid:a6da68b3-3d15-4655-861f-503e63673e7d+urn:upnp-org:serviceId:ContentDirectory", null); //XmlDocument didlDoc = new XmlDocument(); //XmlDocument browseResponse = browse.GetResponse().Document; //didlDoc.LoadXml(browseResponse.DocumentElement.ChildNodes[0].ChildNodes[0].ChildNodes[0].ChildNodes[0].Value); //XmlNamespaceManager xmlns = new XmlNamespaceManager(didlDoc.NameTable); //xmlns.AddNamespace("didl", "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/"); //xmlns.AddNamespace("dc", "http://purl.org/dc/elements/1.1/"); //xmlns.AddNamespace("upnp", "urn:schemas-upnp-org:metadata-1-0/upnp/"); //foreach (XmlNode item in didlDoc.SelectNodes("//didl:container/dc:title/text()", xmlns)) //{ // Console.WriteLine(item.Value); //} Console.WriteLine("Press enter to exit"); Console.Read(); resolver.ServiceFound -= resolver_ServiceFound; resolver.Dispose(); }
public void Resolve_Not_Register() { var enumerable = ServiceResolver.Resolve <IEnumerable <Transient> >(); Assert.NotNull(enumerable); Assert.Empty(enumerable); }
public async Task <IActionResult> Delete(string key) { var testService = new ServiceResolver().Resolve <ITestService>(new TestServiceDefinition()); await testService.DeleteAsync(key); return(Ok()); }
private JustSayingBus CreateBus(IMessagingConfig config, ILoggerFactory loggerFactory) { IMessageSerializationRegister register = ServicesBuilder?.SerializationRegister?.Invoke() ?? ServiceResolver.ResolveService <IMessageSerializationRegister>(); return(new JustSayingBus(config, register, loggerFactory)); }
async Task <MessageResponse> IWatsonConversationService.SendMessage(string message, dynamic context) { using (var client = ServiceResolver.Get <IWebClient>()) { var credential = settings[WatsonCredential]; var endpoint = new UriBuilder(settings[WatsonEndPoint]).Uri; client.Headers.Add("Content-Type", "application/json"); client.Headers.Add("Authorization", $"Basic {credential}"); dynamic inputContext = context; dynamic messageObj = new ExpandoObject(); messageObj.input = new ExpandoObject(); messageObj.input.text = CorrectInputMessage(message); messageObj.context = inputContext; var data = JsonConvert.SerializeObject(messageObj); log.Debug($"message : {message}"); log.Debug($"data : {data}"); var responseMessage = await client.UploadStringTaskAsync(endpoint, data); log.Debug($"responseMessage : {responseMessage}"); return(JsonConvert.DeserializeObject <MessageResponse>(responseMessage)); } }
public void IncompleteUsersDataProcessingFromMatchData() { var responseRaw = TestingResourcesHelper.GetApiResoponses("MatchDetailsValid.json"); var processingService = ServiceResolver.GetService <IUserDataProcessingService>(); var stringResources = JsonConvert.DeserializeObject <AoeNetAPIStringResources>(TestingResourcesHelper.GetApiResoponses("ApiStringResources.json")); Match match = processingService.ProcessMatch(responseRaw, stringResources); Assert.AreEqual(match.Users.Count, 2, "Users in match count is incorrect"); //make sure other fields was processed as expected //test both players profile IDs Assert.IsNotNull(match.Users.First().UserGameProfileId, "Player[0] profile id wasn't processed"); Assert.IsNotNull(match.Users.Last().UserGameProfileId, "Player[1] profile id wasn't processed"); //test both players names Assert.IsNotNull(match.Users.First().Name, "Player[0] name wasn't processed"); Assert.IsNotNull(match.Users.Last().Name, "Player[1] name wasn't processed"); //validate color property (have to be set) Assert.IsNotNull(match.Users.First().Color, "Player[0] color is wasn't processed"); Assert.IsNotNull(match.Users.Last().Color, "Player[1] color is wasn't processed"); //validate user match types and match type Assert.AreEqual(match.MatchType, MatchType.RandomMap); Assert.AreEqual(match.Users.First().MatchType, MatchType.RandomMap); Assert.AreEqual(match.Users.Last().MatchType, MatchType.RandomMap); }
// Code à exécuter lorsque l'application est activée (affichée au premier plan) // Ce code ne s'exécute pas lorsque l'application est démarrée pour la première fois private void Application_Activated(object sender, ActivatedEventArgs e) { if (!e.IsApplicationInstancePreserved) { ServiceResolver.RegisterService <INavigationService>(new PhoneNavigationService(RootFrame)); } }
protected void ExecuteTest(TestLogic testLogic) { ServiceResolver serviceResolver = new ServiceResolver(ServiceResolver.GetTestDefaults()); //Setup Generic Database var resourceManager = serviceResolver.GetService <IResourceManager>(); File.WriteAllBytes($"BBSGEN.DAT", resourceManager.GetResource("MBBSEmu.Assets.BBSGEN.VIR").ToArray()); CopyModuleToTempPath(ResourceManager.GetTestResourceManager()); var modules = new List <MbbsModule> { new MbbsModule(serviceResolver.GetService <IFileUtility>(), serviceResolver.GetService <ILogger>(), "MBBSEMU", _modulePath) }; //Setup and Run Host var host = serviceResolver.GetService <IMbbsHost>(); foreach (var m in modules) { host.AddModule(m); } host.Start(); _session = new TestSession(host); host.AddSession(_session); testLogic(_session); host.Stop(); host.WaitForShutdown(); }
public void SaveCollectionStateTest() { var stateManager = new StateManager(ServiceResolver.GetService <IStateMachine>()); stateManager.UserDevice = new UserDevice() { DeviceId = "100" }; var syncKey = stateManager.GetNewSyncKey("0"); var collState = new CollectionState() { FolderId = "12321", Collections = new List <SyncItemState>() { new SyncItemState() { ServerId = "12334", HashKey = "3242342342" }, new SyncItemState() { ServerId = "12334", HashKey = "3242342342" } } }; stateManager.SaveCollectionState(syncKey, collState); var savedCollState = stateManager.LoadCollectionState(syncKey, collState.FolderId); }
public TelnetSession(Socket telnetConnection) : base(telnetConnection.RemoteEndPoint.ToString()) { SessionType = EnumSessionType.Telnet; SendToClientMethod = Send; _host = ServiceResolver.GetService <IMbbsHost>(); _logger = ServiceResolver.GetService <ILogger>(); _telnetConnection = telnetConnection; _telnetConnection.ReceiveTimeout = (1000 * 60) * 5; //5 Minutes _telnetConnection.ReceiveBufferSize = socketReceiveBuffer.Length; _telnetConnection.Blocking = false; SessionState = EnumSessionState.Negotiating; _senderThread = new Thread(SendWorker); _senderThread.Start(); //Add this Session to the Host _host.AddSession(this); Send(ANSI_ERASE_DISPLAY); Send(ANSI_RESET_CURSOR); SessionState = EnumSessionState.Unauthenticated; ListenForData(); }
public OfflineOrOnlineAdminstrationChoseViewmodel(IView view) { _view = view; OfflineCommand = new RelayCommand(async(object obj) => { _view.Disable(); SQLiteStarter starter = new SQLiteStarter(); IUserProvider desktopUserProvider = ServiceResolver.GetContainer().GetInstance <IUserProvider>(); desktopUserProvider.SetUserId(LoginRepository.Instance.CurrentUser.ID); starter.CreateDBIfNotExists(); // starter.TestSeedDb(); Properties.Settings settings = new Properties.Settings(); if (RememberChoice) { settings.ChoiceIsOnline = false; settings.RememberOnlineChoice = true; settings.Save(); } else { settings.RememberOnlineChoice = false; settings.Save(); } await RepositoryResolver.GetRepository <ITransactionRepository>().CreateInitialFilling(); new MainWindow().Show(); _view.Close(); }); }
protected override void Initialize(string xmlRequest) { if (string.IsNullOrWhiteSpace(xmlRequest)) { throw new InvalidRequestException("SendMail Request Content is Empty."); } var root = XDocument.Parse(xmlRequest).Root; this.ClientId = root.GetElementValueAsString(ComposeMailStrings.ClientId); var sourceEl = root.GetElement(ComposeMailStrings.Source); if (sourceEl != null) { this.Source = new Source() { FolderId = sourceEl.GetElementValueAsString(ComposeMailStrings.FolderId), ItemId = sourceEl.GetElementValueAsString(ComposeMailStrings.ItemId), LongId = sourceEl.GetElementValueAsString(ComposeMailStrings.LongId), InstanceId = sourceEl.GetElementValueAsString(ComposeMailStrings.InstanceId) }; } this.AccountId = root.GetElementValueAsString(ComposeMailStrings.AccountId); this.SaveInSentItems = root.HasChildElement(ComposeMailStrings.SaveInSentItems); var mimeString = root.GetElementValueAsString(ComposeMailStrings.Mime); mimeString = mimeString.Replace("\n", "\r\n"); this.Mime = Encoding.UTF8.GetBytes(mimeString); MailService = ServiceResolver.GetService <IEmailService>(); }
private void DataGrid_AddingNewItem(object sender, AddingNewItemEventArgs e) { e.NewItem = new RelationDescription() { UserId = ServiceResolver.GetService <IUserProvider>().GetUserId() }; }
/// <summary> /// Starts this instance. /// </summary> public static void Start() { ServiceResolver.SetServiceResolver(new DefaultServiceResolver()); var config = GlobalConfiguration.Configuration; NuGetV2WebApiEnabler.UseNuGetV2WebApiFeed( config, "NuGetDefault", "nuget", "PackagesOData", enableLegacyPushRoute: true); config.Services.Replace(typeof(IExceptionLogger), new TraceExceptionLogger()); // Trace.Listeners.Add(new TextWriterTraceListener(HostingEnvironment.MapPath("~/NuGet.Server.log"))); // Trace.AutoFlush = true; config.Routes.MapHttpRoute( name: "NuGetDefault_ClearCache", routeTemplate: "nuget/clear-cache", defaults: new { controller = "PackagesOData", action = "ClearCache" }, constraints: new { httpMethod = new HttpMethodConstraint(HttpMethod.Get) } ); }
public void Resolve_Not_Register() { var many = ServiceResolver.ResolveMany <Transient>(); Assert.NotNull(many); Assert.Equal(0, many.Count()); }
public void Resolve_InstanceSimpleGeneric() { var service = ServiceResolver.Resolve <IInstanceSimpleGeneric <IService> >(); Assert.NotNull(service); Assert.IsType <SimpleGeneric <IService> >(service); }
/// <summary> /// Uploads the round to the server and clears the current round. Returns null if it could not upload the round correctly. /// </summary> public static async Task <RoundModel> CompleteRoundAsync() { //Upload the current round to the server. var request = ServiceResolver.Resolve <IApiRequest>(); // Note the time that the round is ending. CurrentRound.EndTime = DateTime.UtcNow; //upload the round to the server. var completedRound = await request.PostAsync <RoundModel>( Constants.Endpoints.Rounds, CurrentRound); if (completedRound?.Id != Guid.Empty) { //TODO: Modify the logic here to NOT complete the round if we could not delete //the file. //means the upload was a success, so continue with the deletion of the round. if (await DeleteCurrentRoundAsync()) { return(completedRound); } } //upload to the server failed, so return null. return(null); }
public static void Setup(this IServiceCollection services, AppSettings appSettings) { ConfigurationResolver.Setup(services, appSettings); ServiceResolver.Setup(services); DataResolver.Setup(services, appSettings); ExternalServiceResolver.Setup(services); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="platformWebFullSectionName">platform web full section name</param> public Services(string platformWebFullSectionName) { if (platformWebFullSectionName == null) throw new MemoryPointerIsNullException("platformWebFullSectionName"); var authCookiePropertiesProviderResolver = new ServiceResolver<IAuthCookiePropertiesProvider>(new ConfigFileAuthCookiePropertiesProvider(platformWebFullSectionName)); this.Bundle.AddServiceResolver(authCookiePropertiesProviderResolver); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="delegateProviderResolver">delegate provider resolver</param> public Services(IServiceResolver<IDelegateProvider> delegateProviderResolver) { if (delegateProviderResolver == null) throw new MemoryPointerIsNullException("delegateProviderResolver"); var attendeeProviderResolver = new ServiceResolver<IAttendeeProvider>(new AttendeeProvider(delegateProviderResolver)); var meetingProviderResolver = new ServiceResolver<IMeetingProvider>(new MeetingProvider(delegateProviderResolver, attendeeProviderResolver)); this.Bundle.AddServiceResolver(attendeeProviderResolver); this.Bundle.AddServiceResolver(meetingProviderResolver); }
public void ServiceResolverFindRoutePatterns() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("foo/{param}/bar", null, new { param = @"^\d+$" }) .Get(() => { }); ServiceResolver resolver = new ServiceResolver(services); Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/42/bar")); Assert.IsNull(resolver.Find(MethodType.Get, "foo/baz/bar")); }
public void ServiceResolverExistsForAnyMethodType() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("foo/{param}/bar") .Get(() => { }); ServiceResolver resolver = new ServiceResolver(services); Assert.IsTrue(resolver.ExistsForAnyMethodType("foo/baz/bar")); Assert.IsFalse(resolver.ExistsForAnyMethodType("foo/bar")); }
public void ServiceResolverFind() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("foo/{param}/bar") .Get(() => { }); ServiceResolver resolver = new ServiceResolver(services); Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/baz/bar")); Assert.IsNull(resolver.Find(MethodType.Post, "foo/baz/bar")); }
public void ServiceResolverFindRouteTypes() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("foo/{param}/bar", new { param = typeof(Guid) }) .Get(() => { }); ServiceResolver resolver = new ServiceResolver(services); Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/D118CE6F-36BE-4DB4-B0E7-D426809B22FE/bar")); Assert.IsNull(resolver.Find(MethodType.Get, "foo/42/bar")); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="sampleFullSectionName">sample full section name</param> public Services(string sampleFullSectionName) { if (sampleFullSectionName == null) throw new MemoryPointerIsNullException("sampleFullSectionName"); var anotherTypeSetProviderResolver = new ServiceResolver<IAnotherTypeSetProvider>(new AnotherTypeSetProvider()); var anotherTypeStructureProviderResolver = new ServiceResolver<IAnotherTypeStructureProvider>(new ConfigFileAnotherTypeStructureProvider(sampleFullSectionName)); var anotherTypeStructuredDataProviderResolver = new ServiceResolver<IAnotherTypeStructuredDataProvider>( new AnotherTypeStructuredDataProvider(anotherTypeSetProviderResolver, anotherTypeStructureProviderResolver)); this.Bundle.AddServiceResolver(anotherTypeSetProviderResolver); this.Bundle.AddServiceResolver(anotherTypeStructureProviderResolver); this.Bundle.AddServiceResolver(anotherTypeStructuredDataProviderResolver); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="utcTimeProviderResolver">UTC time provider resolver</param> public Services(IServiceResolver<IUTCTimeProvider> utcTimeProviderResolver) { if (utcTimeProviderResolver == null) throw new MemoryPointerIsNullException("utcTimeProviderResolver"); var sampleUserTokenFactoryResolver = new ServiceResolver<ISampleUserTokenFactory>(new SampleUserTokenFactory(utcTimeProviderResolver)); var userTokenProviderResolver = new ServiceResolver<IUserTokenProvider>(new SampleUserTokenProvider(sampleUserTokenFactoryResolver)); var userDataProviderResolver = new ServiceResolver<IUserDataProvider>(new SampleUserDataProvider()); var currentUserTokenProviderResolver = new ServiceResolver<ICurrentUserTokenProvider>(new SampleCurrentUserTokenProvider()); this.Bundle.AddServiceResolver(sampleUserTokenFactoryResolver); this.Bundle.AddServiceResolver(userTokenProviderResolver); this.Bundle.AddServiceResolver(userDataProviderResolver); this.Bundle.AddServiceResolver(currentUserTokenProviderResolver); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="platformFullSectionName">platform full section name</param> public Services(string platformFullSectionName) { if (platformFullSectionName == null) throw new MemoryPointerIsNullException("platformFullSectionName"); var utcTimeProviderResolver = new ServiceResolver<IUTCTimeProvider>(new UTCTimeProvider()); var localTimeOffsetProviderResolver = new ServiceResolver<ILocalTimeOffsetProvider>(new LocalTimeOffsetProvider()); var uiCultureProviderResolver = new ServiceResolver<IUICultureProvider>(new UICultureProvider()); var consoleProviderResolver = new ServiceResolver<IConsoleProvider>(new ConsoleProvider()); this.Bundle.AddServiceResolver(utcTimeProviderResolver); this.Bundle.AddServiceResolver(localTimeOffsetProviderResolver); this.Bundle.AddServiceResolver(uiCultureProviderResolver); this.Bundle.AddServiceResolver(consoleProviderResolver); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> /// <param name="sampleFullSectionName">sample full section name</param> public Services(string sampleFullSectionName) { if (sampleFullSectionName == null) throw new MemoryPointerIsNullException("sampleFullSectionName"); var sampleTypeTestErrorFactoryResolver = new ServiceResolver<IInfoEntityFactory<TestError>>( new InfoEntityWithDescriptionFactory<TestError>(new ResxDescriptionProvider(Sample.Resx.SampleTypes.Resources.ResourceManager, "SampleType_TestError_Description"), descriptionProvider => new TestError(descriptionProvider))); var sampleTypeSetProviderResolver = new ServiceResolver<ISampleTypeSetProvider>(new SampleTypeSetProvider(sampleTypeTestErrorFactoryResolver)); var sampleTypeStructureProviderResolver = new ServiceResolver<ISampleTypeStructureProvider>(new ConfigFileSampleTypeStructureProvider(sampleFullSectionName)); var sampleTypeStructuredDataProviderResolver = new ServiceResolver<ISampleTypeStructuredDataProvider>( new SampleTypeStructuredDataProvider(sampleTypeSetProviderResolver, sampleTypeStructureProviderResolver)); this.Bundle.AddServiceResolver(sampleTypeSetProviderResolver); this.Bundle.AddServiceResolver(sampleTypeStructureProviderResolver); this.Bundle.AddServiceResolver(sampleTypeStructuredDataProviderResolver); }
public void ResolvedServiceGetRequestDeserializer() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); FormatLookupResult result = service.GetRequestDeserializer("application/json"); Assert.IsNull(result); result = service.GetRequestDeserializer(string.Empty); Assert.IsNotNull(result); Assert.AreEqual(MediaType.Empty, result.MediaType); Assert.AreEqual(new PlainTextFormat(), result.Format); services.WithHostFormat(new JsonFormat()); service = new ServiceResolver(services).Find(MethodType.Post, "foo"); result = service.GetRequestDeserializer("application/json"); Assert.IsNotNull(result); Assert.AreEqual(MediaType.Parse("application/json"), result.MediaType); Assert.AreEqual(new JsonFormat(), result.Format); }
/// <summary> /// Creates new instance of <see cref="Services"/> /// </summary> public Services() { var delegateProviderResolver = new ServiceResolver<IDelegateProvider>(new DelegateProvider()); this.Bundle.AddServiceResolver(delegateProviderResolver); }
public ServiceFilterProvider(Func<Type, object> resolve) { _resolver = new ServiceResolver(resolve); }
public void ResolvedServiceInvokeErrorActionsNoContinue() { Payload payload = new Payload() { Date = DateTime.UtcNow, Number = 42, Text = "Hello, world!" }; ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }) .ErrorService<Payload>( (ex, req, resp) => { Assert.AreEqual(payload, req.RequestObject); return false; }) .ErrorService( ex => { Assert.Fail(); return true; }); IDictionary<string, object> routeValues = new Dictionary<string, object>(); routeValues["action"] = "foo"; using (IRequestMessage request = new RequestMessage<Payload>("Test", routeValues, new Uri("http://example.com/foo"), payload)) { using (IResponseMessage response = new ResponseMessage()) { ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); InvokeActionsResult result = service.InvokeErrorActions(request, response, new Exception[0]); Assert.IsFalse(result.Continue); Assert.IsTrue(result.Success); Assert.AreEqual(1, result.Results.Count); } } }
public void ResolvedServiceReadRequest() { ServiceCollection services = new ServiceCollection(); services .WithHostFormat(new JsonFormat()) .WithService("Test", "/") .WithEndpoint("{action}") .Get(() => { }) .Post<Payload>((Payload p) => { }); ResolvedService service = new ServiceResolver(services).Find(MethodType.Get, "foo"); ReadRequestResult result; using (RequestMessage request = new RequestMessage(service.Name, service.RouteValues, new Uri("http://example.com/foo"))) { result = service.ReadRequest(request, 0, null, null, null); Assert.IsNotNull(result); Assert.IsTrue(result.Success); Assert.IsNull(result.Exception); Assert.AreEqual(StatusCode.None, result.StatusCode); Assert.IsNull(result.RequestObject); } using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"date\":\"2012-09-22T18:46:00Z\",\"number\":42,\"text\":\"Hello, world!\"}"))) { using (RequestMessage request = new RequestMessage<Payload>(service.Name, service.RouteValues, new Uri("http://example.com/foo"))) { service = new ServiceResolver(services).Find(MethodType.Post, "foo"); result = service.ReadRequest(request, (int)stream.Length, null, "application/json", stream); Assert.IsNotNull(result); Assert.IsTrue(result.Success); Assert.IsNull(result.Exception); Assert.AreEqual(StatusCode.None, result.StatusCode); Assert.IsNotNull(result.RequestObject); Payload payload = result.RequestObject as Payload; Assert.IsNotNull(payload); Assert.AreEqual(new DateTime(2012, 9, 22, 18, 46, 0, DateTimeKind.Utc), payload.Date); Assert.AreEqual(42L, payload.Number); Assert.AreEqual("Hello, world!", payload.Text); } } }
public void ResolvedServiceReadRequestInvalidJson() { ServiceCollection services = new ServiceCollection(); services .WithHostFormat(new JsonFormat()) .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("this is not JSON"))) { using (RequestMessage request = new RequestMessage<Payload>(service.Name, service.RouteValues, new Uri("http://example.com/foo"))) { ReadRequestResult result = service.ReadRequest(request, (int)stream.Length, null, "application/json", stream); Assert.IsNotNull(result); Assert.IsFalse(result.Success); Assert.IsNotNull(result.Exception); Assert.AreEqual(StatusCode.BadRequest, result.StatusCode); Assert.IsNull(result.RequestObject); } } }
public void ResolvedServiceReadRequestMissingEncoding() { ServiceCollection services = new ServiceCollection(); services .WithHostFormat(new JsonFormat()) .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); byte[] encodedPayload; using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"date\":\"2012-09-22T18:46:00Z\",\"number\":42,\"text\":\"Hello, world!\"}"))) { using (MemoryStream outputStream = new MemoryStream()) { using (GZipStream compressionStream = new GZipStream(outputStream, CompressionMode.Compress)) { stream.CopyTo(compressionStream); } encodedPayload = outputStream.ToArray(); } } ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); using (RequestMessage request = new RequestMessage<Payload>(service.Name, service.RouteValues, new Uri("http://example.com/foo"))) { request.InputStream.Write(encodedPayload, 0, encodedPayload.Length); request.InputStream.Position = 0; request.SetEncodingFilter(EncodingType.Parse("gzip"), new GzipDeflateEncoding()); ReadRequestResult result = service.ReadRequest(request, encodedPayload.Length, "gzip", "application/json", request.InputStream); Assert.IsNotNull(result); Assert.IsFalse(result.Success); Assert.IsNull(result.Exception); Assert.AreEqual(StatusCode.UnsupportedMediaType, result.StatusCode); Assert.IsNull(result.RequestObject); } }
public void ResolvedServiceReadRequestMissingFormat() { ServiceCollection services = new ServiceCollection(); services .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"date\":\"2012-09-22T18:46:00Z\",\"number\":42,\"text\":\"Hello, world!\"}"))) { using (RequestMessage request = new RequestMessage<Payload>(service.Name, service.RouteValues, new Uri("http://example.com/foo"))) { ReadRequestResult result = service.ReadRequest(request, (int)stream.Length, null, "application/json", stream); Assert.IsNotNull(result); Assert.IsFalse(result.Success); Assert.IsNull(result.Exception); Assert.AreEqual(StatusCode.UnsupportedMediaType, result.StatusCode); Assert.IsNull(result.RequestObject); } } }
public void ResolvedServiceWriteResponse() { Payload payload = new Payload() { Date = new DateTime(2012, 9, 22, 18, 46, 0, DateTimeKind.Utc), Number = 42, Text = "Hello, world!" }; ServiceCollection services = new ServiceCollection(); services .WithHostFormat(new JsonFormat()) .WithService("Test", "/") .WithEndpoint("{action}") .Post<Payload>((Payload p) => { }); using (ResponseMessage response = new ResponseMessage()) { response.ResponseObject = payload; ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo"); WriteResponseResult result = service.WriteResponse(response, "gzip, *", "application/json, */*"); Assert.IsNotNull(result); Assert.IsNull(result.Exception); Assert.AreEqual(StatusCode.None, result.StatusCode); Assert.IsTrue(result.Success); response.OutputStream.Position = 0; using (StreamReader reader = new StreamReader(response.OutputStream)) { Assert.AreEqual("{\"date\":\"2012-09-22T18:46:00.0000000Z\",\"number\":42,\"text\":\"Hello, world!\"}", reader.ReadToEnd()); } } }