Alles rund um Magento!

Archiv zur KategorieEntwicklung

FACT-Finder-Features als Magento-Modul verfügbar

Seit Februar ist ein von Flagbit entwickeltes neues Magento-Modul für die Such- und Navigationslösung FACT-Finder verfügbar. Das Modul kann über Magento Connect bezogen und installiert werden. Mit der Extension können Magento-Nutzer derzeit die Fact-Finder-Features Fehlertolerante Suche, Suggest, Automatische Suchoptimierung, After Search Navigation ebenso wie den Campaign Manager in ihren Shop integrieren und auch das FACT-Finder-Management ins Magento-Backend einbinden. Flagbit arbeitet bereits an einer weiteren Version, in der zusätzliche Features ebenfalls kompatibel sind. Weitere Informationen können in einer kürzlich herausgegebenen Pressemitteilung von Flagbit nachgelesen werden.

Cache, Optimizer, DynamicCategories – neue Magento-Module von und mit Flagbit

Endlich haben wir es geschafft und mal wieder ein paar Module veröffentlicht. Diesmal dabei sind die Extensions Flagbit_Cache, Flagbit_Optimizer sowie Firegento_DynamicCategories. Wir haben die Module vorerst in Github geladen, werden das aber auch bald im Magento Connect nachholen. Da muss zunächst noch ein englischer Beschreibungstext verfasst werden.

weiterlesen »

Git unverbindlich testen: git-svn

Wenn man Git erst einmal unverbindlich ausprobieren will ohne gleich das ganze Team auf eine neues SCM-System umstellten zu müssen, ist git-svn genau das Richtige. Es verhält sich zum SVN-Repository hin wie ein normaler Client, bietet aber lokal alle gängigen Git-Features. Branches und Tags lassen sich sowohl lokal als auch remote einfach per Kommandozeile anlegen. Diffs und lokale Commits gehen rasend schnell, weil die komplette Historie lokal vorliegt. Dazu checkt git-svn initial jede Version aus dem SVN-Repository aus und spielt die Versionsgeschichte lokal nach. Das dauert dann bei 1500 Commits auch mal eine halbe Stunde oder länger, aber das muss man ja auch nur einmal machen:

$ git svn clone -s svn://svn.example.org/my-cool-project

Die Option -s sorgt dafür, dass die Standard-SVN-Verzeichnisstruktur mit branches, tags und trunk erkannt wird und auch korrekt in Git als Branches und Tags abgebildet wird. Abweichende Ordnernamen lassen sich über weitere Kommandozeilenparameter konfigurieren. Nach geduldigem Warten listet Git auch brav alle SVN-Branches sowie den lokalen master-Branch auf:

$ git branch -a
* master
  remotes/production
  remotes/trunk

Will man nun ein neues Feature implementieren, kann man sich einfach einen lokalen Branch erstellen:

$ git checkout -b my-new-feature

Darauf kann man nun gemütlich arbeiten, ohne von anderen Änderungen beeinträchtigt zu sein. Will man seine Änderungen an das zentrale SVN-Repository zurückschicken, muss man erst lokal commiten und anschließend ins SVN-Repository:

$ git commit -a
$ git svn dcommit

Wenn man zwischendurch an einer anderen Aufgabe weiterarbeiten will (oder muss), kann man jederzeit einen neuen Branch erstellen oder in den master-Branch zurückwechseln:

$ git checkout master

Die aktuellen Änderungen aus dem SVN-Repository (das Pendant zu svn update) bekommt man mit:

$ git svn rebase

Ein bisschen ausführlicher und auf Englisch ist das Ganze auch in Bart’s Blog erklärt. Ansonsten helfen die umfangreichen Git-Hilfe-Seiten weiter. Zu fast jedem Befehl lassen sich mit git help <command> weitere Informationen anzeigen.

Magento Installation in der Shell

Warum einfach, wenns auch kompliziert geht? War die Shell sonst gerade gut genug, Magento Extensions per Kommandozeile ergänzend zum Grundgerüst zu integrieren, kann man damit auch komplett die neueste Magento Version installieren. Dafür bedarf es nur einer Kommandozeile.

Alle notwendigen Informationen können dann nicht nur in der normalen Installationsoberfläche eingegeben werden, sondern auch als Parameter in der Shell. Die Anbindung an die Datenbank ist ebenso hergestellt und auch der Encryption Key wird definiert. Statt sich dabei mühsam durch die einzelnen Installationsseiten zu klicken, haut man sich den Code auf die Platte und spart in Zukunft viel Zeit. So kann alles bequem in einem Aufwasch abgearbeitet werden und Magento ist auf diesem Wege ebenfalls und ohne Einschränkungen startklar. Ein weiterer Vorteil bei diesem Prozedere: Dank der automatisierten Magentoinstallation können auch Entwicklungsumgebungen zukünftig schneller aufgesetzt werden.

