The WordPress RSS-Combiner is intended to merge several Atom, RSS, RDF, etc. Feeds into one single stream. This might be useful for you if you have several social network accounts like Twitter, SoundCloud, Last.fm, a flickr photostream, etc. that you want to include in your weblogs’ RSS-Feed.

Changes since v1.0:

After a bit, well actually it’s been around 2.5 years, I updated my RSS-Combiner Plugin for WordPress this weekend. There are mostly minor changes, and the final, combined feed output can still be improved a bit (which is on my todo list). But for now there are some enhancements made:

• the SimplePie caching is activated so the plugin uses less server-side ressources.
• the admin page was updated so that it integrates better into the WordPress admin theme.
• Limiting the number of items in the output feed was implemented.
• Changing the length of the articles content and description was implemented.
• Some warnings, that showed on the plugins first run were fixed.

Download & Demo

WordPress RSS-Combiner v1.1 (tar.gz archive, 170KB)
See the demo feed.

Instructions

• Download and unpack the archive.
• Upload its contents to the /wp-content/plugins/ folder of your WordPress installation.
• Make sure the folder /wp-content/plugins/rss-combiner/simplepie/cache is writeable by the server.
• Activate the plugin, and add some input feeds.
• Check that it’s working by accessing www.mydomain.com/blog/?feed=combined-rss2 in your browser.
• Finally, you’ll want to link to the new combined feed. (eg: <link rel="alternate" type="application/rss+xml" title="WordPress » Feed" href="http://mydomain.com/blog/rss2.php" />)
• If you need a file-like URL (parameter-free) for the generated feed, you could optionally add something like this to your WordPress .htaccess file:

  
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteRule rss2.xml ?feed=combined-rss2 [L]
</IfModule>

  (this should be placed outside of the WordPress block)

I did a redesign of the template in late 2009 and took some time this weekend to get it polished up a bit. What I like about DaDaBIK is that you can provide data editing functionality and are able to adjust the look to a clients CI quickly (just replace one logo and change some colours - the PSD is included).

Although the code of DaDaBIK is from another pre-PHP5-decade, I didn’t see much of a need to change the inner workings of DaDaBIK. So what I did is putting some fresh paint on it using CSS. Since there is no template-engine imlemented into DaDaBik, I had to edit core files here and there for simple markup changes. So! The only thing that makes sense is to offer one complete package here: DaDaBik itself and the new design included.

Installation:
If you’re about to use DaDaBIK for the first time, you might want to take a look at www.dadabik.org as well, since there’s a documentation online giving you more insight. Anyways, the setup is quite easy:

1. Download the archive
2. Extract the files, and upload the dadabik folder to your server.
3. Edit the file includes/config.php and enter your DB settings according to your setup.
4. Open up the URL yourdomain.com/pathtodadabik/install.php.
5. DaDaBIK will now set up some internal tables and you’re done.
6. DaDaBIKs default username is root and the password is letizia

Notes:
It’s important that you have created the database, you entered in the config.php file first. (for example using phpmyadmin).
If you want to, you can use a pre-made MySQL table structure with some dummy entries that I have included in the zip: just copy and paste the contents of dadabik-example-db.sql into the SQL window of the new database in phpmyadmin.

Once you’re done with the basic installation, head over to the admin.php which gives you all the admin options you need to include/remove secific tables and set human readable aliases for the tables.

The last step to perfect interfaces is to click the Interface configurator link on that admin page.
The configurator gives you all the options to customize the appearance, set default values, define which fields are mandatory, etc. etc.

Demo:
Check out the demo of DaDaBIK with the new design.
You’ll have to enter username test and password: test@ddbdemo to enter.
(please keep in mind that a lot of features are disabled in the demo, since the test-user doesn’t have admin-rights.)

Download:
DaDaBIK Revised 1.0 (1MB, tar.gz)

Subversion Repository:
There is a Subversion repository in case you want to make use of the open source idea or really want to see some old school PHP4 :O

Changelog:
2010-03-09 initial release of DaDaBIK Revised

Wer speziellere Anpassungen benötigt wird um das Weblication Kompendium meines Kollegen Ulf Mayer kaum herum kommen das er unter Weblication Tipps betreibt.

