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;
}