Und so gehts beispielsweise:

php -f $MAGE_DIR/install.php -- \
--license_agreement_accepted "yes" \
--locale "en_US" \
--timezone "Europe/Berlin" \
--default_currency "EURO" \
--db_host "localhost" \
--db_name "mydatabase" \
--db_user "usernr1" \
--db_pass "1234" \
--db_prefix "" \
--session_save "files" \
--admin_frontname "backend" \
--url "http://meineshopurl.de" \
--skip_url_validation \
--use_rewrites "yes" \
--use_secure "no" \
--secure_base_url "https://meineshopurl.de/" \
--use_secure_admin "no" \
--admin_firstname "Max" \
--admin_lastname "Mustermann" \
--admin_email "max@muster.de" \
--admin_username "super_admin" \
--admin_password "super_admin9876" \
--encryption_key "blablubb"

Logrotate für Magento

Auch wenn an machen Stellen empfohlen wird, die Logfiles aus Performance-Gründen auszuschalten, halte ich nicht viel davon. Denn wenn einmal ein Fehler nicht reproduzierbar auftritt, erweisen sich die Logfiles oft als der einzige Ansatzpunkt zur Fehlersuche. Auch bei reproduzierbaren Fehlern erlauben die Logfiles Rückschlüsse darauf, wie oft der Fehler in der Vergangenheit aufgetreten ist. Wenn man die Logfiles jedoch einfach so immer weiter wachsen lässt, werden sie immer unübersichtlicher und verbrauchen einfach immer mehr Platz. Mit dem Unix-Tool logrotate kann man Logfiles einfach und bequem per Cronjob komprimieren, kopieren und nach einem konfigurierbaren Zeitraum löschen lassen.

Zunächste muss eine entsprechende Konfiguration angelegt werden. Die Pfadangaben beziehen sich auf Debian Lenny. Als Root am besten eine neue Datei /etc/logrotate.d/magento anlegen, ansonsten bietet sich ~/.logrotate.conf an. Im Beispiel werden im Wochenrhythmus verschoben (weekly) und jeweils 5 Versionen (rotate 5) vorgehalten. Die alten Logfiles automatisch komprimiert (compress).

/srv/www/var/log/exception.log {
        weekly
        rotate 5
        compress
}
/srv/www/var/log/system.log {
        weekly
        rotate 5
        compress
}

Die Konfigurationsdatei in /etc/logrotate.d sollte eigentlich bereits automatisch ausgeführt werden. Für andere Dateien muss noch ein separater Cronjob eingerichtet werden:

2 3 * * * /usr/sbin/logrotate -s ~/.logrotate.status ~/.logrotate.conf

Artikel über TypoGento im Internet Magazin & TypoGento-Schulungen

Durch Zufall wurde mir gestern das Internet Magazin gereicht mit dem Hinweis auf einen Artikel namens “Liebeshochzeit?”. Nach dem genaueren Hinsehen wurde klar, worum es eigentlich ging: “Typogento – Magento und TYPO3 miteinander verheiraten”. Die beiden Autoren, Thomas Krähe und Tobias Hauser, schaffen es in der schier unglaublichen Kürze von vier DIN A4-Heftseiten eine komplette Beschreibung des Ablaufs von Installation und Konfiguration von Magento, TYPO3 und TypoGento zu beschreiben, der zum einen recht vollständig ist und zum anderen noch nachvollziehbar bleibt. Hut ab!

Der Artikel ist verblüffend positiv eingestellt, wenn  man bedenkt, dass wir TypoGento wegen anderen Projekten in den vergangenen Monaten recht stiefmütterlich behandeln mussten. Das Fazit lautet (in Ausschnitten):

“Typogento bietet eine hochwertige Integration von Content-Management-System und Online Shop. Es ist ein Leichtes, Daten zwischen den Systemen auszutauschen und Besucher Ihrer Site merken nicht einmal, dass es sich um zwei Systeme handelt. [...] Wenn alles läuft, dann bietet Typogento eine mächtige Plattform mit zahllosen Funktionen für den professionellen Einsatz als integrierter Onlineshop und CMS.”

