GENiALi's Blog

inEN by MS

0TweetsRetweet

Das dasBlog bietet einem die Möglichkeit eigene Makros zu schreiben.
Im Sourcecode von dasBlog gibt es eine Datei Macros.cs (im Projekt newtelligence.DasBlog.Web.Core). 
Dort sind die Makros drin die dasBlog von Haus aus mitbringt. Dort seine eigenen Makors
zu platzieren ist nicht so geschickt. Deshalb kann man seine Makros
in einem eigenen Projekt erstellen und danach im dasBlog einbinden.

Die originale Postings gibt es hier und hier (beides EN) zu finden.

Zuerst muss man sich dasBlog besorgen damit man zugriff auf ein paar
DLL's hat. Das dasBlog kann man bei SourceForge runterladen. Zu beachten ist,
dass man das dasBlog-XX-Source.zip File nimmt.

Danach erstellt man im Visual Studio ein neues Projekt vom Typ Klassenbibliothek.
Wie ihr das Projekt benennen wollt überlasse ich euch selber.

Als nächstes muss man noch ein paar DLL's als Verweise hinzufügen.
Im Projektmappen-Explorer klickt man auf Verweise, wählt im Kontextmenü
Verweis hinzufügen aus.

Der erste Verweis ist der auf System.Web. Bei mir ist es die Version 2.0.0.0 weil
ich mit Visual Studio 2005 arbeite und dadurch das .NET Framework 2.0 installiert ist.

Danach muss man noch die zwei DLL's aus dem dasBlog bin-Ordner referenzieren.
Die muss man je nach Installationsordner selber suchen. Das wären dann noch
die DLL newtelligence.DasBlog.Web.Core.dll und newtelligence.DasBlog.Runtime.dll.

Damit hätte man nun alle DLL's registriert. Jetzt sollte der Ordner
Verweise in etwa so aussehen.

Dann kann oder darf man siche endlich mit dem Code beschäftigen. :-) 
Ich würde aber noch ein paar Sachen anpassen.

1. Die Klasse Class1 umtaufen in Macros oder MyMacros oder ..... Einfach was sinnvolles.
2. Den Namespace anpassen. Bei mir wird aus dem Namespace MyDasBlogMacro dann
   GENiALi.MyDasBlogMacro. Einfach nicht so wie hier im Beispiel.
3. In der Projekteigenschaften erstellt man dann noch ein Postbuildereignis.
   xcopy "$(TargetDir)GENiALis*.*" "E:\Dev2005\dasBlog\source\newtelligence.DasBlog.Web\bin" /Y
   Das Statement kopiert mir alle Assemblies ins bin-Verzeichnis des dasBlog Webordners.

Jetzt darf man Code schreiben so viel man will. Ich kopiere hier einfach mal das Originalbeispiel von
dasBlog rein. Zu finden in der "DasBlog ALL" Solution. Das Projekt heisst FooMacroPlugin.

   1:  using System;

   2:  using System.Web;

   3:  using System.Web.UI;

   4:  using newtelligence.DasBlog.Runtime;

   5:  using newtelligence.DasBlog.Web.Core;

   6:   

   7:     // In your web.config you need to create a mapping between a name and 

   8:     // the .NET type that handles it. 

   9:     //

  10:     // web.config:

  11:     //   

  12:     // <configSections>

  13:     //    <section name="newtelligence.DasBlog.Macros" type="newtelligence.DasBlog.Web.Core.MacroSectionHandler, newtelligence.DasBlog.Web.Core" />

  14:     // </configSections>

  15:     // <newtelligence.DasBlog.Macros>

  16:     //      <!-- The format for a QN is Typename,AssemblyName. Do NOT include the .dll extension. -->

  17:     //     <add macro="foo" type="FooMacroPlugin.FooMacros,FooMacroPlugin"/> 

  18:     // </newtelligence.DasBlog.Macros>

  19:     // 

  20:     // Then your macro DLL would go in your \BIN folder. If you need to debug, include your PDB files.

  21:     //

  22:     // Within your homeTemplate.blogtemplate or itemTemplate.blogtemplate you'd use the macro like this.

  23:     // They are not fully supported in dayTemplate.blogtemplate. Be aware.

  24:     //

  25:     // <%TestControl("here is some text")|foo%>                    

  26:     // <%TestControlWithinEntry()|foo%>

  27:     //

  28:     

  29:  namespace FooMacroPlugin

  30:  {

  31:     /// <summary>

  32:     /// This is an example of how to write a custom macro.

  33:     /// </summary>

  34:     public class FooMacros 

  35:     {

  36:        protected SharedBasePage requestPage;

  37:        protected Entry currentItem;

  38:   

  39:        public FooMacros(SharedBasePage page, Entry item)

  40:        {

  41:           requestPage = page;

  42:           currentItem = item;

  43:        }

  44:   

  45:        //be sure to check and see that currentItem and/or requestPage are NOT NULL before you use them!

  46:        public virtual Control TestControl(string text)

  47:        {

  48:           return new LiteralControl("There are " + requestPage.WeblogEntries.Count  + " entries on this page");

  49:        }

  50:   

  51:        //be sure to check and see that currentItem and/or requestPage are NOT NULL before you use them!

  52:        public virtual Control TestControlWithinEntry()

  53:        {

  54:           return new LiteralControl("The Title of this entry is " + currentItem.Title);

  55:        }

  56:   

  57:     }

  58:  }