1. gab es mehrere Domains zum Webpaket,
2. oder man wollte dem Trend zur Zweit- oder Drittdomain folgen
3. es ließ sich mangels Zugriff auf die httpd- oder vhost.conf nicht anders bewerkstelligen
4. oder man wollte es genau so haben wie es ist ;)

Zuerst die altbekannte Theorie.

Nun, sofern man eine .htaccess-Datei anlegen kann und mod_rewrite verfügbar ist, kann man sich ganz gut behelfen und die einzelnen Domains ganz nach Belieben in Unterverzeichnisse weiterschicken. Die zwei, drei Zeilen die man in seine htaccess packt lesen sich in der Regel so:

1. <IfModule mod_rewrite.c>
2. RewriteEngine On
3. RewriteCond %{HTTP_HOST} ^(www.)?example.com$
4. RewriteCond %{REQUEST_URI} !^/verzeichnis/
5. RewriteCond %{REQUEST_FILENAME} !-f
6. RewriteCond %{REQUEST_FILENAME} !-d
7. RewriteRule ^(.*)$ /verzeichnis/$1
8. </IfModule>

Damit schickt man nun also alle Anfragen die ein Besucher an www.example.com schickt in ein Unterverzeichnis, in dem sich dann ein fleißiges CMS oder 73 tippende Affen um alles weitere kümmern können. Legt man sowas für jede seiner Domains an, kann man diese für eigenständige Projekte getrennt voneinander verwenden. Immerhin.

Was aber tun, wenn…

… man aus reiner Absicht zwei oder drei Domains auf eine einzige WordPress-Installation zeigen läßt? Ein paar Gründe warum man das vielleicht tun möchte könnten sein:

1. Man möchte eine mehrsprachige Seite anbieten. Ein Besucher soll allein anhand der Domain entweder einen deutschsprachigen oder aber englischen Artikel zu Gesicht bekommen. Unter www.meinedomain.de/kategorie/mein-artikel/ auf deutsch und unter www.meinedomain.com/kategorie/mein-artikel/auf englisch.
2. Auch für Entwicklungsumgebungen ist das meist sinnvoll, denn viele Entwickler arbeiten lokal auf einem localhostund nicht direkt auf einem live-Server. Normalerweise muss man sich also händisch einen Virtual Host anlegen oder die Optionen in einer WordPress Datenbank anpassen. Dort nämlich speichert WordPress die Domain unter welcher die Webseite laufen soll.
3. Ein drittes Szenario wären noch Domain-bezogene Software Lizenzen. Seien es kostenpflichtige Statistik Tools, oder sonstwas. Bitte nicht falsch verstehen - Ich will hier nicht zum Mißbrauch von Software-Lizenzen aufrufen. Aber es kann durchaus vorkommen dass man eine Software auf eine Domain lizensiert, die man zu einem späteren Zeitpunkt nicht mehr nutzt, aber durchaus noch Verwendung für die Software hat.

All diese Szenarien haben eins gemein: man möchte mehrere Domains mit einer WordPress-Installation sinnvoll betreiben. Da WordPress aber wie schon erwähnt die Domain in seiner wp_options-Tabelle speichert geht das nicht ohne weiteres. Natürlich funktionieren die weiter oben schon beschriebenen Bordmittel des Apache auch noch wenn man WordPress verwendet, sobald man aber auf einen Link seiner WordPress-Seite klickt wird man feststellen, dass diese wieder auf die intern gespeicherte Domain verweisen.

Ein Plugin schafft Abhilfe

Im WordPress-Forum hat jemand einen grandiosen Helfer (Plugin) gepostet welches genau für diesen Zweck ideal ist:Using different domains for different languages. Dieses ist zwar eigentlich darauf ausgelegt dem Gengo Plugin einen speziellen Sprachparameter zu liefern, man kann es aber sehr leicht anpassen. Ich verwende es zum Beispiel dazu mein WordPress-Backend mit einer zweiten Domain aufzurufen, ich leite damit auch alle Anfragen auf www. Domains auf eine ohne-www-Version weiter und erlaube zusätzlich eine dritte Domain, die meinem Virtual Host unter Windows entspricht. Somit entfällt nerviges Suchen und Ersetzen wenn ich lokal an der Seite arbeite. Ich kann eine 1 zu 1 Kopie sowohl auf XAMPP wie auch auf dem Live-Server einsetzen.