Vielen Dank für die Blumen! Jedem Interessenten bzw. jedem, der nach einer veritablen Anleitung zu TypoGento lechzt, sei die Ausgabe 07/10 des Internet Magazins an’s Herz gelegt.

Außerdem sind wir sehr froh, dass wir in Zusammenarbeit mit der Open Source School aus München ein kleines, aber engagiertes Schulungsprogramm starten dürfen. Wir haben bereits in den vergangenen Monaten versucht, einen Teil unserer Expertise über diesen Blog auszutauschen, aber eine Schulung mit einer kleinen Gruppe von Interessierten vor Ort, auf deren Fragen und Bedürfnisse man direkt eingehen kann, stellt noch einmal eine andere Qualität dar.

Für den Anfang haben wir drei Schulungen konzipiert:

Bei Interesse oder offenen Fragen zu den Schulungen könnt ihr euch gern auch an uns richten.

phpDoc mit Ant erzeugen

Mit Ant lassen sich viele Aufgaben (teil)automatisieren. Unter anderem auch das Generieren der Dokumentation auf Basis der phpDoc-Kommentare (PEAR). In der build.properties werden die folgenden drei Eigenschaften definiert:

### build.properties ###
# Pfad zur php.exe
php.bin=C:/Program Files/PHP_5.2.11/php.exe
# Verzeichnis für die Dokumentation
phpdoc.dir=doc
# Pfad zum phpDocumentor-Skript (Installation via PEAR)
phpdoc.inc=C:/Program Files/PHP_5.2.11/PEAR/PhpDocumentor/phpDocumentor/phpdoc.inc

In der build.xml wird ein neues Target für das Erstellen der Dokumentation definiert.

<!-- build.xml -->
<project name="MyProject" basedir=".">
 
	<property file="build.properties"/>
 
	<target name="phpdoc">
		<delete dir="${phpdoc.dir}" />
		<exec executable="${php.bin}" dir="${basedir}">
			<arg value="${phpdoc.inc}" />
			<arg value="-f" />
			<arg value="*.php" />
			<arg value="-t" />
			<arg value="${phpdoc.dir}" />
			<arg value="-ti" />
			<arg value="MyProject" />
		</exec>
	</target>
 
</project>

Beim Starten des Targets wird zunächst die alte Dokumentation entfernt und anschließend eine neue erzeugt.

Das Verwalten der Dokumentation via VCS ist nicht empfehlenswert, da es hierbei häufig zu Konflikten kommen kann. Bei kleineren Projekten kann sich jeder die Dokumentation mit Ant selbst erstellen. Bei größeren Projekten, wenn die Erstellung längere Zeit in Anspruch nimmt, lässt sich diese durch einen Cronjob, einen SVN-Hook oder einen CI-Server (z. B. phpUnderControl) auslagern.

Erstellen eines Backend-Moduls: Grundlagen und Konfiguration

Grundlegende Erkenntnisse

Magento ist prinzipiell modular aufgebaut. In Version 1.3 besteht Magento aus zirka 50 Core-Module, deren Funktionalität sich durch weitere Community- oder Local-Extensions erweitern und verändern lässt.

Das Backend ist, was dies angeht eher ein schlechtes Beispiel: Es ist nicht modular aufgebaut, wie man dies vom Frontend her gewohnt ist – die meisten Standard-Interfaces befinden sich im Modul „Adminhtml“. Für den Entwickler hat dies einige Nachteile, wie sich im Laufe der Beitragsserie zeigen wird.

Trotzdem bietet auch das Backend einige Möglichkeiten, bestehende Funktionalitäten anzupassen und zu erweitern. Wie das geht, werden wir in den kommenden Wochen mit einigen kleinen Beiträgen anhand einiger bestehender Module beschreiben. Die Möglichkeiten werden in diesen mit Sicherheit nicht ausgeschöpft – falls wir was Wichtiges vergessen haben sollten, weißt uns bitte drauf hin.

Dieser erste Beitrag beschäftigt sich mit den Teilen der Konfiguration, die für die Erstellung von Backend Interfaces interessant sind.

Die Konfiguration

Wie jedes Modul benötigen auch Backend-Module Konfigurations-Einstellungen, die über die Definitionen der config.xml eingestellt werden. Die allgemeinen Einstellungsmöglichkeiten wie die Definition von Models, Blocks oder Helpern sind nicht Bestandteil dieses Beitrags; viel mehr soll fokussiert auf die speziellen Einstellungen für Backend-Module eingegangen werden.

Der <modules>-Block