Mit requestPage und currentItem kann man auf diverse Infos rund ums dasBlog zugreifen.
Hier ist einfach einwenig forschen angesagt.

Beispiele:
int itemCount = sharedBasePage.WeblogEntries.Count;
Gibt einem die Anzahl Einträge auf der Seite zurück.

currentEntry.Content
Damit bekommt man den Inhalt des Eintrages mit allen HTML Tag's.

content = Utils.FilterContent(currentEntry.EntryId, content);
Auch sehr nützlich ist die Utils-Klasse. Wenn ich den Content mit currentEntry.Content hole
ist alles so drin wie im HTML. Die Smileys werden dann nicht in Grafiken umgewandelt.
Wenn ich den Content über den Filter laufen lasse aber schon.

So gibt es noch sehr viele Sachen die man finden wird. Hilfreich sind die Makros in der
Macros.cs (im Projekt newtelligence.DasBlog.Web.Core) Datei. Dort kann man viel abschauen und lernen.

Wenn das Makro wie gewünscht funktioniert muss man es noch einbinden. Na ja. Zuerst
muss man es noch in der web.config einbinden/aktivieren damit man es überhaupt testen
kann. Dazu gibt es zwei Sachen die man ändern muss.

1. Ausführung der Makros zulassen.

   1:  <section name="newtelligence.DasBlog.Macros" type="newtelligence.DasBlog.Web.Core.MacroSectionHandler, newtelligence.DasBlog.Web.Core"/>

Diese Zeile ist normal auskommentiert. Ohne die wird nichts funktionieren.

2. Das eigene Makro registrieren

   1:     <newtelligence.DasBlog.Macros>

   2:        <add macro="GENiALi" type="GENiALis.dasBlog.Macros.Macros, GENiALis.dasBlog.Macros"/>

   3:     </newtelligence.DasBlog.Macros>

Hier gibt man der Makroklasse einen Namen. Der wird noch gebraucht. <add macro="GENiALi"
Der Type ist wie folgt aufgebaut. type="Namespace + Klassenname, Namespace".

Jetzt geht es nur noch darum das Makro im dasBlog einzubauen. Je nach dem wo das Makro aktiv werden
soll muss es im homeTemplate.blogremplate oder im itemTemplate.blogtemplate plaziert werden.

Der Aufruf sieht z.B.: so aus.

   1:  <%GetItem("themes/directionalredux/item/Empfehlung.item", true, false, 1, 2, "[next item]")|GENiALi%>

GetItem ist der Name der Methode. Der Rest sind einfach Parameter die der Methode übergeben werden.
Am Ende, dass |GENiALi, ist dasselbe wie <add macro="GENiALi". Jetzt ist klar für was der Name ist.

Je nach dem sollte jetzt alles reibungslos funktionieren. Wenn nicht hilft einem der Debugger weiter.
Man kann natürlich auch in das Eventlog von dasBlog schreiben. Das macht man wie folgt.

   1:  catch(Exception ex)

   2:  {

   3:      string error = "Fehler bei der Aufbereitung der GetShortCurrentEntry<br><br>" + ex.ToString() + "<br><br>" + string.Format("{0}", currentEntry.Link);

   4:      sharedBasePage.LoggingService.AddEvent(new EventDataItem(EventCodes.Error, error, string.Empty));

   5:  }

Hier noch eine Liste mit Links zum Thema.
- dasBlog - Neue URL zum Sourcecode
- dasBlog 1.9 Sourcecode runterladen
- dasBlog 1.9 mit Visual Studio 2005 kompilieren
- Create Macro (dasBlog Homepage)
- Creating custom macros for dasBlog (das Original)
- DasBlog Macros (Beschreibung der Makros die dasBlog schon mitbringt)

- Vasanth 14 "Extra" Macros
- John Forsythe "My DasBlog themes and macros"