Urler

En sida i en Dynamixlösning har alltid en huvud-url, vad vi kallar den "kanoniska" urlen. Man kan eventuellt nå sidan via andra urler, t ex om man har satt upp genvägar till sidan, men webbläsaren kommer då skickas vidare till den kanoniska urlen. Detta är viktigt bl a av seo-skäl.

Navigeringslägen

Sidor har (i första hand) fyra lägen för vilken sidans kanoniska url skall vara, detta kan man ändra genom att redigera egenskaperna för sidan, t ex genom att högerklicka på sidan i lösningsträdet.

  • Sidans namn – innebär att sidan får sin url efter namnet på sidan och dess position i sajtträdet

  • Angivet namn – innebär att man kan ange ett annat namn som ska användas i urlen, i övrigt identisk med ”Sidans namn”

  • Sidans id – innebär att sidan får en url med sidans id-nummer inbakat, detta kan vara användbart om det finns flera sidor som annars skulle få samma url.

  • Sajtens inställning – innebär att standardinställningen för sajten används, denna kan vara antingen ”Sidans id” eller ”Sidans namn”

Man kan surfa till en sida via andra urler än den kanoniska, man kan t ex alltid nå en sida via dess id, men då kommer alltid webbläsaren skickas vidare till den kanoniska urlen.

Genvägar

Man kan dessutom ha ett antal genvägar som skickar vidare webbläsaren till sidans kanoniska url, detta är användbart både om man vill ha en url som är lätt att komma ihåg (t ex minsajt.se/blogg skickar vidare till minsajt.se/Svenska/Innehall/Startsida_blogg) och om man har flyttat sidor eller migrerat från en annan lösning (tex minsajt.se/blog.php?view=categorylist skickar vidare till minsajt.se/Svenska/Innehall/Blog/Kategorier)

För en specifik sida redigeras genvägarna enklast via egenskaperna, samma flik som url-inställningarna.

Om man vill få en överblick över alla genvägar i lösningen kan man använda genvägsverktyget, där kan man även lägga upp genvägar till andra objekt som implementerar IUrl.

Routing

Om man vill att en sida ska ha en annan kanonisk url än de som är möjliga genom att ändra navigeringsläge och/eller skicka med parametrar till sidan kan man göra en egen router-metod som registreras hos Dynamix huvud-router (förslagsvis i Global.asax). Denna routermetod kommer sedan att anropas när Dynamix försöker matcha en url med rätt sida och då kan man kolla om den efterfrågade urlen ska skickas vidare till en annan sida och sätta eventuella parametrar.

  1. protected void Application_Start(Object sender, EventArgs e)
  2. {
  3. ...
  4. Dynamix.Routing.Routes.Router += Blog_Router;
  5. ...
  6. }

Routing-metoden får ett objekt av typen Dynamix.Routing.RoutingEventArgs som parameter, detta objekt har ett antal egenskaper som du kan skriva till i din metod för att precisera hur en url ska hanteras.

  • Site - denna parameter kan du läsa av för att se vilken sajt besökaren har surfat till i en lösning som innehåller flera webbplatser

  • OriginalHRef – den efterfrågade urlen, kontrollera om detta är en url som du vill hantera

  • IsMatch – sätt denna till true om du har hanterat urlen

  • NewUrl – den nya url som ska användas istället för den efterfrågade

  • Action – ange om det ska göras en intern övergång (InternalTransfer) eller om den nya urlen ska skickas tillbaka till webbläsaren (Redirect)

  • Parameters – här kan du lägga in parametrar som kan läsas av innehåll på sidan, detta motsvarar url-parametrar

  • IsDone - denna ska sättas till true om NewUrl pekar på en "fysisk" fil (en egen aspx eller liknande), om NewUrl går till en Dynamix-sida krävs ett ytterligare routing-steg och IsDone ska då vara false.

Ett exempel är om du har blogginlägg på sajten som i lösningsträdet ligger direkt under "blog" men där du vill att enskilda inlägg ska ha urler av formen "minsajt.se/blog/kategori/rubrik". I din router-metod behöver du då kontrollera om OriginalHRef matchar ett blogginlägg och sätta NewUrl till urlen för blogginläggets sida.

  1. void Blog_Router( Dynamix.Routing.RoutingEventArgs e )
  2. {
  3. // Try to find a matching blog page
  4. Dynamix.NavigationItem blogPage = GetBlogPage( e.OriginalHref );
  6. // If we found a blog page and it is active we will redirect to that page
  7. if( blogPage != null && blogPage.IsActive )
  8. {
  9. e.IsMatch = true;
  10. e.NewUrl = blogPage.Url;
  11. e.Action = Dynamix.Routing.RoutingAction.InternalTransfer;
  12. e.IsDone = false;
  13. }
  14. }

