Vous vous demandez comment transformer vos favoris en firefox en un blog WordPress?
Je me le demandais aussi. J'ai essayé et passé plusieurs heures à essayer, mais j'ai finalement pu continuer. J'ai découvert quelques choses qui ne seront pas évidentes pour la plupart des gens en cours de route, alors je vais poster quelques étapes ici. Vous devriez être capable de le configurer vous-même en un rien de temps sur un serveur de test. Si quelqu'un a trouvé un autre moyen de le faire, s'il vous plaît faites le moi savoir.
Tout d’abord, j’avais voulu que tous mes marque-pages soient organisés un peu, et bien qu’il existe quelques extensions de marquage pour firefox, beaucoup semblaient trop volumineuses. Rétrospectivement, j’aurais pu en essayer d’abord.
J'ai choisi d'utiliser delicious.com (anciennement del.icio.us) pour marquer mes favoris pour moi. Cela semblait la façon la plus simple de s'y prendre, et la plupart des 1 500 signets que je connaissais étaient connus de ce site, donc des balises étaient disponibles. Vous pourrez utiliser l'extension firefox delicious ou l'importer directement sur leur site web.
Ils ont une API, et cachée à l'intérieur c'est cette URL http:// username:[email protected]/v1/posts/all
ce qui devrait vous amener à avoir vos signets, maintenant avec des balises, sous forme de fichier xml.
Ensuite, vous utiliserez le script d’ici http://memografia.com/wordpress/delicious-to-wordpress-importer/ pour l’importer comme un blog. Mais vous ne pouvez pas mettre ce script dans votre répertoire plugins et le faire fonctionner! WordPress 3.0 a changé la façon de faire des importateurs, MAIS ils ont laissé un support existant (bien que cela ne soit documenté nulle part.) Créez simplement un dossier nommé 'input' dans le dossier wp-admin et déposez-y le fichier delicious.php. . (Cela fonctionne avec n'importe quel script d'importateur qui utilise la fonction register_importer ().)
Maintenant, lorsque vous accédez à votre tableau de bord et que vous regardez sous Outils> Importer, vous verrez que Delicious est une option. Vous pouvez importer les balises de signets sous forme de catégories ou de balises. Un post pour chaque signet sera publié.
Si quelqu'un essaye cela, j'aimerais avoir des conseils sur ce qu'il faut faire ensuite. J'ai cherché comment faire cela afin de pouvoir contrôler mes signets et de commenter ceux qui étaient les plus utiles. Je peux le faire, mais si quelqu'un connait des plugins qui pourraient extraire des extraits pour préciser les choses, faites-le-moi savoir. Il est plutôt intéressant de disposer d'une archive de vos signets pouvant être facilement triée par heure.
Pour être sur le thème de la question (firefox), je ne pense pas que l’on préfère utiliser délicieuse étape intermédiaire, car:
- vous perdez la taxonomie hiérarchique appliquée dans Firefox (leur manière de structurer les choses)
- vous perdez les favicons rassemblés dans firefox
- vous perdez les informations ajoutées par les séparateurs entre les liens
- vous perdez des informations sur l'ordre des répertoires et des URL appliqués dans Firefox
- il n'est pas compatible avec d'autres sources de signets, par exemple. d'autres navigateurs et par exemple un répertoire d'urls
Par conséquent, mon approche consiste à a) exporter firefox vers une structure de répertoire "BOOKMARK" avec chaque signet enregistré en tant qu'URL. b) ce répertoire de signets est le cœur même et peut être rempli à partir d’autres navigateurs, contient les informations hiérarchiques et, à l’intérieur des fichiers .url, des métadonnées supplémentaires peuvent être placées.
(A ce stade, j'ai supprimé l'export diviseur dans mon code actuel)
À partir de WordPress, vous pouvez parcourir la structure de répertoires et la placer dans WP. Ce que vous remarquerez, c’est que les liens, tels qu’ils sont actuellement dans WordPress, perdent également la taxonomie des annuaires appliqués (par exemple, aucune catégorie hiérarchique) et n’ont pas de bonne table méta. J’ai donc choisi de créer une table latérale pour que mon stockage de liens conserve ces informations (voir autre rubrique). répondre pour les étapes après cela).
Ce qui suit pourrait être la chose nécessaire si vous voulez vous concentrer sur l’exportation en premier de Firefox. encore une fois: parcourir un répertoire physique puis le lire, par ex. une table de base de données (wplinks) est prête à l'emploi:
require_once("class-EdlSqliteDb.php");
require_once("class-EdlUtil.php");
class EdlFirefox {
const BOOKMARKTYPE_URL = 1;
const BOOKMARKTYPE_DIRECTORY = 2;
const BOOKMARKTYPE_DIVIDER = 3;
const FMODE = 0777;
const DIVIDER = '--------------';
var $use_cache = true;
var $dbh;
public function __construct($DbLocation, $ffRoot, $exportLocationBookmarks)
{
$this->mDbLocation = $DbLocation;
$this->mRootTitle = $ffRoot;
$this->mExportLocation = $exportLocationBookmarks;
// database settings
$this->dbh = new EdlSqliteDb($DbLocation);
$this->dbh->addQ(1,"SELECT id FROM moz_bookmarks WHERE title=?");
$this->dbh->addQ(2,"SELECT id, title, type, fk FROM moz_bookmarks WHERE parent=? ORDER BY position");
$this->dbh->addQ(3,"SELECT content FROM moz_items_annos WHERE item_id=?");
$this->dbh->addQ(4,"SELECT url,favicon_id FROM moz_places WHERE id=?");
$this->dbh->addQ(5,"SELECT data, mime_type FROM moz_favicons WHERE id=?");
// parse the content
$this->ParseTree();
}
/*
* check the ff database for the the root folder folders
*
*/
function ParseTree()
{
$row = $this->dbh->DbExecutePrepared(1, Array($this->mRootTitle), 'row');
if (USE_FIREFOX_FOLDER)
{
$this->ParsePagesPerTree($row[0], $this->mExportLocation . '/'. FIREFOX_FOLDER . '/');
}
else
{
$this->ParsePagesPerTree($row[0], $this->mExportLocation . '/');
}
return;
}
/*
* if a bookmark is a url then write it as a file
*
*/
function processFFUrl($moz_bookmarks_id, $moz_bookmarks_fk, $moz_bookmarks_title, $strRootFolder)
{
// (1.1) Get from the annotations the description of the url
$moz_items_annos_row = $this->dbh->DbExecutePrepared(3, Array($moz_bookmarks_id), 'row');
$moz_items_annos_description = $moz_items_annos_row[0];
// (1.2) get the url and favicon_id from moz_places
if ($moz_places_recordset = $this->dbh->DbExecutePrepared(4, Array($moz_bookmarks_fk), 'recordset'))
{
foreach ($moz_places_recordset as $moz_places_row)
{
$moz_places_url = $moz_places_row[0];
$moz_places_favicon_id = $moz_places_row[1];
}
}
$this->getFaviconIcon($moz_places_favicon_id, $moz_places_url);
// (1.3) create the file
$link_url_string = "[InternetShortcut]\n";
$link_url_string .= 'URL=' . $moz_places_url . "\n";
$link_url_string .= 'description=' . $moz_items_annos_description . "\n";
if (!is_file($strRootFolder . '/'. $moz_bookmarks_title . '.url'))
{
$filename = $strRootFolder . '/'. $moz_bookmarks_title . '.url';
$fp = fopen($filename, 'w');
fwrite($fp, $link_url_string);
fclose($fp);
}
}
/*
* for each logical folder create a physical folder
*
*/
function parsePagesPerTree($intRootId, $strRootFolder)
{
if ($moz_bookmarks_recordset = $this->dbh->DbExecutePrepared(2, Array($intRootId), 'recordset'))
{
foreach ($moz_bookmarks_recordset as $moz_bookmarks_row)
{
$moz_bookmarks_id = $moz_bookmarks_row[0];
$moz_bookmarks_title = EdlUtil::filename_safe($moz_bookmarks_row[1]);
$moz_bookmarks_type = $moz_bookmarks_row[2];
$moz_bookmarks_fk = $moz_bookmarks_row[3];
$moz_bookmarks_url = '';
$moz_bookmarks_favicon_id = '';
// A bookmark can be one of three things: process (1) urls, (2) directories and (3) dividers
if ($moz_bookmarks_type==self::BOOKMARKTYPE_URL)
{
$this->processFFUrl($moz_bookmarks_id, $moz_bookmarks_fk, $moz_bookmarks_title, $strRootFolder);
}
elseif ($moz_bookmarks_type==self::BOOKMARKTYPE_DIRECTORY)
{
$dir = $strRootFolder . '/'. $moz_bookmarks_title . '/';
if (!file_exists($dir))
{
if (!mkdir($dir, 0777, true))
{
die('Failed to create folders...');
}
}
$this->parsePagesPerTree($moz_bookmarks_id, $strRootFolder . '/'. $moz_bookmarks_title);
}
elseif ($moz_bookmarks_type==self::BOOKMARKTYPE_DIVIDER)
{
// todo
}
}
}
return;
}
//
function getFaviconIcon($moz_bookmarks_favicon_id, $moz_bookmarks_url)
{
$icon_data = '';
$moz_bookmarks_favicon = '';
if ($moz_bookmarks_favicon_id)
{
if ($moz_favicons_recordset = $this->dbh->DbExecutePrepared(5, Array($moz_bookmarks_favicon_id), 'recordset'))
{
foreach ($moz_favicons_recordset as $moz_favicons_row)
{
$icon_data = $moz_favicons_row[0];
$icon_mime_type = $moz_favicons_row[1];
// the following array is also defined in the google icon checker!
$icon_type = array( 'image/png' => 'a.png',
'image/gif' => 'a.gif',
'image/x-icon' => 'a.ico',
'image/jpeg' => 'a.jpg',
'image/bmp' => 'a.bmp');
$moz_bookmarks_favicon = $icon_type[$icon_mime_type];
// TODO reimplement echo 'warning: you should add:' . $icon_mime_type;
//if ('http://apps.facebook.com/frontierville/' == $moz_bookmarks_url)
//{
// echo $moz_bookmarks_favicon_id . " - " . $icon_mime_type . " - " .
// $moz_bookmarks_favicon;
//}
}
}
}
// if $moz_bookmarks_favicon = empty then provide weird name
if ($moz_bookmarks_favicon) {
$populair_cache = new EdlCache($moz_bookmarks_url, $moz_bookmarks_favicon);
$obj = $populair_cache->CheckCacheData($icon_data, FILECACHE_FIREFOX, false);
}
// we dont want to return the data it only needs to be update
return;
}
}
J'espère pouvoir vous donner des indices pour aller plus loin dans cette démarche.
1) Ce que je voulais, c’est un moyen plus facile de gérer mes favoris et de les enrichir avec des informations déjà disponibles. 2) les différents systèmes comme Alexa, Delcious, StumbleUpon, etc., ne donnent pas tous les informations au niveau de l’URL, par exemple. Alexa donne des informations sur un niveau supérieur de la structure de domaine, par exemple. abc.def.com: vous avez besoin de def.com pour le classement ou abc.def.com/w Whatever/rtc.php: pour cela, par exemple. besoin de def.com/user (comme youtube). Donc, vous avez besoin à la fois de la structure de domaine et de la structure d'URL relative et vous devez avoir chaque nœud de chaque URL possible (domaine et relatif) comme entrée dans la base de données pour pouvoir le représenter plus tard et l'enrichir et vous avez besoin des relations entre eux. participer à l'URL pour pouvoir le représenter.
J'ai écrit une classe qui se charge dans la structure officielle du TLD et je l'ai utilisée comme élément racine dans ma base de données. Ainsi, .uk obtient l'identifiant 1 et .co.uk, un identifiant parent 1. J'ai utilisé à la fois la liste Mozilla et autre: source est la liste des suffixes publics de Mozilla: http: // publicsuffix. org/ mais c'est un peu désuet, il faut donc y ajouter
Maintenant que j'ai le TLD officiel, j'ai une classe qui se charge dans les 1.000.000 premiers sites Alexa. Cela liera de la même manière. Beaucoup d'entre eux sont une sorte de TLD de premier niveau non officiels. Depuis par exemple "google.com" n'est pas aussi officiel que le TLD de certains pays, mais cela semble plus important. En faisant cela, vous découvrirez des modèles, mais également des exceptions, par exemple. vous trouverez des adresses IP qui sont populair. Chacune de ces entrées remplit le champ "Classement Alexa". (pour la performance, je charge d’abord le fichier .csv dans une table d’aide) Alexa vous forcera à passer en revue les modèles pour que ce soit correct (bon ensemble de tests)
J'ai écrit une classe qui parcourt mes bases de données Firefox (sql lite) et exporte toutes les URL qui s'y trouvent au format .URL dans une structure de répertoires hiérarchique. Il exporte également les favicons, qu’ils soient .ico, .png, .gif, etc. (voir ci-dessous). Ceci est également lu dans la base de données. Depuis que je mets à jour cela beaucoup, cela correspond à la base de données décrite en 1 et 2. (au début, j’exportais aussi les séparateurs mais j’avais cessé de le faire).
J'ai commencé à glisser-déposer des signets dans cette structure de répertoires à partir d'autres navigateurs, par exemple. de chrome je viens de faire glisser un signet du navigateur vers le répertoire qui fournit également ce fichier .url. La structure de répertoire des URL, j'ai donné des propriétés supplémentaires, par exemple. (h) au début du nom mènera à un "coeur" par ex. une URL que j'apprécie particulièrement et # 01 # le placera en haut (ou du moins c'est la manière dont le code le traite plus loin). J'ai placé cette structure de répertoire dans une boîte de dépôt. Je dois encore écrire le code sur le serveur pour être constamment synchronisé avec la partie serveur de Dropbox. (Mon mot WORDPRESS sur l'homologue du serveur lit en permanence la structure de répertoire d'URL pour la synchronisation et la mise à jour des signets comme ci-dessus, mais j'utilise maintenant la synchronisation ftp)
J'ai écrit des cours pour delicious (vous avez besoin d'un MD5) et StumbleUpon pour obtenir non seulement le classement (delicious = nombre de signets) (SU = nombre d'avis et le nombre de pages vues), mais également la balise TAGS et la description utilisée par les utilisateurs (pourquoi J'invente mes propres tags si les gens les ont déjà donnés). Comme vous avez un nombre limité d’appels que vous pouvez effectuer sur ces systèmes, vous devez les étaler sur une période prolongée pour enrichir votre base de données. (si vous allez maintenant à delicious et cherchez un lien, voyez le bon côté et obtenez une idée de la taxonomie des tags donnés aux liens)
J'utilise le fournisseur de favicons Google (const GOOGLE_ICON_URL = 'http://www.google.com/s2/favicons?domain=';) pour afficher les favicons MAIS puisque Google n'a pas toutes les icônes (par exemple, pas pour les applications Facebook) J'enrichis le cache avec les icônes que j'ai exportées depuis Firefox. Pour cela, vous avez besoin d’un système de priorité construit dans lequel le bon favicon est choisi.
Pour mettre cela en cache, j'ai une structure de cache qui ressemble au domaine inversé pour le. pièces par exemple .com.facebook.apps.geochallenge et à un niveau plus profond de la structure de chemin relative. Dans chaque répertoire de cette structure de cache, je stocke les favicons de cache. Dans une version précédente, j'y stocke également les résultats des appels à delicious et stumblupon.
Il semble que ce soit WordPress hors de portée, mais en fait (sourire), il est très utile. La fonctionnalité de lien intégré n'a pas de bonnes options méta/pas de table méta et elle a quelques restrictions supplémentaires telles que l'absence de catégories hiérarchiques, etc ... De plus, vous devez taper des informations dans ce fichier alors qu'il existe de nombreux services qui catégorisent déjà les URL. (par exemple, dmoz) et donnez-lui les balises etc ... qui sont devenues une sorte de défaut.
Donc, cela se trouve "sous" mon site WordPress pour gérer mes liens.
Je suis en train de faire cette configuration avec toutes les informations d’au moins les 1.000.000 sites les plus importants afin de réduire le nombre d’appels et de le partager ultérieurement en tant que plug-in. J'ai un stumbleupon plugin dans la base de données du plugin wp et cela a conduit à cela. Il peut vous donner des informations sur les liens externes que vous avez dans votre blog. Il y a beaucoup de plugins qui vous donnent des informations sur le référencement général, mais aucun ne vous montre des rapports et des comparaisons, par exemple. "Quel pourcentage de vos liens sortants appartient à quelle catégorie? Populaires ou non, etc..´. Il donne également des classements à vos liens entrants et sortants, etc.