Vielleicht ist dieser Tip ja auch anderen nützlich bzw. eine Arbeitserleichterung.

Für den Fall, dass sich am WordPress-Forum mal was ändert, oder die Seite offline sein sollte, gibt es hier sicherheitshalber nochmal eine Kopie des Plugins: Using different domains for different languages bei snipplr.com.

An example.

Let’s say we wanted to find out what people prefer for breakfast. We would most likely create a web-based form to store someones individual preferences. You can see what this form might eventually look like in my first screenshot. Let’s write down all the possible options into a single array now - I’ll explain later why this is actually making sense. So the array looks like this:

1. Array (
2. [0] => "apple"
3. [1] => "coffee"
4. [2] => "newspaper"
5. [3] => "strawberries"
6. [4] => "cereals"
7. [5] => "bread"
8. [6] => "nutella"
9. ...
10. )

Now that we have created a form and have an array of options, let’s take a look what this Bit Masking thing is good for.
The basic idea behind bit masking is to associate each part of an array (where each value can either be true or false) with an exponential value of two.
Say what? Let’s look at this small function and the resulting masked array:

1. function getMaskedArray($array) {
2. $i = 0;
3. foreach ($array as $key => $value) {
4. $maskedArray[pow(2,$i)] = $value;
5. $i++;
6. }
7. return $maskedArray;
8. }

Using this function ($masked_breakfast_preferences = getMaskedArray($breakfast_preferences);), gives us the following:

1. Array (
2. [1] => "apple",
3. [2] => "coffee",
4. [4] => "newspaper",
5. [8] => "strawberries",
6. [16] => "cereals",
7. [32] => "bread",
8. [64] => "nutella",
9. )

Okay, now here’s the reason, we are doing all this: once we submit a form for a specific persons’ preferences, we are able to describe these preferences with a unique number: the summary of the corresponding keys.
For example: someone who would like an apple, strawberries, cereals and bread for breakfast would give a sum of 57 (that is 1 + 8 + 16 + 32).
And now you’ll understand why we need to use exponential growth on the key values here: it ensures that the result of our summary is always unique. The advantage is obvious: instead of bloating your database or handling each value separately you can handle complex selections (maybe your culinary experience leads to a form with hundreds of options) in one single number.

The function used to calculate this bit mask could look like this: (in this case, a selected checkbox has a value of 1) <input type="checkbox" name="brekfast_preferences[]" value="1">

1. function getBitmask($masked_array) {
2. foreach ($masked_array as $key => $value) {
3. if ($value === 1) {
4. $res = $res + $key;
5. }
6. }
7. return $res;
8. }

Now you’re familiar with the basic concept of bit masking.
But there’s one more thing we need in order to have a practical use for this technique: a function that can reverse the bit mask back into it’s initial Array.
All we need to get rebuild the settings for a specific user now is its stored bitmask 57 and the array of usersettings so we can reassign our bools to it:

1. function getBinmaskArray($bitmask,$array) {
2. if (is_array($array)) {
3. if (is_int($bitmask)) {
4. $bin_val = base_convert($bitmask,10,2);
5. $bin_val = strrev($bin_val);
6. for ($i = 0; $i < count($origArray); $i++) {
7. $val = substr ($bin_val, $i, 1);
8. if (!strlen($val)) $val = 0;
9. $tmpArray[$origArray[$i]] = $val;
10. }
11. return $tmpArray;
12. }
13. print "The first parameter is expected to be a valid bitmask. ";
14. }
15. print "The second parameter is expected to be an array.";
16. }

Please note that these examples are really simplified to illustrate the concept of bitmasking. In a production environment you would probably code your own bitmasking class or use a pre-made class (PHPClasses.org has a good one)

I do know that the breakfast example is rather trivial, but just think of a CMS where you want to control wether a specific content element should show up in the actual context or not… you have an ‘archive view’ a listing of ‘search results’, an ‘index view’, ‘product detail view’ and ‘product listing view’ and so on…
If you want to place a box in specific contexts of your page you could achieve that by assigning a number, a specific bitmask to it.

