public KeyValueService(IContentRepository contentRepository, IContextResolver contextResolver) { Guard.ValidateObject(contentRepository); Guard.ValidateObject(contextResolver); _contentRepository = contentRepository; _contextResolver = contextResolver; }
/// <summary> /// Initializes a new instance of the <see cref="AutoResponseApiEventHttpResponseMapper"/> class. /// </summary> /// <param name="contextResolver">The context resolver.</param> /// <param name="formatter">The formatter.</param> public AutoResponseApiEventHttpResponseMapper( IContextResolver contextResolver, IAutoResponseExceptionFormatter formatter) : base(formatter) { this.contextResolver = contextResolver ?? throw new ArgumentNullException(nameof(contextResolver)); }
public SiteSettingsService(IContentRepository contentRepository, IContextResolver contextResolver, IStartPageService startPageRepository) { Guard.ValidateObject(contentRepository); Guard.ValidateObject(contextResolver); Guard.ValidateObject(startPageRepository); _contentRepository = contentRepository; _contextResolver = contextResolver; _startPageRepository = startPageRepository; }
public static ContextResolverTypedBindingProvider FromContextResolverType(Type t) { if (!typeof(IContextResolver).IsAssignableFrom(t)) { throw new ContextResolverTypeMismatchException(t.Name); } IContextResolver resolver = (IContextResolver)Activator.CreateInstance(t); return(new ContextResolverTypedBindingProvider(resolver)); }
public RuntimeContext(IContextResolver contextResolver) : base("name=BD.MedView.Services.Models.RuntimeContext") { this.contextResolver = contextResolver; Configuration.LazyLoadingEnabled = false; Configuration.ProxyCreationEnabled = false; if (this.contextResolver != null) { Database.Connection.StateChange += Connection_StateChange; } }
public ConfigurationContext(IContextResolver contextResolver, DbConnection existingConnection, bool contextOwnsConnection) : base(existingConnection, contextOwnsConnection) { this.contextResolver = contextResolver; Configuration.LazyLoadingEnabled = false; Configuration.ProxyCreationEnabled = false; if (this.contextResolver != null) { Database.Connection.StateChange += Connection_StateChange; } }
public override void Draw() { EditorDrawingHelper.DrawRoundedRect(Owner.BoundingBox, CurrentColor, 10f); IValidationHandler validation = EditorConfigurator.Instance.Validation; if (validation.IsAllowedToValidate()) { IContextResolver resolver = validation.ContextResolver; IContext context = resolver.FindContext(Owner.Step.Data, GlobalEditorHandler.GetCurrentCourse()); if (validation.LastReport != null) { List <EditorReportEntry> errors = validation.LastReport.GetEntriesFor(context); if (errors.Count > 0) { string tooltip = ValidationTooltipGenerator.CreateStepTooltip(errors, resolver.FindContext(Owner.ActiveChapter.Data, GlobalEditorHandler.GetCurrentCourse())); GUIContent content = new GUIContent("", null, tooltip); Rect rect = new Rect(Owner.BoundingBox.x + Owner.BoundingBox.width * 0.70f, Owner.BoundingBox.y - 8, 16, 16); // Label icons are too small so we draw a label for the tool tip and icon separated. GUI.Label(rect, content); GUI.DrawTexture(rect, EditorGUIUtility.IconContent("Warning").image); } } } float labelX = Owner.BoundingBox.x + labelBorderOffsetInwards; float labelY = Owner.BoundingBox.y + labelBorderOffsetInwards; float labelWidth = Owner.BoundingBox.width - labelBorderOffsetInwards * 2f; float labelHeight = Owner.BoundingBox.height - labelBorderOffsetInwards * 2f; Rect labelPosition = new Rect(labelX, labelY, labelWidth, labelHeight); GUIStyle labelStyle = new GUIStyle { alignment = TextAnchor.MiddleCenter, normal = { textColor = TextColor }, wordWrap = false, }; string name = EditorDrawingHelper.TruncateText(Owner.Step.Data.Name, labelStyle, labelPosition.width); GUIContent labelContent = new GUIContent(name); GUI.Label(labelPosition, labelContent, labelStyle); }
public EditLoadBackend(EntityApi entityApi, ContentGroupList contentGroupList, IServiceProvider serviceProvider, IUiContextBuilder contextBuilder, IContextResolver ctxResolver, ITargetTypes mdTargetTypes, // for prefetch IValueConverter valueConverter, EntityPickerApi entityPickerBackend) : base(serviceProvider, "Cms.LoadBk") { _entityApi = entityApi; _contentGroupList = contentGroupList; _contextBuilder = contextBuilder; _ctxResolver = ctxResolver; _mdTargetTypes = mdTargetTypes; _valueConverter = valueConverter; _entityPickerBackend = entityPickerBackend; }
public WebsiteDependencies( IContentRepository contentRepository, IContextResolver contextResolver, ICacheManager cacheManager, IAssetHandler assetHandler, ISiteSettingsService siteSettingsPageRepository) { Guard.ValidateObject(cacheManager); Guard.ValidateObject(contentRepository); Guard.ValidateObject(contextResolver); Guard.ValidateObject(assetHandler); Guard.ValidateObject(siteSettingsPageRepository); CacheManager = cacheManager; ContentRepository = contentRepository; ContextResolver = contextResolver; AssetHandler = assetHandler; _siteSettingsPageRepository = siteSettingsPageRepository; }
public AssetHandler( IContentRepository contentRepository, IBlobFactory blobFactory, IContextResolver contextResolver, ILinkResolver linkResolver, IContentTypeRepository contentTypeRepository, ContentMediaResolver contentMediaResolver) { Guard.ValidateObject(contentRepository); Guard.ValidateObject(blobFactory); Guard.ValidateObject(contextResolver); Guard.ValidateObject(linkResolver); Guard.ValidateObject(contentTypeRepository); Guard.ValidateObject(contentMediaResolver); _contentRepository = contentRepository; _blobFactory = blobFactory; _contextResolver = contextResolver; _linkResolver = linkResolver; _contentTypeRepository = contentTypeRepository; _contentMediaResolver = contentMediaResolver; }
public StatefulControllerDependencies(IZoneMapper zoneMapper, ITenantResolver tenantResolver, IUserResolver userResolver, //IModuleDefinitionRepository moduleDefinitionRepository, IModuleRepository moduleRepository, //ISettingRepository settingRepository, //OqtaneContainer oqtaneContainer, OqtTempInstanceContext oqtTempInstanceContext, IServiceProvider serviceProvider, IContextResolver ctxResolver ) { ServiceProvider = serviceProvider; CtxResolver = ctxResolver; ZoneMapper = zoneMapper; TenantResolver = tenantResolver; UserResolver = userResolver; //ModuleDefinitionRepository = moduleDefinitionRepository; ModuleRepository = moduleRepository; //SettingRepository = settingRepository; //_oqtaneContainer = oqtaneContainer; OqtTempInstanceContext = oqtTempInstanceContext; }
public AdamTransUpload(Lazy <AdamState <TFolderId, TFileId> > adamState, IContextResolver ctxResolver) : base(adamState, ctxResolver, "Adm.TrnUpl") { }
public EntityBackend(IServiceProvider serviceProvider, IContextResolver ctxResolver) : base(serviceProvider, "Bck.Entity") { _ctxResolver = ctxResolver.Init(Log); }
public HyperlinkBackend(Lazy <AdamContext <TFolderId, TFileId> > adamState, IContextResolver ctxResolver, IServiceProvider serviceProvider) : base(serviceProvider, "Bck.HypLnk") { _adamState = adamState; _ctxResolver = ctxResolver.Init(Log); }
/// <summary> /// This method has to be called once at the beginning of the applications /// lifecycle to provide the utils. /// </summary> /// <param name="logger">The logger to use inside all utilities.</param> /// <param name="contextResolver"></param> public static void Init(ILogger logger, IContextResolver contextResolver) { Logger = logger; ContextResolver = contextResolver; }
/// <summary> /// Allows to execute a given <paramref name="func"/> within an ensured <paramref name="ctx"/> including /// disposing the <paramref name="ctx"/> if none was given. /// </summary> /// <typeparam name="TResult">The result type of the <paramref name="func"/>.</typeparam> /// <typeparam name="TContext">The type of DbContext which should be used.</typeparam> /// <param name="func">The function to execute including an EF context.</param> /// <param name="ctx">The context or <c>null</c> if a new should be created.</param> /// <param name="resolver">A type which knows how to get the correct DbContext for a given entity type.</param> /// <param name="logger">The logger to use inside the operation.</param> /// <returns>The result of the <paramref name="func"/>.</returns> public static TResult ExecuteContextWrapped <TContext, TResult>(Func <TContext, TResult> func, TContext ctx, IContextResolver resolver, ILogger logger = null) where TContext : DbContext { if (func == null) { var ex = new ArgumentNullException(nameof(func)); logger?.LogException("ECU-EX-02", ex); throw ex; } var dispose = false; if (ctx == null) { ctx = resolver.GetContext(typeof(TContext)) as TContext; if (ctx == null) { throw new InvalidOperationException("Can not resolve database context."); } dispose = true; } var result = func.Invoke(ctx); if (dispose) { ctx.Dispose(); } return(result); }
/// <summary> /// New View Model Builder /// </summary> /// <param name="keyProvider">A View Model Key provider</param> public ViewModelFactory(IViewModelKeyProvider keyProvider, IViewModelResolver resolver, ILinkResolver linkResolver, IRichTextResolver richTextResolver, IContextResolver contextResolver, IDD4TConfiguration configuration, ILogger logger ) { if (keyProvider == null) { throw new ArgumentNullException("keyProvider"); } if (resolver == null) { throw new ArgumentNullException("resolver"); } if (linkResolver == null) { throw new ArgumentNullException("linkResolver"); } if (richTextResolver == null) { throw new ArgumentNullException("richTextResolver"); } if (contextResolver == null) { throw new ArgumentNullException("contextResolver"); } if (configuration == null) { throw new ArgumentNullException("DD4Tconfiguration"); } if (logger == null) { throw new ArgumentNullException("logger"); } this._keyProvider = keyProvider; this._resolver = resolver; this._linkResolver = linkResolver; this._richtTextResolver = richTextResolver; this._contextResolver = contextResolver; this._configuration = configuration; this._logger = logger; // Trying to find the entry assembly to load view models from. // For web applications, a special trick is needed to do this (see below). Assembly entryAssembly = GetWebEntryAssembly(); if (entryAssembly == null) { entryAssembly = Assembly.GetEntryAssembly(); } if (entryAssembly != null) { LoadViewModels(new List <Assembly> { entryAssembly }); } }
public AdamTransFolder(Lazy <AdamContext <TFolderId, TFileId> > adamState, IContextResolver ctxResolver) : base(adamState, ctxResolver, "Adm.TrnFld") { }
public ContextResolverBinding(IContextResolver contextResolver) { m_contextResolver = contextResolver; }
public MoviesController(IContextResolver contextResolver) { this.db = contextResolver.GetCurrentContext<MovieContext>(); }
public AppContent(IServiceProvider sp, EntityApi entityApi, Lazy <EntitiesToDictionary> entToDicLazy, IContextResolver ctxResolver) : base(sp, "Sxc.ApiApC") { _entityApi = entityApi; _entToDicLazy = entToDicLazy; _ctxResolver = ctxResolver; }
public AdamTransRename(Lazy <AdamState <TFolderId, TFileId> > adamState, IContextResolver ctxResolver) : base(adamState, ctxResolver, "Adm.TrnRen") { }
/// <summary> /// Allows to execute a given <paramref name="action"/> within an ensured <paramref name="ctx"/> including /// disposing the <paramref name="ctx"/> if none was given. /// </summary> /// <param name="action">The action to execute including an EF context.</param> /// <param name="ctx">The context or <c>null</c> if a new should be created.</param> /// <param name="resolver">A type which knows how to get the correct DbContext for a given entity type.</param> /// <param name="logger">The logger to use inside the operation.</param> public static void ExecuteContextWrapped <TContext>(Action <TContext> action, TContext ctx, IContextResolver resolver, ILogger logger = null) where TContext : DbContext { if (action == null) { var ex = new ArgumentNullException(nameof(action)); logger?.LogException("ECU-EX-01", ex); throw ex; } var dispose = false; if (ctx == null) { ctx = resolver.GetContext(typeof(TContext)) as TContext; if (ctx == null) { throw new InvalidOperationException("Can not resolve database context."); } dispose = true; } action.Invoke(ctx); if (dispose) { ctx.Dispose(); } }
public HomeController(IContextResolver contextResolver, MyDataContext myDataContext) { _contextResolver = contextResolver; _myDataContext = myDataContext; }
public ListsBackendBase(IPagePublishing publishing, Lazy <CmsManager> cmsManagerLazy, IContextResolver ctxResolver) : base("Bck.Lists") { CtxResolver = ctxResolver; _cmsManagerLazy = cmsManagerLazy; _publishing = publishing.Init(Log); }
public AppQuery(IServiceProvider serviceProvider, IContextResolver ctxResolver) : base(serviceProvider, "Sxc.ApiApQ") { _ctxResolver = ctxResolver; }
public ContextResolverValueProvider(IContextResolver resolver, FunctionBindingContext context) { m_resolver = resolver; m_context = context; }
public CarRepository(IContextResolver context) { this.context = context; }
public EditSaveBackend(SxcPagePublishing pagePublishing, Lazy <AppManager> appManagerLazy, IServiceProvider serviceProvider, IContextResolver ctxResolver) : base(serviceProvider, "Cms.SaveBk") { _pagePublishing = pagePublishing; _appManagerLazy = appManagerLazy; _ctxResolver = ctxResolver; }
public ContextResolverTypedBindingProvider(IContextResolver resolver) { m_resolver = resolver; }
//public const int UseAppIdFromContext = -12456; #region Constructor / DI protected AdamTransactionBase(Lazy <AdamContext <TFolderId, TFileId> > adamState, IContextResolver ctxResolver, string logName) : base(logName) { _adamState = adamState; _ctxResolver = ctxResolver.Init(Log); }
/// <summary> /// Default constructor for a util. /// </summary> /// <param name="logger">The logger to use.</param> /// <param name="contextResolver">The context resolver to use.</param> public BaseUtil(ILogger logger, IContextResolver contextResolver) { Logger = logger; ContextResolver = contextResolver; }