public List <object> GetList(Type type, Dictionary <string, object> clauses) { if (typeof(Summary).IsAssignableFrom(type)) { List <Type> types; if (clauses.ContainsKey("@Types")) { types = (List <Type>)clauses["@Types"]; } else { types = ContentTypeHierarchy.GetSummaryContainers(type); } var typeGroups = types .GroupBy(ct => Registered(ct)); List <object> res = new List <object>(); foreach (var typeGroup in typeGroups) { clauses["@Types"] = typeGroup.ToList(); res.AddRange(typeGroup.Key.GetList(type, clauses)); } return(res); } return(Registered(type).GetList(type, clauses)); }
/// <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); } }
public IEnumerable <PropertyStore> Get(Type type, Dictionary <string, object> clauses, List <string> fields, bool excludeFields) { if (typeof(Summary).IsAssignableFrom(type)) { if (clauses.ContainsKey("@Type")) { return(Registered((Type)clauses["@Type"]).Get(type, clauses, fields, excludeFields)); } List <Type> types; if (clauses.ContainsKey("@Types")) { types = (List <Type>)clauses["@Types"]; } else { types = ContentTypeHierarchy.GetSummaryContainers(type); } var typeGroups = types .GroupBy(ct => Registered(ct)); List <PropertyStore> resAll = new List <PropertyStore>(); foreach (var typeGroup in typeGroups) { clauses["@Types"] = typeGroup.ToList(); var res = typeGroup.Key.Get(type, clauses, fields, excludeFields); resAll.AddRange(res); } return(resAll); } return(Registered(type).Get(type, clauses, fields, excludeFields)); }
/// <summary> /// Get the possible patterns for a new url of the given type /// </summary> /// <param name="datatype">Type as its name as a string</param> /// <returns>The patterns as JSON</returns> public ActionResult TypePatterns(string datatype) { Type type = ContentTypeHierarchy.GetContentType(datatype); var patterns = ContentMap.Instance.GetUrlPatterns(type); return(Json(patterns, JsonRequestBehavior.AllowGet)); }
/// <summary> /// Standard Startup file initialisation /// </summary> /// <param name="app">Application Builder</param> /// <param name="life">Application Lifetime</param> public void Initialise(IApplicationBuilder app, IApplicationLifetime life) { if (app != null) { RequestContextManager.Instance = new RequestContextManager(app.ApplicationServices); // Initialise user system this.SecurityManager = Membership.SecurityManager.Current = app.ApplicationServices.GetService <ISecurityManager>(); this.SecurityManager.InitialiseDataApi(); var partManager = app.ApplicationServices.GetService <ApplicationPartManager>(); var controllerFeature = new ControllerFeature(); partManager.PopulateFeature(controllerFeature); ContentTypeHierarchy.RegisterControllers(controllerFeature.Controllers); } Modules.ValidateModules(); Settings.RunTypeSetup?.Invoke(Collator); if (Settings.ApplyDbContext == null) // use SqlServer setup by default { Settings = Settings.UseDefaultDbContextBuilder((builder, conn) => builder.UseSqlServer(conn)); } Collator.BuildRepository(); Modules.Initialise(this); if (life != null) { life.ApplicationStopped.Register(Modules.Shutdown); } }
/// <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> /// Get the possible patterns for a new url of the given type /// </summary> /// <param name="datatype">Type as its name as a string</param> /// <returns>The patterns as JSON</returns> public IActionResult TypePatterns(string datatype) { Type type = ContentTypeHierarchy.GetContentType(datatype); var patterns = RouteData.GetTemplatePatterns(type); return(Json(patterns)); }
public LyniconSystemFixture() { ContentTypeHierarchy.RegisterControllersFromAssemblies(new List <Assembly> { this.GetType().GetTypeInfo().Assembly }); LyniconSystem = new LyniconSystem(new LyniconSystemOptions() .UseTypeSetup(col => { col.SetupTypeForBasic <TestData>(); col.SetupType <HeaderContent>(); col.SetupType <HeaderContent2>(); col.SetupType <Sub1TContent>(); col.SetupType <Sub2TContent>(); col.SetupType <RefContent>(); col.SetupType <RefTargetContent>(); col.SetupType <RestaurantContent>(); col.SetupType <ChefContent>(); col.SetupType <PathAddressData>(); col.SetupType <SplitAddressData>(); col.SetupType <PropertyRedirectContent>(); col.SetupTypeForBasic <RedirectData>(); col.SetupType <RedirectTargetContent>(); col.SetupType <SingleContent>(); col.System.Repository.Register(null, new ContentRepository(col.System, new MockDataSourceFactory(col.System))); col.System.Repository.Register(typeof(TestData), new BasicRepository(col.System, new MockDataSourceFactory(col.System))); col.System.Repository.Register(typeof(RedirectData), new BasicRepository(col.System, new MockDataSourceFactory(col.System))); col.System.Repository.Register(typeof(ContentItem), new ContentRepository(col.System, new MockDataSourceFactory(col.System))); })); LyniconSystem.Extender.AddExtensionRule(typeof(TestData), typeof(IExtTestData)); LyniconSystem.Extender.AddExtensionRule(typeof(ICoreMetadata), typeof(IPublishable)); LyniconSystem.Extender.AddExtensionRule(typeof(ICoreMetadata), typeof(IInternational)); LyniconSystem.Construct(new Lynicon.Extensibility.Module[] { new CoreModule(LyniconSystem) }); LyniconSystem.Modules.SkipDbStateCheck = true; LyniconSystem.SetAsPrimarySystem(); LyniconSystem.Initialise(); //SetupLyniconSystemWithDb(); //VersionManager.Instance.RegisterVersion(new TestVersioner()); var testingRoutes = new RouteCollection(); testingRoutes.AddTestDataRoute <HeaderContent>("header", "header/{_0}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <TestData>("test-data", "testd/{_0}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <ChefContent>("chef", "header/{_0}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <HeaderContent2>("hc2", "header2", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <SingleContent>("single", "single/{abc}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <RefContent>("ref", "ref/{_0}/{_1}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <RestaurantContent>("rest", "restaurant/{abc}", new { controller = "mock", action = "mock" }); testingRoutes.AddTestDataRoute <HeaderContent>("header-write", "header-write/{_0}", new { controller = "mock", action = "mock" }, new ContentPermission((roles, data) => true)); ContentMap.Instance.RouteCollection = testingRoutes; VersionManager.Instance.RegisterVersion(new PublishingVersioner(LyniconSystem, t => t == typeof(HeaderContent))); VersionManager.Instance.RegisterVersion(new I18nVersioner(LyniconSystem, new string[] { "en-GB", "es-ES" }, "locale", "en-GB", s => s)); Collator.Instance.SetupType <TestContent>(new TestCollator(), null); }
/// <summary> /// Get markup to refresh an individual item on the List page /// </summary> /// <param name="datatype">Type of the item</param> /// <param name="id">Id of the item</param> /// <returns>Markup for the item</returns> public ActionResult GetItem(string datatype, string id) { ViewData.Add("UrlPermission", LyniconSecurityManager.Current.CurrentUserInRole(Lynicon.Membership.User.EditorRole)); Type type = ContentTypeHierarchy.GetContentType(datatype); var summ = Collator.Instance.Get <Summary>(new ItemId(type, id)); return(PartialView("ItemListSummary", summ)); }
/// <summary> /// Constructs an address from a serialized string form (created via .ToString()) /// </summary> /// <param name="serialized">the serialized string</param> public Address(string serialized) { this.Type = ContentTypeHierarchy.GetContentType(serialized.UpTo(":")); foreach (string kvpStr in serialized.After(":").Split('&')) { this.Add(HttpUtility.UrlDecode(kvpStr.UpTo("=")), HttpUtility.UrlDecode(kvpStr.After("="))); } }
/// <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); }
//public IEnumerable<string> GetUrls(object item) //{ // Type type = item.GetType(); // if (type == typeof(ContentItem)) // type = ContentTypeHierarchy.GetContentType((item as ContentItem).DataType); // var routes = RouteTable.Routes // .OfType<Route>() // .Where(r => r.GetType().IsGenericType // && r.GetType().GetGenericTypeDefinition() == typeof(DataRoute<>) // && r.GetType().GetGenericArguments()[0] == type); // foreach (var route in routes) // { // var urls = GetUrls(route, item); // foreach (string url in urls) // yield return url; // } //} //public List<string> GetUrls(Route route, object item) //{ // return Registered(route.GetType().GetGenericArguments()[0]).GetUrls(route, item); //} public Dictionary <string, string> GetAddress(object item) { Type type = item.GetType(); if (item is ContentItem) { type = ContentTypeHierarchy.GetContentType(((ContentItem)item).DataType); } return(Registered(type).GetAddress(item)); }
/// <summary> /// Get items by a query /// </summary> /// <typeparam name="T">type of items returned by repository</typeparam> /// <param name="targetType">type of items these will produce, and in terms of which the query body is defined</param> /// <param name="queryBody">function to apply to a source queryable to filter to the queryable required</param> /// <returns>items in containers or the items themselves</returns> public IEnumerable <T> Get <T>(Type targetType, Func <IQueryable <T>, IQueryable <T> > queryBody) where T : class { if (typeof(Summary).IsAssignableFrom(targetType)) { return(Get <T>(targetType, ContentTypeHierarchy.GetSummaryContainers(targetType), queryBody)); } else { return(Registered(targetType).Get <T>(targetType, new Type[] { targetType }, queryBody)); } }
public void Set(Type type, PropertyStore val, object id) { var query = GetQuery(type, val, id, ProcessQuerySet); query.ShouldInsert = false; // int affected = query.RunUpdateInsert(); if (affected == 0) // insert { ContentTypeHierarchy.EnsureContainsType(type); // this might be the first content item of this type in the db } }
/// <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); }
/// <summary> /// Get markup to show all the items of a type in a paged box on the List page /// </summary> /// <param name="datatype">The data type</param> /// <returns>Markup of the paged box listing the items</returns> public ActionResult GetPage(string datatype) { ViewData.Add("UrlPermission", LyniconSecurityManager.Current.CurrentUserInRole(Lynicon.Membership.User.EditorRole)); ViewData.Add("DelPermission", LyniconSecurityManager.Current.CurrentUserInRole(Lynicon.Membership.User.AdminRole)); Type type = ContentTypeHierarchy.GetContentType(datatype); Type containerType = Collator.Instance.ContainerType(type); // invoke Collator.Instance.GetList<Summary, type>(new Type[] { type }, RouteData).ToArray(); var summs = (IEnumerable <Summary>)ReflectionX.InvokeGenericMethod(Collator.Instance, "GetList", new Type[] { typeof(Summary), containerType }, new Type[] { type }, RouteData); var data = summs.ToArray(); return(PartialView("ItemPage", data)); }
public IActionResult RefQuery(string query, string listId, string allowedVsn) { var types = listId.Split('_').Select(cn => ContentTypeHierarchy.GetContentType(cn)).ToList(); bool showType = types.Count > 1; var qWords = query.ToLower().Split(new char [] { ' ' }, StringSplitOptions.RemoveEmptyEntries); ItemVersion maskVsn = null; ItemVersion currMaskedVsn = null; bool versioned = false; if (!string.IsNullOrEmpty(allowedVsn)) { maskVsn = new ItemVersion(allowedVsn); ItemVersion curr = sys.Versions.CurrentVersion; ItemVersion vsn = curr.Superimpose(maskVsn); currMaskedVsn = curr.Mask(maskVsn); sys.Versions.PushState(VersioningMode.Specific, vsn); versioned = true; } try { var cachedTypes = types.Where(t => Cache.IsTotalCached(LyniconModuleManager.Instance, t, true)).ToList(); var uncachedTypes = types.Except(cachedTypes).ToList(); var items = Enumerable.Range(0, 1).Select(n => new { label = "", value = "" }).ToList(); items.Clear(); if (uncachedTypes.Count > 0) { // TO DO add attribute for containers specifying which field or fields to scan for title, add code to create query to scan here } if (cachedTypes.Count > 0) { items.AddRange(Collator.Instance.Get <Summary, Summary>(cachedTypes, iq => iq.Where(s => qWords.All(w => ((s.Title ?? "").ToLower() + " " + s.Type.Name.ToLower()).Contains(w))).Take(30)) .Select(summ => new { label = summ.Title + (showType ? " (" + LyniconUi.ContentClassDisplayName(summ.Type) + ")" : "") + (versioned && !currMaskedVsn.ContainedBy(summ.Version.Mask(maskVsn)) ? " [" + sys.Versions.DisplayVersion(summ.Version.Mask(maskVsn)).Select(dv => dv.Text).Join(" ") + "]" : ""), value = versioned ? summ.ItemVersionedId.Mask(maskVsn).ToString() : summ.ItemId.ToString() }) .OrderBy(s => s.label)); } return(Json(new { items })); } finally { if (versioned) { sys.Versions.PopState(); } } }
/// <summary> /// Get items via a query /// </summary> /// <typeparam name="T">return type, this can be a summmary type, a content type, or a class from which several content types inherit. The query will be applied across all content types which could output an item of this type.</typeparam> /// <typeparam name="TQuery">the type in terms of which the query is expressed: the content type or possibly a class from which several content types inherit</typeparam> /// <param name="queryBody">a function which takes an iqueryable and adds the query to the end of it</param> /// <returns>list of items of (or cast to) return type</returns> public IEnumerable <T> Get <T, TQuery>(Func <IQueryable <TQuery>, IQueryable <TQuery> > queryBody) where T : class where TQuery : class { if (typeof(Summary).IsAssignableFrom(typeof(T))) { return(Get <T, TQuery>(ContentTypeHierarchy.GetSummaryContainers(typeof(T)), queryBody)); } else { return(Get <T, TQuery>(ContentTypeHierarchy.GetAssignableContentTypes(this, typeof(T)), queryBody)); } }
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> /// Get a data item, or list of items, via the route which maps to them /// </summary> /// <typeparam name="T">type of the item(s), a generic list if a list of items, could be a summary type</typeparam> /// <param name="contentType">the content type of the item(s)</param> /// <param name="rd">route data</param> /// <returns>the mapped items(s)</returns> public T Get <T>(Type contentType, RouteData rd) where T : class { //CodeTimer.MarkTime("Get via route START"); try { if (typeof(T).IsGenericType() && typeof(T).GetGenericTypeDefinition() == typeof(List <>)) { Type elType = typeof(T).GetGenericArguments()[0]; ICollator coll; List <Type> contentTypes; bool isSummary = typeof(Summary).IsAssignableFrom(elType); if (isSummary) { contentTypes = ContentTypeHierarchy.GetSummaryContainers(elType); if (contentTypes.Select(ct => Registered(ct)).Distinct().Count() != 1) { throw new Exception("Content types containing summary type " + elType.FullName + " dont have 1 unique registered collator, requirement for a dataroute with list type"); } coll = Registered(contentTypes.First()); } else { coll = Registered(elType); contentTypes = new List <Type> { elType }; } T itemList = (T)ReflectionX.InvokeGenericMethod(coll, "GetList", new Type[] { elType, isSummary ? elType : ContainerType(elType) }, contentTypes, rd); return(itemList); } else { ICollator coll = Registered(contentType); return(coll.Get <T>(new List <Address> { coll.GetAddress(contentType, rd) }).FirstOrDefault()); } } finally { //CodeTimer.MarkTime("Get via route END"); } }
/// <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> /// Construct an ItemId by deserializing it from a string (created via .ToString()) /// </summary> /// <param name="s">Serialized ItemId</param> public ItemId(string s) { if (string.IsNullOrEmpty(s) || !s.Contains(":")) { return; } string[] parts = s.Split(':'); var idStr = parts[0].Trim(); var typeStr = parts[1].Trim(); if (string.IsNullOrEmpty(idStr) || string.IsNullOrEmpty(typeStr)) { return; } this.Id = idStr; this.Type = ContentTypeHierarchy.GetContentType(typeStr); }
/// <summary> /// Construct an ItemId by deserializing it from a string (created via .ToString()) /// </summary> /// <param name="s">Serialized ItemId</param> public ItemId(string s) { if (string.IsNullOrEmpty(s) || !s.Contains(":")) { throw new ArgumentException("Serialized ItemId in wrong format: " + (s ?? "NULL")); } string[] parts = s.Split(':'); var idStr = parts[0].Trim(); var typeStr = parts[1].Trim(); if (string.IsNullOrEmpty(idStr) || string.IsNullOrEmpty(typeStr)) { throw new ArgumentException("Serialized ItemId in wrong format: " + (s ?? "NULL")); } this.Id = idStr; this.Type = ContentTypeHierarchy.GetContentType(typeStr); }
/// <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); }
/// <summary> /// Process all content items using a contentProcessor /// </summary> /// <typeparam name="T">Type to which all content items must be assigned</typeparam> /// <param name="contentProcessor">Set of methods for processing content</param> public static void ProcessLoop <T>(this IContentProcessor contentProcessor) where T : class { log.InfoFormat("**Process all for {0} begins", contentProcessor.Name); var contentTypes = ContentTypeHierarchy.GetAssignableContentTypes(typeof(T)); foreach (Type t in contentTypes) { Debug.WriteLine("Processing: " + t.FullName); foreach (object content in Collator.Instance.Get <object, object>(new Type[] { t }, iq => iq)) { try { contentProcessor.Process(content); Collator.Instance.Set(null, content, new Dictionary <string, object> { { "setAudit", false } }); } catch (Exception ex) { try { Summary s = Collator.Instance.GetSummary <Summary>(content); log.Error("Error processing content item " + s.Title + " for " + contentProcessor.Name, ex); } catch { log.Error("Error processing unidentified content item for " + contentProcessor.Name, ex); } } } } log.InfoFormat("**Process all for {0} ends", contentProcessor.Name); }