Multiple-selects <select multiple="multiple" size="7"> are another great example for this. If you want to highlight a selction that has already been made on such an element you can do so by simply adding the selected="selected" attribute to those <option>s with this technique.

If you think this a few steps further, you could also use this technique to reduce the number of SQL requests necessary to display a certain webpage to a minimum. Not only that elements or boxes of the webpage can be turned on or off with this technique, even functions or methods that get data from the database can be enabled or disabled just by requesting a certain URL and thus context of your webpage. So no need to grab more data from the DB then really needed.

Think about this, you will come up with your own ideas quickly.

I guess many people had this problem before and I think everybody managed to solve this quite similar. Anyways, just in case this is useful for anybody: here’s how I added a pagination to a site recently.

Given you have an array of products for example. Or maybe search results, a list of articles… something like that. Unfortunately they are too many to display them on a single page. Well, sure, you could but let’s be honest: that isn’t an option as the page would exceed its “scrollable-with-no-harm-to-scroll-fingers” length. And you don’t want to get sued by your visitors, right ;)
Ok, so you’re going to add a nice pagination to your site, so that everybody is happy.
What I found out to be a bit tricky was to calculate the actual number of pages. We need that number so that we know, how many page links we will show next to our current view.

Two simple examples to illustrate the probelm:
Let’s say we have 8 items. 8 divided by 4 is 2, so we’re going to need two pages. No big deal.
Now we try this calculation with 9 items. 9 divided by 4 gives us 2.25. So we will clearly need a 3rd page for product number 9, but how do we calculate this from our result?

1. $itemcount = $res->length();
2. $pagemin = $itemcount / 4;
3. $pagemax = ceil($itemcount / 4);
4. if ( $pagemax - intval($pagemin) === 1) ) {
5. $pages = $pagemax;
6. } else {
7. $pages = intval($pagemin);
8. }

The code explained

That’s why I compare two values here: the actual division result and the next bigger integer (that’s what ceil returns). If they differ by 1 we have a scenario where we do want another page, so we pick the bigger result as our page number (lines 4-7). If not we are just happy and use the smaller number.

So now that we know our actual page count we can do something (slightly simplified) like this:

1. while($i = 0;$i < $pages; $i++) {
2. if ($i === $_GET['page']) {
3. $class = ' class="current"';
4. } else {
5. $class = '';
6. }
7. print "<a href=\"?page=$i\" title=\"Page $i of $pages\"$class>".($i+1)."</a>";
8. }

With a little bit of styling this even looks nice. And of course, this is just a start. You also might want to add “previous” and “next buttons”, or those “first page”, “last page” buttons, limit the maximum number of page links shown, or you could center the currently viewed page in the middle, hide the previous button on the first page, etc… There are a lot of fine tuning options that will improve the user experience of your pagination.

1. SELECT *
2. FROM `phpr_db_manager`
3. WHERE `db_table` = 'projekte'
4. LIMIT 0 , 30

Nun fügt man z.B. die Priorität hinzu:

1. UPDATE `phprojekt`.`phpr_db_manager`
2. SET `list_pos` = '6'
3. WHERE `phpr_db_manager`.`db_name` = 'wichtung'
4. LIMIT 1

Erklärung: “phpprojekt” ist der Name der Datenbank, “phpr” ist der Präfix aller PHProjekt-Tabellen und kann ggf. abweichen (das legt man in der Regel bei der Installation fest). Das Feld “list_pos” in der Tabelle “phpr_db_manager” steuert die Projektübersicht die wir hier anpassen wollen, wobei der Wert 0 bedeutet, dass eine Projekteigenschaft ausgeblendet ist. Ein ganzzahliger Wert hingegen blendet eine Eigenschaft ein und legt zugleich deren Position in der Tabelle fest.

Eigentlich schade dass dieses Feature nicht (vielleicht ist das ja doch über ein addon möglich…) in einem Einstellungs- oder Optionspunkt bereitgestellt wird.

Nachtrag: Mit “grausig, häßlich” ist die aktuelle Version 5.x gemeint - wie ich gesehen habe wird wohl eifrig an einer neuen Version 6 gearbeitet, die anscheinend auch optisch ordentlich aufpoliert wird.

