/// <summary> /// Configure the data system to map requests for User type onto TUser via Identity mechanisms /// </summary> public virtual void InitialiseDataApi() { ContentTypeHierarchy.RegisterType(typeof(User)); ContentTypeHierarchy.RegisterType(typeof(TUser)); var sys = LyniconSystem.Instance; var extender = LyniconSystem.Instance.Extender; extender.RegisterForExtension(typeof(User)); //extender.RegisterExtensionType(typeof(LyniconIdentityUser)); var efDSFactory = new EFDataSourceFactory <TContext>(sys); var appDbRepository = new BasicRepository(sys, efDSFactory); efDSFactory.DbSetSelectors[typeof(TUser)] = db => db.Users.AsNoTracking(); efDSFactory.ContextLifetimeMode = ContextLifetimeMode.PerCall; // We DON'T want to register TUser with CompositeTypeManager var basicCollator = new BasicCollator(sys); Collator.Instance.Register(typeof(TUser), new BasicCollator(sys)); Repository.Instance.Register(typeof(TUser), appDbRepository); // override existing collator registration for User var identityAdaptorCollator = new IdentityAdaptorCollator <TUser, TUserManager>(sys); Collator.Instance.Register(typeof(User), identityAdaptorCollator); //Repository.Instance.Register(typeof(User), new BasicRepository()); }
/// <summary> /// Initialise the core dbcontext, the collator, the repository and the editor redirect for a content type /// </summary> /// <param name="t">content type</param> /// <param name="coll">the collator</param> /// <param name="repo">the repository</param> /// <param name="redir">the editor redirect</param> public void SetupType(Type t, ICollator coll, IRepository repo, DiversionStrategy divert) { if ((coll ?? this.Registered(null)).ContainerType(t) == t) // type t is its own container, so it may be extended { System.Extender.RegisterForExtension(t); } if (!typeof(IContentContainer).IsAssignableFrom(t)) { ContentTypeHierarchy.RegisterType(t); } if (coll != null) { coll.System = this.System; this.Register(t, coll); } if (repo != null) { System.Repository.Register(t, repo); } if (divert != null) { DataDiverter.Instance.Register(t, divert); } }
/// <summary> /// Adds a PageRoute with DataRoute functionality for providing data to routes in a classic ASP.Net application /// </summary> /// <typeparam name="TData">The type of the content data attached by the PageDataRoute</typeparam> /// <param name="routes">The route collection</param> /// <param name="name">Name of the route table entry</param> /// <param name="url">The url matching pattern</param> /// <param name="pageUrl">The url of the .aspx page template</param> /// <returns>The PageDataRoute that was created and registered</returns> static public DataRoute <TData> AddPageDataRoute <TData>(this RouteCollection routes, string name, string url, string pageUrl) where TData : class, new() { ContentTypeHierarchy.RegisterType(typeof(TData)); var route = new DataRoute <TData>(url, new RouteValueDictionary(), new PageRouteHandler(pageUrl)); routes.Add(name, route); return(route); }
/// <summary> /// Configure the data system to map requests for User type onto TUser via Identity mechanisms /// </summary> public virtual void InitialiseDataApi() { ContentTypeHierarchy.RegisterType(typeof(User)); var sys = LyniconSystem.Instance; sys.Extender.RegisterForExtension(typeof(User)); Collator.Instance.Register(typeof(User), new BasicCollator(sys)); Repository.Instance.Register(typeof(User), new BasicRepository(sys, new CoreDataSourceFactory(sys))); }
/// <summary> /// Add a DataRoute to an RouteCollection with route name, url pattern, default values and constraints /// </summary> /// <typeparam name="TData">The type of the content data attached by the DataRoute</typeparam> /// <param name="routes">A RouteCollection to add the route to</param> /// <param name="name">Name of the route table entry</param> /// <param name="url">The url matching pattern</param> /// <param name="defaults">Default values for unmatched pattern elements</param> /// <param name="constraints">Constraints for when the route should match</param> /// <returns>The DataRoute that was created and registered</returns> static public DataRoute <TData> AddDataRoute <TData>(this RouteCollection routes, string name, string url, object defaults, object constraints) where TData : class, new() { ValidateRouteSpec(name, typeof(TData), url, defaults); ContentTypeHierarchy.RegisterType(typeof(TData)); var route = new DataRoute <TData>(url, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new MvcRouteHandler()); routes.Add(name, route); return(route); }
/// <summary> /// Adds a route to the <see cref="IRouteBuilder"/> configured for data fetching, with the specified name, template, default values, and /// data tokens. /// </summary> /// <param name="routeBuilder">The <see cref="IRouteBuilder"/> to add the route to.</param> /// <param name="name">The name of the route.</param> /// <param name="template">The URL pattern of the route.</param> /// <param name="defaults"> /// An object that contains default values for route parameters. The object's properties represent the names /// and values of the default values. /// </param> /// <param name="constraints"> /// An object that contains constraints for the route. The object's properties represent the names and values /// of the constraints. /// </param> /// <param name="dataTokens"> /// An object that contains data tokens for the route. The object's properties represent the names and values /// of the data tokens. /// </param> /// <param name="writePermission"> /// A permission object which specifies who can create or edit the content item via this route /// </param> /// <param name="divertOverride"> /// A function which checks whether to switch out the default inner router with one which diverts the user /// to an editor controller /// </param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IRouteBuilder MapDataRoute <T>( this IRouteBuilder routeBuilder, string name, string template, object defaults = null, object constraints = null, object dataTokens = null, ContentPermission writePermission = null, DiversionStrategy divertOverride = null) where T : class, new() { if (routeBuilder.DefaultHandler == null) { throw new InvalidOperationException("Default handler must be set"); } var inlineConstraintResolver = (IInlineConstraintResolver)routeBuilder .ServiceProvider .GetService(typeof(IInlineConstraintResolver)); // Interpose a DataFetchingRouter between the classic Route and the DefaultHandler, which // tries to fetch the data for the route var dataFetchingRouter = new DataFetchingRouter <T>(routeBuilder.DefaultHandler, false, writePermission, divertOverride); var dataRoute = new DataRoute( dataFetchingRouter, name, template, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new RouteValueDictionary(dataTokens), inlineConstraintResolver); routeBuilder.Routes.Add(dataRoute); // Record the data route on Lynicon's internal RouteCollection used for reverse url generation if (ContentMap.Instance.RouteCollection == null) { ContentMap.Instance.RouteCollection = new RouteCollection(); } ContentMap.Instance.RouteCollection.Add(dataRoute); Type registerType = typeof(T); if (registerType.IsGenericType() && registerType.GetGenericTypeDefinition() == typeof(List <>)) { registerType = registerType.GetGenericArguments()[0]; } ContentTypeHierarchy.RegisterType(registerType); return(routeBuilder); }
public CoreModule(params string[] dependentOn) : base("Core", dependentOn) { if (!VerifyDbState("LyniconInit 0.1")) { this.Blocked = true; return; } ContentTypeHierarchy.RegisterType(typeof(User)); Collator.Instance.SetupType(typeof(ContentItem), null, null); Collator.Instance.SetupType(typeof(User), new BasicCollator(Repository.Instance), new UserRepository()); }
/// <summary> /// Add a DataRoute to an RouteCollection with route name, url pattern, default values and constraints /// </summary> /// <typeparam name="TData">The type of the content data attached by the DataRoute</typeparam> /// <param name="routes">A RouteCollection to add the route to</param> /// <param name="name">Name of the route table entry</param> /// <param name="url">The url matching pattern</param> /// <param name="defaults">Default values for unmatched pattern elements</param> /// <param name="constraints">Constraints for when the route should match</param> /// <param name="dataTokens">Data tokens to add to the route</param> /// <param name="redirectOverride">An editor redirect to use with this route</param> /// <returns>The DataRoute that was created and registered</returns> static public DataRoute <TData> AddDataRoute <TData>(this RouteCollection routes, string name, string url, object defaults, object constraints, object dataTokens, IEditorRedirect redirectOverride) where TData : class, new() { ValidateRouteSpec(name, typeof(TData), url, defaults); ContentTypeHierarchy.RegisterType(typeof(TData)); var route = new DataRoute <TData>(url, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new RouteValueDictionary(dataTokens), new MvcRouteHandler()); if (redirectOverride != null) { route.RedirectOverride = redirectOverride; } routes.Add(name, route); return(route); }
/// <summary> /// Add a DataRoute to an AreaRegistractionContext with route name, url pattern, default values and specific EditorRedirect to use /// </summary> /// <typeparam name="TData">The type of the content data attached by the DataRoute</typeparam> /// <param name="areaReg">An AreaRegistrationContext</param> /// <param name="name">Name of the route table entry</param> /// <param name="url">The url matching pattern</param> /// <param name="defaults">Default values for unmatched pattern elements</param> /// <param name="constraints">Constraints for when the route should match</param> /// <param name="dataTokens">Data tokens to add to the route</param> /// <param name="redirectOverride">An editor redirect to use with this route</param> /// <returns>The DataRoute that was created and registered</returns> static public DataRoute <TData> AddDataRoute <TData>(this AreaRegistrationContext areaReg, string name, string url, object defaults, object constraints, object dataTokens, IEditorRedirect redirectOverride) where TData : class, new() { ValidateRouteSpec(name, typeof(TData), url, defaults); ContentTypeHierarchy.RegisterType(typeof(TData)); DataRoute <TData> route = areaReg.Routes.AddDataRoute <TData>(name, url, defaults, constraints, dataTokens, redirectOverride); route.DataTokens["area"] = areaReg.AreaName; // disabling the namespace lookup fallback mechanism keeps this areas from accidentally picking up // controllers belonging to other areas //bool useNamespaceFallback = (namespaces == null || namespaces.Length == 0); //route.DataTokens["UseNamespaceFallback"] = useNamespaceFallback; return(route); }
public static void Initialise() { // Set up data types here ContentTypeHierarchy.RegisterType(typeof(HeaderContent)); ContentTypeHierarchy.RegisterType(typeof(HeaderContent2)); ContentTypeHierarchy.RegisterType(typeof(TestData)); ContentTypeHierarchy.RegisterType(typeof(Sub1TContent)); ContentTypeHierarchy.RegisterType(typeof(Sub2TContent)); ContentTypeHierarchy.RegisterType(typeof(RefContent)); ContentTypeHierarchy.RegisterType(typeof(RefTargetContent)); ContentTypeHierarchy.RegisterType(typeof(PathAddressData)); ContentTypeHierarchy.RegisterType(typeof(SplitAddressData)); ContentTypeHierarchy.RegisterType(typeof(RestaurantContent)); ContentTypeHierarchy.RegisterType(typeof(ChefContent)); LyniconModuleManager.Instance.Initialise(); }
/// <summary> /// Adds a route to the <see cref="IRouteBuilder"/> configured for data fetching, with the specified name, template, default values, and /// data tokens. /// </summary> /// <param name="routeBuilder">The <see cref="IRouteBuilder"/> to add the route to.</param> /// <param name="name">The name of the route.</param> /// <param name="template">The URL pattern of the route.</param> /// <param name="defaults"> /// An object that contains default values for route parameters. The object's properties represent the names /// and values of the default values. /// </param> /// <param name="constraints"> /// An object that contains constraints for the route. The object's properties represent the names and values /// of the constraints. /// </param> /// <param name="dataTokens"> /// An object that contains data tokens for the route. The object's properties represent the names and values /// of the data tokens. /// </param> /// <param name="divertOverride"> /// A function which checks whether to switch out the default inner router with one which diverts the user /// to an editor controller /// </param> /// <returns>A reference to this instance after the operation has completed.</returns> public static IRouteBuilder MapDataRoute <T>( this IRouteBuilder routeBuilder, string name, string template, object defaults, object constraints, object dataTokens, Func <IRouter, RouteContext, object, IRouter> divertOverride) where T : class, new() { if (routeBuilder.DefaultHandler == null) { throw new InvalidOperationException("Default handler must be set"); } var inlineConstraintResolver = (IInlineConstraintResolver)routeBuilder .ServiceProvider .GetService(typeof(IInlineConstraintResolver)); // Interpose a DataFetchingRouter between the classic Route and the DefaultHandler, which // tries to fetch the data for the route var dataFetchingRouter = new DataFetchingRouter <T>(routeBuilder.DefaultHandler, false, divertOverride); var dataRoute = new DataRoute( dataFetchingRouter, name, template, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new RouteValueDictionary(dataTokens), inlineConstraintResolver); routeBuilder.Routes.Add(dataRoute); // Record the data route on Lynicon's internal RouteCollection used for reverse url generation if (ContentMap.Instance.RouteCollection == null) { ContentMap.Instance.RouteCollection = new RouteCollection(); } ContentMap.Instance.RouteCollection.Add(dataRoute); ContentTypeHierarchy.RegisterType(typeof(T)); return(routeBuilder); }
/// <summary> /// Configure the data system to map requests for User type onto TUser via Identity mechanisms /// </summary> public virtual void InitialiseDataApi() { ContentTypeHierarchy.RegisterType(typeof(TUser)); CompositeTypeManager.Instance.RegisterExtensionType(typeof(LyniconIdentityUser)); var efDSFactory = new EFDataSourceFactory <TContext>(); var appDbRepository = new BasicRepository(efDSFactory); efDSFactory.DbSetSelectors[typeof(TUser)] = db => db.Users.Include(u => u.Roles); efDSFactory.ContextLifetimeMode = ContextLifetimeMode.PerCall; // We DON'T want to register TUser with CompositeTypeManager Collator.Instance.Register(typeof(TUser), new BasicCollator(Repository.Instance)); Repository.Instance.Register(typeof(TUser), appDbRepository); // override existing collator registration for User var identityAdaptorCollator = new IdentityAdaptorCollator <TUser, TUserManager>(GetUserManager); identityAdaptorCollator.Repository = Repository.Instance; Collator.Instance.Register(typeof(User), identityAdaptorCollator); }
public static void Init() { ContentTypeHierarchy.RegisterType(typeof(PropertyRedirectContent)); }