Om du har en sida som kan visa blogginlägg som hör till en viss kategori kan du även se till man kan komma till en lista med inlägg som hör till en viss kategori via urler av formen minsajt.se/blog/kategori genom att routa sådana urler till sidan som visar kategorilistan och skicka med den efterfrågade kategorin i en parameter.

  1. void Blog_Router( Dynamix.Routing.RoutingEventArgs e )
  2. {
  3. ...
  4. // Try to find a matching blog category
  5. BlogCategory category = GetBlogCategory( e.OriginalHRef );
  7. // If we found a category, redirect to the category page and set the parameter
  8. if( category != null )
  9. {
  10. e.IsMatch = true;
  11. e.NewUrl = GetBlogCategoryPage().Url;
  12. e.Action = Dynamix.Routing.RoutingAction.InternalTransfer;
  13. e.AddParameter( "category", category );
  14. e.IsDone = false;
  15. }
  16. }

I innehållskontrollen eller mallen kan man sedan läsa parametern och visa blogginlägg från den kategorin.

  1. void RenderBlogPosts( HtmlTextWriter writer )
  2. {
  3. //Get category from parameters
  4. var category = RequestContext.Current.GetParameterObject<BlogPostCategory>( "category" );
  6. //Render blogposts in category
  7. ...
  8. }

Ändra kanonisk url

En nackdel med att bara registrera en router-metod är att även om en sidas url externt (från en besökares perspektiv) verkar vara en annan än dess kanoniska url så är det fortfarande den kanoniska urlen som returneras av NavigationUtil.GetObjectUrl, dvs interna länkar till sidan kommer att använda minsajt.se/blog/sidnamn även om du har gjort en router som ser till att du kan surfa till sidan via minsajt.se/blog/kategori/rubrik.

För att ändra sidans kanoniska url måste du registrera en UrlProvider för typen NavigationItem.

  1. [assembly: UrlProvider( ProviderType = typeof( BlogUrlProvider ), TargetType = typeof( NavigationItem ) )]

I metoden GetUrl kan du sedan kontrollera om objektet som skickas in är en sida som du vill ta hand om, och returnera den url som du tycker att den ska ha. I exemplet nedan kollar vi om sidan är en bloggsida och returnerar blogginläggets url.

  1. public class BlogUrlProvider : IUrlProvider
  2. {
  3. public Url GetUrl( object x )
  4. {
  5. var item = x as NavigationItem;
  6. if( item != null )
  7. {
  8. // Try to find a blog post with this page
  9. var post = BlogPost.GetBlogPost( item );
  10. if ( post != null )
  11. return new Url( post.GetUrl() );
  12. }
  13. // item is not a NavigationItem null or it does not represent a blog post
  14. return null;
  15. }
  16. }

Navigationsstruktur

Ibland vill man att den navigationsstruktur som besökare upplever skall vara en annan än den som syns i Dynamix-gränssnittet (t ex i panelen "Webbplatser och sidor"). En vanlig sitiuation är när du vill lägga till nya "virtuella" sidor som pekar på en existerande sida med vissa parameter satta, t ex om du har en sida som visar information om en produkt kan du på detta sätt få det att se ut som om varje produkt har en egen, unik sida. Ett annat exempel är om du har artiklar som taggas med kategorier, då kanske du vill ha en virtuell sida för varje kategori och visa de artiklar som tillhör en kategori som undersidor till kategorisidan.

Som vi såg tidigare kan man registrera en routermetod som hanterar urler av formen minsajt.se/blog/kategorinamn och ser till att de routas till en sida som visar en lista med blogginlägg och skickar med "kategorinamn" som en parameter så att bara blogginlägg som hör till den kategorin visas. Ett problem med denna lösning är att om din sajt använder standardkontroller för navigation och/eller sajtkarta/sidindex, eller en modul (t ex Initivas Seo-modul) som genererar en xml-sajtkarta för sökmotorer, vill du nog att dina "virtuella" kategorisidor kommer med även där, men standardkontrollerna kan ju inte veta att det ska finnas fler sidor och var de ska ligga i strukturen. Detta problem kan lösas genom att registrera en NavigationProvider.

I de flesta fall är navigationsträdet uppbyggd av Site- och NavigationItem-objekt men man kan även lägga in andra typer av objekt. Både Site och NavigationItem implementerar interfacet INavigation och kan returnera ett NavigationInformation-objekt som innehåller information om dess plats i navigationsträdet men genom att registrera en NavigationProvider har man möjlighet att returnera annan information än standard.