Außerhalb eines CMS, oder beim Verwenden einer eigenen Redaktionssystem-Kreation die ohne solche Mechanismen, setzt man seine Formulare der grausamen Webrealität aus. :D Fahrlässig!
Da bleibt einem oft nur die Möglichkeit eine CAPTCHA-Funktion zu benutzen.
Umsetzen kann man soetwas mit einer Reihe von vorgefertigten, umfangreichen Klassen oder Funktionen. (lesenswert dazu auch der Wikipedia-Eintrag Captcha).

Die einfachste und simpelste Form eines CAPTCHAs auf die ich bisher gestoßen bin, hat der Programmierer Donald Tetto geschrieben. In seinem Galerie-Skript Folderblog kommt eine sehr einfache und auch einfach zu integrierende Funktion zum Einsatz.

1. Das Formular vorbereiten

Zunächst baut man das Bild und das zugehörige Textfeld in sein Formular (also innerhalb des <form>-Elements)

1. <img src="./landscape.php" alt="beautiful landscape" />
2. <input size="4" maxlength="4" name="C" />

2. Die eigentliche Datei

Den folgenden Code speichern wir in die soeben als Bild verlinkte Datei im selben Verzeichnis, wo sich auch die Webseite mit dem Formular befindet.

1. <?php
2. session_start();
3. $letters=substr(str_shuffle("ACDJKMNOPSTVWXYZ"),0,4);
4. $image = imagecreate(40,16);
5. imagecolorallocate($image, 255, 255, 255);
6. imagecolorallocate($image, 0, 0, 0);
7. imagecolorallocate($image, rand(50,175), rand(125,225), rand(125,225));
8. imagecolorallocate($image, rand(125,225), rand(50,175), rand(125,225));
9. imageline($image, 0, rand(9,14), 40, rand(2,7), 2);
10. imagestring($image, 5, 3, 0, " " . $letters[0] . " " . $letters[1], 1);
11. imageline($image, 0, rand(2,7), 40, rand(9,14), 3);
12. imagestring($image, 5, 3, 0, $letters[2] . " " . $letters[3], 1);
13. $_SESSION["md5"] = md5($letters[2] . $letters[0] . $letters[3] . $letters[1]);
14. header('Content-type: image/png');
15. imagepng($image);
16. ?>

Beim Aufruf der Seite (und damit des Bildes) generiert diese Datei eine Zufalls-Buchstabenkombination und zeigt das Bild an, es generiert die md5-Checksum des Buchstabensalats und schreibt sie in eine Session.

Das input-Feld gibt dem Besucher nun die Möglichkeit den angezeigten Text zu bestätigen.

3. Formulardaten annehmen und verarbeiten

In der Datei in der man den Formularinhalt weiterverarbeitet hat man nun die Möglichkeit die Eingabe in dem Feld, mit Namen “captcha”, auf Korrektheit zu prüfen, bevor man mit dem Formularinhalt nun irgendetwas anstellt.

1. $captcha = $_POST['C'];
2. if ( isset($captcha) &&
3. strlen($captcha) &&
4. isset($_SESSION["md5"]) &&
5. $_SESSION["md5"]==md5(strtoupper($captcha)) )
6. {
7. // das Captcha wurde erfolgreich validiert.
8. print "Danke für Ihre Mitteilung/Kommentar/etc.";
9. }

Fertig.

So einfach kann man sich Ruhe von nervigen Spam-Mails verschaffen.
Wenn man es noch etwas hübscher haben will, kann man statt der Standarschrift auf eine eigene Schriftdatei zurückgreifen. Eine angepasste Version, zusammen mit einer Freefont kann man sich hier als ZIP-Datei herunterladen. (Dazu braucht man eine halbwegs aktuelle PHP Version mit GD Bibliothek mind. aber v3.0.8)

Als Tip sei noch etwas eigentlich selbstverständliches angemerkt: bei der Auswahl der möglichen Lettern (und der Schrift) sollte man dem Besucher zu Liebe auf Unverwechselbarkeut achten. Das ist ja sonst nur frustrierend, wenn man nicht weiß ob man jetzt ein O (oooh) oder eine 0 (null) (oder auch bei 8 und B oft problem.) eingeben soll.