API für Entwickler
Wir <3 Menschen die programmieren.
- 1. Verzeichnisstruktur
- 2. Werkzeuge
- 2.1. Webeditor
- 2.2. Webserver
- 2.3. Webgenerator
- 2.4. Erweiterungen
- 2.5. Layouts
- 3. Objekte
- 3.1. Yellow
- 3.2. Yellow-Content
- 3.3. Yellow-Media
- 3.4. Yellow-System
- 3.5. Yellow-Language
- 3.6. Yellow-User
- 3.7. Yellow-Extension
- 3.8. Yellow-Lookup
- 3.9. Yellow-Toolbox
- 3.10. Yellow-Page
- 3.11. Yellow-Page-Collection
- 3.12. Yellow-String
- 4. Ereignisse
- 4.1. Yellow-Core-Ereignisse
- 4.2. Yellow-Parse-Ereignisse
- 4.3. Yellow-Edit-Ereignisse
- 4.4. Yellow-Command-Ereignisse
- 4.5. Yellow-Update-Ereignisse
- 5. Verwandte Informationen
Verzeichnisstruktur
Du kannst alles im Dateimanager auf deinem Computer ändern. Das content
-Verzeichnis enthält die Inhaltsdateien der Webseite. Hier bearbeitet man seine Webseite. Das media
-Verzeichnis enthält die Mediendateien der Webseite. Hier speichert man seine Bilder und Dateien. Das system
-Verzeichnis enthält die Systemdateien der Webseite. Hier findet man installierte Erweiterungen, Konfigurationsdateien und die Logdatei.
Die folgenden Konfigurationsdateien und Systemdateien sind verfügbar:
system/extensions/yellow-system.ini
= Datei mit Systemeinstellungen
system/extensions/yellow-language.ini
= Datei mit Spracheinstellungen
system/extensions/yellow-user.ini
= Datei mit Benutzereinstellungen
system/extensions/yellow-website.log
= Logdatei der Webseite
Werkzeuge
Webeditor
Du kannst deine Webseite im Webbrowser bearbeiten. Die Anmeldeseite ist auf deiner Webseite vorhanden als http://website/edit/
. Melde dich mit deinem Benutzerkonto an. Du kannst die normale Navigation benutzen, Änderungen machen und das Ergebnis sofort sehen. Der eingebaute Webeditor gibt dir die Möglichkeit Inhaltsdateien zu bearbeiten und Mediendateien hochzuladen. Es ist eine großartige Art Webseiten zu aktualisieren. Textformatierung mit Markdown wird unterstützt. HTML und Abkürzungen werden auch unterstützt. Weitere Informationen zum Webeditor.
Webserver
Du kannst einen Webserver in der Befehlszeile starten. Der eingebaute Webserver ist praktisch für Entwickler, Designer und Übersetzer. Das gibt dir die Möglichkeit Webseiten auf deinem Computer anzuzeigen, sie zu überprüfen und später auf den externen Webserver hochzuladen. Öffne ein Terminalfenster. Gehe ins Installations-Verzeichnis, dort wo sich die Datei yellow.php
befindet. Gib ein php yellow.php serve
, du kannst wahlweise eine URL angeben. Öffne einen Webbrowser und gehe zur angezeigten URL. Weitere Informationen zum Webserver.
Webgenerator
Du kannst eine statische Webseite in der Befehlszeile generieren. Der Static-Site-Generator macht die gesamte Webseite im Voraus, anstatt darauf zu warten dass eine Datei angefordert wird. Öffne ein Terminalfenster. Gehe ins Installations-Verzeichnis, dort wo sich die Datei yellow.php
befindet. Gib ein php yellow.php generate
, du kannst wahlweise ein Verzeichnis und einen Ort angeben. Das generiert eine statische Webseite im public
-Verzeichnis. Lade die statische Webseite auf deinen Webserver hoch und generiere bei Bedarf eine neue. Weitere Informationen zum Webgenerator.
Erweiterungen
Du kannst die Funktionen deiner Webseite anpassen. Es gibt einen Core und alles andere sind Erweiterungen. Die installierten Erweiterungen befinden sich im system/extensions
-Verzeichnis. Die Idee ist, dass in der Standardinstallation nur die wichtigsten Dinge enthalten sind um kleine Webseiten zu machen. Es gibt Methoden wie onLoad()
und onParseContentShortcut()
mit denen man Ereignisse verarbeiten kann. Dieses System gibt dir die vollständige Kontrolle. Installiere einige Erweiterungen und schau dir an wie sie funktionieren. Weitere Informationen zu Erweiterungen.
Layouts
Du kannst das Aussehen deiner Webseite anpassen. Die Layoutdateien befinden sich im system/layouts
-Verzeichnis. Dem Layoutsystem ist es eigentlich egal was in den Layoutdateien enthalten ist. Der HTML-Code bleibt unverändert. Es gibt Methoden wie getHtml()
und getContentHtml()
mit denen man die aktuelle Seite so ausgeben kann wie man will. Es ist möglich Schleifen zu verwenden und Kontrollstrukturen zu erstellen. Dazu musst du kein besonderes Webframework lernen, sondern kannst normales PHP verwenden. Weitere Informationen zu Layouts.
Objekte
Mit Hilfe der API kann man auf Dateien, Einstellungen und mehr zugreifen. Ein grundlegendes Objekt ist $this->yellow->page
um auf die aktuelle Seite zuzugreifen. Die API ist in mehrere Objekte aufgeteilt und spiegelt im Grunde genommen das Dateisystem wieder. Es gibt $this->yellow->content
um auf Inhaltsdateien zuzugreifen, $this->yellow->media
um auf Mediendateien zuzugreifen und $this->yellow->system
um auf Systemeinstellungen zuzugreifen. Den Quellcode der gesamten API findet man in der Datei system/extensions/core.php
.
Die folgenden Objekte sind verfügbar:
$this->yellow
= Zugang zur API
$this->yellow->content
= Zugang zu Inhaltsdateien
$this->yellow->media
= Zugang zu Mediendateien
$this->yellow->system
= Zugang zu Systemeinstellungen
$this->yellow->language
= Zugang zu Spracheinstellungen
$this->yellow->user
= Zugang zu Benutzereinstellungen
$this->yellow->extension
= Zugang zu Erweiterungen
$this->yellow->lookup
= Zugang zu Nachschlags- und Normalisierungsmethoden
$this->yellow->toolbox
= Zugang zur Werkzeugkiste mit Hilfsmethoden
$this->yellow->page
= Zugang zur aktuellen Seite
Yellow
Die Klasse Yellow
gibt Zugang zur API. Die folgenden Methoden sind verfügbar:
command
getLayoutArguments
layout
load
request
Beschreibung der Methoden und Argumente:
yellow->load(): void
Verarbeite die Initialisierung
yellow->request(): int
Verarbeite eine Anfrage vom Webbrowser
yellow->command($line = ""): int
Verarbeite einen Befehl von der Befehlszeile
yellow->layout($name, $arguments = null): void
Binde ein Layout ein
yellow->getLayoutArguments($sizeMin = 9): array
Hole die Layout-Argumente
Layoutdatei mit Header und Footer:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php echo $this->yellow->page->getContentHtml() ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-Content
Die Klasse YellowContent
gibt Zugang zu Inhaltsdateien. Die folgenden Methoden sind verfügbar:
clean
find
index
multi
path
top
Beschreibung der Methoden und Argumente:
content->find($location, $absoluteLocation = false): YellowPage|null
Hole eine Seite, null falls nicht vorhanden
content->index($showInvisible = false, $multiLanguage = false, $levelMax = 0): YellowPageCollection
Hole eine Seitenkollektion mit allen Seiten
content->top($showInvisible = false, $showOnePager = true): YellowPageCollection
Hole eine Seitenkollektion mit Hauptseiten der Navigation
content->path($location, $absoluteLocation = false): YellowPageCollection
Hole eine Seitenkollektion mit Pfad in der Navigation
content->multi($location, $absoluteLocation = false, $showInvisible = false): YellowPageCollection
Hole eine Seitenkollektion mit mehreren Sprachen im Mehrsprachen-Modus
content->clean(): YellowPageCollection
Hole eine Seitenkollektion die leer ist
Layoutdatei um alle Seiten anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->index(true, true) ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("title") ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um Seiten unterhalb eines bestimmten Orts anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->find("/help/")->getChildren() ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("title") ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um die Hauptseiten der Navigation anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->top() ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("titleNavigation") ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-Media
Die Klasse YellowMedia
gibt Zugang zu Mediendateien. Die folgenden Methoden sind verfügbar:
clean
index
find
Beschreibung der Methoden und Argumente:
media->find($location, $absoluteLocation = false): YellowPage|null
Hole eine Seite mit Informationen über Mediendatei, null falls nicht vorhanden
media->index($showInvisible = false, $multiPass = false, $levelMax = 0): YellowPageCollection
Hole eine Seitenkollektion mit allen Mediendateien
media->clean(): YellowPageCollection
Hole eine Seitenkollektion die leer ist
Layoutdatei um alle Mediendateien anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $files = $this->yellow->media->index(true) ?>
<?php $this->yellow->page->setLastModified($files->getModified()) ?>
<ul>
<?php foreach ($files as $file): ?>
<li><?php echo $file->getLocation(true) ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um die neusten Mediendateien anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $files = $this->yellow->media->index()->sort("modified", false) ?>
<?php $this->yellow->page->setLastModified($files->getModified()) ?>
<ul>
<?php foreach ($files as $file): ?>
<li><?php echo $file->getLocation(true) ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um Mediendateien eines bestimmten Typen anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $files = $this->yellow->media->index()->filter("type", "pdf") ?>
<?php $this->yellow->page->setLastModified($files->getModified()) ?>
<ul>
<?php foreach ($files as $file): ?>
<li><?php echo $file->getLocation(true) ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-System
Die Klasse YellowSystem
gibt Zugang zu Systemeinstellungen. Die folgenden Methoden sind verfügbar:
get
getAvailable
getDifferent
getHtml
getModified
getSettings
isExisting
save
set
setDefault
Beschreibung der Methoden und Argumente:
system->save($fileName, $settings): bool
Speichere Systemeinstellungen in Datei
system->setDefault($key, $value): void
Setze Standard-Systemeinstellung
system->set($key, $value): void
Setze eine Systemeinstellung
system->get($key): string
Hole eine Systemeinstellung
system->getHtml($key): string
Hole eine Systemeinstellung, HTML-kodiert
system->getDifferent($key): string
Hole einen anderen Wert für eine Systemeinstellung
system->getAvailable($key): array
Hole die vorhandenen Werte einer Systemeinstellung
system->getSettings($filterStart = "", $filterEnd = ""): array
Hole Systemeinstellungen
system->getModified($httpFormat = false): int|string
Hole das Änderungsdatum von Systemeinstellungen, Unix-Zeit oder HTTP-Format
system->isExisting($key): bool
Überprüfe ob die Systemeinstellung existiert
Layoutdatei um den Webmaster anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php echo "Name: ".$this->yellow->system->getHtml("author")."<br />" ?>
<?php echo "Email: ".$this->yellow->system->getHtml("email")."<br />" ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um zu überprüfen ob eine bestimmte Einstellung aktiviert ist:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php $debugMode = $this->yellow->system->get("coreDebugMode") ?>
Debug mode is <?php echo htmlspecialchars($debugMode ? "on" : "off") ?>.
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um die Core-Einstellungen anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php foreach ($this->yellow->system->getSettings("core") as $key=>$value): ?>
<?php echo htmlspecialchars("$key: $value") ?><br />
<?php endforeach ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-Language
Die Klasse YellowLanguage
gibt Zugang zu Spracheinstellungen. Die folgenden Methoden sind verfügbar:
getDateFormatted
getDateRelative
getDateStandard
getModified
getSettings
getText
getTextHtml
isExisting
isText
setDefaults
setText
Beschreibung der Methoden und Argumente:
language->setDefaults($lines): void
Setze Standard-Spracheinstellungen
language->setText($key, $value, $language): void
Setze eine Spracheinstellung
language->getText($key, $language = ""): string
Hole eine Spracheinstellung
language->getTextHtml($key, $language = ""): string
Hole eine Spracheinstellung, HTML-kodiert
page->getDateStandard($text, $language = ""): string
Hole einen Text als sprachspezifisches Datum, in eines der Standardformate konvertieren
page->getDateRelative($timestamp, $format, $daysLimit, $language = ""): string
Hole eine Unix-Zeit als Datum, relativ zu heute
page->getDateFormatted($timestamp, $format, $language = ""): string
Hole eine Unix-Zeit als Datum
language->getSettings($filterStart = "", $filterEnd = "", $language = ""): array
Hole Spracheinstellungen
language->getModified($httpFormat = false): int|string
Hole das Änderungsdatum von Spracheinstellungen, Unix-Zeit oder HTTP-Format
language->isText($key, $language = ""): bool
Überprüfe ob die Spracheinstellung existiert
language->isExisting($language): bool
Überprüfe ob die Sprache existiert
Layoutdatei um eine Spracheinstellung anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p><?php echo $this->yellow->language->getTextHtml("wikiModified") ?>
<?php echo $this->yellow->page->getDateHtml("modified") ?></p>
<?php echo $this->yellow->page->getContentHtml() ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um zu überprüfen ob eine bestimmte Sprache existiert:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $found = $this->yellow->language->isExisting("sv") ?>
<p>Swedish language <?php echo htmlspecialchars($found ? "" : "not") ?> installed.</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um Sprachen und Übersetzer anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php foreach ($this->yellow->system->getAvailable("language") as $language): ?>
<?php echo $this->yellow->language->getTextHtml("languageDescription", $language) ?> -
<?php echo $this->yellow->language->getTextHtml("languageTranslator", $language) ?><br />
<?php endforeach ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-User
Die Klasse YellowUser
gibt Zugang zu Benutzereinstellungen. Die folgenden Methoden sind verfügbar:
getModified
getSettings
getUser
getUserHtml
isExisting
isUser
remove
save
setUser
Beschreibung der Methoden und Argumente:
user->save($fileName, $email, $settings): bool
Speichere Benutzereinstellungen in Datei
user->remove($fileName, $email): bool
Entferne Benutzereinstellungen von Datei
user->setUser($key, $value, $email): void
Setze eine Benutzereinstellung
user->getUser($key, $email = ""): string
Hole eine Benutzereinstellung
user->getUserHtml($key, $email = ""): string
Hole eine Benutzereinstellung, HTML-kodiert
user->getSettings($email = ""): array
Hole Benutzereinstellungen
user->getModified($httpFormat = false): int|string
Hole das Änderungsdatum von Benutzereinstellungen, Unix-Zeit oder HTTP-Format
user->isUser($key, $email = ""): bool
Überprüfe ob die Benutzereinstellung existiert
user->isExisting($email): bool
Überprüfe ob der Benutzer existiert
Layoutdatei um den aktuellen Benutzer anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php echo "Name: ".$this->yellow->user->getUserHtml("name")."<br />" ?>
<?php echo "Email: ".$this->yellow->user->getUserHtml("email")."<br />" ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um zu überprüfen ob ein Benutzer angemeldet ist:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $found = $this->yellow->user->isUser("name") ?>
<p>You are <?php echo htmlspecialchars($found? "" : "not") ?> logged in.</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um Benutzer und ihren Status anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php foreach ($this->yellow->system->getAvailable("email") as $email): ?>
<?php echo $this->yellow->user->getUserHtml("name", $email) ?> -
<?php echo $this->yellow->user->getUserHtml("status", $email) ?><br />
<?php endforeach ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-Extension
Die Klasse YellowExtension
gibt Zugang zu Erweiterungen. Die folgenden Methoden sind verfügbar:
get
getModified
isExisting
Beschreibung der Methoden und Argumente:
extension->get($key): object
Hole eine Erweiterung
extension->getModified($httpFormat = false): int|string
Hole das Änderungsdatum von Erweiterungen, Unix-Zeit oder HTTP-Format
extension->isExisting($key): bool
Überprüfe ob die Erweiterung existiert
Layoutdatei um Erweiterungen anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php foreach($this->yellow->extension->data as $key=>$value): ?>
<?php echo htmlspecialchars($key." ".$value["version"]) ?><br />
<?php endforeach ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um zu überprüfen ob eine bestimmte Erweiterung existiert:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $found = $this->yellow->extension->isExisting("search") ?>
<p>Search extension <?php echo htmlspecialchars($found ? "" : "not") ?> installed.</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Code um eine Funktion aus einer anderen Erweiterung aufzurufen:
if ($this->yellow->extension->isExisting("image")) {
$fileName = "media/images/photo.jpg";
list($src, $width, $height) = $this->yellow->extension->get("image")->getImageInformation($fileName, "100%", "100%");
echo "<img src=\"".htmlspecialchars($src)."\" width=\"".htmlspecialchars($width)."\" height=\"".htmlspecialchars($height)."\" />";
}
Yellow-Lookup
Die Klasse YellowLookup
gibt Zugang zu Nachschlags- und Normalisierungsmethoden. Die folgenden Methoden sind verfügbar:
findContentLocationFromFile
findFileFromContentLocation
findFileFromMediaLocation
findMediaDirectory
findMediaLocationFromFile
getUrlInformation
isCommandLine
isContentFile
isFileLocation
isMediaFile
isSystemFile
isValidFile
normaliseArguments
normaliseData
normaliseHeaders
normaliseLocation
normaliseName
normalisePath
normaliseUrl
Beschreibung der Methoden und Argumente:
lookup->findContentLocationFromFile($fileName): string
Hole Inhaltsort aus dem Dateipfad
lookup->findFileFromContentLocation($location, $directory = false): string
Hole Dateipfad aus dem Inhaltsort
lookup->findMediaLocationFromFile($fileName): string
Hole Medienort aus dem Dateipfad
lookup->findFileFromMediaLocation($location): string
Hole Dateipfad aus dem Medienort
lookup->findMediaDirectory($key): string
Hole Medienpfad für eine Systemeinstellung
lookup->normaliseName($text, $removePrefix = false, $removeExtension = false, $filterStrict = false): string
Normalisiere einen Namen
lookup->normaliseData($text, $type = "html", $filterStrict = true): string
Normalisiere Elemente und Attribute in HTML/SVG-Daten
lookup->normaliseHeaders($input, $type = "mime", $filterStrict = true): string
Normalisiere Felder in MIME-Headers
lookup->normalisePath($text): string
Normalisiere relative Pfadanteile
lookup->normaliseLocation($location, $pageLocation, $filterStrict = true): string
Normalisiere einen Ort, mache absoluten Ort
lookup->normaliseArguments($text, $appendSlash = true, $filterStrict = true): string
Normalisiere Ortargumente
lookup->normaliseUrl($scheme, $address, $base, $location, $filterStrict = true): string
Normalisiere eine URL, mache absolute URL
lookup->getUrlInformation($url): string
Hole URL-Informationen
lookup->isFileLocation($location): bool
Überprüfe ob der Ort eine Datei oder ein Verzeichnis angibt
lookup->isValidFile($fileName): bool
Überprüfe ob die Datei gültig ist
lookup->isContentFile($fileName): bool
Überprüfe ob Inhaltsdatei
lookup->isMediaFile($fileName): bool
Überprüfe ob Mediendatei
lookup->isSystemFile($fileName): bool
Überprüfe ob Systemdatei
lookup->isCommandLine(): bool
Überprüfe ob Befehlszeile ausgeführt wird
Layoutdatei um Bildpfade anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p>
<?php $pathInstall = $this->yellow->system->get("coreServerInstallDirectory") ?>
<?php $pathImages = $this->yellow->lookup->findMediaDirectory("coreImageLocation") ?>
<?php $pathThumbs = $this->yellow->lookup->findMediaDirectory("coreThumbnailLocation") ?>
<?php echo "Image files: ".htmlspecialchars($pathInstall.$pathImages)."<br />" ?>
<?php echo "Image thumbnails: ".htmlspecialchars($pathInstall.$pathThumbs)."<br />" ?>
</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um den Seitentyp anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $fileLocation = $this->yellow->lookup->isFileLocation($this->yellow->page->location) ?>
<p>Page is <?php echo htmlspecialchars($fileLocation? "file" : "directory") ?>.</p>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Code um eine URL in Bestandteile zu zerlegen:
if (!is_string_empty($url)) {
list($scheme, $address, $base) = $this->yellow->lookup->getUrlInformation($url);
echo "Found scheme:$scheme address:$address base:$base\n";
}
Yellow-Toolbox
Die Klasse YellowToolbox
gibt Zugang zur Werkzeugkiste mit Hilfsmethoden. Die folgenden Methoden sind verfügbar:
appendFile
copyFile
createFile
createTextDescription
deleteDirectory
deleteFile
getCookie
getDirectoryEntries
getDirectoryEntriesRecursive
getFileModified
getFileType
getLocationArguments
getServer
getTextArguments
getTextLines
getTextList
log
mail
modifyFile
readFile
renameDirectory
renameFile
Beschreibung der Methoden und Argumente:
toolbox->getCookie($key): string
Hole das Browsercookie der aktuellen HTTP-Anfrage
toolbox->getServer($key): string
Hole das Serverargument der aktuellen HTTP-Anfrage
toolbox->getLocationArguments(): string
Hole die Ortargumente der aktuellen HTTP-Anfrage
toolbox->getDirectoryEntries($path, $regex = "/.*/", $sort = true, $directories = true, $includePath = true): array
Hole Dateien und Verzeichnisse
toolbox->getDirectoryEntriesRecursive($path, $regex = "/.*/", $sort = true, $directories = true, $levelMax = 0): array
Hole Dateien und Verzeichnisse rekursiv
toolbox->readFile($fileName, $sizeMax = 0): string
Lese eine Datei, leerer String falls nicht vorhanden
toolbox->createFile($fileName, $fileData, $mkdir = false): bool
Erstelle eine Datei
toolbox->appendFile($fileName, $fileData, $mkdir = false): bool
Hänge an eine Datei an
toolbox->copyFile($fileNameSource, $fileNameDestination, $mkdir = false): bool
Kopiere eine Datei
toolbox->renameFile($fileNameSource, $fileNameDestination, $mkdir = false): bool
Benenne eine Datei um
toolbox->renameDirectory($pathSource, $pathDestination, $mkdir = false): bool
Benenne ein Verzeichnis um
toolbox->deleteFile($fileName, $pathTrash = ""): bool
Lösche eine Datei
toolbox->deleteDirectory($path, $pathTrash = ""): bool
Lösche ein Verzeichnis
toolbox->modifyFile($fileName, $modified): bool
Setze das Änderungsdatum von Datei/Verzeichnis, Unix-Zeit
toolbox->getFileModified($fileName): int
Hole das Änderungsdatum von Datei/Verzeichnis, Unix-Zeit
toolbox->getFileType($fileName): string
Hole den Typ der Datei
toolbox->getTextLines($text): array
Hole die Zeilen eines Texts, einschließlich Zeilenumbruch
toolbox->getTextList($text, $separator, $size): array
Hole ein Array mit bestimmter Grösse aus dem Text
toolbox->getTextArguments($text, $optional = "-", $sizeMin = 9): array
Hole ein Array mit variabler Grösse aus dem Text, durch Leerzeichen getrennt
toolbox->createTextDescription($text, $lengthMax = 0, $removeHtml = true, $endMarker = "", $endMarkerText = ""): string
Erstelle eine Textbeschreibung, mit oder ohne HTML
toolbox->mail($action, $headers, $message): bool
Sende E-Mail-Nachricht
toolbox->log($action, $message): void
Schreibe Informationen in die Logdatei
Code um Textzeilen von einer Datei zu lesen:
$fileName = $this->yellow->system->get("coreExtensionDirectory").$this->yellow->system->get("coreSystemFile");
$fileData = $this->yellow->toolbox->readFile($fileName);
foreach ($this->yellow->toolbox->getTextLines($fileData) as $line) {
echo $line;
}
Code um Dateien in einem Verzeichnis anzuzeigen:
$path = $this->yellow->system->get("coreExtensionDirectory");
foreach ($this->yellow->toolbox->getDirectoryEntries($path, "/.*/", true, false) as $entry) {
echo "Found file $entry\n";
}
Code um Text in mehreren Dateien zu ändern:
$path = $this->yellow->system->get("coreContentDirectory");
foreach ($this->yellow->toolbox->getDirectoryEntriesRecursive($path, "/^.*\.md$/", true, false) as $entry) {
$fileData = $fileDataNew = $this->yellow->toolbox->readFile($entry);
$fileDataNew = str_replace("I drink a lot of water", "I drink a lot of coffee", $fileDataNew);
if ($fileData!=$fileDataNew && !$this->yellow->toolbox->createFile($entry, $fileDataNew)) {
$this->yellow->toolbox->log("error", "Can't write file '$entry'!");
}
}
Yellow-Page
Die Klasse YellowPage
gibt Zugang zur einer Seite und ihren Seiteneinstellungen. Die folgenden Methoden sind verfügbar:
error
get
getBase
getChildren
getChildrenRecursive
getContentHtml
getContentRaw
getDate
getDateFormatted
getDateFormattedHtml
getDateHtml
getDateRelative
getDateRelativeHtml
getExtraHtml
getHeader
getHtml
getLastModified
getLocation
getModified
getPage
getPages
getParent
getParentTop
getRequest
getRequestHtml
getSiblings
getStatusCode
getUrl
isActive
isAvailable
isCacheable
isError
isExisting
isHeader
isPage
isRequest
isVisible
set
status
Beschreibung der Methoden und Argumente:
page->set($key, $value): void
Setze eine Seiteneinstellung
page->get($key): string
Hole eine Seiteneinstellung
page->getHtml($key): string
Hole eine Seiteneinstellung, HTML-kodiert
page->getDate($key, $format = ""): string
Hole eine Seiteneinstellung als sprachspezifisches Datum
page->getDateHtml($key, $format = ""): string
Hole eine Seiteneinstellung als sprachspezifisches Datum, HTML-kodiert
page->getDateRelative($key, $format = "", $daysLimit = 30): string
Hole eine Seiteneinstellung als sprachspezifisches Datum, relativ zu heute
page->getDateRelativeHtml($key, $format = "", $daysLimit = 30): string
Hole eine Seiteneinstellung als sprachspezifisches Datum, relativ zu heute, HTML-kodiert
page->getDateFormatted($key, $format): string
Hole eine Seiteneinstellung als Datum
page->getDateFormattedHtml($key, $format): string
Hole eine Seiteneinstellung als Datum, HTML-kodiert
page->getContentRaw(): string
Hole Seiteninhaltsdaten, Rohformat
page->getContentHtml(): string
Hole Seiteninhaltsdaten, HTML-kodiert
page->getExtraHtml($name): string
Hole Seitenextradaten, HTML-kodiert
page->getParent(): YellowPage|null
Hole die übergeordnete Seite, null falls nicht vorhanden
page->getParentTop($homeFallback = false): YellowPage|null
Hole die oberste übergeordnete Seite, null falls nicht vorhanden
page->getSiblings($showInvisible = false): YellowPageCollection
Hole eine Seitenkollektion mit Seiten auf dem selben Level
page->getChildren($showInvisible = false): YellowPageCollection
Hole eine Seitenkollektion mit untergeordneten Seiten
page->getChildrenRecursive($showInvisible = false, $levelMax = 0): YellowPageCollection
Hole eine Seitenkollektion mit untergeordneten Seiten rekursiv
page->getPages($key): YellowPageCollection
Hole eine Seitenkollektion mit zusätzlichen Seiten
page->getPage($key): YellowPage
Hole eine geteilte Seite
page->getUrl(): string
Hole die URL der Seite
page->getBase($multiLanguage = false): string
Hole die Basis der Seite
page->getLocation($absoluteLocation = false): string
Hole den Ort der Seite
page->getRequest($key): string
Hole das angefragte Argument der Seite
page->getRequestHtml($key): string
Hole das angefragte Argument der Seite, HTML-kodiert
page->getHeader($key): string
Hole den Antwort-Header der Seite
page->getModified($httpFormat = false): int|string
Hole das Änderungsdatum der Seite, Unix-Zeit oder HTTP-Format
page->getLastModified($httpFormat = false): int|string
Hole das letzte Änderungsdatum der Seite, Unix-Zeit oder HTTP-Format
page->getStatusCode($httpFormat = false): int|string
Hole den Statuscode der Seite, Zahl oder HTTP-Format
page->status($statusCode, $location = ""): void
Antworte mit Statuscode, ohne Seiteninhalt
page->error($statusCode, $errorMessage = ""): void
Antworte mit Fehlerseite
page->isAvailable(): bool
Überprüfe ob die Seite vorhanden ist
page->isVisible(): bool
Überprüfe ob die Seite sichtbar ist
page->isActive(): bool
Überprüfe ob die Seite innerhalb der aktuellen HTTP-Anfrage ist
page->isCacheable(): bool
Überprüfe ob die Seite zwischengespeichert werden kann
page->isError(): bool
Überprüfe ob die Seite einen Fehler hat
page->isExisting($key): bool
Überprüfe ob die Seiteneinstellung existiert
page->isRequest($key): bool
Überprüfe ob das Anfrage-Argument existiert
page->isHeader($key): bool
Überprüfe ob der Antwort-Header existiert
page->isPage($key): bool
Überprüfe ob die geteilte Seite existiert
Layoutdatei um den Seiteninhalt anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php echo $this->yellow->page->getContentHtml() ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um den Seiteninhalt und den Autor anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p><?php echo $this->yellow->page->getHtml("author") ?></p>
<?php echo $this->yellow->page->getContentHtml() ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um den Seiteninhalt und das Änderungsdatum anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<p><?php echo $this->yellow->page->getDateHtml("modified") ?></p>
<?php echo $this->yellow->page->getContentHtml() ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-Page-Collection
Die Klasse YellowPageCollection
gibt Zugang zu mehreren Seiten. Die folgenden Methoden sind verfügbar:
append
diff
filter
getFilter
getModified
getPageNext
getPagePrevious
getPaginationCount
getPaginationLocation
getPaginationNext
getPaginationNumber
getPaginationPrevious
group
intersect
isEmpty
isPagination
limit
match
merge
paginate
prepend
remove
reverse
shuffle
similar
sort
Beschreibung der Methoden und Argumente:
pages->append($page): void
Hänge Seite an das Ende der Seitenkollektion
pages->prepend($page): void
Stelle Seite an den Anfang der Seitenkollektion
pages->remove($page): YellowPageCollection
Entferne Seite aus der Seitenkollektion
pages->filter($key, $value, $exactMatch = true): YellowPageCollection
Filtere eine Seitenkollektion nach Seiteneinstellung
pages->match($regex = "/.*/", $filterByLocation = true): YellowPageCollection
Filtere eine Seitenkollektion nach Ort oder Datei
pages->similar($page): YellowPageCollection
Sortiere eine Seitenkollektion nach Einstellungsähnlichkeit
pages->sort($key, $ascendingOrder = true): YellowPageCollection
Sortiere eine Seitenkollektion nach Seiteneinstellung
pages->group($key, $ascendingOrder = true, $format = ""): array
Gruppiere eine Seitenkollektion nach Seiteneinstellung, gebe Array mit mehreren Kollektionen zurück
pages->merge($input): YellowPageCollection
Berechne Vereinigungsmenge, füge eine Seitenkollektion hinzu
pages->intersect($input): YellowPageCollection
Berechne Schnittmenge, entferne Seiten die nicht in einer anderen Seitenkollektion sind
pages->diff($input): YellowPageCollection
Berechne Restmenge, entferne Seiten die in einer anderen Seitenkollektion sind
pages->limit($pagesMax): YellowPageCollection
Begrenze die Anzahl der Seiten in der Seitenkollektion
pages->reverse(): YellowPageCollection
Drehe die Seitenkollektion um
pages->shuffle(): YellowPageCollection
Mach die Seitenkollektion zufällig
pages->paginate($limit): YellowPageCollection
Erstelle eine Paginierung für die Seitenkollektion
pages->getPaginationNumber(): int
Hole die aktuelle Seitennummer
pages->getPaginationCount(): int
Hole die höchste Seitennummer
pages->getPaginationLocation($absoluteLocation = true, $pageNumber = 1): string
Hole den Ort einer Seite in der Paginierung
pages->getPaginationPrevious($absoluteLocation = true): string
Hole den Ort der vorherigen Seite in der Paginierung
pages->getPaginationNext($absoluteLocation = true): string
Hole den Ort der nächsten Seite in der Paginierung
pages->getPagePrevious($page): YellowPage|null
Hole die vorherige Seite in der Seitenkollektion, null falls nicht vorhanden
pages->getPageNext($page): YellowPage|null
Hole die nächste Seite in der Seitenkollektion, null falls nicht vorhanden
pages->getFilter(): string
Hole den aktuellen Seitenfilter
pages->getModified($httpFormat = false): int|string
Hole das Änderungsdatum der Seitenkollektion, Unix-Zeit oder HTTP-Format
pages->isPagination(): bool
Überprüfe ob eine Paginierung vorhanden ist
pages->isEmpty(): bool
Überprüfe ob Seitenkollektion leer ist
Layoutdatei um drei zufällige Seiten anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->index()->shuffle()->limit(3) ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("title") ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um die neusten Seiten anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->index()->sort("modified", false) ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("title") ?></li>
<?php endforeach ?>
</ul>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Layoutdatei um die neusten Seiten mit Paginierung anzuzeigen:
<?php $this->yellow->layout("header") ?>
<div class="content">
<div class="main" role="main">
<h1><?php echo $this->yellow->page->getHtml("titleContent") ?></h1>
<?php $pages = $this->yellow->content->index()->sort("modified", false)->paginate(10) ?>
<?php $this->yellow->page->setLastModified($pages->getModified()) ?>
<ul>
<?php foreach ($pages as $page): ?>
<li><?php echo $page->getHtml("title") ?></li>
<?php endforeach ?>
</ul>
<?php $this->yellow->layout("pagination", $pages) ?>
</div>
</div>
<?php $this->yellow->layout("footer") ?>
Yellow-String
Die folgenden Funktionen erweitern PHP-Stringfunktionen und Arrayfunktionen:
is_array_empty
is_string_empty
strlenu
strposu
strrposu
strtoloweru
strtoupperu
substru
Beschreibung der Funktionen und Argumente:
strtoloweru($string): string
Wandle String in Kleinschrift um, UTF-8 kompatibel
strtoupperu($string): string
Wandle String in Großschrift um, UTF-8 kompatibel
strlenu($string): int
+ strlenb($string): int
Hole Stringlänge, UTF-8-Zeichen oder Bytes
strposu($string, $search): int|false
+ strposb($string, $search): int|false
Hole Stringposition des ersten Treffers, UTF-8-Zeichen oder Bytes
strrposu($string, $search): int|false
+ strrposb($string, $search): int|false
Hole Stringposition des letzten Treffers, UTF-8-Zeichen oder Bytes
substru($string, $start, $length): string
+ substrb($string, $start, $length): string
Hole Teilstring, UTF-8-Zeichen oder Bytes
is_string_empty($string): bool
Überprüfe ob der String leer ist
is_array_empty($array): bool
Überprüfe ob das Array leer ist
Code um Strings zu konvertieren:
$string = "Für Menschen und Maschinen";
echo strtoloweru($string); // für menschen und maschinen
echo strtoupperu($string); // FÜR MENSCHEN UND MASCHINEN
Code um auf Strings zuzugerifen:
$string = "Text mit UTF-8-Zeichen åäö";
echo strlenu($string); // 26
echo strposu($string, "UTF"); // 9
echo substru($string, -3, 3); // åäö
Code um zu überprüfen ob Strings leer sind:
var_dump(is_string_empty("")); // bool(true)
var_dump(is_string_empty("text")); // bool(false)
var_dump(is_string_empty("0")); // bool(false)
Code um zu überprüfen ob Arrays leer sind:
var_dump(is_array_empty(array())); // bool(true)
var_dump(is_array_empty(new ArrayObject())); // bool(true)
var_dump(is_array_empty(array("entry"))); // bool(false)
Ereignisse
Mit Hilfe von Ereignissen informiert dich die Webseite wenn etwas passiert. Zuerst werden die Erweiterungen geladen und es wird onLoad
aufgerufen. Sobald alle Erweiterungen geladen sind wird onStartup
aufgerufen. Eine Anfrage vom Webbrowser kann mit verschiedenen Ereignissen verarbeitet werden. In den meisten Fällen wird der Inhalt einer Seite erzeugt. Sollte ein Fehler aufgetreten sein, wird eine Fehlerseite erzeugt. Zum Schluss wird die Seite ausgegeben und es wird onShutdown
aufgerufen.
Die folgenden Ereignisse sind verfügbar:
onCommand
onCommandHelp
onEditContentFile
onEditMediaFile
onEditSystemFile
onEditUserAccount
onLoad
onLog
onMail
onParseContentHtml
onParseContentRaw
onParseContentShortcut
onParseMetaData
onParsePageExtra
onParsePageLayout
onParsePageOutput
onRequest
onShutdown
onStartup
onUpdate
Yellow-Core-Ereignisse
Yellow-Core-Ereignisse unterrichten wenn sich ein Zustand ändert:
public function onLoad($yellow)
Verarbeite die Initialisierung
public function onStartup()
Verarbeite das Hochfahren
public function onRequest($scheme, $address, $base, $location, $fileName)
Verarbeite die Anfrage
public function onShutdown()
Verarbeite das Runterfahren
Erweiterung um die Initialisierung zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.1";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
}
Yellow-Parse-Ereignisse
Yellow-Parse-Ereignisse unterrichten wenn eine Seite angezeigt wird:
public function onParseMetaData($page)
Verarbeite die Metadaten einer Seite
public function onParseContentRaw($page, $text)
Verarbeite den Seiteninhalt im Rohformat
public function onParseContentShortcut($page, $name, $text, $type)
Verarbeite den Seiteninhalt einer Abkürzung
public function onParseContentHtml($page, $text)
Verarbeite den Seiteninhalt im HTML-Format
public function onParsePageLayout($page, $name)
Verarbeite das Layout einer Seite
public function onParsePageExtra($page, $name)
Verarbeite die Extradaten einer Seite
public function onParsePageOutput($page, $text)
Verarbeite die Ausgabedaten einer Seite
Erweiterung um eine Abkürzung zu erstellen:
<?php
class YellowExample {
const VERSION = "0.1.2";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle page content of shortcut
public function onParseContentShortcut($page, $name, $text, $type) {
$output = null;
if ($name=="example" && ($type=="block" || $type=="inline")) {
$output = "<div class=\"".htmlspecialchars($name)."\">";
$output .= "Add more HTML code here";
$output .= "</div>";
}
return $output;
}
}
Erweiterung um einen HTML-Header zu erstellen:
<?php
class YellowExample {
const VERSION = "0.1.3";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle page extra data
public function onParsePageExtra($page, $name) {
$output = null;
if ($name=="header") {
$extensionLocation = $this->yellow->system->get("coreServerBase").$this->yellow->system->get("coreExtensionLocation");
$output = "<link rel=\"stylesheet\" type=\"text/css\" media=\"all\" href=\"{$extensionLocation}example.css\" />\n";
$output .= "<script type=\"text/javascript\" defer=\"defer\" src=\"{$extensionLocation}example.js\"></script>\n";
}
return $output;
}
}
Yellow-Edit-Ereignisse
Yellow-Edit-Ereignisse unterrichten wenn eine Seite bearbeitet wird:
public function onEditContentFile($page, $action, $email)
Verarbeite Änderungen an Inhaltsdatei
public function onEditMediaFile($file, $action, $email)
Verarbeite Änderungen an Mediendatei
public function onEditSystemFile($file, $action, $email)
Verarbeite Änderungen an Systemdatei
public function onEditUserAccount($action, $email, $password)
Verarbeite Änderungen am Benutzerkonto
Erweiterung um Änderungen an Inhaltsdatei zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.4";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle content file changes
public function onEditContentFile($page, $action, $email) {
if ($action=="edit") {
$title = $page->get("title");
$name = $this->yellow->user->getUser("name", $email);
$this->yellow->toolbox->log("info", "Edit page by user '".strtok($name, " ")."'");
}
}
}
Erweiterung um Änderungen an Mediendatei zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.5";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle media file changes
public function onEditMediaFile($file, $action, $email) {
if ($action=="upload") {
$fileName = $file->fileName;
$fileType = $this->yellow->toolbox->getFileType($file->get("fileNameShort"));
$name = $this->yellow->user->getUser("name", $email);
$this->yellow->toolbox->log("info", "Upload file by user '".strtok($name, " ")."'");
}
}
}
Yellow-Command-Ereignisse
Yellow-Command-Ereignisse unterrichten wenn ein Befehl ausgeführt wird:
public function onCommand($command, $text)
Verarbeite Befehle
public function onCommandHelp()
Verarbeite Hilfe für Befehle
Erweiterung um einen Befehl zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.6";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle command
public function onCommand($command, $text) {
$statusCode = 0;
if ($command=="example") {
echo "Yellow $command: Add more text here\n";
$statusCode = 200;
}
return $statusCode;
}
// Handle command help
public function onCommandHelp() {
return "example";
}
}
Erweiterung um mehrere Befehle zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.7";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle command
public function onCommand($command, $text) {
switch ($command) {
case "hello": $statusCode = $this->processCommandHello($command, $text); break;
case "goodbye": $statusCode = $this->processCommandGoodbye($command, $text); break;
default: $statusCode = 0;
}
return $statusCode;
}
// Handle command help
public function onCommandHelp() {
return array("hello [name]", "goodbye [name]");
}
// Handle command for hello
public function processCommandHello($command, $text) {
if (is_string_empty($text)) $text = "World";
echo "Hello $text\n";
return 200;
}
// Handle command for goodbye
public function processCommandGoodbye($command, $text) {
if (is_string_empty($text)) $text = "World";
echo "Goodbye $text\n";
return 200;
}
}
Yellow-Update-Ereignisse
Yellow-Update-Ereignisse unterrichten wenn eine Aktualisierung passiert:
public function onUpdate($action)
Verarbeite Aktualisierung
public function onMail($action, $headers, $message)
Verarbeite E-Mail
public function onLog($action, $message)
Verarbeite Logging
Erweiterung um ein Aktualisierung-Ereignis zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.8";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle update
public function onUpdate($action) {
if ($action=="install") {
$this->yellow->toolbox->log("info", "Install event");
}
}
}
Erweiterung um ein tägliches Ereignis zu verarbeiten:
<?php
class YellowExample {
const VERSION = "0.1.9";
public $yellow; // access to API
// Handle initialisation
public function onLoad($yellow) {
$this->yellow = $yellow;
}
// Handle update
public function onUpdate($action) {
if ($action=="daily") {
$this->yellow->toolbox->log("info", "Daily event");
}
}
}
Verwandte Informationen
Hast du Fragen? Hilfe finden.