Här följer ett exempel på hur man kan ha virtuella sidor för produkter. Notera att klassen Product antingen måste implementera IUrl eller ha en registrerad UrlProvider som returnerar vilken url enskilda produkter ska ha, förmodligen något i stil med: http://www.minsajt.se/produkter/produktid, samt att det måste finnas en router-metod som hanterar urler på den formen, lagrar produktid i en parameter och skickar vidare till http://www.minsajt.se/produkter eller motsvarande.

  1. [assembly: NavigationProvider( ProviderType = typeof( ProductNavigationProvider ), TargetType = typeof( NavigationItem ) )]
  2. [assembly: NavigationProvider( ProviderType = typeof( ProductNavigationProvider ), TargetType = typeof( Product ) )]
  4. public class BlogNavigationProvider : INavigationProvider
  5. {
  6. public NavigationInformation GetNavigationInformation( object x, User user )
  7. {
  8. var item = x as NavigationItem;
  9. if( item != null )
  10. {
  11. if( Equals( x, Settings.Instance.ProductsRoot ) )
  12. {
  13. return new ProductsRootNavigationInformation( Dynamix.Util.CurrentUser );
  14. }
  15. }
  17. var product = x as Product;
  18. if( product != null )
  19. {
  20. return new ProductPageNavigationInformation( Dynamix.Util.CurrentUser, Product product );
  21. }
  22. }
  23. }
  25. public class ProductsRootNavigationInformation: NavigationItemNavigationInformation
  26. {
  27. public ProductsRootNavigationInformation( User user )
  28. : base( Settings.Instance.ProductsRoot , user )
  29. {
  30. }
  32. public override IEnumerable<object> NavigationChildren
  33. {
  34. get
  35. {
  36. return Dynamix.Object.GetAll<Product>().Cast<object>().ToList();
  37. }
  38. }
  39. }
  41. public class ProductPageNavigationInformation: NavigationInformation
  42. {
  43. private Product _product;
  44. public ProductPageNavigationInformation( User user, Product product )
  45. {
  46. _product = product;
  47. }
  49. public override IEnumerable<object> NavigationChildren
  50. {
  51. get
  52. {
  53. yield break;
  54. }
  55. }
  56. public override object NavigationParent
  57. {
  58. get
  59. {
  60. return Settings.Instance.ProductsRoot;
  61. }
  62. }
  63. public override bool IsNavigationVisible
  64. {
  65. get
  66. {
  67. return false;
  68. }
  69. }
  70. public override bool IsContentVisible
  71. {
  72. get
  73. {
  74. return true;
  75. }
  76. }
  77. public override bool IsIndexed
  78. {
  79. get
  80. {
  81. return true;
  82. }
  83. }
  84. }

När man gör en kontroll eller liknande som ska använda sig av navigationsstukturen, t ex en meny-navigationskontroll, bör man inte använda INavigation-interfacet direkt utan hämta NavigationInformation-objektet via NavigationUtil.GetNavigationInformation för att eventuella NavigationProviders ska få möjlighet att bygga om navigationsträdet.

Här följer ett enkelt exempel på hur en kontroll som renderar ut en sajtkarta kan se ut:

  1. public class MySiteMapControl : System.Web.UI.WebControls.CompositeControl
  2. {
  3. protected override void Render( HtmlTextWriter writer )
  4. {
  5. writer.WriteFullBeginTag("ul");
  6. foreach( var site in Dynamix.GetAll<Site>() )
  7. {
  8. RenderObject(site);
  9. }
  10. writer.WriteEndTag("ul");
  11. }
  13. private void RenderObject( HtmlTextWriter writer, object obj )
  14. {
  15. var navigationInformation = NavigationUtil.GetNavigationInformation( obj, Util.CurrentUser );
  16. var url = NavigationUtil.GetObjectUrl( obj );
  17. writer.WriteFullBeginTag("li");
  18. writer.WriteBeginTag( "a" );
  19. writer.WriteAttribute( "href", url.HRef );
  20. writer.Write(">");
  21. writer.Write( NamesUtil.GetObjectName( obj ) );
  22. writer.WriteEndTag( "a" );
  23. writer.WriteFullBeginTag("ul");
  24. foreach( var child in navigationInformation.NavigationChildren )
  25. {
  26. RenderObject( child );
  27. }
  28. writer.WriteEndTag("ul");
  29. writer.WriteEndTag("li");
  30. }
  31. }