Im ersten Block werden allgemeine Informationen zum Modul definiert, wie der Name, die Version und ob das Modul aktiv ist oder nicht:

  <modules>
    <Flagbit_Glossary>
      <active>true</active>
      <codePool>local</codePool>
      <version>0.2.0</version>
    </Flagbit_Glossary>
  </modules>

Der <admin>-Block

Nachdem wir im modules-Block zunächst allgemeine Informationen über das Modul gegeben haben, bietet der zweite Block zwei wichtige allgemeine Einstellungen des Magento-Backends: die Registrierung unseres Admin-Controllers sowie die Definition unserer Adressen.

  <admin>
    <routers>
      <glossary>
        <use>admin</use>
        <args>
          <module>Flagbit_Glossary</module>
          <frontName>glossary</frontName>
        </args>
      </glossary>
    </routers>

Damit ein Modul überhaupt eigene Informationen verarbeiten kann, muss es einen oder mehrere Controller bei den Routern definieren können. (Action-)Controller sind für die Steuerung der Abläufe und Prozesse innerhalb der MVC-Architektur von Magento zuständig. Router wiederum sind Controller, die einen bestimmten Aufruf anhand der Adresse an einen Action Controller übergeben.

Innerhalb des routers-Block verstecken sich folgende Angaben (vgl. Mage_Core_Controller_Varien_Router_Standard :: collectRoutes()):

  • Das XML-Tag <glossary> bestimmt den Namen der aktuellen Route. Auf diese Art und Weise wäre es möglich, bestehende Routen über ein eigenes Modul zu überschreiben.
  • Im Backend ist es natürlich wichtig, dass alle Sicherheitsbestimmungen greifen und die Interfaces nicht aus dem Frontend aufgerufen werden können. Dementsprechend wird hier der Wert „admin“ übergeben.
  • Das Module beschreibt natürlich das aktuelle Modul.
  • Der FrontName wiederum bestimmt, unter welcher URL das eigene Modul aufgerufen werden kann. In unserem Fall wäre dies „http://www.example.com/glossary“.
    <rewrite>
      <Flagbit_Glossary>
        <from>
          <![CDATA[#^/{adminhtml}/glossary/#]]>
        </from>
        <to>/glossary/admin/</to>
      </Flagbit_Glossary>
    </rewrite>
  </admin>

Um das Backend-Modul nun optimal in das Magento-Backend zu integrieren, sollten sich auch die URLs des Moduls an den Admin-Adressen orientieren – die bisherige URL sieht eher wie die im Frontent aus. Hierfür steht der <rewrite>-Block, der alle Aufrufe von „/{adminhtml}/glossary“ auf den AdminController unseres Frontnames weiterleitet. ”{adminhtml}“ ist hierbei als Platzhalter für das die Adresse des Backend zu verstehen – dieser wird von Magento automatisch ausgetauscht. Als Resultat wird dem Nutzer automatisch unser AdminController angezeigt, wenn er den “GlossarController von Adminhtml” aufrufen möchte.

Der <adminhtml>-Block

  <adminhtml>
    <menu>
      <cms>
        <children>
          <glossary translate="title" module="glossary">
            <title>Glossary</title>
            <action>adminhtml/glossary</action>
            <sort_order>50</sort_order>
          </glossary>
        </children>
      </cms>
    </menu>

Der erste Teil des XML-Blocks beschreibt die Einbindung unseres Moduls in das Menü des Backends. Die Hauptmenü-Punkte sind Kindknoten von <menu>; in unserem Fall bauen wir keinen neuen Punkt in der ersten Ebene ein, sondern fügen einen neuen Unterpunkt zu CMS hinzu.

<cms> versteht sich als Referenz auf die Definitionen, die in der config.xml des CMS-Moduls eingefügt wurden – so könnten andere Module wiederum auf die Definitionen von <glossary> zugreifen und diese ändern oder erweitern. Zu beachten ist hierbei auch, dass zwei Module einer Extensions auch eindeutige Keys benötigen!

<title>, <action> und <sort_order> sind an sich selbsterklärend; bei <action> sollte nach Möglichkeit die Adresse angegeben werden, die wir im <rewrite> definiert haben.

    <acl>
      <resources>
        <admin>
          <children>
            <cms>
              <children>
                <glossary translate="title" module="glossary">
                  <title>Glossary</title>
                  <sort_order>50</sort_order>
                </glossary>
              </children>
            </cms>
          </children>
        </admin>
      </resources>
    </acl>
  </adminhtml>

Der <acl>-Bereich ist bezüglich des Aufbaus verwandt mit dem beschriebenen Menü. Er ermöglicht die Rechteverwaltung im Backend von Magento. Logischerweise wird der Glossar auch hier wieder als Kindknoten von CMS definiert.

Als Resultat gibt es in der Rechteverwaltung eine neue Checkbox – beim Generieren des Menüs und Aufruf des Moduls wird überprüft, ob das entsprechende Häkchen gesetzt ist oder eben nicht. Als Hinweis sei erlaubt, dass beim Testen der Rechte ein neuer Login Wunder bewirken kann, da die Rechte beim Login überprüft und in die Session des Nutzers gespeichert werden.

Die gesamte config.xml

Wie die gesamte Konfiguration aussehen kann, zeigt das folgende Listing:

<?xml version="1.0"?>
<config>
  <modules>
    <Flagbit_Glossary>
      <active>true</active>
      <codePool>local</codePool>
      <version>0.2.0</version>
    </Flagbit_Glossary>
  </modules>
  <admin>
    <routers>
      <glossary>
        <use>admin</use>
        <args>
          <module>Flagbit_Glossary</module>
          <frontName>glossary</frontName>
        </args>
      </glossary>
    </routers>
    <rewrite>
      <Flagbit_Glossary>
        <from>
          <![CDATA[#^/{adminhtml}/glossary/#]]>
        </from>
        <to>/glossary/admin/</to>
      </Flagbit_Glossary>
    </rewrite>
  </admin>
  <adminhtml>
    <menu>
      <cms>
        <children>
          <glossary translate="title" module="glossary">
            <title>Glossary</title>
            <action>adminhtml/glossary</action>
            <sort_order>50</sort_order>
          </glossary>
        </children>
      </cms>
    </menu>
    <acl>
      <resources>
        <admin>
          <children>
            <cms>
              <children>
                <glossary translate="title" module="glossary">
                  <title>Glossary</title>
                  <sort_order>50</sort_order>
                </glossary>
              </children>
            </cms>
          </children>
        </admin>
      </resources>
    </acl>
  </adminhtml>
</config>

Fazit

Im ersten Beitrag zur Entwicklung von Backend-Modulen haben wir die Definitionen der Konfiguration kurz unter die Lupe genommen. Mangels Dokumentation fällt deren Interpretation nicht immer leicht – den Platzhalter für {adminhtml} mussten wir uns auch im Quelltext zusammensuchen.

Mit der Konfiguration konnten wir den Grundstein für die Entwicklung von Backend-Modulen legen, indem wir unsere Controller registriert und in das Menü mit eingebunden haben. Viel Funktionalität haben wir damit natürlich noch nicht – in den kommenden Beiträgen werden wir diese Hülle mit Leben füllen.

ANT und Zend Studio 7

Um ANT im Zend Studio 7 zu aktivieren sind folgende Schritte nötig:

  1. Neues Projekt anlegen: File -> New -> Other
    Den Haken “Show All Wizards” setzen, jetzt kann Java Project from Existing Ant Buildfile auswählt werden, Auswahl mit “next >” bestätigen. zend-studio_new-java-project-ant
  2. Haken bei “Always enable activities and don´t ask me again” setzen und mit “OK” bestätigenzend-studio_confirm-enablement
  3. Projekt erstellen abbrechen “Cancel”zend-studio_new-java-project-cancel

Und damit ist ANT aktiviert und kann genutzt werden.

Beitragsserie: Entwicklung eines Backendmoduls

In den Gesprächen der letzten Tage im offiziellen deutschen Magento-IRC-Channel (#magento-de bei irc.freenode.net) kamen vermehrt Fragen zur Entwicklung von Modulen im Magento-Backend auf.

  • Wie muss ich den Router definieren, damit meine Controller angesprochen werden?
  • Wie kann ich ein Grid erstellen und Erweitern?
  • Wie definiert man neue Menü-Einträge? Wie konfiguriert man das Rechtemanagement?

Diese und weitere Fragen sollen in einer Beitragsserie hier im Mage :: Blog beleuchtet werden. Leider muss ich alle enttäuschen, die heute bereits sehnsüchtig nach dem – zugegebenermaßen für heute versprochenen – ersten Teil der Serie warten. Ich werde versuchen, diesen noch am Wochenende nachzureichen.

UPDATE: Offensichtlich verzögert sich die Veröffentlichung leider ein wenig. Wir arbetien daran, den ersten Beitrag so schnell wie möglich online zu bekommen.

Nächste Einträge »

Page optimized by WP Minify WordPress Plugin