public void Can_get_and_set_tenant_context() { HttpContext httpContext = new DefaultHttpContext(); var tenantContext = new TenantContext<TestTenant>(new TestTenant()); httpContext.SetTenantContext(tenantContext); Assert.Same(tenantContext, httpContext.GetTenantContext<TestTenant>()); }
public PortfolioRepository(TenantContext context) { _context = context; }
private IServiceProvider GetProviderFromFactory(IServiceCollection collectionClone, TenantContext <TTenant> tenantContext) { ServiceProvider provider = collectionClone.BuildServiceProvider(); IServiceProviderFactory <IServiceCollection> factory = provider.GetService <IServiceProviderFactory <IServiceCollection> >(); using (provider) { return(factory.CreateServiceProvider(factory.CreateBuilder(collectionClone))); } }
public DashboardController(TenantContext context) { _context = context; }
private async Task <RequestResult <AuthorizationData> > AddFacebookToExistingUser(TokenInfo tokenInfo, TenantContext requestTenant) { var user = await _authRepository .AddFacebookLoginToUser(requestTenant.TenantId, tokenInfo.Email, tokenInfo.ExternalUserId); await _avatarRepository .StoreAvatar(user.Id, AvatarType.Facebook, tokenInfo.ImageUrl); return(await GetAuthorizationDataResult(requestTenant, user)); }
private async Task <RequestResult <AuthorizationData> > GetAuthorizationDataResult(TenantContext requestTenant, TenantUser user) { var tenantSettings = await _tenantsRepository.GetTenantSettings(requestTenant.TenantId); var token = _jwtTokenFactory.Create(user, tenantSettings, requestTenant.TenantCode); return(RequestResult <AuthorizationData> .Success( new AuthorizationData { Token = token, User = _mapper.Map <UserDto>(user), })); }
protected override string GetTenantProfileName(TenantContext <AppTenant> tenantContext) { return(tenantContext.Tenant.Name); }
public TestTenantIdConstraintsTypeDbContext(TenantContext tenantContext, DbContextOptions <TestTenantIdConstraintsTypeDbContext> options) : base(tenantContext, options) { }
public static void SetTenantContext(this IOwinContext context, TenantContext tenantContext) { context.Environment.Add(tenantContextKey, tenantContext); }
protected MultiTenantIdentityDbContext(TenantContext tenantContext, DbContextOptions options) : base(tenantContext, options) { }
public void TearDown() { TenantContext.Exit(); _container.Dispose(); }
public CapacidadHandlerEF(TenantContext tc) { ctx = tc; }
public BroadcastController(IGroupService groupService, IStopService stopService, TenantContext tenantContext) { this.stopService = stopService; this.tenantContext = tenantContext; }
/// <summary> /// Checks the <c>TenantId</c> on entities taking into account /// the <c>tenantNotSetMode</c> and the <c>tenantMismatchMode</c>. /// </summary> /// <remarks> /// <list type="bullet"> /// <item><description>This method is called from <c>SaveChanges</c> or <c>SaveChangesAsync</c> of the derived <c>DbContext</c>.</description></item> /// <item><description>If any changes are detected in an entitiy with the <c>MultiTenant</c> attribute then the <c>TenantContext</c> must not be null.</description></item> /// </list> /// </remarks> /// /// <param name="tenantContext"></param> /// <param name="changeTracker"></param> /// <param name="tenantNotSetMode"></param> /// <param name="tenantMismatchMode"></param> internal static void EnforceTenantId(TenantContext tenantContext, ChangeTracker changeTracker, TenantNotSetMode tenantNotSetMode, TenantMismatchMode tenantMismatchMode) { var changedMultiTenantEntities = changeTracker.Entries(). Where(e => e.State == EntityState.Added || e.State == EntityState.Modified || e.State == EntityState.Deleted). Where(e => e.Entity.GetType().GetCustomAttribute <MultiTenantAttribute>() != null); // ensure tenant context is valid if (changedMultiTenantEntities.Any()) { CheckTenantContext(tenantContext); } // get list of all added entities with TenantScope attribute var addedTenantScopeEntities = changedMultiTenantEntities. Where(e => e.State == EntityState.Added); // handle Tenant Id mismatches for added entities var mismatchedAdded = addedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue != null && (string)e.Property("TenantId").CurrentValue != tenantContext.Id); if (mismatchedAdded.Any()) { switch (tenantMismatchMode) { case TenantMismatchMode.Throw: throw new MultiTenantException($"{mismatchedAdded.Count()} added entities with Tenant Id mismatch.");; case TenantMismatchMode.Ignore: // no action needed break; case TenantMismatchMode.Overwrite: foreach (var e in mismatchedAdded) { e.Property("TenantId").CurrentValue = tenantContext.Id; } break; } } // for added entities TenantNotSetMode is always Overwrite var notSetAdded = addedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue == null); foreach (var e in notSetAdded) { e.Property("TenantId").CurrentValue = tenantContext.Id; } // get list of all modified entities with TenantScope attribute var modifiedTenantScopeEntities = changedMultiTenantEntities. Where(e => e.State == EntityState.Modified); // handle Tenant Id mismatches for modified entities var mismatchedModified = modifiedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue != null && (string)e.Property("TenantId").CurrentValue != tenantContext.Id); if (mismatchedModified.Any()) { switch (tenantMismatchMode) { case TenantMismatchMode.Throw: throw new MultiTenantException($"{mismatchedModified.Count()} modified entities with Tenant Id mismatch.");; case TenantMismatchMode.Ignore: // no action needed break; case TenantMismatchMode.Overwrite: foreach (var e in mismatchedModified) { e.Property("TenantId").CurrentValue = tenantContext.Id; } break; } } // handle Tenant Id not set for modified entities var notSetModified = modifiedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue == null); if (notSetModified.Any()) { switch (tenantNotSetMode) { case TenantNotSetMode.Throw: throw new MultiTenantException($"{notSetModified.Count()} modified entities with Tenant Id not set.");; case TenantNotSetMode.Overwrite: foreach (var e in notSetModified) { e.Property("TenantId").CurrentValue = tenantContext.Id; } break; } } // get list of all deleted entities with TenantScope attribute var deletedTenantScopeEntities = changedMultiTenantEntities. Where(e => e.State == EntityState.Deleted); // handle Tenant Id mismatches for deleted entities var mismatchedDeleted = deletedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue != null && (string)e.Property("TenantId").CurrentValue != tenantContext.Id); if (mismatchedDeleted.Any()) { switch (tenantMismatchMode) { case TenantMismatchMode.Throw: throw new MultiTenantException($"{mismatchedDeleted.Count()} deleted entities with Tenant Id mismatch.");; case TenantMismatchMode.Ignore: // no action needed break; case TenantMismatchMode.Overwrite: // no action needed break; } } // handle Tenant Id not set for deleted entities var notSetDeleted = deletedTenantScopeEntities. Where(e => (string)e.Property("TenantId").CurrentValue == null); if (notSetDeleted.Any()) { switch (tenantNotSetMode) { case TenantNotSetMode.Throw: throw new MultiTenantException($"{notSetDeleted.Count()} deleted entities with Tenant Id not set.");; case TenantNotSetMode.Overwrite: // no action needed break; } } }
protected override IEnumerable <string> GetTenantIdentifiers(TenantContext <Tenant> context) => new string[] { context.Tenant.Domain };
public TestWrongTenantIdTypeDbContext(TenantContext tenantContext, DbContextOptions <TestWrongTenantIdTypeDbContext> options) : base(tenantContext, options) { }
private async Task InitAsync() { _maxDispatchedCheckpoint = 0; DumpProjections(); TenantContext.Enter(_config.TenantId); await _housekeeper.InitAsync().ConfigureAwait(false); await ConfigureProjectionsAsync().ConfigureAwait(false); // cleanup await _housekeeper.RemoveAllAsync(_persistence).ConfigureAwait(false); var allSlots = _projectionsBySlot.Keys.ToArray(); var allClients = new List <ICommitPollingClient>(); //recreate all polling clients. foreach (var bucket in _config.BucketInfo) { string pollerId = "bucket: " + String.Join(",", bucket.Slots); var client = _pollingClientFactory.Create(_persistence, pollerId); allClients.Add(client); _bucketToClient.Add(bucket, client); } // Once we created all the buckets we will simply configure all of them. foreach (var bucketKeyValue in _bucketToClient) { var client = bucketKeyValue.Value; var bucket = bucketKeyValue.Key; var slots = bucket.Slots; if (slots[0] == "*") { //ok we have all bucket, it is calculated getting all the slots and removing //other slots that are in different slots. var asteriskSlots = _projectionsBySlot.Keys.ToList(); foreach (var otherBucket in _bucketToClient.Keys.Where(b => b != bucket)) { asteriskSlots.RemoveAll(s => otherBucket.Slots.Contains(s)); } slots = asteriskSlots.ToArray(); } client.Configure(GetStartGlobalCheckpoint(slots), 4000); } _clients = allClients.ToArray(); foreach (var slotName in allSlots) { KernelMetricsHelper.CreateMeterForDispatcherCountSlot(slotName); var startCheckpoint = GetStartCheckpointForSlot(slotName); _logger.InfoFormat("Slot {0} starts from {1}", slotName, startCheckpoint); var name = slotName; //find right consumer var slotBucket = _config.BucketInfo.SingleOrDefault(b => b.Slots.Any(s => s.Equals(slotName, StringComparison.OrdinalIgnoreCase))) ?? _config.BucketInfo.Single(b => b.Slots[0] == "*"); var client = _bucketToClient[slotBucket]; client.AddConsumer($"SLOT: {slotName}", commit => DispatchCommitAsync(commit, name, startCheckpoint)); } Initialized = true; KernelMetricsHelper.SetProjectionEngineCurrentDispatchCount(() => _countOfConcurrentDispatchingCommit); }
public TenantProvider(TenantContext context, IHttpContextAccessor accessor) { _context = context; _accessor = accessor; }
private async Task DispatchCommitAsync(IChunk chunk, string slotName, Int64 startCheckpoint) { Interlocked.Increment(ref _countOfConcurrentDispatchingCommit); _loggerThreadContextManager.SetContextProperty("commit", $"{chunk.OperationId}/{chunk.Position}"); if (_logger.IsDebugEnabled) { _logger.DebugFormat("Dispatching checkpoit {0} on tenant {1}", chunk.Position, _config.TenantId); } TenantContext.Enter(_config.TenantId); var chkpoint = chunk.Position; if (!lastCheckpointDispatched.ContainsKey(slotName)) { lastCheckpointDispatched[slotName] = 0; } if (lastCheckpointDispatched[slotName] >= chkpoint) { var error = String.Format("Sequence broken, last checkpoint for slot {0} was {1} and now we dispatched {2}", slotName, lastCheckpointDispatched[slotName], chkpoint); _logger.Error(error); throw new JarvisFrameworkEngineException(error); } if (lastCheckpointDispatched[slotName] + 1 != chkpoint && lastCheckpointDispatched[slotName] > 0) { _logger.DebugFormat("Sequence of commit not consecutive (probably holes), last dispatched {0} receiving {1}", lastCheckpointDispatched[slotName], chkpoint); } lastCheckpointDispatched[slotName] = chkpoint; if (chkpoint <= startCheckpoint) { //Already dispatched, skip it. Interlocked.Decrement(ref _countOfConcurrentDispatchingCommit); return; } var projections = _projectionsBySlot[slotName]; object[] events = GetArrayOfObjectFromChunk(chunk); var eventCount = events.Length; //now it is time to dispatch the commit, we will dispatch each projection //and for each projection we dispatch all the events present in changeset bool someProjectionProcessedTheEvent = false; foreach (var projection in projections) { var cname = projection.Info.CommonName; Object eventMessage = null; try { //Foreach projection we need to dispach every event for (int index = 0; index < eventCount; index++) { eventMessage = events[index]; var message = eventMessage as IMessage; string eventName = eventMessage.GetType().Name; _loggerThreadContextManager.SetContextProperty("evType", eventName); _loggerThreadContextManager.SetContextProperty("evMsId", message?.MessageId); _loggerThreadContextManager.SetContextProperty("evCheckpointToken", chunk.Position); _loggerThreadContextManager.SetContextProperty("prj", cname); var checkpointStatus = _checkpointTracker.GetCheckpointStatus(cname, chunk.Position); long ticks = 0; try { //pay attention, stopwatch consumes time. var sw = new Stopwatch(); sw.Start(); var eventProcessed = await projection .HandleAsync(eventMessage, checkpointStatus.IsRebuilding) .ConfigureAwait(false); someProjectionProcessedTheEvent |= eventProcessed; sw.Stop(); ticks = sw.ElapsedTicks; KernelMetricsHelper.IncrementProjectionCounter(cname, slotName, eventName, ticks, sw.ElapsedMilliseconds); if (_logger.IsDebugEnabled) { _logger.DebugFormat("[Slot:{3}] [Projection {4}] Handled checkpoint {0}: {1} > {2}", chunk.Position, chunk.PartitionId, $"eventName: {eventName} [event N°{index}]", slotName, cname ); } } catch (Exception ex) { var error = String.Format("[Slot: {3} Projection: {4}] Failed checkpoint: {0} StreamId: {1} Event Name: {2}", chunk.Position, chunk.PartitionId, eventName, slotName, cname); _logger.Fatal(error, ex); _engineFatalErrors.Add(String.Format("{0}\n{1}", error, ex)); throw; } } //End of event cycle } catch (Exception ex) { _loggerThreadContextManager.ClearContextProperty("commit"); _logger.ErrorFormat(ex, "Error dispathing Chunk [{0}]\n Message: {1}\n Error: {2}\n", chunk.Position, eventMessage?.GetType()?.Name, ex.Message); throw; } finally { _loggerThreadContextManager.ClearContextProperty("evType"); _loggerThreadContextManager.ClearContextProperty("evMsId"); _loggerThreadContextManager.ClearContextProperty("evCheckpointToken"); _loggerThreadContextManager.ClearContextProperty("prj"); } projection.CheckpointProjected(chunk.Position); //TODO: Evaluate if it is needed to update single projection checkpoint //Update this projection, set all events of this checkpoint as dispatched. //await _checkpointTracker.UpdateProjectionCheckpointAsync(cname, chunk.Position).ConfigureAwait(false); } //End of projection cycle. await _checkpointTracker.UpdateSlotAndSetCheckpointAsync( slotName, projections.Select(_ => _.Info.CommonName), chunk.Position, someEventDispatched : someProjectionProcessedTheEvent).ConfigureAwait(false); KernelMetricsHelper.MarkCommitDispatchedCount(slotName, 1); await _notifyCommitHandled.SetDispatched(slotName, chunk).ConfigureAwait(false); // ok in multithread wihout locks! if (_maxDispatchedCheckpoint < chkpoint) { if (_logger.IsDebugEnabled) { _logger.DebugFormat("Updating last dispatched checkpoint from {0} to {1}", _maxDispatchedCheckpoint, chkpoint ); } _maxDispatchedCheckpoint = chkpoint; } _loggerThreadContextManager.ClearContextProperty("commit"); Interlocked.Decrement(ref _countOfConcurrentDispatchingCommit); }
protected override void ConfigureTenantProfileContainer(IContainer tenantProfile, TenantContext <AppTenant> tenantContext) { // NOTE: // - Could configure profile as part of Container configuration, then just retrieve it using the tenant/profile name, but we are going to configure it here // - as we are doing tenant configuring here, could equally use "Container.CreateChildContainer();" // more info on Profiles and Child Containers -> http://structuremap.github.io/the-container/profiles-and-child-containers/ // for Tenant 2, want to override IMessageService to use OtherMessageService if (tenantProfile.ProfileName.Equals("Tenant 2", StringComparison.InvariantCultureIgnoreCase)) { tenantProfile.Configure(c => { c.For <IMessageService>().Use <OtherMessageService>(); }); } // Tenant 2 -> IMessageService should use OtherMessageService // all other tenants -> IMessageService should use the default MessageService //var whatDoIHave = tenantProfile.WhatDoIHave(); }
/// <summary> /// Start rebuild process. /// </summary> /// <returns></returns> public async Task <RebuildStatus> RebuildAsync() { if (Logger.IsInfoEnabled) { Logger.InfoFormat("Starting rebuild projection engine on tenant {0}", _config.TenantId); } DumpProjections(); await _eventUnwinder.UnwindAsync().ConfigureAwait(false); _status = new RebuildStatus(); TenantContext.Enter(_config.TenantId); await ConfigureProjections().ConfigureAwait(false); var allSlots = _projectionsBySlot.Keys.ToArray(); //initialize dispatching of the commits foreach (var bucket in _config.BucketInfo) { _consumers.Add(bucket, new List <RebuildProjectionSlotDispatcher>()); _status.AddBucket(); } //Setup the slots foreach (var slotName in allSlots) { Logger.InfoFormat("Slot {0} will be rebuilded", slotName); var projectionsForThisSlot = _projectionsBySlot[slotName]; Int64 maximumDispatchedValue = projectionsForThisSlot .Select(p => _checkpointTracker.GetCheckpoint(p)) .Max(); var dispatcher = new RebuildProjectionSlotDispatcher(Logger, slotName, _config, projectionsForThisSlot, maximumDispatchedValue, _loggerThreadContextManager); KernelMetricsHelper.SetCheckpointCountToDispatch(slotName, () => dispatcher.CheckpointToDispatch); _rebuildDispatchers.Add(dispatcher); //find right consumer var slotBucket = _config.BucketInfo.SingleOrDefault(b => b.Slots.Any(s => s.Equals(slotName, StringComparison.OrdinalIgnoreCase))) ?? _config.BucketInfo.Single(b => b.Slots[0] == "*"); var consumerList = _consumers[slotBucket]; consumerList.Add(dispatcher); } //Creates TPL chain and start polling everything on the consumer foreach (var consumer in _consumers) { var bucketInfo = String.Join(",", consumer.Key.Slots); if (consumer.Value.Count == 0) { Logger.InfoFormat("Bucket {0} has no active slot, and will be ignored!", bucketInfo); _status.BucketDone(bucketInfo, 0, 0, 0); continue; } var consumerBufferOptions = new DataflowBlockOptions(); consumerBufferOptions.BoundedCapacity = consumer.Key.BufferSize; var _buffer = new BufferBlock <UnwindedDomainEvent>(consumerBufferOptions); ExecutionDataflowBlockOptions executionOption = new ExecutionDataflowBlockOptions(); executionOption.BoundedCapacity = consumer.Key.BufferSize; var dispatcherList = consumer.Value; _projectionInspector.ResetHandledEvents(); List <SlotGuaranteedDeliveryBroadcastBlock.SlotInfo <UnwindedDomainEvent> > consumers = new List <SlotGuaranteedDeliveryBroadcastBlock.SlotInfo <UnwindedDomainEvent> >(); foreach (var dispatcher in dispatcherList) { ExecutionDataflowBlockOptions consumerOptions = new ExecutionDataflowBlockOptions(); consumerOptions.BoundedCapacity = consumer.Key.BufferSize; var actionBlock = new ActionBlock <UnwindedDomainEvent>((Func <UnwindedDomainEvent, Task>)dispatcher.DispatchEventAsync, consumerOptions); HashSet <Type> eventsOfThisSlot = new HashSet <Type>(); foreach (var projection in dispatcher.Projections) { var domainEventTypesHandledByThisProjection = _projectionInspector.InspectProjectionForEvents(projection.GetType()); foreach (var type in domainEventTypesHandledByThisProjection) { eventsOfThisSlot.Add(type); } } SlotGuaranteedDeliveryBroadcastBlock.SlotInfo <UnwindedDomainEvent> slotInfo = new SlotGuaranteedDeliveryBroadcastBlock.SlotInfo <UnwindedDomainEvent>( actionBlock, dispatcher.SlotName, eventsOfThisSlot); consumers.Add(slotInfo); KernelMetricsHelper.CreateMeterForRebuildDispatcherBuffer(dispatcher.SlotName, () => actionBlock.InputCount); } var allTypeHandledStringList = _projectionInspector.EventHandled.Select(t => t.Name).ToList(); var broadcaster = SlotGuaranteedDeliveryBroadcastBlock.Create(consumers, bucketInfo, consumer.Key.BufferSize); _buffer.LinkTo(broadcaster, new DataflowLinkOptions() { PropagateCompletion = true }); KernelMetricsHelper.CreateGaugeForRebuildFirstBuffer(bucketInfo, () => _buffer.Count); KernelMetricsHelper.CreateGaugeForRebuildBucketDBroadcasterBuffer(bucketInfo, () => broadcaster.InputCount); KernelMetricsHelper.CreateMeterForRebuildEventCompleted(bucketInfo); //fire each bucket in own thread #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed Task.Factory.StartNew(() => StartPoll( _buffer, broadcaster, bucketInfo, dispatcherList, allTypeHandledStringList, consumers)); //await StartPoll(_buffer, _broadcaster, bucketInfo, dispatcherList, allTypeHandledStringList, consumers).ConfigureAwait(false); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed } KernelMetricsHelper.SetProjectionEngineCurrentDispatchCount(() => RebuildProjectionMetrics.CountOfConcurrentDispatchingCommit); return(_status); }
private async Task <RequestResult <AuthorizationData> > CreateNewFacebookUser(TokenInfo tokenInfo, TenantContext requestTenant) { var userGuid = _guid.GetGuid(); var userData = _mapper.Map <CreateUserData>(tokenInfo); userData.UserGuid = userGuid; userData.TenantId = requestTenant.TenantId; userData.AvatarType = AvatarType.Facebook; var user = await _authRepository.CreateFacebookUser(userData); await _avatarRepository .StoreAvatar(user.Id, AvatarType.Facebook, tokenInfo.ImageUrl); return(await GetAuthorizationDataResult(requestTenant, user)); }
public void HandleTenantMismatchWhenDeleting() { try { _connection.Open(); var tenant1 = new TenantContext("abc", "abc", "abc", "DataSource=testdb.db", null, null); // TenantMismatchMode.Throw using (var db = new TestDbContext(tenant1, _options)) { db.Database.EnsureDeleted(); db.Database.EnsureCreated(); var blog1 = new Blog { Title = "abc" }; db.Blogs.Add(blog1); db.SaveChanges(); db.TenantMismatchMode = TenantMismatchMode.Throw; db.Entry(blog1).Property("TenantId").CurrentValue = "17"; db.Blogs.Remove(blog1); var e = Assert.Throws <MultiTenantException>(() => db.SaveChanges()); } // TenantMismatchMode.Ignore using (var db = new TestDbContext(tenant1, _options)) { db.TenantMismatchMode = TenantMismatchMode.Ignore; var blog1 = db.Blogs.First(); db.Entry(blog1).Property("TenantId").CurrentValue = "17"; db.Blogs.Remove(blog1); Assert.Equal(1, db.SaveChanges()); } // TenantMismatchMode.Overwrite using (var db = new TestDbContext(tenant1, _options)) { db.Database.EnsureDeleted(); db.Database.EnsureCreated(); var blog1 = new Blog { Title = "abc" }; db.Blogs.Add(blog1); db.SaveChanges(); db.TenantMismatchMode = TenantMismatchMode.Overwrite; db.Entry(blog1).Property("TenantId").CurrentValue = "17"; db.Blogs.Remove(blog1); Assert.Equal(1, db.SaveChanges()); } } finally { _connection.Close(); } }
public CostoHandlerEF(TenantContext tc) { ctx = tc; }
protected override IEnumerable <string> GetTenantIdentifiers(TenantContext <TestTenant> context) { return(context?.Tenant?.Paths); }
public async Task Invoke(HttpContext httpContext, ITenantResolverService tenantResolverService, ITenantMapperService <TTenantMapping> tenantMapperService, ITenantInfoService <TTenant> tenantInfoService) { TenantContext <TTenant> _tenantContext = null; TenantResolveResult _tenantResolveResult = null; TenantMapResult <TTenantMapping> _tenantMapResult = null; TTenant _tenant = default; TTenantMapping _tenantMapping = default; ResolutionResult _resolutionResult = ResolutionResult.NotFound; MappingResult _mappingResult = MappingResult.NotFound; ResolutionType _resolutionType = ResolutionType.Nothing; string _tenantResolvedData = ""; _tenantResolveResult = await tenantResolverService.ResolveTenantAsync(httpContext); _resolutionResult = _tenantResolveResult.ResolutionResult; switch (_resolutionResult) { case ResolutionResult.Success: _resolutionType = _tenantResolveResult.ResolutionType; _tenantResolvedData = _tenantResolveResult.Value; switch (_resolutionType) { case ResolutionType.TenantId: _mappingResult = MappingResult.NotApply; break; case ResolutionType.TenantName: _mappingResult = MappingResult.Success; break; } break; case ResolutionResult.NotApply: _mappingResult = MappingResult.NotApply; _tenantResolvedData = ""; break; case ResolutionResult.NotFound: _mappingResult = MappingResult.NotFound; _tenantResolvedData = ""; break; case ResolutionResult.Error: _mappingResult = MappingResult.Error; _tenantResolvedData = ""; break; } if (_resolutionResult == ResolutionResult.Success) { if (_mappingResult != MappingResult.NotApply) //if applies mapping call mapping service { _tenantMapResult = await tenantMapperService.MapTenantAsync(_tenantResolveResult.Value); _mappingResult = _tenantMapResult.MappingResult; switch (_mappingResult) { case MappingResult.Success: _tenantMapping = _tenantMapResult.Value; _tenantResolvedData = _tenantMapping.TenantId; break; case MappingResult.NotFound: _tenantResolvedData = ""; _resolutionResult = ResolutionResult.NotFound; _resolutionType = ResolutionType.Nothing; break; case MappingResult.Error: _tenantResolvedData = ""; _resolutionResult = ResolutionResult.Error; _resolutionType = ResolutionType.Nothing; break; } } //at this point it must be the id if (!string.IsNullOrWhiteSpace(_tenantResolvedData)) { _tenant = await tenantInfoService.GetTenantInfoAsync(_tenantResolvedData); } } _tenantContext = new TenantContext <TTenant>(_tenant, _resolutionResult, _mappingResult, _resolutionType); httpContext.SetTenantContext(_tenantContext); await _next(httpContext); }
public SampleApplicationController(TenantContext <Tenant> tenantContext, IContainer container) { this.tenantContext = tenantContext; this.container = container; }
public RecursosHandlerEF(TenantContext tc) { ctx = tc; }
internal void UploadFile(String jobFile, DocumentImportTask task) { String fname = ""; try { TenantContext.Enter(task.Tenant); if (!task.Uri.IsFile) { LogAndThrow("Error importing task file {0}: Uri is not a file: {1}", jobFile, task.Uri); } fname = task.Uri.LocalPath; if (FileHasImportFailureMarker(fname, task.FileTimestamp)) { return; } if (!File.Exists(fname)) { LogAndThrow("Error importing task file {0}: File missing: {1}", jobFile, fname); } var blobStore = GetBlobStoreForTenant(); var identityGenerator = GetIdentityGeneratorForTenant(); if (blobStore == null || identityGenerator == null) { Logger.ErrorFormat("Tenant {1} not found or not configured for file: {1}", task.Tenant, fname); return; } BlobId blobId; if (!String.IsNullOrEmpty(task.FileName)) { //use the real file name from the task not the name of the file using (FileStream fs = File.Open(fname, FileMode.Open, FileAccess.Read)) { blobId = blobStore.Upload(task.Format, new FileNameWithExtension(task.FileName), fs); } } else { //No filename given in task, use name of the blob blobId = blobStore.Upload(task.Format, fname); } if (task.Format == OriginalFormat) { var descriptor = blobStore.GetDescriptor(blobId); var fileName = new FileNameWithExtension(task.FileName); var handleInfo = new DocumentHandleInfo(task.Handle, fileName, task.CustomData); var documentId = identityGenerator.New <DocumentDescriptorId>(); var createDocument = new InitializeDocumentDescriptor( documentId, blobId, handleInfo, descriptor.Hash, fileName ); _commandBus.Send(createDocument, "import-from-file"); } else { var reader = _tenantAccessor.Current.Container.Resolve <IDocumentWriter>(); var handle = reader.FindOneById(task.Handle); var documentId = handle.DocumentDescriptorId; var command = new AddFormatToDocumentDescriptor( documentId, task.Format, blobId, new PipelineId("user-content") ); _commandBus.Send(command, "import-from-file"); } TaskExecuted(task); DeleteImportFailure(fname); } catch (Exception ex) { Logger.ErrorFormat(ex, "Job Import Queue - Error importing {0} - {1}", jobFile, ex.Message); ImportFailure failure = new ImportFailure() { Error = ex.ToString(), FileName = fname, Timestamp = DateTime.Now, ImportFileTimestampTicks = task.FileTimestamp.Ticks, }; MarkImportFailure(failure); } finally { TenantContext.Exit(); } }
protected override IEnumerable <string> GetTenantIdentifiers(TenantContext <AppTenant> context) { return(context.Tenant.Hostnames); }
public TestDbContext(TenantContext tenantContext, DbContextOptions <TestDbContext> options) : base(tenantContext, options) { }