In diesem Tutorial möchte ich beschreiben, wie man seine Fotos von Flickr auf seiner eigenen Website einbindet .. Verwendet wird die Flickr-API ..
Das Tutorial verschafft zwar ein Grundwissen über die Flickr-API und ihre Funktionsweise, doch setz auch Grundwissen in XML, PHP und HTML vorraus .. Ich werde nicht auf den Aufbau eines XML-Files bzw. grundlegende PHP Methoden, so wie Schleifen, Abfragen oder Zugriffe auf Objekte eingehen .. Die verwendeten Methoden werde ich kurz beschreiben, wer genaueres darüber erfahren will muss auf PHP.net nachlesen, das in meinen Augen bessere Beschreibungen liefert, als ich jemals geben könnte 
..
Ganz am Schluss unter den Links werde ich alle PHP-Funktionen zusammenfassen und direkt verlinken !!
Die Flickr-API
Die Flickr-API bietet einige verschiedene Methoden aus den verschiedenen Bereichen von Flickr (z.B. Photos, Photosets, Comments usw.) um An Informationen oder Daten zu kommen .. Jede dieser Methoden hat gewisse Parameter, die zum Teil benötigt werden oder auch optional sind ..
Eine Methode z.B. heißt flickr.photosets.getInfo .. Durch sie bekommt man den Namen und die Beschreibung sowie einige weitere Infos zu einem bestimmten Photoset (Album) zurück .. Sie benötigt die Parameter API-Key, und PhotosetId ..
Der API-Key ist ein Schlüssel, den jeder, der die Flickr-API verwenden will benötigt .. Es ist einfach eine Bestätigung, dass man bei Flickr angemeldet ist .. Unterschieden wird zwischen dem öffentlichen und geheimen Schlüssel, wobei wir für unsere Anfragen nur den normalen, öffentlichen brauchen ..
Die PhotosetId ist die einzigartige Id des Photosets, die dieses eindeutig bestimmen lässt ..
Oft kommen dann noch optionale Parameter wie Anzahl der Ergebnisse usw. hinzu ..
Alle Methoden sowie ihre Parameter und Erklärungen sind ziemlich gut, wenn auch manchmal etwas dürftig, in der Flickr-API Documentation beschrieben ..
Die Funktionsweise der Flickr-API ist relativ einfach .. Man ruft eine URL auf, die als Parameter die Methode sowie deren Parameter enthält und bekommt eine Seite mit den gewünschten Informationen in einem bestimmten Ausgabeformat zurück .. Standardmäßig wird die Ausgabe im XML-Format durchgeführt, da dieses das universellste ist .. Weitere Formate sind Serial PHP, JSON oder SOAP ..
In diesem Tutorial wird mit dem XML Antwortformat gearbeitet ..
Zum Testen kann man die einzelnen Methoden mit einer Art Wizard Aufrufen .. Man gibt die verschiedenen Parameter in Textfelder ein und erhält das gewünschte Ergebnis innerhalb der offenen Seite .. Zum Ausprobieren ist das eine gute Möglichkeit !!
Das Ziel
Das erste Ziel ist es, eine einfache Liste der Alben (auch genannt Photosets) zu erstellen, die auf der eigenen Website leicht und valide ausgegeben werden kann .. So wie auf dieser Seite rechts in der Sidebar ..
Andererseits soll es eine eigene Fotoseite geben, die einen Link zum persönlichen Fotostream, ein Zufallsbild, generiert aus allen Bildern eines Users, sowie eine Liste aller Photosets mit auch jeweils einem Zufallsbild aus dem Album enthält .. Mein Ergebnis kann man auf meiner Fotoseite unter Fotos anschauen !!
Das Problem
Das Problem an der ganzen Sache ist, dass die Flickr-API etwas langsam ist .. Auch wenn man glauben sollte, das der Aufruf eines einfachen XML Files sehr schnell geht wird man hier ziemlich enttäuscht ..
Beispielsweise dauert der Aufruf der einfachen Liste, die nur die Namen der Alben enthält 1-2 (zu schlechten Zeiten noch mehr) Sekunden .. Der Aufruf der Fotoseite, wo insg. 15 (hängt natürlich von der Anzahl der Alben ab) XML Files geladen werden dauert sicher zwischen 15-20 Sekunden .. Für eine Website also komplett unbrauchbar ..
Das Lösungskonzept
Die Lösung besteht darin, die XML-Files auf dem eigenen Server zu cachen und somit eine schnellere Zugriffsmöglichkeit auf die Daten zu haben .. Die XML-Files werden einfach als einzelne Files auf dem Server gespeichert und das Script, dass sie aufruft und zu einer Ausgabe zusammen bastelt, ruft jeweils die Files auf, die es braucht direkt auf dem eigenen Webserver auf ..
In diesem Tutorial wird beschrieben, wie man das Cachen, Aufrufen und Verarbeiten realisiert .. Ich habe mich bemüht, immer einen schönen Code sowie ein schönes Grundkonzept zu verwenden .. Ein einfaches Übersichts-Script, das die gerade aktuellen Cachefiles auflistet, bestätigt, ob alle gebrauchten da sind, das Datum der ältesten Cachedatei zurückgibt und eine Möglichkeit bietet, dass neue Daten gecached werden, wird innerhalb dieses Tutorials auch gestaltet ..
Was ich hier nicht beschreibe, ist eine Möglichkeit, dass sich die Cache-Files automatisch aktualisieren .. Da sich in meinem Flickr-Fotostream nicht sooooo oft etwas tut werde ich nach Änderungen den Cache selber über das beschriebene Übersichts-Script refreshen ..
Wer will, dass sie sich automatisch refreshen, kann das entweder mit einem Cronjob direkt auf dem Server oder über die Seitenaufrufe direkt machen ..
Falls jemand dieses Feature zusätzlich einbaut, würde es mich sehr interessieren, wie es gelöst wurde !!
Meine Lösung im Detail
Grundsätzlich habe ich mich bemüht, das ganze recht übersichtlich und logisch aufzubauen .. Des weiteren habe ich versucht, Logik und Ausgabe so gut wie möglich von einander zu trennen ..
Ich habe das ganze nicht objektorientiert aufgebaut, da es mir für dieses recht kleine Projekt etwas übertrieben vorgekommen ist .. Sehr wohl habe ich aber versucht ein möglichst gute Funktionshirarchie zu erstellen ..
Nur um Missverständnissen vorzubeugen, hier eine Liste an Begriffen, die ich mir für gewisse Aktionen festgelegt habe
- Cache: Cache-Files sind die Files, die auf dem Server gespeichert werden und den Inhalt der Flickr-API Aufrufe enthalten
- Refresh: Refreshen bedeutet es, die Cache-Files neu zu laden
Das Filesystem
Als kleiner Vorgeschmal hier das Filesystem im XML-Format
<flickr>
<cached -data>
</cached>
<get>
<getphotosetlist .inc.php />
<getphotosfromphotoset .inc.php />
<getpublicphotos .inc.php />
<getuserphotostreamurl .inc.php />
</get>
<read>
<readphotosetlist .inc.php />
<readphotosetphotos .inc.php />
<readpublicphotos .inc.php />
<readstatus .inc.php />
<readuserphotostreamurl .inc.php />
</read>
<config .inc.php />
<photosetlist .php />
<photosite .php />
<refresh .php />
</flickr>
- cached-data: In diesem Verzeichnis werden die Cache-Files gespeichert .. Man könnte sie auch in einen temporären PHP Ordner irgendwo auf dem Server speichern, aber wenn man sie an der Position speichert, hat man sicher keine Probleme mit Safe Mode oder Open Basedir ..
- get: In diesem Ordner liegen alle Files, die auf die Flickr-API zugreifen und die Ergebnisse in ein File in dem Cache-Verzeichnis speichern
- read: In diesem Verzeichnis liegen alle Daten, die die gecachten Dateien lesen und sie in ein Format verwandlen, das von der Ausgabe gelesen werden kann .. Ein “besonderes” File ist das readStatus.inc.php, das Infos zum Dateisystem ausliest
- config.inc.php: Hier werden alle Konstanten definiert
- photosetList.php: Das ist ein Ausgabe-File .. Hier wird die Ausgabe der einfachen Photoset-Liste gestaltet
- photoSite.php: Ein weiteres Ausgabe-File .. Hier wird die Ausgabe der Fotoseite gestaltet
- refresh.php: Das ist das Refresh-File .. Hier kann man manuell den Cache erneuern, sieht alle Cache-Files, sowie deren letzte Änderung und ob alle benötigten Cache-Files vorhanden sind
Datei- und Methodennamen
Die Namen der Datein und Funktionen sind etwas anders als nach dem normalen “Getter - Setter” Prinzip benannt ..
Alles was ein “get” im Namen hat bzw. der gesamte get-Ordner greift auf die Flickr-API zu, holt die XML-Files von dort und speichert die gesamten Files in den Ordner für die Cache-Files ..
Alles was ein “read” im Namen hat bzw. die Datein im read-Ordner liest etwas aus den Cache-Files bzw. aus dem Filesystem ..
Die einzelnen PHP-Files
config.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| < ?php
/*
* Statische Variablen festlegen
*/
define ("USERID", "25832905%40N05"); //Flickr User-ID
define ("APIKEY", "........"); //Flickr API Key
define ("USERNAME", "brainzina"); //Flickr Username
define ("PATH", "/var/ ... /wp-content/themes/brz_three_cols_utf/scripts/flickr/"); //Pfad in dem die ganze Application liegt
define ("TEMPPATH", PATH . "cached-data/"); //Temporaerer Pfad zum Zwischenspeichern der API Antowrten
define ("REFRESHRATE", 86400); //Refreshrate in Sekunden; 86400 = 1 Tag
define ("APICALLURLSTART", "http://api.flickr.com/services/rest/?"); //Der Anfang jeder URL zum API Aufruf
define ("PHOTOSETPATH", "sets/"); //Pfad zu den Alben eines Users
define ("PHOTOPATHSTART", "http://farm"); //Anfang des Pfades von jedem Foto
define ("PHOTOPATHDOMAIN", ".static.flickr.com/"); //Mittelteil, Domain des Pfades jedes Fotos
define ("PHOTOSETTHUMBNAILSIZE", "m"); //Groesse in der die Thumbnails angezeigt werden sollen
/*
* Namen der Files, die lokal gespeichert werden festlegen
*/
define ("USERSTREAMFILENAME", "user-photostream-url");
define ("PHOTOSETLISTFILENAME", "photoset-list");
define ("PUBLICPHOTOSFILENAME", "public-photos");
define ("PHOTOSETPHOTOSFILENAMEPREFIX", "photoset-photos-");
?> |
Hier werden die Konstanten für das ganze Tool gesetzt ..
Wichtig sind hier die Flickr-Userdaten (API-Key, Username, UserId) und der Pfad, wo das Script liegt .. Es muss der interne Pfad am Server sein, gesehen von / .. Wem die Namen der Cache-Files nicht gefallen kann diese im unteren Teil ändern .. Der mittlere Teil sollte nicht verändert werden, da hier nur die Teile stehen, aus denen sich die Urls der Fotos zusammensetzen ..
Die Thumbnailgröße kann auch angepasst werden ..
Es ist hier sogar schon eine Konstante vorgesehen, die bestimmt, alle wieviele Sekunden sich der Cache neu laden soll .. Für dieses Tool wird sie allerdings nicht benötigt ..
getUserPhotostreamUrl.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| < ?php
/*
* API Aufruf zum Ermitteln der URL zum Fotostreams eines Users
*/
function getUserPhotostreamUrl($userId) {
$streamParams = array(
'method' => 'flickr.urls.getUserPhotos',
'api_key' => APIKEY,
'user_id' => $userId,
);
$streamEncodedParams = array ();
foreach ($streamParams as $u => $z) {
$streamEncodedParams[] = urlencode($u).'='.$z;
}
$streamUrl = APICALLURLSTART . implode('&', $streamEncodedParams);
$localStreamDataPath = TEMPPATH . USERSTREAMFILENAME;
file_put_contents($localStreamDataPath, file_get_contents($streamUrl));
//echo "
UserStream Datei erzeugt
";
}
?> |
Hier sieht man das erste File, dass einen Aufruf an die Flickr-API tätigt und das Ergebnis in ein File speichert .. Hierbei handelt es sich um einen einfachen Aufruf, der das File, in dem die URL zum Fotostream eines Users steht, ermittelt ..
In den Zeilen 6-10 werden die Parameter der URL in ein Array ($streamParams) geschrieben .. Die UserId muss hier der Funktion beim Aufruf übergeben werden, man könnte sie sich aber auch ganz einfach aus der config.inc.php holen, wie den Api-Key ..
Ab Zeile 14, werden die Parameter in ein für eine URL encodetes Array ($streamEncodedParams) geschrieben ..
In Zeile 18 wird dann der API-Aufruf getätigt .. Die Url setzt sich zusammen aus dem Anfang, der in der config.inc.php festgelegt wurde, und aus den Parametern aus dem vorher erzeugten Array ($streamEncodedParams), die nacheinander über implode aufgelistet werden ..
In Zeile 20 wird der Pfad für das zu schreibende Cache-File erstellt .. Er setzt sich zusammen aus dem Pfad für die Cache-Files und dem Namen für dieses bestimmte Cache-File ..
In Zeile 22 wird dann das eigentliche File geschrieben ..
file_put_contents schreibt in ein File .. Wenn das File nicht existiert, wird es erstellt; wenn es existiert und beschrieben ist, wird der Inhalt gelöscht und neu geschrieben .. file_get_contents holt sich die Daten aus der aufgerufenen Quelle (hier die URL) und gibt sie in einem String zurück .. Über file_put_contents wird dieser String dann in das vorher bestimmt File geschrieben ..
getPublicPhotos.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| < ?php
/*
* API Aufruf zum Ermitteln aller Public Photos eines Users
*/
function getPublicPhotos($userId) {
$publicParams = array(
'method' => 'flickr.people.getPublicPhotos',
'api_key' => APIKEY,
'user_id' => $userId,
);
$publicEncodedParams = array ();
foreach ($publicParams as $w => $e) {
$publicEncodedParams[] = urlencode($w).'='.$e;
}
$publicUrl = APICALLURLSTART . implode('&', $publicEncodedParams);
$localPublicPhotosDataPath = TEMPPATH . PUBLICPHOTOSFILENAME;
file_put_contents($localPublicPhotosDataPath, file_get_contents($publicUrl));
//echo "
Public Photos Datei erzeugt
";
}
?> |
In diesem File wird eine Liste aller öffentlichen Fotos eines Users zurückgegeben ..
getPhotosetList.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| < ?php
/*
* API Aufruf zum Ermitteln einer Liste aller Photosets
*/
function getPhotosetList($userId) {
$photosetsParams = array(
'method' => 'flickr.photosets.getList',
'api_key' => APIKEY,
'user_id' => $userId,
);
$photosetsEncodedParams = array();
foreach ($photosetsParams as $k => $v){
$photosetsEncodedParams[] = urlencode($k).'='.$v;
}
$photosetsUrl = APICALLURLSTART . implode('&', $photosetsEncodedParams);
$localPhotosetListDataPath = TEMPPATH . PHOTOSETLISTFILENAME;
file_put_contents($localPhotosetListDataPath, file_get_contents($photosetsUrl));
//echo "
PhotosetList Datei erzeugt
";
}
?> |
In diesem File wird eine Liste aller Photosets eines Users ermittelt
Die beiden letzten Datein gleichen der erste bis auf die geringen Unterschiede der Methode und der Namen .. Es sollten hier keine weiteren Erklärungen notwendig sein ..
getPhotosFromPhotoset.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| < ?php
/*
* Aufruf der API Funktion, die alle Photos eines Photosets holt fuer alle Photosets im Cache
*/
function getPhotosFromAllPhotosets() {
if(file_exists(TEMPPATH . PHOTOSETLISTFILENAME)) {
$allPhotosets = simplexml_load_file(TEMPPATH . PHOTOSETLISTFILENAME);
$allPhotosetsIdsArray = array();
$i = 0;
foreach($allPhotosets->photosets->photoset as $photoset) {
$allPhotosetsIdsArray[$i] = $photoset->attributes()->id;
$i++;
}
for ($j = 0; $j < sizeOf($allPhotosetsIdsArray); $j++) {
getPhotosFromPhotoset($allPhotosetsIdsArray[$j]);
}
}
}
/*
* API Aufruf zum Ermitteln aller Photos in einem Photoset
*/
function getPhotosFromPhotoset($photosetId) {
$photosetPhotosParams = array(
'method' => 'flickr.photosets.getPhotos',
'api_key' => APIKEY,
'photoset_id' => $photosetId,
);
$photosetPhotosEncodedParams = array();
foreach ($photosetPhotosParams as $r => $t){
$photosetPhotosEncodedParams[] = urlencode($r).'='.$t;
}
$photosetPhotosUrl = APICALLURLSTART . implode('&', $photosetPhotosEncodedParams);
$localphotosetPhotosDataPath = TEMPPATH . PHOTOSETPHOTOSFILENAMEPREFIX . $photosetId;
file_put_contents($localphotosetPhotosDataPath, file_get_contents($photosetPhotosUrl));
//echo "
Photoset(" . $photosetId . ") Photos Datei erzeugt
";
}
?> |
In diesem File sollen die Photos, die einem Photoset zugeordnet sind gespeichert werden .. Dazu muss logischerweise füre jedes Photoset ein eigenes File angelegt werden ..
Wenn wir zuerst die zweite Funktion (getPhotosFromPhotoset($photosetId)) in dem File betrachten wird uns auffallen, dass nicht viel anders ist, als bei den restlichen get-Files ..
Der einzige Unterschied (in Zeile 41) besteht darin, dass das erstellte File einen anderen Namen bekommt .. Er besteht aus dem Pfad aller Cache-Files, dem Prefix für diese Art von Datein und dann der ID des Photosets dessen Fotos das File enthält .. Dazu wird einfach die ID des Photosets, die der Funktion übergeben wird hinten an die schon bekannten Konstanten dran gehängt ..
Kommen wir nun zum oberen Teil und zur Funktion getPhotosFromAllPhotosets() ..
Hier wir zuerst überprüft, ob das File mit der Liste aller Photosets existiert, da man ja sonst gar nicht wüsste, welche Fotos man aus welchen Photosets sucht ..
In Zeile 7 wird mit Hilfe von simplexml_load_file das angegebene XML-File, mit der Liste aller Photosets, in ein Objekt umgewandelt ..
Hier ein kurzer Auszug aus dem XML-File mit der Liste aller Photosets .. Damit lässt sich der kommende Code der getPhotosFromAllPhotosets()-Funktion besser verstehen ..
< ?xml version="1.0" encoding="utf-8" ?>
<rsp stat="ok">
<photosets>
<photoset id="72157606480379548" primary="2720242328" secret="a9c0cf1c73" server="3065" farm="4" photos="37" videos="0">
<title>Africa 2008</title>
<description>Reise durch Südafrika (Kapstadt, dann über die Garden Route nach Port Elizabeth), zu den Victoria Falls in Zambia und durch Tansania (Serengeti, Ngorongorokrater und Zanzibar)</description>
</photoset>
<photoset id="72157606480372826" primary="2720065904" secret="202671aa34" server="3212" farm="4" photos="11" videos="0">
<title>UK 2007</title>
<description>...<description />
</description></photoset>
</photosets>
</rsp>
Ab Zeile 11 werden nun die einzelnen Photosets (also alles zwischen und ), mit Hilfe von $allPhotosets->photosets->photoset ansprechen und ihre ID mit Hilfe von $allPhotosetsIdsArray[$i] = $photoset->attributes()->id; in ein Array schreiben, dass die IDs alles Photosets enthält ..
Ab Zeile 16 wird dann die Funktion getPhotosFromPhotoset($photosetId) mit allen Photosets (bzw. deren IDs) aufgerufen und so werden für alle Photosets eigene Files erstellt mit jeweils den Fotos aus einem Photoset darin ..
Mit Hilfe dieser 4 get-Files sollten also alle unsere benötigten Cache-Files erstellt werden können !! Nun ist es an der Zeit, die Funktionen, die das erledigen auch von wo aufzurufen .. Das machen wir in unserem readStatus.inc.php !!
readStatus.inc.php
Das readStatus.inc.php ist das erste längere File drum werde ich es unterteilen und die Erklärungen direkt unter die relevanten Teile schreiben .. Die Zeilennummern bleiben aber durchgängig !!
1
2
3
4
5
| < ?php
include(PATH . "get/getPhotosetList.inc.php");
include(PATH . "get/getPhotosFromPhotoset.inc.php");
include(PATH . "get/getPublicPhotos.inc.php");
include(PATH . "get/getUserPhotostreamUrl.inc.php"); |
Im oberen Teil werden alle get-Files includet, damit man auf deren Funktionen zugreifen kann ..
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| /*
* Erzeugt eine Uebersicht der Infos zu den Cache Datein
*/
function readStatus() {
$cacheDirectory = opendir(TEMPPATH);
if ($cacheDirectory != false) {
$cacheDirFilesArray = scandir(TEMPPATH);
$cacheFilesArray = array();
for ($i = 0; $i < sizeOf($cacheDirFilesArray); $i++) {
if (is_file(TEMPPATH . $cacheDirFilesArray[$i])) {
$cacheFileData = lstat(TEMPPATH . $cacheDirFilesArray[$i]);
$cacheFilesArray[$i] = array (
'name' => $cacheDirFilesArray[$i],
'size' => $cacheFileData[7],
'lastChange' => $cacheFileData[10],
);
}
}
$cacheFilesArray = array_values($cacheFilesArray);
return $cacheFilesArray;
}
} |
Die Funktion readStatus() dient dazu, den Status der Cache-Files zu erfragen ..
In Zeile 10 wird das Verzeichnis mit den Cache-Files geöffnet .. Falls dieses nicht vorhanden ist, wir false in die Variable geschrieben ..
In Zeile 12 wird abgefragt, ob das Verzeichnis vorhanden ist, in dem geprüft wird, ob die vorher beschrieben Variable nicht false ist ..
In Zeile 14 wir das Verzeichnis mit scandir gescannt und der Inhalt, also alle Cache-Files, als Array in alphabetischer Reihenfolge in ein Array ($cacheDirFilesArray) geschrieben ..
Ab Zeile 16 wird dieses Array durchlaufen und zu jedem der darin enthaltenen Files (Verzeichnisse werden ignoriert durch is_file-Abfrage) werden über lstat Informationen ermittelt .. Mit den gewünschten Informationen (Größe und Zeitpunkt der letzten Änderung) und dem Namen des Files wird ein weitere assoziatives Array ($cacheFilesArray) befüllt ..
In Zeile 29 werden dann noch mit Hilfe von array_values($cacheFilesArray) die Array Elemente des erstellten Array ($cacheFilesArray), die durch Verzeichnisse (auf jeden Fall “.” und “..”) oder Verknüfungen, die sich in dem Cache-Verzeichnis befinden, keinen Wert bekommen haben, herausgenommen ..
In Zeile 31 wir dann mit return das erstellt Array zurückgegeben ..
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
| function readLastRefresh() {
$cacheDirectory = opendir(TEMPPATH);
if ($cacheDirectory != false) {
$cacheFilesArray = scandir(TEMPPATH);
$cacheFilesRefreshsArray = array();
for ($i = 0; $i < sizeOf($cacheFilesArray); $i++) {
if (is_file(TEMPPATH . $cacheFilesArray[$i])) {
$cacheFileData = lstat(TEMPPATH . $cacheFilesArray[$i]);
$cacheFilesRefreshsArray[$i] = $cacheFileData[10];
}
}
return min($cacheFilesRefreshsArray);
}
} |
Innerhalb der Funktion readLastRefresh() soll der Refresh-Zeitpunkt des ältesten Cache-Files ermittelt werden ..
Die Zeilen 35-43 gleichen der letzten Funktion ..
In Zeile 44 wird wieder mittels lstat Information zu den Files abgerufen, wobei uns diesmal nur der Zeitpunkt der letzten Änderung interessiert ..
Diesen speichern wir dann auch in Zeile 45 in ein eigenes Array dafür .. In diesem Array ist also nach Ablauf der Schleife der Zeitpunkte der letzten Änderung der jeweiligen Files gespeichert ..
In Zeile 49 wir dann das Minimum mittels min des gerade befüllten Arrays ermittelt (also das File, das den ältesten Zeipunkt der letzten Änderung hat) und das auch direkt zurückgegeben ..
53
54
55
56
| function checkRefresh() {
if (time() - readLastRefresh() > REFRESHRATE) return true;
else return false;
} |
Diese kleine Funktion ist für eine automatische Refresh-Funktion .. Sie prüft, ob das aktuelle Datum kürzer als die eingegebene Refreshrate vom Zeitpunkt der letzten Änderung des ältesten Files entfernt ist und gibt dementsprechend true oder false zurück ..
Da wir keinen automatischen Refresh ausprogrammieren werden, interessiert uns diese Funktion im Moment gar nicht ..
57
58
59
60
61
62
63
64
65
| /*
* Ruft alle Methoden der Flickr API auf um die Daten lokal zu speichern
*/
function refreshAll() {
getUserPhotoStreamUrl(USERID);
getPublicPhotos(USERID);
getPhotosetList(USERID);
getPhotosFromAllPhotosets();
} |
Die refreshAll() Funktion ist eine sehr wichtige Funktion, da sie die jenige ist, die alle get-Funktionen aufruft und somit alle Cache-Files erneuert ..
Im Prinzip gibt es dazu nicht wirklich viel zu sagen, da ja nichts passiert, außer das 4 Funktionen aufgerufen werden 
..
Etwas sollte allerdings beachtet werden; Die Reihenfolge der Funktionen ..
Nachdem die getPhotosFromAllPhotosets() die Liste der Photosets benötigt ist es von Vorteil, wenn man die Funktion, getPhotosetList(USERID), die diese Liste erzeugt davor aufruft ..
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
| /*
* FILE CHECK METHODEN
*
* Checkt, ob das Cache File der Photosets exisitert
*/
function checkCachePhotoset() {
if (file_exists(TEMPPATH . PHOTOSETLISTFILENAME)) {
return true;
} else {
return false;
}
}
/*
* Checkt, ob das Cache File fuer die URL des Photostreams exisitert
*/
function checkCacheStreamUrl() {
if (file_exists(TEMPPATH . USERSTREAMFILENAME)) {
return true;
} else {
return false;
}
}
/*
* Checkt, ob das Cache File fuer die URL des Photostreams exisitert
*/
function checkCachePublicPhotos() {
if (file_exists(TEMPPATH . PUBLICPHOTOSFILENAME)) {
return true;
} else {
return false;
}
} |
Die letzten 3 Funktionen (checkCachePhotoset(), checkCacheStreamUrl(), checkCachePublicPhotos()) checken, ob die jeweiligen Cache-Files vorhanden sind .. Dementsprechend geben sie dann true oder false zurück ..
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
| /*
* Checkt, ob die Cache Files der Photos innerhalb der Photosets exisiteren
*/
function checkCachePhotosetPhotos() {
$endBool = 0;
$ids = readPhotosetIds();
for ($i = 0; $i < sizeOf($ids); $i++) {
if (!file_exists(TEMPPATH . PHOTOSETPHOTOSFILENAMEPREFIX . $ids[$i])) $endBool++;
}
if ($endBool == 0) {
return true;
} else {
return false;
}
} |
Diese Funktion checkt, ob alle Cache-Files vorhanden sind, die jeweils alle Fotos aus einem Photoset enthalten ..
In Zeile 104 wird eine Funktion (readPhotosetIds(), siehe unten unter readPhotosetList.inc.php) ausgeführt, die ein Array mit allen Photoset-IDs zurück gibt ..
Ab Zeile 106 wird dieses Array dann durchlaufen und so jedes einzelne File auf seine Existenz geprüft ..
In Zeile 107 wir geprüft, ob das jeweilige File vorhanden ist .. Ist ist nicht vorhanden wird eine Check-Variable ($endBool) um eines erhöht ..
In Zeile 19 wird dann gefragt, ob diese Variable 0 ist .. Wenn sie größer ist, also irgendein File nicht vorhanden war, wird false zurück gegeben, sonst true ..
117
118
119
120
121
122
123
124
125
126
127
128
129
130
| /*
* Ruft alle File Check Methoden auf und gibt true zurueck, wenn alle true sind
*/
function checkFiles() {
if (checkCachePhotoset() == true &&
checkCachePhotosetPhotos() == true &&
checkCacheStreamUrl() == true &&
checkCachePublicPhotos() == true) {
return true;
} else {
return false;
}
}
?> |
Die Funktion checkFiles() checkt nacheinander alle oben beschriebenen Check-Funktionen durch .. Wann alle true zurückgeben gibt auch die checkFiles() Funktion true zurück .. Sonst false ..
refresh.php
So, jetzt haben wir genug Code um schöne Ausgaben zu erzeugen !! Als erstes wollen wir unsere “File-Zentrale” ausgeben, mit der man die Cache-Files refreshen sowie einige wichtige Infos zu den Cache-Files sehen kann !!
Auch hier werde ich das File wieder unterteilen, damit man es leichter lesen kann !!
1
2
3
4
| < ?php
include("config.inc.php");
include(PATH . "read/readPhotosetList.inc.php");
include(PATH . "read/readStatus.inc.php"); |
Wir inlkudieren auch hier wieder alle Files, die wir zum Ausführen der Funktionen brauchen !!
5
6
7
8
9
10
11
12
13
14
15
| /*
* Ausgabe des Startlinks fuer die Refreshfunktion
*/
echo "
<h1><a href="\">Refresh Now</a></h1>
";
/*
* Wenn Link gedrueckt, wird die Methode zum Alles Refreshen aufgerufen
*/
if ($_GET['refresh'] == 1) refreshAll(); |
Im oberen Teil wird nur ein Link angezeigt, der die Seite nochmal mit dem GET-Parameter refresh=1 aufruft ..
Im unteren Teil (Zeile 13) wird der GET-Parameter der Seite geprüft und falls er 1 ist (also der Link oben gedrückt wurde) wird die Funktion refreshAll() ausgeführt und somit alle Files refreshed ..
14
15
16
17
18
19
20
| /*
* Ausgabe des aeltesten Refreshs
*/
echo "
<h1>Oldest Refresh Data</h1>
\n";
echo strftime("%A, %d.%m.%Y %R:%S", readLastRefresh()) . "\n"; |
Hier wird der Zeitpunkt der letzten Änderung des ältesten Cache-Files ausgegeben ..
Der Wert wird durch die Funktion readLastRefresh() ermittelt und mittels strftime() in ein schönes Format gebracht ..
21
22
23
24
25
26
27
28
| /*
* Ausgabe des Ergebnis des File Checkers
*/
echo "
<h1>Filesystemcheck</h1>
";
if (checkFiles() == true) echo "Alle Files vorhanden";
else echo "Cache Files fehlen"; |
Hier wird der Filesystemcheck ausgeführt .. Es wird also geprüft, ob alle Files vorhanden sind ..
Gibt checkFiles() true zurück, wird eine Erfolgsmeldung ausgegeben .. Bei false eine Warnung, dass Files fehlen ..
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
| /*
* Ausgabe der Uebersicht
*/
$statusInfo = readStatus();
echo "
<h1>Cache Files Info</h1>
\n";
echo "
<table border="0">\n";
echo "\t
<tbody>
<tr>\n";
echo "\t\t
<th>Name</th>
\n";
echo "\t\t
<th>Size</th>
\n";
echo "\t\t
<th>Last Change</th>
\n";
echo "\t</tr>
\n";
for ($j = 0; $j < sizeOf($statusInfo); $j++) {
echo "\t
<tr>\n";
echo "\t\t
<th>" . $statusInfo[$j]['name'] . "</th>
\n";
echo "\t\t
<td>" . $statusInfo[$j]['size'] . " Bytes</td>
\n";
echo "\t\t
<td>" . strftime("%A, %d.%m.%Y %R:%S", $statusInfo[$j]['lastChange']) . "</td>
\n";
echo "\t\n";
}
echo "
</tbody></table>
\n";
?> |
Im letzten Teil wird eine Tabelle mit den ermittelten File-Informationen ausgegeben ..
In Zeile 31 wird die Funktion readStatus() aufgerufen um das assoziative Array mit den Files und ihren File-Informationen zu erhalten ..
In den Zeilen 33-40 wird eine Überschrift und eine Zeile der Tabelle ausgegeben ..
Ab Zeile 42 wird dann das assoziative Array in der Variable $statusInfo durchlaufen .. Jeder Durchlauf, also jedes File bedeutet eine neue Zeile der Tabelle, wobei in die einzelnen Zellen die Daten (Filename, Größe und Zeitpunkt der letzten Änderung) geschrieben werden ..
In Zeile 46 wird wieder mittels strftime() der Timestamp der letzten Änderung in ein schönes Ausgabeformat verwandelt ..
In Zeile 50 wird die Tabelle wieder geschlossen ..
Mit dem Refresh-File kann man also nun den Cache refreshen, und sich die wichtigsten Daten über die Files anschauen !!
Jetzt werden wir uns daran machen, die Daten aus den gechachten Files zu verarbeiten !!
readUserPhotostreamUrl.inc.php
1
2
3
4
5
6
7
8
9
10
11
12
13
| < ?php
include(PATH . "config.inc.php");
/*
* Gibt die URL das Photostreams zurueck
*/
function readPhotostreamUrl() {
$url = simplexml_load_file(TEMPPATH . USERSTREAMFILENAME);
$streamUrl = $url->user->attributes()->url;
return $streamUrl;
}
?> |
In Zeile 2 wird die config.inc.php inkludiert ..
In Zeile 6 beginnt die Funktion readPhotostreamUrl(), die nicht anderes tun soll, als die URL des Fotostreams des Users zurückzugeben ..
In Zeile 7 greift sie auf das erstellte Cache-File zu und verwandlet es mittels simplexml_load_file in ein Objekt ..
In Zeile 9 wird dann noch ein Variable erstellt, die mit der URL des Fotostreams definiert wird und dann in Zeile 10 zurückgegeben wird ..
Die Zugriffe auf die verschiedenen Daten in dem XML-File bzw. in dem Objekt laufen relativ einfach .. Um es besser zu verstehen lohnt es sich, die Struktur eines XML-Files anzuschauen und so herauszufinden wie es genau funktioniert ..
Grundsätzlich geht man in Unterobjekte mit dem -> und in die Attribute mit attributes()-> ..
readPublicPhotos.inc.php
In diesem File werden mittels einer Methode alle öffentlichen Bilder eines Users ermittelt und ein Zufallsbild daraus generiert ..
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| < ?php
include(PATH . "config.inc.php");
/*
* Bestimmt ein Zufallsbild aus allen Public Photos
*/
function createRandomPhoto() {
$photostreamUrl = readPhotostreamUrl();
$publicPhotos = simplexml_load_file(TEMPPATH . PUBLICPHOTOSFILENAME);
$publicPhotosArray = array();
if ($publicPhotos->attributes()->stat == "ok") {
$i = 0;
foreach ($publicPhotos->photos->photo as $photo) {
$publicPhotosArray[$i] = $photo;
$i++;
}
$randId = rand(0, sizeOf($publicPhotosArray));
$randPhoto = array(
'title' => $publicPhotosArray[$randId]->attributes()->title,
'path' => PHOTOPATHSTART . $publicPhotosArray[$randId]->attributes()->farm . PHOTOPATHDOMAIN . $publicPhotosArray[$randId]->attributes()->server . '/' . $publicPhotosArray[$randId]->attributes()->id . '_' . $publicPhotosArray[$randId]->attributes()->secret . '.jpg',
'url' => $photostreamUrl . $publicPhotosArray[$randId]->attributes()->id,
);
return $randPhoto;
} else {
return false;
}
}
?> |
In Zeile 2 wird die config.inc.php eingebunden
In Zeile 7 beginnt die Funktion createRandomPhoto(), die am Anfang wieder das Cache-File mit den öffentlichen Fotos ausliest und das erhaltene Objekt in eine Variable steckt ..
In Zeile 8 wird die Fotostream-URL in eine Variable geladen ..
In Zeile 14 wird gecheckt, ob der Status des Cache-Files (bzw. der Abfrage) “ok” ist, wenn ja wird weitergemacht ..
Ab Zeile 17 wird jedes Photo aus dem Cache-File angesprochen und in ein weiteres Array ($publicPhotosArray) gesteckt .. Diese Array enthält also nach Ablauf der Schleife alle Fotos des Users ..
In Zeile 22 wird mittels rand() eine Zufallszahl ermittelt, die den Arrayeintrag des Fotos bestimmt, das als Zufallsbild gelten soll ..
In Zeile 24 wird das Array $randPhoto erzegt, in das danach der Titel, die URL und der Pfad des generierten Zufallsbildes gespeichert werden ..
Der Titel ist einfach der Titel, wie er in dem Cache-File steht und die URL bestelt aus der Fotostream-URL und der ID des Fotos ..
Der Pfad des Fotos, also die Adresse des Bildes ansich besteht aus einer Menge Parametern, die man zu einer Adresse zusammenfassen muss .. Infos dazu gibts in der URL-Dokumentation in der API-Dokumentation
In Zeile 30 wird dann der befüllte Array zurückgegeben ..
readPhotosetPhoto.inc.php
In diesem File wird mittels einer Funktion ein Zufallsbild aus einem bestimmten Photoset generiert ..
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
| < ?php
include(PATH . "config.inc.php");
/*
* Bestimmt ein Zufallsbild aus einem Photoset
*/
function createRandomPhotoFromPhotoset($photosetId) {
$photos = simplexml_load_file(TEMPPATH . PHOTOSETPHOTOSFILENAMEPREFIX . $photosetId);
$photosArray = array();
if ($photos->attributes()->stat == "ok") {
$i = 0;
foreach ($photos->photoset->photo as $photoo) {
$photosArray[$i] = $photoo;
$i++;
}
$randId = rand(0, sizeOf($photosArray) - 1);
$randPhotoPath = PHOTOPATHSTART
. $photosArray[$randId]->attributes()->farm
. PHOTOPATHDOMAIN
. $photosArray[$randId]->attributes()->server
. '/'
. $photosArray[$randId]->attributes()->id
. '_'
. $photosArray[$randId]->attributes()->secret
. '_'
. PHOTOSETTHUMBNAILSIZE
. '.jpg';
return $randPhotoPath;
} else {
return false;
}
}
?> |
Dieses File unterscheidet sich vom vorangegangenen File nur sehr gering .. Es hat ja auch das gleiche Ziel: Aus einer gewissen Menge an Bilden ein Zufallsbild zu generieren ..
Zwischen Zeile 1-19 läuft alles gleich wie beim vorigen File, bis auf die Namen ..
In Zeile 21 wir dann wieder das Zufallsbild generiert ..
Ab Zeile 23 wird dann wird dann der Pfad des Fotos zusammengestellt .. Diesmal etwas übersichtlicher ..
In Zeile 35 wird der Pfad des Zufallsbildes dann zurückgegeben
readPhotosetList.inc.php
Jetzt kommt wieder ein etwas längeres File .. In diesem File stehen zwei Funktionen, die zwei verschiedene Versionen von Listen von Photosets zurückgeben .. Die zwei andere Funktionen werden auch noch für andere Aufgaben benötigt ..
Das File wird wieder in die einzelnen Funktionen unterteilt ..
1
2
3
4
5
6
7
8
9
10
11
12
| < ?php
include(PATH . "config.inc.php");
/*
* Liest die Daten aus der Photoset List in ein Objekt
*/
function readPhotosetList() {
$photosetList = simplexml_load_file(TEMPPATH . PHOTOSETLISTFILENAME);
if ($photosetList->attributes()->stat == "ok") return $photosetList;
else return false;
} |
Ganz oben wird wieder das config.inc.php eingebunden ..
Die Funktion readPhotosetList() ruft das Cache-File nach bekanntem Schema auf und gibt das Objekt zurück, falls der Status des Aufrufes ok war ..
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| /*
* Gibt ein Array mit einer Liste der Photoset Ids zurueck
*/
function readPhotosetIds() {
$photosetList = readPhotosetList();
$photosetIds = array();
$i = 0;
foreach ($photosetList->photosets->photoset as $photoset) {
$photosetIds[$i] = $photoset->attributes()->id;
$i++;
}
return $photosetIds;
} |
Die Funktion readPhotosetIds() soll ein Array zurückgeben, dass die IDs alles Photosets enthält .. Wie schon oben beschrieben wird es z.B. benötigt um die Check-Funktion verschiedenen Photoset-Photos-Files auszuführen ..
In Zeile 17 wird das Objekt mit allen Photosets aufgerufen und in die Variable $photosetList geschrieben ..
Ab Zeile 22 wird das Objekt durchlaufen und die Photosets einzeln angesprochen ..
In Zeile 23 wird dann die jeweilige ID in ein Array geschrieben ..
Das Array, dass nach der Schleife alle IDs der Photosets enthält wir in Zeile 27 zurückgegeben
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| /*
* Befuellt ein Array fuer die Verarbeitung der grossen Photoset List
*/
function createFullPhotosetList() {
$photosetList = readPhotosetList();
$photostreamUrl = readPhotostreamUrl();
if ($photosetList != false) {
$photosetsArray = array();
$i = 0;
foreach($photosetList->photosets->photoset as $photoset) {
$photosetsArray[$i] = array (
'title' => $photoset->title,
'url' => $photostreamUrl . PHOTOSETPATH . $photoset->attributes()->id,
'thumb' => createRandomPhotoFromPhotoset($photoset->attributes()->id),
);
$i++;
}
return $photosetsArray;
} else {
return false;
}
} |
Die Funktion createFullPhotosetList() soll ein Array mit allen Photosets und jeweils dem Namen, der URL und einem Zufallsbild zurückgeben ..
In den Zeilen 34 und 35 holt sich die Funktion die URL des Fotostreams und das Objekt mit allen Photosets und schreibt die zwei Rückgabewerte jeweils in eine Variable ..
Ab Zeile 41 wird dann das Objekt mit allen Photosets durchlaufen, wobei jedes Photoset einzeln angesprochen wird ..
Ab Zeile 42 wird ein Array-Element mit den Informationen (Titel, URL und Pfad des Zufallsbildes) über das jeweilige Photoset befüllt ..
In Zeile 43 der Titel, der einfach aus dem Objekt übernommen werden kann
In Zeile 44 wird die URL zu dem Photoset aus Fotostream-URL, Photoset-Pfad und der ID zusammengestellt
In Zeile 45 wird die Funktion createRandomPhotoFromPhotoset() aufgerufen, die die Adresse eines Zufallsbildes aus dem jeweiligen Photoset zurückgibt
Nach Ablauf der Schleife wird in Zeile 50 das erstellt und befüllte assoziative Array zurückgegeben ..
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
| /*
* Befuellt ein Array fuer die Verarbeitung der kleinen Photoset List
*/
function createSimplePhotosetList() {
$photosetList = readPhotosetList();
$photostreamUrl = readPhotostreamUrl();
if ($photosetList != false) {
$photosetsArray = array();
$i = 0;
foreach($photosetList->photosets->photoset as $photoset) {
$photosetsArray[$i] = array (
'name' => $photoset->title,
'url' => $photostreamUrl . PHOTOSETPATH . $photoset->attributes()->id,
);
$i++;
}
return $photosetsArray;
} else {
return false;
}
}
?> |
Die Funktion createSimplePhotosetList() läuft im Prinzip genau gleich ab wie die vorige, nur das zu dem Photoset kein Zufallsbild gespeichert wird ..
Weitere Erklärungen sollten also nicht notwendig sein ..
Nachdem wir jetzt alle get- und read-Files besprochen haben, können wir mit der eigentlichen Ausgabe der Ergebnisse beginnen ..
photoSite.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| < ?php
include("config.inc.php");
include(PATH . "read/readUserPhotostreamUrl.inc.php");
include(PATH . "read/readPublicPhotos.inc.php");
include(PATH . "read/readPhotosetList.inc.php");
include(PATH . "read/readPhotosetPhotos.inc.php");
include(PATH . "read/readStatus.inc.php");
/*
* Checkt, ob das Filesystem komplett vorhanden ist
* Falls Ja wird direkt ausgegeben, wenn nicht wird der Cach refreshed
*/
if (checkFiles() == true) {
outputPhotoSite();
} else {
refreshAll();
outputPhotoSite();
} |
Im oberen Teil werden die read-Files eingebunden ..
In Zeile 13 wird dann einmal die Funktion checkFiles() aufgerufen, um zu checken, ob alle Files vorhanden sind .. Gibt die Funktion true zurück sind alle Files da und es wird mit der Ausgabe begonnen .. Gibt sie false zurück, werden alle Files refreshed und dann wird mit der Ausgabe begonnen ..
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
| /*
* Ausgabe des Zufallsbildes aus allen Public Photos
*/
function outputPhotoSite() {
$streamUrl = readPhotostreamUrl();
echo "
<h2>Fotostream\n";
echo "
\n";
echo "\t<a title="\"Flickr" href="\">" . strchr($streamUrl, "www") . "</a>\n";
echo "
\n\n";
$randPhoto = createRandomPhoto();
echo "</h2>
<h2>Zufallsbild</h2>
\n";
echo "
\n";
echo "\t<a title="\""" href="\"><img src="\" alt="\""" /></a>\n";
echo "
\n\n";
/*
* Ausgabe der Liste der Photosets mit Thumbnails
*/
$allPhotosets = createFullPhotosetList();
echo "
<h2>Alben</h2>
\n";
echo "
<ul class="\"ul-flickr-photoset-list\"">\n";
for ($i = 0; $i < sizeOf($allPhotosets); $i++) {
echo "
<li>\n";
echo "\t<a title="\""" href="\"><img title="\""" src="\" alt="\""" /></a>\n";
echo "\t<a title="\""" href="\">" . $allPhotosets[$i]['title'] . "</a>\n";
echo "\n";
}
echo "
</ul>
\n";
}
?> |
In Zeile 22 beginnt die Funktion, outputPhotoSite(), die für die Ausgabe zuständig ist
In Zeile 23 wird die Fotostream-URL geladen und darunter ein einfacher Link dorthin erzeugt .. Mittels strchr() wird das “http://” in der Ausgabe der Adresse verhindert ..
In der Zeile 30 wir die Funktion createRandomPhoto() aufgerufen um ein Zufallsbild zu generieren .. Danach wird dieses ausgegeben ..
In Zeile 40 werden dann alle Photosets mit Zufallsbilden in eine Variable geladen ..
Ab Zeile 45 wird dann eine Schleife durchlaufen, die nach einander jedes Photoset mit Zufallsbild in ein Listenelement schreibt ..
photosetList.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| < ?php
include("config.inc.php");
include(PATH . "read/readUserPhotostreamUrl.inc.php");
include(PATH . "read/readPublicPhotos.inc.php");
include(PATH . "read/readPhotosetList.inc.php");
include(PATH . "read/readPhotosetPhotos.inc.php");
include(PATH . "read/readStatus.inc.php");
/*
* Checkt, ob das Filesystem komplett vorhanden ist
* Falls Ja wird direkt ausgegeben, wenn nicht wird der Cach refreshed
*/
if (checkFiles() == true) {
outputPhotosetList();
} else {
refreshAll();
outputPhotosetList();
}
/*
* Gibt eine einfache Liste der Photosets aus
*/
function outputPhotosetList() {
$rsp = createSimplePhotosetList();
$showCount = 8;
if ($showCount > sizeOf($rsp)) $showCount = sizeOf($rsp);
/*
* Ausgabe
*/
echo "
<ul class="\"ul-sidebar-flickr\"">\n";
for ($i = 0; $i < $showCount; $i++) {
echo "\t
<li><a title="\""" href="\">" . $rsp[$i]['name'] . "</a>\n";
}
echo "
</ul>
";
}
?> |
Zwischen Zeile 1-18 läuft hier alles wie beim vorigen File ..
In Zeile 24 beginnt dann die Funktion outputPhotosetList(), die eine ganz einfache Liste mit den Namen alles Photosets ausgeben soll ..
In Zeile 25 wird die Funktion createSimplePhotosetList() geladen, um die wichtigsten Informationen zu einem Photoset aus dem Cache-File zu laden ..
In Zeile 26 wird festgelegt, wieviele Photosets in der Ausgabenliste erscheinen sollen ..
In Zeile 28 wird geprüft ob die eingegebene Anzahl an auszugebenden Listenelementen größer ist als die Gesamtanzahl an Photosets .. Ist das der Fall wird die Anzahl der auszugebenden Listenelementen auf die Gesamtanzahl aller Photosets gesetzt ..
Ab Zeile 35 wird dann wieder das Array mit allen Photosets durchlaufen und für jedes Ein Listenelement erstellt ..
Fazit
Probleme, die ich hatte
- Doppelte Inlcudes: Durch das verschachtelte einbinden von Files in andere Files hatte ich ein paar Mal Files doppelt eingebunden .. Das führt dann dazu, dass Funktionen mehrmals bestimmt werden, was einen PHP-Fehler zur Folge hat
- Dadurch, dass ich die kleine Liste mit den Photosets und die große Fotoseite zum Teil auf einer Seite habe, musste ich alle Includes der PhotoSite.php wegnehmen, da diese sowieso schon durch die photosetList.php eingebunden waren
- Ein weiteres Problem daran, dass ich zum Teil photoSite.php und photosetList.php auf der gleichen Seite anzeige ist, dass man Funktionen wie
output nicht gleich nennen darf .. Drum auch in dem Tutorial die längeren Namen für die Output-Funktionen
Ich hoffe, dass ich mit diesem Tutorial einen kleinen Überblick über die Flickr-API und ihre Funktionsweise bzw. Anwendungsweise geben konnte !!
Ich biete alle Files auch im richtigen Filesystem hier zum Download an !! flickr.zip
Links
Flickr
PHP
