This page lists files in the current directory. You can view content, get download/execute commands for Wget, Curl, or PowerShell, or filter the list using wildcards (e.g., `*.sh`).
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/01_Installation.md'# Les pré-requis sur le serveur
FreshRSS est un logiciel développé en PHP reposant sur le modèle client - serveur. C’est-à-dire qu’il vous faudra un serveur web pour en profiter. Ensuite, FreshRSS ne demande pas une configuration très fournie et peut donc, en théorie, tourner sur la plupart des serveurs mutualisés.
Il est toutefois de votre responsabilité de vérifier que votre hébergement permettra de faire tourner FreshRSS avant de nous taper dessus. Dans le cas où les informations listées ci-dessous ne seraient pas à jour, vous pourrez.
| Logiciel | Recommandé | Fonctionne aussi avec |
| -------- | ----------- | --------------------- |
| Serveur web | **Apache 2.4+** | nginx, lighttpd |
| PHP | **PHP 7.4+** | |
| Modules PHP | Requis : libxml, cURL, JSON, PDO_MySQL, PCRE et ctype<br />Requis (32 bits seulement) : GMP<br />Recommandé : Zlib, mbstring et iconv, ZipArchive<br />*Pour une liste complète des modules nécessaires voir le [Dockerfile](https://github.com/FreshRSS/FreshRSS/blob/edge/Docker/Dockerfile-Alpine#L7-L9)* | |
| Base de données | **PostgreSQL 9.5+** | SQLite, MySQL 5.5.3+, MariaDB 5.5+ |
| Navigateur | **Firefox** | Chrome, Opera, Safari, or Edge |
## Choisir la bonne version de FreshRSS
FreshRSS possède trois versions différentes (nous parlons de branches) qui sortent à des fréquences plus ou moins rapides. Aussi prenez le temps de comprendre à quoi correspond chacune de ces versions.
### La version stable
[Téléchargement](https://github.com/FreshRSS/FreshRSS/archive/latest.zip)
Cette version sort lorsqu’on considère qu’on a répondu à nos objectifs en terme de nouvelles fonctionnalités. Deux versions peuvent ainsi sortir de façon très rapprochée si les développeurs travaillent bien. En pratique, comme nous nous fixons de nombreux objectifs et que nous travaillons sur notre temps libre, les versions sont souvent assez espacées (plusieurs mois). Son avantage est que le code est particulièrement stable et vous ne devriez pas faire face à de méchants bugs.
### La version de développement
[Téléchargement](https://github.com/FreshRSS/FreshRSS/archive/edge.zip)
Comme son nom l’indique, il s’agit de la version sur laquelle les développeurs travaillent. **Elle est donc instable !** Si vous souhaitez recevoir les améliorations au jour le jour, vous pouvez l’utiliser, mais attention à bien suivre les évolutions sur GitHub (via [le flux RSS de la branche](https://github.com/FreshRSS/FreshRSS/commits/edge.atom) par exemple). On raconte que les développeurs principaux l’utilisent quotidiennement sans avoir de soucis. Sans doute savent-ils ce qu’ils font…
## Installation sur Apache
```apache
<VirtualHost *:80>
DocumentRoot /var/www/html/
#Site par défaut...
ErrorLog ${APACHE_LOG_DIR}/error.default.log
CustomLog ${APACHE_LOG_DIR}/access.default.log vhost_combined
</VirtualHost>
<VirtualHost *:80>
ServerName rss.example.net
DocumentRoot /path/to/FreshRSS/p/
<Directory /path/to/FreshRSS/p>
AllowOverride AuthConfig FileInfo Indexes Limit
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/freshrss_error.log
CustomLog ${APACHE_LOG_DIR}/freshrss_access.log combined
AllowEncodedSlashes On
</VirtualHost>
<IfModule mod_ssl.c>
<VirtualHost *:443>
ServerName rss.example.net
DocumentRoot /path/to/FreshRSS/p/
<Directory /path/to/FreshRSS/p>
AllowOverride AuthConfig FileInfo Indexes Limit
Require all granted
</Directory>
ErrorLog ${APACHE_LOG_DIR}/freshrss_error.log
CustomLog ${APACHE_LOG_DIR}/freshrss_access.log combined
<IfModule mod_http2.c>
Protocols h2 http/1.1
</IfModule>
# Pour l’API
AllowEncodedSlashes On
SSLEngine on
SSLCompression off
SSLCertificateFile /path/to/server.crt
SSLCertificateKeyFile /path/to/server.key
# Additional SSL configuration, e.g. with LetsEncrypt
</VirtualHost>
</IfModule>
```
## Installation sur Nginx
Voici un fichier de configuration pour nginx. Il couvre la configuration pour HTTP, HTTPS, et PHP.
*Vous pourrez trouver d’autres fichiers de configuration plus simples mais ces derniers ne seront peut-être pas compatibles avec l’API FreshRSS.*
```nginx
server {
listen 80;
listen 443 ssl;
# configuration https
ssl on;
ssl_certificate /etc/nginx/server.crt;
ssl_certificate_key /etc/nginx/server.key;
# l’URL ou les URLs de votre serveur
server_name rss.example.net;
# le répertoire où se trouve le dossier p de FreshRSS
root /srv/FreshRSS/p/;
index index.php index.html index.htm;
# les fichiers de log nginx
access_log /var/log/nginx/rss.access.log;
error_log /var/log/nginx/rss.error.log;
# gestion des fichiers php
# il est nécessaire d’utiliser cette expression régulière pour le bon fonctionnement de l’API
location ~ ^.+?\.php(/.*)?$ {
fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
fastcgi_split_path_info ^(.+\.php)(/.*)$;
# Par défaut la variable PATH_INFO n’est pas définie sous PHP-FPM
# or l’API FreshRSS greader.php en a besoin. Si vous avez un “Bad Request”, vérifiez bien cette dernière !
# REMARQUE : l’utilisation de la variable $path_info est requis. Pour plus de détails, voir :
# https://trac.nginx.org/nginx/ticket/321
set $path_info $fastcgi_path_info;
fastcgi_param PATH_INFO $path_info;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}
location / {
try_files $uri $uri/ index.php;
}
}
```
Pour un tutoriel pas à pas, vous pouvez suivre [cet article dédié](http://www.pihomeserver.fr/2013/05/08/raspberry-pi-home-server-installer-un-agregateur-de-flux-rss-pour-remplacer-google-reader/).
## Conseils de sécurité
> **TODO**
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/02_First_steps.md'Découvrir un nouveau logiciel n’est pas toujours facile. Si nous avons voulu
FreshRSS le plus intuitif possible, vous aurez peut-être besoin d’un coup de
main pour le maîtriser.
Cette section se propose de vous aider dans la prise en main de l’outil. Il
ne s’agit que de liens menant vers les autres pages de la documentation mais
ordonnées dans un ordre spécifique aux nouveaux arrivants.
[Après l’installation](../../en/admins/03_Installation.md), la première
chose à faire est d’ajouter un ou plusieurs sites à suivre. Pour cela
plusieurs choix s’offrent à vous :
1. [Ajouter un flux manuellement](04_Subscriptions.md#ajouter-un-flux)
2. [Importer un fichier OPML ou JSON](04_Subscriptions.md#import-et-export)
3. [Utiliser le bookmark dédié](04_Subscriptions.md#utiliser-le-bookmark)
Une fois que vous avez ajouté vos flux à FreshRSS, il est temps de les
lire. Pour cela, trois modes de lecture s’offrent à vous :
1. [La vue normale](03_Main_view.md#la-vue-normale) qui permet de voir et de
lire rapidement les nouveaux articles
2. [La vue globale](03_Main_view.md#la-vue-globale) est destinée à vous
offrir un panorama de l’état de vos flux
3. [La vue lecture](03_Main_view.md#la-vue-lecture) est pensée pour vous
offrir un meilleur confort de lecture
Bien, vous maitrisez maintenant la vue que vous préférez ? Il est temps de
vous offrir un peu plus de confort de lecture. FreshRSS est grandement
configurable et c’est à vous de trouver la configuration qui vous conviendra
le plus. Voici tout de même quelques pistes pour améliorer votre quotidien
sur FreshRSS :
* [Rangez vos flux dans des catégories](04_Subscriptions.md#organisation-des-flux)
* [Configurez votre page d’accueil](05_Configuration.md#personnaliser-la-vue)
* [Configurez vos options de lecture](05_Configuration.md#reading)
* [Mettez à jour vos flux](03_Main_view.md#rafraîchir-les-flux)
* [Filtrez les articles](03_Main_view.md#filtrer-les-articles) pour accéder rapidement à ceux que vous voulez lire en priorité
* [Retrouvez un article](03_Main_view.md#rechercher-des-articles) qui a été publié il y a quelques jours ou mois
* [Accédez à vos flux même sur mobile](06_Mobile_access.md)
* [Ajoutez quelques extensions](https://github.com/FreshRSS/Extensions)
* [Foire aux questions](07_Frequently_Asked_Questions.md)
* [Recevoir les articles instantannément grâce à WebSub](08_PubSubHubbub.md)
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/03_Main_view.md'# La page principale
## La vue normale
> **À FAIRE**
## La vue globale
> **À FAIRE**
## La vue lecture
> **À FAIRE**
## Rafraîchir les flux
Pour profiter pleinement de FreshRSS, il faut qu’il récupère les nouveaux
articles disponibles des flux auxquels vous avez souscrit. Pour cela, il
existe plusieurs méthodes.
### Mise à jour automatique
C’est la méthode recommandée car il n’y a pas besoin d’y penser, elle se
fait toute seule, à la fréquence que vous avez choisi.
#### Par le script actualize_script.php
Cette méthode n’est possible que si vous avez accès aux tâches planifiées de
la machine sur laquelle est installée votre instance de FreshRSS.
Le script qui permet de mettre à jour les articles s’appelle
*actualize_script.php* et se trouve dans le répertoire *app* de votre
instance de FreshRSS. La syntaxe des tâches planifiées ne sera pas expliquée
ici, cependant voici [une introduction rapide à
crontab](http://www.adminschoice.com/crontab-quick-reference/) qui peut vous
aider.
Ci-dessous vous trouverez un exemple permettant la mise à jour des articles
toutes les heures.
```cron
0 * * * * php /chemin/vers/FreshRSS/app/actualize_script.php > /tmp/FreshRSS.log 2>&1
```
« Paramètres de configuration du script; Ils sont utilisables simultanément
: »
* Parameter `ajax` <https://freshrss.example.net/i/?c=feed&a=actualize&ajax=1>
Only a status site is returned and not a complete website. Example: "OK"
* Parameter `maxFeeds`
<https://freshrss.example.net/i/?c=feed&a=actualize&maxFeeds=30> If *maxFeeds*
is set the configured amount of feeds is refreshed at once. The default
setting is `10`.
* Parameter `token`
<https://freshrss.example.net/i/?c=feed&a=actualize&token=542345872345734>
Security parameter to prevent unauthorized refreshes. For detailed
Documentation see "Form authentication".
#### Online cron
If you do not have access to the installation server scheduled task, you can
still automate the update process.
To do so, you need to create a scheduled task, which need to call a specific
URL: <https://freshrss.example.net/i/?c=feed&a=actualize> (it could be
different depending on your installation). Depending on your application
authentication method, you need to adapt the scheduled task.
##### Aucune authentification
C’est le cas le plus simple, puisque votre instance est publique, vous
n’avez rien de particulier à préciser :
```cron
0 * * * * curl 'https://freshrss.example.net/i/?c=feed&a=actualize'
```
##### Authentification par formulaire
Dans ces cas-là, si vous avez autorisé la lecture anonyme des articles, vous
pouvez aussi permettre à n’importe qui de rafraîchir vos flux (« Autoriser
le rafraîchissement anonyme des flux »).
L’url précédente devient donc accessible à n’importe qui et vous pouvez
utiliser la tâche cron de la partie précédente.
Vous pouvez aussi configurer un jeton d’authentification pour accorder un
droit spécial sur votre serveur.
La tâche cron à utiliser sera de la forme suivante :
```cron
0 * * * * curl 'https://freshrss.example.net/i/?c=feed&a=actualize&token=mon-token'
```
You can also target a different user by adding their username to the query
string, with `&user=insert-username`:
```cron
0 * * * * curl 'https://freshrss.exemple.net/i/?c=feed&a=actualize&user=quelquun&token=mon-token'
```
##### Authentification HTTP
Dans ce cas-là, le token et les permissions “anonymes” sont inutilisables et
il vous sera nécessaire d’indiquer vos identifiants dans la tâche
cron. **Notez que cette solution est grandement déconseillée puisqu’elle
implique que vos identifiants seront visibles en clair !**
```cron
0 * * * * curl -u alice:motdepasse123 'https://freshrss.exemple.net/i/?c=feed&a=actualize'
```
### Mise à jour manuelle
Si vous ne pouvez pas ou ne voulez pas utiliser la méthode automatique, vous
pouvez le faire de façon manuelle. Il existe deux méthodes qui permettent de
mettre à jour tout ou partie des flux.
#### Mise à jour complète
Cette mise à jour se fait pour l’ensemble des flux de l’instance. Pour
initier cette mise à jour, il suffit de cliquer sur le lien de mise à jour
disponible dans le menu de navigation.
Lorsque la mise à jour démarre, une barre de progression apparait et
s’actualise au fur et à mesure de la récupération des articles.
#### Mise à jour partielle
Cette mise à jour se fait pour le flux sélectionné uniquement. Pour initier
cette mise à jour, il suffit de cliquer sur le lien de mise à jour
disponible dans le menu du flux.
## Filtrer les articles
Avec le nombre croissant d’articles stockés par FreshRSS, il devient
important d’avoir des filtres efficaces pour n’afficher qu’une partie des
articles. Il existe plusieurs méthodes qui filtrent selon des critères
différents. Ces méthodes peuvent être combinées dans la plus part des cas.
### Par catégorie
C’est la méthode la plus simple. Il suffit de cliquer sur le titre d’une
catégorie dans le panneau latéral. Il existe deux catégories spéciales qui
sont placées en haut dudit panneau :
* *Flux principal* qui affiche uniquement les articles des flux marqués
comme visible dans cette catégorie
* *Favoris* qui affiche uniquement les articles, tous flux confondus,
marqués comme favoris
### Par flux
Il existe plusieurs méthodes pour filtrer les articles par flux :
* en cliquant sur le titre du flux dans le panneau latéral
* en cliquant sur le titre du flux dans le détail de l’article
* en filtrant dans les options du flux dans le panneau latéral
* en filtrant dans la configuration du flux
### Par statut
Chaque article possède deux attributs qui peuvent être combinés. Le premier
attribut indique si l’article a été lu ou non. Le second attribut indique si
l’article a été noté comme favori ou non.
Dans la version 0.7.x, les filtres sur les attributs sont accessibles depuis
la liste déroulante qui gère l’affichage des articles. Dans cette version,
il n’est pas possible de combiner les filtres. Par exemple, on ne peut pas
afficher les articles lus qui ont été notés comme favori.
Starting with version 0.8, all attribute filters are visible as toggle
icons. They can be combined. As any combination is possible, some have the
same result. For instance, the result for all filters selected is the same
as no filter selected.
By default, this filter displays only unread articles
### By content
It is possible to filter articles by their content by inputting a string in
the search field.
### Grâce au champ de recherche
Il est possible d’utiliser le champ de recherche pour raffiner les résultats :
* par ID de flux : `f:123` ou plusieurs flux (*ou*) : `f:123,234,345`
* par auteur : `author:nom` ou `author:'nom composé'`
* par titre : `intitle:mot` ou `intitle:'mot composé'`
* par URL : `inurl:mot` ou `inurl:'mot composé'`
* par tag : `#tag`
* par texte libre : `mot` ou `'mot composé'`
* par date d’ajout, en utilisant le [format ISO 8601 d’intervalle entre deux dates](https://fr.wikipedia.org/wiki/ISO_8601#Intervalle_entre_deux_dates) : `date:<intervalle-de-dates>`
* D’un jour spécifique, ou mois, ou année :
* `date:2014-03-30`
* `date:2014-03` or `date:201403`
* `date:2014`
* D’une heure spécifiée d’un jour donné :
* `date:2014-05-30T13`
* `date:2014-05-30T13:30`
* Entre deux dates :
* `date:2014-02/2014-04`
* `date:2014-02--2014-04`
* `date:2014-02/04`
* `date:2014-02-03/05`
* `date:2014-02-03T22:00/22:15`
* `date:2014-02-03T22:00/15`
* Après une date donnée :
* `date:2014-03/`
* Avant une date donnée :
* `date:/2014-03`
* Pour une certaine durée après une date donnée :
* `date:2014-03/P1W`
* Pour une certaine durée avant une date donnée :
* `date:P1W/2014-05-25T23:59:59`
* Pour une certaine durée avant maintenant (la barre oblique finale est facultative) :
* `date:P1Y/` or `date:P1Y` (depuis un an)
* `date:P2M/` (depuis deux mois)
* `date:P3W/` (depuis trois semaines)
* `date:P4D/` (depuis quatre jours)
* `date:PT5H/` (depuis cinq heures)
* `date:PT30M/` (depuis trente minutes)
* `date:PT90S/` (depuis 90 secondes)
* `date:P1DT1H/` (depuis un jour et une heure)
* par date de publication, avec la même syntaxe : `pubdate:<date-interval>`
* par ID d’étiquette : `L:12` ou de plusieurs étiquettes : `L:12,13,14` ou avec n’importe quelle étiquette : `L:*`
* par nom d’étiquette : `label:étiquette`, `label:"mon étiquette"` ou d’une étiquette parmi une liste (*ou*) : `labels:"mon étiquette,mon autre étiquette"`
* par plusieurs noms d’étiquettes (*et*) : `label:"mon étiquette" label:"mon autre étiquette"`
* par ID d’article (entrée) : `e:1639310674957894` ou de plusieurs articles (*ou*) : `e:1639310674957894,1639310674957893`
* par nom de filtre utilisateur (recherche enregistrée) : `search:maRecherche`, `search:"Ma recherche"` ou par ID de recherche : `S:3`
* en interne, ces références sont remplacées par le filtre utilisateur correspondant dans l’expression de recherche
Attention à ne pas introduire d’espace entre l’opérateur et la valeur
recherchée.
Certains opérateurs peuvent être utilisé négativement, pour exclure des
articles, avec la même syntaxe que ci-dessus, mais préfixé par `!` ou `-` :
`!f:123`, `-author:nom`, `-intitle:mot`, `-inurl:mot`, `-#tag`, `!mot`, `!date:2019`, `!date:P1W`, `!pubdate:P3d/`.
Il est également possible de combiner les mots-clefs pour faire un filtrage
encore plus précis, et il est autorisé d’avoir plusieurs instances de :
`f:`, `author:`, `intitle:`, `inurl:`, `#`, et texte libre.
Combiner plusieurs critères implique un *et* logique, mais le mot clef `OR`
peut être utilisé pour combiner plusieurs critères avec un *ou* logique : `author:Dupont OR author:Dupond`
Enfin, les parenthèses peuvent être utilisées pour des expressions plus complexes, avec un support basique de la négation :
* `(author:Alice OR intitle:bonjour) (author:Bob OR intitle:monde)`
* `(author:Alice intitle:bonjour) OR (author:Bob intitle:monde)`
* `!((author:Alice intitle:bonjour) OR (author:Bob intitle:monde))`
* `(author:Alice intitle:bonjour) !(author:Bob intitle:monde)`
* `!(S:1 OR S:2)`
> ℹ️ Si vous devez chercher une parenthèse, elle doit être *échappée* comme suit : `\(` ou `\)`
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/04_Subscriptions.md'# Ajouter un flux
1. Pour ajouter un flux, copiez le lien vers le fichier RSS ou Atom qui vous intéresse (par exemple, le lien RSS du Framablog est `https://framablog.org/feed/`).
2. Sur l’interface de FreshRSS, cliquez sur « Gestion des abonnements ».
3. Collez l’URL du flux dans le champ « Ajouter un flux RSS » juste en dessous du titre.
4. (facultatif) : Vous pouvez descendre jusqu’à « Catégorie » et sélectionner la catégorie dans laquelle vous souhaitez enregistrer votre flux. Par défaut, le nouveau flux sera dans « Sans catégorie ».
## Import et export
Voir [export/import SQLite]( https://github.com/FreshRSS/FreshRSS/tree/edge/cli) pour une alternative.
## Exportation
1. Pour exporter votre liste d’abonnements, allez dans « Gestion des abonnements ».
2. Cliquez ensuite sur « Importer / exporter » dans le menu de gauche.
3. Vous pouvez mettre dans votre export :
1. la liste des flux
2. les articles que vous avez étiquetés
3. les articles que vous avez mis en favoris
4. et enfin, vous pouvez sélectionner les flux que vous voulez exporter (par défaut tous les flux sont sélectionnés)
4. Cliquez sur « Exporter ».
## Importation
1. Pour importer un fichier d’abonnement vers votre compte FreshRSS, allez dans l’espace « Importer / exporter » comme ci-dessus
2. Cliquez sur « Parcourir » et sélectionnez votre fichier sur votre ordinateur.
3. Validez en cliquant sur « Importer ».
> **Important**: vous ne pouvez pas importer directement depuis un fichier texte.
> Vous devez le convertir au format _OPML_ au préalable.
> Voici une liste d’outils que vous pouvez utiliser :
>
> - [Pandoc](https://pandoc.org/) disponible sur la plus part des systèmes,
> - [OPML generator](https://opml-gen.ovh/) disponible en ligne,
> - [txt2opml](https://alterfiles.com/convert/txt/opml) disponible en ligne.
## Utiliser le « bookmarklet »
Les « bookmarklets » sont de petits scripts que vous pouvez exécuter pour effectuer des tâches diverses et variées. FreshRSS offre un signet « bookmark » pour s’abonner aux fils de nouvelles.
1. Ouvrez « Gestion des abonnements ».
2. Cliquez sur « Outils d’abonnement ».
3. Glissez le bouton « S’abonner » dans la barre d’outils des signets ou
cliquez droit et choisissez l’action « Lien vers les signets » de votre navigateur.
## Organisation des flux
Vous pouvez trier vos flux dans différentes catégories. Un flux ne peut être que dans une seule catégorie.
1. Ouvrez « Gestion des abonnements ».
2. Vous pouvez ajouter une catégorie d’abonnements de cette manière :
1. Tapez le nom de votre catégorie dans le champ « Nouvelle catégorie »
2. Cliquez ensuite sur le bouton « Valider »
3. Ensuite, vous pouvez glisser vos abonnements de catégorie en catégorie
4. (facultatif) : Pour qu’un flux s’affiche dans la catégorie, et non pas dans l’onglet principal, dans son paramètre « Visibilité », choisissez « Afficher dans sa catégorie ».
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/05_Configuration.md'
# Personnaliser la vue
## Langue
À l’heure actuelle, FreshRSS est disponible en 13 langues. Après validation
de ce choix, l’interface sera affichée dans la langue choisie, même si
certaines parties de l’interface peuvent ne pas encore avoir été
traduites. Si vous voulez aider à la traduction, regardez comment vous
pouvez [contribuer au
projet](../contributing.md#contribute-to-internationalization-i18n).
Il y a des parties de FreshRSS qui ne sont pas traduites et qui n’ont pas
vocation à l’être. Pour le moment, les logs visibles dans l’application
ainsi que celle générées par le script de mise à jour automatique en font
partie.
Les langues disponibles sont:
| Langue (nom français) | Langue (endonyme) | Classé par code de langue (ISO-639-1) |
|:------------------------|:-----------------------|:-------------------------------------|
| Tchèque | Čeština | cs |
| Allemand | Deutsch | de |
| Grec | Ελληνικά | el |
| Anglais | English | en |
| Anglais (États-Unis) | English (United States) | en-us |
| Espagnol | Español | es |
| Français | Français | fr |
| Hébreu | עברית | he |
| Indonésien | Bahasa Indonesia | id |
| Italien | Italiano | it |
| Japonais | 日本語 | ja |
| Coréen | 한국어 | ko |
| Letton | Latviešu | lv |
| Néerlandais | Nederlands | nl |
| Occitan | Occitan | oc |
| Polonais | Polski | pl |
| Portugais brésilien | Português (Brasil) | pt-br |
| Russe | Русский | ru |
| Slovaque | Slovenčina | sk |
| Turc | Türkçe | tr |
| Chinois (simplifié, République populaire de Chine) | 简体中文 | zh-cn |
| Chinois (traditionnel, Taïwan) | 正體中文 | zh-tw |
## Thème
Les goûts et les couleurs, ça ne se discute pas. C’est pourquoi FreshRSS
propose 13 thèmes officiels :
| Thème | Auteur | Notes |
|:--------------|:-------------------------------------------------------|:--------------------------------------------------------------|
| Alternative Dark | Ghost | |
| Ansum | Thomas Guesnon | |
| Dark | AD | |
| Dark pink | Miicat_47 | |
| Flat design | Marien Fressinaud | N’est plus pris en charge. Sera supprimé avec FreshRSS V1.22.0 |
| Mapco | Thomas Guesnon | |
| Nord theme | joelchrono12 | |
| Origine | Marien Fressinaud | (default theme) |
| Origine-compact | Kevin Papst | |
| Pafat | Plopoyop | |
| Swage | Patrick Crandol | |
Si aucun de ceux proposés ne convient, il est toujours possible de [créer
son propre thème](../developers/04_Frontend/02_Design.md).
Pour sélectionner un thème, il suffit de faire défiler les thèmes jusqu’à
l’apparition du thème choisi. Après validation, le thème sera appliqué à
l’interface.
## Largeur du contenu
Il y en a qui préfère des lignes de texte courtes, d’autres qui préfèrent
maximiser l’espace disponible sur l’écran. Pour satisfaire le maximum de
personne, il est possible de choisir la largeur du contenu affiché. Il y a
quatre réglages disponibles :
* **Fine** qui affiche le contenu jusqu’à 550 pixels
* **Moyenne** qui affiche le contenu jusqu’à 800 pixels
* **Large** qui affiche le contenu jusqu’à 1000 pixels
* **Pas de limite** qui affiche le contenu sur 100% de la place disponible
## Icônes d’article
Veuillez noter que cette section n’affecte que la vue normale.
Chaque article est rendu avec un en-tête (ligne supérieure) et un pied de
page (ligne inférieure). Dans cette section, vous pouvez choisir ce qui sera
affiché dans ceux-ci.
Si vous désactivez tous les éléments de la ligne supérieure, vous pourrez
toujours les voir, puisqu’il contient le nom du flux et le titre de
l’article. Mais si vous faites le même chose pour la ligne inférieure, elle
sera vide.
## Temps d’affichage de la notification HTML5
Après la mise à jour automatique des flux, FreshRSS utilise l’API de
notification de HTML5 pour avertir de l’arrivée de nouveaux articles.
Il est possible de régler la durée d’affichage de cette notification. Par
défaut, la valeur est 0.
## Show the navigation button
By default, FreshRSS displays buttons to ease the article navigation when
browsing on mobile. The drawback is that they eat up some precious space.
If you don’t use those buttons because you never browse on mobile or because
you browse with gestures, you can disable them from the interface.
# Reading
> **À FAIRE**
# Archivage
> **À FAIRE**
# Partage
Pour vous faciliter la vie, vous pouvez partager des articles directement
via FreshRSS.
At the moment, FreshRSS supports 18 sharing methods, ranging from
self-hosted services (Shaarli, etc.) to proprietary services (Facebook,
etc.).
By default, the sharing list is empty. 
Pour ajouter un nouvel élément à la liste, veuillez suivre les étapes
simples ci-dessous :
1. Select the desired sharing method in the drop-down list.
1. Press the ```✚``` button to add it to the list.
1. Configure the method in the list. All names can be modified in the
display. Some methods need the sharing URL to be able to work properly
(ex: Shaarli).
1. Submit your changes.
To remove an item from the list, follow those simple steps:
1. Press the ```❌``` button next to the share method you want to remove.
1. Submit your changes.
# Raccourcis
To ease the use of the application, FreshRSS comes with a lot of predefined
keyboard shortcuts. They allow actions to improve the user experience with
a keyboard.
Of course, if you’re not satisfied with the key mapping, you can change you
configuration to fit your needs.
There are 4 types of shortcuts:
1. Views: they allow switching views with ease.
1. Navigation: they allow navigation through articles, feeds, and
categories.
1. Article actions: they allow interactions with an article, like sharing
or opening it on the original web-site.
1. Other actions: they allow other interactions with the application, like
opening the user queries menu or accessing the documentation.
It’s worth noting that the share article action has two levels. Once you
press the shortcut, a menu containing all the share options opens. To
choose one share option, you need to select it by its number. When there is
only one option, it’s selected automatically though.
The same process applies to the user queries.
Be aware that there is no validation on the selected shortcuts. This means
that if you assign a shortcut to more than one action, you’ll end up with
some unexpected behavior.
# User queries
You can configure your [user queries](./03_Main_view.md) in that
section. There is not much to say here as it is pretty straightforward. You
can only change user query titles or drop them.
At the moment, there is no helper to build a user query from here.
# Users
> **À FAIRE**
## Authentication methods
### HTTP Authentication (Apache)
1. User control is based on the `.htaccess` file.
2. It is best practice to place the `.htaccess` file in the `./i/`
subdirectory so the API and other third party services can work.
3. If you want to limit all access to registered users only, place the file
in the FreshRSS directory itself or in a parent directory. Note that
WebSub and API will not work!
4. Example `.htaccess` file for a user "marie":
```apache
AuthUserFile /home/marie/repertoire/.htpasswd
AuthGroupFile /dev/null
AuthName "Chez Marie"
AuthType Basic
Require user marie
```
Plus d’informations dans [la documentation
d’Apache.](http://httpd.apache.org/docs/trunk/howto/auth.html#gettingitworking)
# Gestion des flux
## Informations
> **À FAIRE**
## Archivage des flux
> **À FAIRE**
## Identification
> **À FAIRE**
## Avancé
### Récupérer un flux tronqué à partir de FreshRSS
La question revient régulièrement, je vais essayer de clarifier ici comment
on peut récupérer un flux RSS tronqué avec FreshRSS. Sachez avant tout que
la manière de s’y prendre n’est absolument pas "user friendly", mais elle
fonctionne. :)
Sachez aussi que par cette manière vous générez beaucoup plus de trafic vers
les sites d’origines et qu’ils peuvent vous bloquer par conséquent. Les
performances de FreshRSS sont aussi moins bonnes car vous devez alors aller
chercher le contenu des articles un par un. C’est donc une fonctionnalité à
utiliser avec parcimonie !
Ce que j’entends par "Chemin CSS des articles sur le site d’origine"
correspond en fait au "chemin" constitué par les IDs et les classes (en
html, correspond aux attributs id et class) pour récupérer uniquement la
partie intéressante qui correspond à l’article. L’idéal est que ce chemin
commence par un id (qui est unique pour la page).
#### Exemple : Rue89
Pour trouver ce chemin, il faut se rendre à l’adresse d’un des articles tronqués.
Il faut alors chercher le "bloc" HTML correspondant au contenu de l’article
(dans le code source !)
On trouve ici que le bloc qui englobe uniquement le contenu de l’article est ```<div class="content clearfix">```. On ne va garder que la classe `.content` ici. Néanmoins, comme je le disais plus haut, il est préférable de commencer le chemin avec un id. Si on remonte au bloc parent, il s’agit du bloc ```<div id="article">``` et c’est parfait ! Le chemin sera donc ```#article .content```.
#### Liste de correspondances site → chemin css
* Rue89 : ```#article .content```
* PCINpact : ```#actu_content```
* Lesnumériques : ```article#body div.text.clearfix```
* Phoronix : ```#main .content```
### Récupérer un flux tronqué à l’aide d’outils externes
Des outils complémentaires peuvent être utilisés pour récupérer le contenu
complet d’un article, comme :
* [RSS-Bridge](https://github.com/RSS-Bridge/rss-bridge)
* [Full-Text RSS](https://bitbucket.org/fivefilters/full-text-rss)
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/06_Fever_API.md'# FreshRSS - API compatible Fever
Voir la page [sur notre API compatible Google Reader](06_Mobile_access.md)
pour une autre possibilité et des généralités sur l’accès par API.
## Clients compatibles GReader
De nombreux clients RSS prennent en charge l’API Fever, mais ils semblent
comprendre l’API Fever un peu différemment. Si votre client préféré ne
fonctionne pas correctement avec cette API, veuiller créer un ticket et nous
y jetterons un oeil. Mais nous ne pouvons le faire que pour les clients
gratuits.
### Utilisation et authentification
Avant de pouvoir commencer à utiliser cette API, vvous devez activer et
configurer l’accès à l’API, qui est [documenté
ici](https://freshrss.github.io/FreshRSS/en/users/06_Mobile_access.html), et
réinitialisez ensuite le mot de passe API de l’utilisateur.
Connectez ensuite votre application mobile en utilisant l’adresse de l’API
(e.g. `https://freshrss.example.net/api/fever.php`).
## Clients compatibles Fever
| App | Platform | License |
|:----------------------------------------------------------------------------------:|:-------------------:|:--------------------------------------------------------:|
|[Fluent Reader](https://hyliu.me/fluent-reader/) |Windows, Linux, macOS|[BSD-3-Clause](https://github.com/yang991178/fluent-reader/blob/master/LICENSE)|
|[Fluent Reader lite](https://hyliu.me/fluent-reader-lite/) |Android, iOS |[BSD-3-Clause](https://github.com/yang991178/fluent-reader-lite)|
|[Read You](https://github.com/Ashinch/ReadYou/) |Android |[GPLv3](https://github.com/Ashinch/ReadYou/blob/main/LICENSE)|
|[Fiery Feeds](https://apps.apple.com/app/fiery-feeds-rss-reader/id1158763303) |iOS |Source fermée |
|[Unread](https://apps.apple.com/app/unread-rss-reader/id1252376153) |iOS |Source fermée |
|[Reeder](https://www.reederapp.com/) |iOS |Source fermée |
|[ReadKit](https://apps.apple.com/app/readkit/id588726889) |macOS |Source fermée |
## Fonctionnalités
Les fonctionnalités suivantes sont implémentées :
* récupération des catégories
* récupération des flux
* récupération des entrées (new, favorites, unread, by_id, by_feed, by_category,since)
* récupération des favicons
* marquage des entrées comme lues
* marquage des entrées comme favoris
* marquage d’un flux comme lu
* marquage d’une catégorie comme lue
* support des extensions grace au hook `entry_before_display`
Les fonctionnalités suivantes ne sont pas implémentées :
* « Hot Links » car il n’y a encore rien dans FreshRSS qui soit similaire ou
qui puisse être utilisé pour le simuler.
## Tester et déboguer
Si l’API ne fonctionne pas comme attendu dans votre lecteur, il est possible
de la tester manuellement avec un outil tel que
[Postman](https://www.getpostman.com/).
Envoyer une requête POST à l’adresse
<https://freshrss.example.net/api/fever.php?api> devrait vous renvoyer le
résultat suivant :
```json
{
"api_version": 3,
"auth": 0
}
```
Super, la configuration de base fonctionne !
Maintenant essayons de faire un appel authentifié. Fever utilise un
paramètre `api_key` qui contient le résultat de la fonction de hachage MD5
de la valeur `"$username:$apiPassword"`. En considérant que l’utilisateur
est `kevin` et que son mot de passe est `freshrss`, voici la commande à
lancer pour calculer la valeur du paramètre `api_key` :
```sh
api_key=`echo -n "kevin:freshrss" | md5sum | cut -d' ' -f1`
```
Ajoutez un contenu sous forme de `form-data`à votre requête POST ainsi que
le paramètre `api_key` contenant la valeur calculée à l’étape précédente :
```sh
curl -s -F "api_key=$api_key" 'https://freshrss.exemple.net/api/fever.php?api'
```
Vous devriez obtenir le résultat suivant :
```json
{
"api_version": 3,
"auth": 1,
"last_refreshed_on_time": "1520013061"
}
```
Parfait, maintenant vous êtes autentifié et vous pouvez commencer à tester
les fonctions avancées. Pour cela, il suffit de changer l’adresse en lui
ajoutant les paramètres nécessaires à la réalisation des actions
supportées. Pour plus d’information, veuillez vous référer à la
[documentation officielle de Fever](https://feedafever.com/api).
Voici quelques exemples simples d’appels réalisables :
* <https://freshrss.example.net/api/fever.php?api&items>
* <https://freshrss.example.net/api/fever.php?api&feeds>
* <https://freshrss.example.net/api/fever.php?api&groups>
* <https://freshrss.example.net/api/fever.php?api&unread_item_ids>
* <https://freshrss.example.net/api/fever.php?api&saved_item_ids>
* <https://freshrss.example.net/api/fever.php?api&items&since_id=some_id>
* <https://freshrss.example.net/api/fever.php?api&items&max_id=some_id>
* <https://freshrss.example.net/api/fever.php?api&mark=item&as=read&id=some_id>
* <https://freshrss.example.net/api/fever.php?api&mark=item&as=unread&id=some_id>
Remplacez `some_id` par un identifiant réel de votre base de données
`freshrss_username_entry`.
### Déboguer
Si rien ne fonctionne correctement et que votre client se comporte
étrangement, vous pouvez ajouter les quelques lignes suivantes au début du
fichier `fever.api` pour déterminer la cause des problèmes rencontrés :
```php
file_put_contents(__DIR__ . '/fever.log', $_SERVER['HTTP_USER_AGENT'] . ': ' . json_encode($_REQUEST) . PHP_EOL, FILE_APPEND);
```
Utilisez ensuite votre client RSS pour interroger l’API et vérifier le
fichier `fever.log`.
## Remerciements
Ce plugin a été inspiré par le
[tinytinyrss-fever-plugin](https://github.com/dasmurphy/tinytinyrss-fever-plugin).
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/06_Mobile_access.md'Cette page suppose que vous ayez fini [l’installation du
serveur](01_Installation.md).
# Activer l’API dans FreshRSS
1. Dans la section “Authentification”, cocher l’option “Autoriser l’accès
par API (nécessaire pour les applis mobiles)”.
2. Dans la section “Profil”, remplir le champ “Mot de passe API (ex. : pour applis mobiles)”.
* Chaque utilisateur doit choisir son mot de passe API.
* La raison d’être d’un mot de passe API
différent du mot de passe principal est que le mot de passe API est
potentiellement utilisé de manière moins sûre, mais il permet aussi moins de choses.
Le reste de cette page concerne l’API compatible Google Reader. Voir la
[page sur l’API compatible Fever](06_Fever_API.md) pour une autre
possibilité.
# Tester
1. Dans la section “Profil”, cliquer sur le lien de la forme
`https://rss.example.net/api/` à côté du champ “Mot de passe API”.
2. Cliquer sur le premier lien “Check full server configuration”:
* Si vous obtenez `PASS`, tout est bon : passer à l’étape 6.
* Si vous obtenez *Bad Request!* ou *Not Found*, alors votre serveur ne semble pas accepter les slashs `/` qui sont encodés `%2F`. Passer à l’étape 5.
* Si vous obtenez un autre message d’erreur, passer à l’étape 5.
# Déboguer la configuration du serveur
* Cliquer sur le second lien “Check partial server configuration (without `%2F` support)”:
* Si vous obtenez `PASS`, alors le problème est bien que votre serveur n’accepte pas les slashs `/` qui sont encodés `%2F`.
* Avec Apache, vérifiez la directive [`AllowEncodedSlashes On`](http://httpd.apache.org/docs/trunk/mod/core.html#allowencodedslashes)
* Ou utilisez un client qui n’encode pas les slashs (comme EasyRSS), auquel cas passer à l’étape 6.
* Si vous obtenez *Service Unavailable!*, retourner à l’étape 6.
* Avec __Apache__:
* Si vous obtenez *FAIL getallheaders!*, alors la combinaison de votre version de PHP et de votre serveur Web ne permet pas l’accès à [`getallheaders`](http://php.net/getallheaders)
* Activer Apache `mod_setenvif` (souvent activé par défault), ou `mod_rewrite` avec la procédure suivante :
* Autoriser [`FileInfo` dans `.htaccess`](http://httpd.apache.org/docs/trunk/mod/core.html#allowoverride) : revoir [l’installation du serveur](01_Installation.md).
* Activer [`mod_rewrite`](http://httpd.apache.org/docs/trunk/mod/mod_rewrite.html) :
* Sur Debian / Ubuntu : `sudo a2enmod rewrite`
* Avec __nginx__:
* Si vous obtenez *Bad Request!*, vérifier la configuration `PATH_INFO` de votre serveur.
* Si vous obtenez *File not found!*, vérifier la configuration `fastcgi_split_path_info` de votre serveur.
* Si vous obtenez *FAIL 64-bit or GMP extension!*, alors votre installation PHP soit n’est pas en 64 bit, soit n’a pas l’extension PHP [GMP](http://php.net/gmp) activée.
* Le plus simple est d’activer l’extension GMP. Sur Debian / Ubuntu : `sudo apt install php-gmp`
* Mettre à jour et retourner à l’étape 3.
# Clients compatibles
1. Sur la même page de l’API FreshRSS, notez l’adresse donnée sous "Votre adresse API", comme `https://freshrss.example.net/api/greader.php`
* Saisissez l’adresse de l’API dans le client sélectionné puis votre nom d’utilisateur et votre mot de passe spécialement créé pour l’API.
2. Vous pouvez maintenant tester sur une application mobile:
* Android
* [News+](https://github.com/noinnion/newsplus/blob/master/apk/NewsPlus_202.apk) avec [News+ Google Reader extension](https://github.com/noinnion/newsplus/blob/master/apk/GoogleReaderCloneExtension_101.apk) (Closed source)
* [FeedMe 3.5.3+](https://play.google.com/store/apps/details?id=com.seazon.feedme) (Propriétaire)
* [EasyRSS](https://github.com/Alkarex/EasyRSS) (Libre, [F-Droid](https://f-droid.org/packages/org.freshrss.easyrss/))
* [Readrops](https://github.com/readrops/Readrops) (Libre)
* [Fluent Reader Lite](https://hyliu.me/fluent-reader-lite/) (Libre)
* [Read You](https://github.com/Ashinch/ReadYou/) (Libre)
* [FocusReader](https://play.google.com/store/apps/details?id=allen.town.focus.reader) (Commercial)
* Linux
* [FeedReader 2.0+](https://jangernert.github.io/FeedReader/) (Libre)
* [Newsboat 2.24+](https://newsboat.org/) (Libre)
* macOS, iOS
* [Vienna RSS](http://www.vienna-rss.com/) (Libre)
* [Fluent Reader Lite](https://hyliu.me/fluent-reader-lite/) (Libre)
* [Reeder](https://www.reederapp.com/) (Commercial)
* [lire](https://lireapp.com/) (Commercial)
* Firefox
* [FreshRSS-Notify](https://addons.mozilla.org/firefox/addon/freshrss-notify-webextension/) (Libre)
# API compatible Google Reader
Exemples de requêtes simples :
```sh
# Authentification utilisant le mot de passe API (Email et Passwd peuvent être passés en GET, ou POST - mieux)
curl 'https://freshrss.example.net/api/greader.php/accounts/ClientLogin?Email=alice&Passwd=Abcdef123456'
SID=alice/8e6845e089457af25303abc6f53356eb60bdb5f8
Auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8
# Exemples de requêtes en lecture
curl -s -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
'https://freshrss.example.net/api/greader.php/reader/api/0/subscription/list?output=json'
curl -s -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
'https://freshrss.example.net/api/greader.php/reader/api/0/unread-count?output=json'
curl -s -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
'https://freshrss.example.net/api/greader.php/reader/api/0/tag/list?output=json'
# Demande de jeton pour faire de requêtes de modification
curl -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
'https://freshrss.example.net/api/greader.php/reader/api/0/token'
8e6845e089457af25303abc6f53356eb60bdb5f8ZZZZZZZZZZZZZZZZZ
# Récupère les articles, envoyés à jq pour une lecture JSON plus facile
curl -s -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
'https://freshrss.example.net/api/greader.php/reader/api/0/stream/contents/reading-list' | jq .
# Se désabonner d’un flux
curl -H "Authorization:GoogleLogin auth=alice/8e6845e089457af25303abc6f53356eb60bdb5f8" \
-d 'ac=unsubscribe&s=feed/52' 'https://freshrss.example.net/api/greader.php/reader/api/0/subscription/edit'
```
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/07_Frequently_Asked_Questions.md'Il est possible que nous n’ayons pas répondu à toutes vos questions dans les
parties précédentes. La FAQ regroupe certaines interrogations qui n’ont pas
trouvé leur réponse ailleurs.
## C’est quoi ce `/i` à la fin de l’URL ?
Bien entendu, le ```/i``` n’est pas là pour faire joli ! Il s’agit d’une
question de performances et de praticité :
* Cela permet de servir les icônes, images, styles, scripts sans
cookie. Sans cela, ces fichiers seraient souvent re-téléchargés, en
particulier lorsque le formulaire de connexion est utilisé. De plus, les
requêtes vers ces ressources seraient plus lourdes.
* La racine publique ```./p/``` peut être servie sans restriction d’accès
HTTP (qui peut avantageusement être mise en place dans ```./p/i/```).
* Cela permet d’éviter des problèmes pour des fichiers qui doivent être
publics pour bien fonctionner, comme ```favicon.ico```, ```robots.txt```, etc.
* Cela permet aussi d’avoir un logo FreshRSS plutôt qu’une page blanche pour
accueillir l’utilisateur par exemple dans le cas de la restriction d’accès
HTTP ou lors de l’attente du chargement plus lourd du reste de
l’interface.
## Pourquoi le ```robots.txt``` se trouve dans un sous-répertoire ?
Afin d’améliorer la sécurité, FreshRSS est découpé en deux parties : une
partie publique (le répertoire ```./p```) et une partie privée (tout le
reste !). Le ```robots.txt``` se trouve donc dans le sous-répertoire
```./p```.
Comme expliqué dans les [conseils de
sécurité](01_Installation.md#conseils-de-securite), il est recommandé de
faire pointer un nom de domaine vers ce sous-répertoire afin que seule la
partie publique ne soit accessible par un navigateur web. De cette manière
<https://demo.freshrss.org/> pointe vers le répertoire ```./p``` et le
```robots.txt``` se trouve bien à la racine du site :
<https://demo.freshrss.org/robots.txt>
L’explication est la même pour les fichiers ```favicon.ico``` et
```.htaccess```.
## Pourquoi j’ai des erreurs quand j’essaye d’enregistrer un flux ?
Il peut y avoir différentes origines à ce problème. Le flux peut avoir une
syntaxe invalide, il peut ne pas être reconnu par la bibliothèque SimplePie,
l’hébergement peut avoir des problèmes, FreshRSS peut être boggué. Il faut
dans un premier temps déterminer la cause du problème.Voici la liste des
étapes à suivre pour la déterminer :
1. __Vérifier la validité du flux__ grâce à l’[outil en ligne du
W3C](https://validator.w3.org/feed/ "Validateur en ligne de flux RSS et
Atom"). Si ça ne fonctionne pas, nous ne pouvons rien faire.
1. __Vérifier la reconnaissance par SimplePie__ grâce à l’[outil en ligne de
SimplePie](https://simplepie.org/demo/ "Démo officielle de
SimplePie"). Si ça ne fonctionne pas, nous ne pouvons rien faire.
1. __Vérifier l’intégration dans FreshRSS__ grâce à la
[démo](https://demo.freshrss.org "Démo officielle de FreshRSS"). Si ça ne
fonctionne pas, il faut [créer un ticket sur
GitHub](https://github.com/FreshRSS/FreshRSS/issues/new "Créer un ticket
pour FreshRSS") pour que l’on puisse regarder ce qui se passe. Si ça
fonctionne, il y a probablement un problème avec l’hébergement.
## Comment changer un mot de passe oublié ?
Depuis la version
[1.10.0](https://github.com/FreshRSS/FreshRSS/releases/tag/1.10.0),
l’administrateur peut modifier le mot de passe d’un utilisateur depuis
l’interface. Cette interface est disponible dans le menu ```Administration →
Gestion des utilisateurs```. Il suffit de sélectionner l’utilisateur, de
saisir un mot de passe et de valider.
Depuis la version
[1.8.0](https://github.com/FreshRSS/FreshRSS/releases/tag/1.8.0),
l’administrateur peut modifier le mot de passe d’un utilisateur depuis un
terminal. Il est bon de noter que celui-ci doit avoir un accès à PHP en
ligne de commande. Pour cela, il suffit d’ouvrir son terminal et de saisir
la commande suivante :
```sh
./cli/update_user.php --user <username> --password <password>
```
Pour plus d’information à ce sujet, il existe la [documentation
dédiée](../../cli/README.md).
## Gérer les permissions sous SELinux
Certaines distributions Linux comme Fedora ou RedHat Enterprise Linux (RHEL)
activent par défaut le système SELinux. Celui-ci permet de gérer des
permissions au niveau des processus. Lors de l’installation de FreshRSS,
l’étape 2 procède à la vérification des droits sur certains répertoires, il
faut donc exécuter la commande suivante en tant que root:
```sh
semanage fcontext -a -t httpd_sys_rw_content_t '/usr/share/FreshRSS/data(/.*)?'
restorecon -Rv /usr/share/FreshRSS/data
```
## Pourquoi y a-t-il une page blanche lorsque je configure les options de partage ?
Le mot `sharing` dans l’URL est un mot déclencheur pour certaines règles des
bloqueurs de publicités. À partir de la version 1.16, `sharing` a été
remplacé par `integration` dans l’URL posant problème tout en conservant
exactement la même dénomination à travers l’application.
Si vous utilisez une version antérieure à 1.16, vous pouvez désactiver votre
bloqueur de publicité pour FreshRSS ou vous pouvez ajouter une règle pour
permettre la consultation de la page de configuration « partage ».
Exemples avec _uBlock_ :
* Ajoutez votre instance FreshRSS à la liste blanche de en l’ajoutant dans
_uBlock > Ouvrir le tableau de bord > Liste blanche_.
* Autorisez votre instance FreshRSS à appeler la page de configuration
`sharing` en ajoutant la règle `*sharing,domain=~votredomaine.com` dans
_uBlock > Ouvrir le fichier tableau de bord > Mes filtres_
wget 'https://sme10.lists2.roe3.org/FreshRSS/docs/fr/users/08_PubSubHubbub.md'# Qu’est-ce que WebSub ?
Derrière le nom de [WebSub](https://www.w3.org/TR/websub/) (anciennement [PubSubHubbub](https://github.com/pubsubhubbub/PubSubHubbub)) se cache un protocole qui vient compléter Atom et RSS.
En effet, le fonctionnement de base de ces deux derniers implique de vérifier à intervalles réguliers s’il existe de nouveaux articles sur les sites suivis.
Cela même si le site concerné n’a rien publié depuis la dernière synchronisation.
Le [protocole WebSub](https://www.w3.org/TR/websub/) permet d’éviter des synchronisations inutiles en notifiant en temps réel l’agrégateur de la présence de nouveaux articles.
## Fonctionnement de WebSub
On va retrouver trois notions dans WebSub : **les éditeurs** (les sites qui publient du contenu comme des flux ATOM / RSS), **les abonnés** (les agrégateurs de flux RSS comme FreshRSS), et **les hubs**.
Lorsqu’un agrégateur s’abonne à un site et récupère son flux RSS, il peut y trouver l’adresse d’un hub.
Si c’est le cas — car un site peut ne pas en préciser —, l’agrégateur va s’abonner au hub et non pas à l’éditeur directement.
Ainsi, lorsqu’un éditeur va publier du contenu, il va notifier le hub qui va lui-même notifier et envoyer le contenu à tous ses abonnés.
Pour pouvoir être notifié, les abonnés doivent fournir une adresse accessible publiquement sur Internet.
## Activer WebSub dans FreshRSS
FreshRSS supporte nativement WebSub, mais requiert une addresse publique (lu depuis la configuration `base_url`),
et requiert aussi aussi que le répertoire `./FreshRSS/p/api/` soit accessible publiquement (comme pour les autres APIs de FreshRSS).
Durant l’installation Web initiale, le support de WebSub est activé si le serveur semble avoir une adresse publique.
Dans tous les cas, vérifiez votre `./data/config.php` pour :
```php
'base_url' => 'https://freshrss.example.net/',
'pubsubhubbub_enabled' => true,
```
Des logs supplémentaires relatifs à WebSub sont consultables dans `./FreshRSS/data/users/_/log_pshb.txt`
## Tester la compatibilité WebSub de votre instance FreshRSS
Vous pouvez tester que le support WebSub de votre instance FreshRSS est correct avec un service comme :
* <http://push-tester.cweiske.de>
Quand vous y créez un nouvel article, celui-ci devrait être immédiatement disponible dans votre FreshRSS.
## Tester la compatibilité WebSub d’un flux RSS / ATOM
* <https://test.livewire.io> (pour n’importe quel flux)
* <https://websub.rocks/publisher> (pour les flux que vous contrôlez)
## Exemples de flux utilisant WebSub
Vous pouvez recevoir en temps réel les articles des sites qui affichent dans leur flux RSS un « hub »,
tels [Friendica](https://friendi.ca), WordPress (WordPress.com ou avec [une extension](https://wordpress.org/plugins/pubsubhubbub/)), Blogger, Medium, etc.
## Ajouter WebSub à votre flux RSS / ATOM
Votre CMS (par exemple WordPress) supporte peut-être déjà WebSub en option, comme :
* <https://wordpress.org/plugins/pushpress/>
Sinon, vous pouvez faire une solution qui notifie un hub, comme :
* <https://websubhub.com>
* <https://pubsubhubbub.appspot.com>
Ou encore déployer votre propre hub, comme :
* <https://github.com/flusio/Webubbub>
## Tester la compatibilité WebSub d’un hub
* <https://websub.rocks/hub/100>