design.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2013, Various
# This file is distributed under the same license as the Elgg package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Juho Jaakkola <juho.a.jaakkola@gmail.com>, 2020
# Florian DANIEL aka Facyla <i.daniel.florian@gmail.com>, 2020
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Elgg master\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-08-03 11:15+0200\n"
"PO-Revision-Date: 2017-12-28 11:58+0000\n"
"Last-Translator: Florian DANIEL aka Facyla <i.daniel.florian@gmail.com>, 2020\n"
"Language-Team: French (https://www.transifex.com/elgg/teams/11337/fr/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: fr\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"

#: ../../design/actions.rst:2
msgid "Actions"
msgstr "Actions"

#: ../../design/actions.rst:4
msgid "Actions are the primary way users interact with an Elgg site."
msgstr ""
"Les actions sont la première modalité d'interaction des utilisateurs avec un"
" site Elgg."

#: ../../design/actions.rst:10 ../../design/amd.rst:8
#: ../../design/database.rst:11 ../../design/events.rst:9
msgid "Overview"
msgstr "Aperçu"

#: ../../design/actions.rst:12
msgid ""
"An action in Elgg is the code that runs to make changes to the database when"
" a user does something. For example, logging in, posting a comment, and "
"making a blog post are actions. The action script processes input, makes the"
" appropriate modifications to the database, and provides feedback to the "
"user about the action."
msgstr ""
"Dans Elgg, une action est le code qui est exécuté pour faire des "
"modifications dans la base de données quand un utilisateur effectue quelque "
"chose. Par exemple, le fait de se connecter, de publier un commentaire, ou "
"de créer un article de blog sont des actions. Le script d'action traite le "
"processus d'entrée, effectue les modifications appropriées dans la base de "
"données, et fournit un retour à l'utilisateur à propos de l'action."

#: ../../design/actions.rst:15
msgid "Action Handler"
msgstr "Gestionnaire d'action"

#: ../../design/actions.rst:17
msgid ""
"Actions are registered during the boot process by calling "
"``elgg_register_action()``. All actions URLs start with ``action/`` and are "
"served by Elgg's front end controller through the action service. This "
"approach is different from traditional PHP applications that send "
"information to a specific file. The action service performs :doc:`CSRF "
"security checks </design/security>`, and calls the registered action script "
"file, then optionally forwards the user to a new page. By using the action "
"service instead of a single script file, Elgg automatically provides "
"increased security and extensibility."
msgstr ""
"Les actions sont enregistrées durant le processus de démarrage (boot) en "
"appelant ``elgg_register_action()``. Toutes les URLs d'action commencent par"
" ``action/`` et sont servies par le contrôleur front end d'Elgg à travers le"
" service action. Cette approche est différente d'application PHP "
"traditionnelles qui envoient l'information à un fichier spécifique. Le "
"service action réalise des :doc:`CSRF vérifications de sécurité "
"</design/security>`, et appelle le fichier de script d'action enregistré, "
"puis renvoient éventuellement l'utilisateur vers une nouvelle page. En "
"utilisant le service action au lieu d'un seul fichier de script, Elgg "
"fournit automatiquement une sécurité et une extensibilité améliorées."

#: ../../design/actions.rst:19
msgid ""
"See :doc:`/guides/actions` for details on how to register and construct an "
"action. To look at the core actions, check out the directory /actions."
msgstr ""
"Voyez :doc:`/guides/actions` pour plus de détails sur comment enregistrer et"
" construire une action. Pour regarder les actions du noyau, regardez dans le"
" répertoire /actions."

#: ../../design/amd.rst:2
msgid "AMD"
msgstr "AMD"

#: ../../design/amd.rst:10
msgid ""
"There are two JavaScript system in Elgg: the deprecated 1.8 system, and the "
"newer `AMD (Asynchronous Module Definition) "
"<http://requirejs.org/docs/whyamd.html>`_ compatible system introduced in "
"1.9."
msgstr ""
"Il existe deux systèmes JavaScript dans Elgg : le système 1.8 devenu "
"obsolète, et le nouveau système compatible `AMD (Asynchronous Module "
"Definition) <http://requirejs.org/docs/whyamd.html>`_ introduit dans la 1.9."

#: ../../design/amd.rst:13
msgid "This discusses the benefits of using AMD in Elgg."
msgstr "Discussions au sujet des bénéfices de l'utilisation d'AMD dans Elgg."

#: ../../design/amd.rst:16
msgid "Why AMD?"
msgstr "Pourquoi AMD ?"

#: ../../design/amd.rst:18
msgid ""
"We have been working hard to make Elgg's JavaScript more maintainable and "
"useful. We made some strides in 1.8 with the introduction of the "
"\"``elgg``\" JavaScript object and library, but have quickly realized the "
"approach we were taking was not scalable."
msgstr ""
"Nous avons beaucoup travaillé pour rendre le JavaScript d'Elgg plus "
"maintenable et plus utile. Nous avons fait quelques grands pas dans la 1.8 "
"en introduisant l'objet et la bibliothèque JavaScript \"``elgg``\", mais "
"avons rapidement réalisé que l'approche que nous prenions n'était pas "
"susceptible de passer à l'échelle."

#: ../../design/amd.rst:22
msgid ""
"The size of `JS on the web is growing "
"<http://httparchive.org/trends.php?s=All&minlabel=Feb+11+2011&maxlabel=Feb+1+2013#bytesJS&reqJS>`_"
" quickly, and JS in Elgg is growing too. We want Elgg to be able to offer a "
"solution that makes JS development as productive and maintainable as "
"possible going forward."
msgstr ""
"La taille du `JS sur le web est rapidement croissante "
"<http://httparchive.org/trends.php?s=All&minlabel=Feb+11+2011&maxlabel=Feb+1+2013#bytesJS&reqJS>`_,"
" et le JS dans Elgg s’accroît également. Nous voulons qu'Elgg soit capable "
"d'offrir une solution qui rende le développement JS aussi productif et "
"maintenable que possible pour aller plus loin."

#: ../../design/amd.rst:27
msgid ""
"The `reasons to choose AMD <http://requirejs.org/docs/whyamd.html>`_ are "
"plenteous and well-documented. Let's highlight just a few of the most "
"relevant reasons as they relate to Elgg specifically."
msgstr ""
"Les `raisons de choisir AMD <http://requirejs.org/docs/whyamd.html>`_ sont "
"nombreuses et bien documentées. Mettons en avant seulement les raisons les "
"plus pertinentes dans la mesure où elles sont  liées à Elgg spécifiquement."

#: ../../design/amd.rst:32
msgid "1. Simplified dependency management"
msgstr "1. Gestion des dépendances simplifiée"

#: ../../design/amd.rst:33
msgid ""
"AMD modules load asynchronously and execute as soon as their dependencies "
"are available, so this eliminates the need to specify \"priority\" and "
"\"location\" when registering JS libs in Elgg. Also, you don't need to worry"
" about explicitly loading a module's dependencies in PHP. The AMD loader "
"(RequireJS in this case) takes care of all that hassle for you. It's also "
"possible have `text dependencies <http://requirejs.org/docs/api.html#text>`_"
" with the RequireJS text plugin, so client-side templating should be a "
"breeze."
msgstr ""
"Les modules AMD se chargent de manière asynchrone et s'exécutent dès que "
"leurs dépendances sont disponibles, ce qui élimine le besoin de préciser des"
" \"priorités\" et des emplacements \"location\" lorsqu'on enregistre une "
"bibliothèque JS dans Elgg. De plus, vous n'avez pas besoin de vous soucier "
"de charger explicitement les dépendances d'un module dans PHP. Le chargeur "
"AMD (RequireJS en l'occurrence) prend soin de tous ces tracas pour vous. Il "
"est également possible d'avoir des `dépendances texte "
"<http://requirejs.org/docs/api.html#text>`_ avec le plugin text de "
"RequireJS, de sorte que le templating côté client devrait être un plaisir."

#: ../../design/amd.rst:41
msgid "2. AMD works in all browsers. Today."
msgstr "2. AMD fonctionne dans tous les navigateurs. Dès maintenant."

#: ../../design/amd.rst:42
msgid ""
"Elgg developers are already writing lots of JavaScript. We know you want to "
"write more. We cannot accept waiting 5-10 years for a native JS modules "
"solution to be available in all browsers before we can organize our "
"JavaScript in a maintainable way."
msgstr ""
"Les développeurs Elgg ont déjà écrit beaucoup de JavaScript. Nous savons que"
" vous voulez en écrire plus. Nous ne pouvons pas accepter d'attendre 5-10 "
"ans pour qu'une solution native de modules JS soit disponible dans tous les "
"navigateurs avant que nous puissions organiser notre JavaScript d'une "
"manière maintenable."

#: ../../design/amd.rst:47
msgid "3. You do not need a build step to develop in AMD."
msgstr ""
"3. Vous n'avez pas besoin d'une étape de build pour développer avec AMD."

#: ../../design/amd.rst:48
msgid ""
"We like the edit-refresh cycle of web development. We wanted to make sure "
"everyone developing in Elgg could continue experiencing that joy. "
"Synchronous module formats like Closure or CommonJS just weren't an option "
"for us. But even though AMD doesn't require a build step, *it is still very "
"build-friendly*. Because of the ``define()`` wrapper, it's possible to "
"concatenate multiple modules into a single file and ship them all at once in"
" a production environment. [#]_"
msgstr ""
"Nous apprécions le cycle édition-mise à jour (\"edit-refresh\")du web. Nous "
"voulions faire en sorte que toute personne qui développe avec Elgg puisse "
"continuer à expérimenter ce plaisir. Des formats de modules synchrones comme"
" Closure ou CommonJS n'étaient tout simplement pas une option pour nous. "
"Mais même si AMD n'a pas besoin d'une étape de build, *il reste cependant "
"très adapté pour le build*. A cause du wrapper ``define()``, il est possible"
" de concaténer de multiples modules dans un seul fichier et de livrer "
"l'ensemble en une seule fois dans un environnement de production. [#]_"

#: ../../design/amd.rst:54
msgid ""
"AMD is a battle-tested and well thought out module loading system for the "
"web today. We're very thankful for the work that has gone into it, and are "
"excited to offer it as the standard solution for JavaScript development in "
"Elgg starting with Elgg 1.9."
msgstr ""
"AMD est un système de chargement de modules largement éprouvé et bien pensé "
"pour le web d'aujourd'hui. Nous avons beaucoup de gratitude pour le travail "
"qui a été mis dedans, et sommes excités de l'offrir comme la solution "
"standard pour le développement JavaScript dans Elgg à partir de Elgg 1.9."

#: ../../design/amd.rst:58
msgid ""
"This is not currently supported by Elgg core, but we'll be looking into it "
"since reducing round-trips is critical for a good first-view experience, "
"especially on mobile devices."
msgstr ""
"Ceci n'est pas encore supporté par le noyau Elgg, mais nous sommes en train "
"de nous pencher dessus dans la mesure où la réduction des allers-retours est"
" critique pour une bonne première expérience, particulièrement sur les "
"appareils mobiles."

#: ../../design/database.rst:2
msgid "Database"
msgstr "Base de données"

#: ../../design/database.rst:4
msgid "A thorough discussion of Elgg's data model design and motivation."
msgstr ""
"Une discussion solide sur le design du modèle de données Elgg et ses "
"motivations."

#: ../../design/database.rst:8 ../../design/events.rst:6
#: ../../design/security.rst:12
msgid "Contents"
msgstr "Contenu"

#: ../../design/database.rst:13
msgid ""
"In Elgg, everything runs on a unified data model based on atomic units of "
"data called entities."
msgstr ""
"Dans Elgg, tout fonctionne sur un modèle de données unifié construit sur des"
" unités atomiques de données appelées entités."

#: ../../design/database.rst:16
msgid ""
"Plugins are discouraged from interacting directly with the database, which "
"creates a more stable system and a better user experience because content "
"created by different plugins can be mixed together in consistent ways. With "
"this approach, plugins are faster to develop, and are at the same time much "
"more powerful."
msgstr ""
"Il est recommandé que les plugins n'interagissent pas directement avec la "
"base de données, afin de créer un système plus stable et une meilleure "
"expérience utilisateur parce que les contenus créés par différents plugins "
"peut être mélangés ensemble de manières cohérentes. Avec cette approche, les"
" plugins sont plus rapides à développer, et sont en même temps plus "
"puissants."

#: ../../design/database.rst:22
msgid ""
"Every entity in the system inherits the ``ElggEntity`` class. This class "
"controls access permissions, ownership, containment and provides consistent "
"API for accessing and updating entity properties."
msgstr ""
"Chaque entité dans le système hérite de la classe ``ElggEntity``. Cette "
"classe contrôle les permissions d'accès, la propriété, le conteneur, et "
"fournit une API cohérente pour accéder aux propriétés des entités et les "
"modifier."

#: ../../design/database.rst:28
msgid "You can extend entities with extra information in two ways:"
msgstr ""
"Vous pouvez étendre les entités avec des informations supplémentaires de "
"deux manières :"

#: ../../design/database.rst:33
msgid "``Metadata``: This information describes the entity, it is usually"
msgstr ""
"``Metadata`` : Ces informations décrivent l'entité, elles sont "
"habituellement"

#: ../../design/database.rst:31
msgid ""
"added by the author of the entity when the entity is created or updated. "
"Examples of metadata include tags, ISBN number or a third-party ID, "
"location, geocoordinates etc. Think of metadata as a simple key-value "
"storage."
msgstr ""
"ajoutées par l'auteur de l'entité quand l'entité est créée ou modifiée. Des "
"exemples de métadonnées incluent les tags, un numéro ISBN ou un ID tierce-"
"partie, une adresse, des coordonnées géographiques, etc. Imaginez les "
"métadonnées comme un simple système de stockage clef-valeur."

#: ../../design/database.rst:36
msgid ""
"``Annotations``: This information extends the entity with properties usually"
msgstr ""
"``Annotations`` : Ces informations étendent l'entité avec des propriétés, "
"habituellement"

#: ../../design/database.rst:36
msgid ""
"added by a third party. Such properties include ratings, likes, and votes."
msgstr ""
"ajoutées par une tierce-partie. De telles propriétés comprennent les "
"notations, likes et votes."

#: ../../design/database.rst:38
msgid "The main differences between metadata and annotations:"
msgstr "La principale différence entre métadonnées et annotations :"

#: ../../design/database.rst:40
msgid "metadata does not have owners, while annotations do"
msgstr ""
"les métadonnées n'ont pas de propriétaire, alors que les annotations en ont"

#: ../../design/database.rst:41
msgid "metadata is not access controlled, while annotations are"
msgstr ""
"les métadonnées ne disposent pas de contrôle d'accès, alors que les "
"annotations en disposent"

#: ../../design/database.rst:42
msgid ""
"metadata is preloaded when entity is constructed, while annotations are only"
" loaded on demand"
msgstr ""
"les métadonnées sont préchargées lorsque l'entité est construite, alors que "
"les annotations ne sont chargées que sur demande"

#: ../../design/database.rst:44
msgid ""
"These differences might have implications for performance and your business "
"logic, so consider carefully, how you would like to attach data to your "
"entities."
msgstr ""
"Ces différences peuvent avoir des implications sur les performances et votre"
" logique applicative, aussi considérez avec soin la manière dont vous "
"souhaiter attacher des données à vos entités."

#: ../../design/database.rst:47
msgid ""
"In certain cases, it may be benefitial to avoid using metadata and "
"annotations and create new entities instead and attaching them via "
"``container_guid`` or a relationship."
msgstr ""
"Dans certains cas, il peut être préférable d'éviter d'utiliser ces "
"métadonnées et annotations et de créer de nouvelles entités à la place, puis"
" de les attacher via ``container_guid`` ou une relation."

#: ../../design/database.rst:51
msgid "Datamodel"
msgstr "Modèle de données (datamodel)"

#: ../../design/database.rst:58
msgid "The Elgg data model diagram"
msgstr "Le diagramme du modèle de données d'Elgg"

#: ../../design/database.rst:61
msgid "Entities"
msgstr "Entités"

#: ../../design/database.rst:63
msgid ""
"``ElggEntity`` is the base class for the Elgg data model and supports a "
"common set of properties and methods."
msgstr ""
"``ElggEntity`` est la classe de base pour le modèle de données d'Elgg et "
"supporte un jeu de propriétés et méthodes communes."

#: ../../design/database.rst:66
msgid "A numeric Globally Unique IDentifier (See `GUIDs`_)."
msgstr ""
"Un identifiant global unique (Globally Unique IDentifier - Voir `GUIDs`_)."

#: ../../design/database.rst:67
msgid ""
"Access permissions. (When a plugin requests data, it never gets to touch "
"data that the current user doesn't have permission to see.)"
msgstr ""
"Permissions d'accès . (Quand un plugin demande des données, il n'accède "
"jamais à des données que l'utilisateur actuel n'a pas la permission de "
"voir.)"

#: ../../design/database.rst:69
msgid "An arbitrary subtype (more below)."
msgstr "Un sous-type arbitraire (plus d'informations ci-dessous)."

#: ../../design/database.rst:70
msgid "An owner."
msgstr "Un propriétaire (owner)."

#: ../../design/database.rst:71
msgid "The site that the entity belongs to."
msgstr "Le site auquel appartient cette entité."

#: ../../design/database.rst:72
msgid "A container, used to associate content with a group or a user."
msgstr ""
"Un conteneur, utilisé pour associer le contenu avec un groupe ou un "
"utilisateur."

#: ../../design/database.rst:75
msgid "Types"
msgstr "Types"

#: ../../design/database.rst:77
msgid ""
"*Actual* entities will be instances of four different subclasses, each "
"having a distinct **type** property and their own additional properties and "
"methods."
msgstr ""
"Les *véritables* entités seront des instances de quatre sous-classes "
"différentes, chacune ayant une propriété **type** distincte et leur propres "
"propriétés et méthodes additionnelles."

#: ../../design/database.rst:81
msgid "Type"
msgstr "Type"

#: ../../design/database.rst:81
msgid "PHP class"
msgstr "Classe PHP"

#: ../../design/database.rst:81 ../../design/database.rst:514
msgid "Represents"
msgstr "Représente"

#: ../../design/database.rst:83
msgid "object"
msgstr "objet"

#: ../../design/database.rst:83
msgid "``ElggObject``"
msgstr "``ElggObject``"

#: ../../design/database.rst:83
msgid "Most user-created content, like blog posts, uploads, and bookmarks."
msgstr ""
"Les plupart des contenus créés par les utilisateurs, tels que des articles "
"de blog, des chargements de fichiers, et des signets."

#: ../../design/database.rst:84
msgid "group"
msgstr "groupe"

#: ../../design/database.rst:84
msgid "``ElggGroup``"
msgstr "``ElggGroup``"

#: ../../design/database.rst:84
msgid "An organized group of users with its own profile page"
msgstr "Un groupe organisé d'utilisateurs avec sa propre page de profil"

#: ../../design/database.rst:85
msgid "user"
msgstr "utilisateur"

#: ../../design/database.rst:85
msgid "``ElggUser``"
msgstr "``ElggUser``"

#: ../../design/database.rst:85
msgid "A user of the system"
msgstr "Un utilisateur du système"

#: ../../design/database.rst:86
msgid "site"
msgstr "site"

#: ../../design/database.rst:86
msgid "``ElggSite``"
msgstr "``ElggSite``"

#: ../../design/database.rst:86
msgid "The site served by the Elgg installation"
msgstr "Le site servi par l'installation Elgg"

#: ../../design/database.rst:89
msgid ""
"Each type has its own extended API. E.g. users can be friends with other "
"users, group can have members, while objects can be liked and commented on."
msgstr ""
"Chaque type a sa propre API étendue. Par ex. les utilisateurs peuvent être "
"en contact avec d'autres utilisateurs, un groupe peut avoir des membres, "
"tandis que les objets peuvent être \"likés\" et commentés."

#: ../../design/database.rst:93
msgid "Subtypes"
msgstr "Sous-types (subtypes)"

#: ../../design/database.rst:95
msgid ""
"Each entity must define a **subtype**, which plugins use to further "
"specialize the entity. Elgg makes it easy to query specific for entities of "
"a given subtype(s), as well as assign them special behaviors and views."
msgstr ""
"Chaque entité doit définir un **sous-type** (subtype), que les plugins "
"utilisent pour spécialiser encore l'entité. Elgg rend facile le fait de "
"rechercher des entités spécifiques d'un ou de plusieurs sous-types donnés, "
"ainsi que de leur assigner des comportements et vues spéciales."

#: ../../design/database.rst:98
msgid ""
"Subtypes are most commonly given to instances of ``ElggEntity`` to denote "
"the kind of content created. E.g. the blog plugin creates objects with "
"subtype ``\"blog\"``."
msgstr ""
"Les sous-types sont communément donnés aux instances de ``ElggEntity`` pour "
"définir le type de contenu créé. Par ex. le plugin blog crée des objets avec"
" le sous-type ``\"blog\"``."

#: ../../design/database.rst:101
msgid ""
"By default, users, groups and sites have the the subtypes of ``user``, "
"``group`` and ``site`` respectively."
msgstr ""
"Par défaut, les utilisateurs, les groupes et les sites ont respectivement le"
" sous-type ``user``, ``group`` et ``site``."

#: ../../design/database.rst:103
msgid ""
"Plugins can use custom entity classes that extend the base type class. To do"
" so, they need to register their class at runtime (e.g. in the "
"``'init','system'`` handler), using ``elgg_set_entity_class()``. For "
"example, the blog plugin could use ``elgg_set_entity_class('object', 'blog',"
" \\ElggBlog::class)``."
msgstr ""
"Les plugins peuvent utiliser des classes d'entités personnalisées qui "
"étendent l classe de base du type. Pour cela, ils doivent enregistrer leur "
"classe au démarrage (par ex. dans le gestionnaire ``'init','system'``), en "
"utilisant ``elgg_set_entity_class()``. Par exemple, le plugin blog pourraity"
" utiliser ``elgg_set_entity_class('object', 'blog', \\ElggBlog::class)``."

#: ../../design/database.rst:107
msgid ""
"Plugins can use ``elgg-plugin.php`` to define entity class via shortcut "
"``entities`` parameter."
msgstr ""
"Les plugins peuvent utiliser ``elgg-plugin.php`` pour définir une classe "
"d'entité via le paramètre raccourci ``entities``."

#: ../../design/database.rst:110
msgid "Subtype Gotchas"
msgstr "Trucs à savoir sur les sous-types"

#: ../../design/database.rst:112
msgid ""
"Before an entity's ``save()`` method is called, the subtype must be set by "
"writing a string to the ``subtype`` property."
msgstr ""
"Avant que la méthode ``save()`` d'une entité soit appelée, le sous-type doit"
" être défini en écrivant une chaîne de caractère dans la propriété "
"``subtype``."

#: ../../design/database.rst:113
msgid "*Subtype cannot be changed after saving.*"
msgstr "*Le sous-type ne peut pas être changé après l'enregistrement.*"

#: ../../design/database.rst:116
msgid "GUIDs"
msgstr "GUIDs"

#: ../../design/database.rst:118
msgid ""
"A GUID is an integer that uniquely identifies every entity in an Elgg "
"installation (a Globally Unique IDentifier). It's assigned automatically "
"when the entity is first saved and can never be changed."
msgstr ""
"Un GUID est un entier qui définit de manière unique chaque entité dans une "
"installation Elgg (un IDentifiant Global Unique - Globally Unique "
"IDentifier). Il est assigné automatiquement la première fois qu'une entité "
"est enregistré, et ne peut jamais être changé."

#: ../../design/database.rst:122
msgid ""
"Some Elgg API functions work with GUIDs instead of ``ElggEntity`` objects."
msgstr ""
"Certaines fonctions de l'API Elgg focntionnenet avec des GUIDs au lieu "
"d'objets ``ElggEntity``."

#: ../../design/database.rst:125
msgid "ElggObject"
msgstr "ElggObject"

#: ../../design/database.rst:127
msgid ""
"The ``ElggObject`` entity type represents arbitrary content within an Elgg "
"install; things like blog posts, uploaded files, etc."
msgstr ""
"Le type d'entité ``ElggObject`` représente un type de contenu arbitraire au "
"sein d'une installation Elgg ; des choses telles que des articles de blog, "
"des fichiers, etc."

#: ../../design/database.rst:130
msgid "Beyond the standard ElggEntity properties, ElggObjects also support:"
msgstr ""
"Au-delà des propriétés standards de ElggEntity, ElggObjects supporte "
"également :"

#: ../../design/database.rst:132
msgid "``title`` The title of the object (HTML escaped text)"
msgstr "``title`` Le titre de l'objet (texte sans HTML)"

#: ../../design/database.rst:133
msgid "``description`` A description of the object (HTML)"
msgstr "``description`` Une description de l'objet (HTML)"

#: ../../design/database.rst:135
msgid "Most other data about the object is generally stored via metadata."
msgstr ""
"La plupart des autrse données à propos de l'objet sont généralement stockées"
" via des métadonnées."

#: ../../design/database.rst:138
msgid "ElggUser"
msgstr "ElggUser"

#: ../../design/database.rst:140
msgid ""
"The ``ElggUser`` entity type represents users within an Elgg install. These "
"will be set to disabled until their accounts have been activated (unless "
"they were created from within the admin panel)."
msgstr ""
"Le type d'entité ``ElggUser`` représente les utilisateurs au sien d'une "
"installation Elgg. Il seront définis comme désactivés jusqu'à-ce que leur "
"compte ait été activé (à moins qu'ils n'aient été créés à partir du panneau "
"d'administration)."

#: ../../design/database.rst:144
msgid "Beyond the standard ElggEntity properties, ElggUsers also support:"
msgstr ""
"Au-delà des propriétés standards de ElggEntity, ElggUsers supporte également"
" :"

#: ../../design/database.rst:146
msgid "``name`` The user's plain text name. e.g. \"Hugh Jackman\""
msgstr "``name`` Le nom de l'utilisateur en texte brut. Par ex. \"Hugh Jackman\""

#: ../../design/database.rst:147
msgid "``username`` Their login name. E.g. \"hjackman\""
msgstr "``username`` Leur nom d'utilisateur. Par ex. \"hjackman\""

#: ../../design/database.rst:148
msgid "``password`` A hashed version of their password"
msgstr "``password`` Une version hachée de leur mot de passe"

#: ../../design/database.rst:149
msgid "``email`` Their email address"
msgstr "``email`` Leur adresse email"

#: ../../design/database.rst:150
msgid "``language`` Their default language code."
msgstr "``language`` Leur code de langue par défaut."

#: ../../design/database.rst:151
msgid "``code`` Their session code (moved to a separate table in 1.9)."
msgstr ""
"``code`` Leur code de session (déplacé vers une table séparée dans la 1.9)."

#: ../../design/database.rst:152
msgid "``last_action`` The UNIX timestamp of the last time they loaded a page"
msgstr ""
"``last_action`` Le timestamp UNIX de la dernière fois qu'ils ont chargé une "
"page"

#: ../../design/database.rst:153
msgid "``prev_last_action`` The previous value of ``last_action``"
msgstr "``prev_last_action`` La précédente valeur de ``last_action``"

#: ../../design/database.rst:154
msgid "``last_login`` The UNIX timestamp of their last log in"
msgstr "``last_login`` Le timestamp UNIX de leur dernière connexion"

#: ../../design/database.rst:155
msgid "``prev_last_login`` the previous value of ``last_login``"
msgstr "``prev_last_login`` la précédente valeur de ``last_login``"

#: ../../design/database.rst:158
msgid "ElggSite"
msgstr "ElggSite"

#: ../../design/database.rst:160
msgid ""
"The ``ElggSite`` entity type represents your Elgg installation (via your "
"site URL)."
msgstr ""
"Le type d'entité ``ElggSite`` représente votre installation Elgg (via l'URL "
"de votre site)."

#: ../../design/database.rst:162
msgid "Beyond the standard ElggEntity properties, ElggSites also support:"
msgstr ""
"Au-delà des propriétés standards de ElggEntity, ElggSites supporte également"
" :"

#: ../../design/database.rst:164
msgid "``name`` The site name"
msgstr "``name`` Le nom du site"

#: ../../design/database.rst:165
msgid "``description`` A description of the site"
msgstr "``description`` Une description du site"

#: ../../design/database.rst:166
msgid "``url`` The address of the site"
msgstr "``url`` L'adresse du site"

#: ../../design/database.rst:169
msgid "ElggGroup"
msgstr "ElggGroup"

#: ../../design/database.rst:171
msgid ""
"The ``ElggGroup`` entity type represents an association of Elgg users. Users"
" can join, leave, and post content to groups."
msgstr ""
"Le type d'entité ``ElggGroup`` représente une association d'utilisateurs "
"Elgg. Les utilisateurs peuvent rejoindre, quitter les groupes, et y publier "
"du contenu."

#: ../../design/database.rst:174
msgid "Beyond the standard ElggEntity properties, ElggGroups also support:"
msgstr ""
"Au-delà des propriétés standards de ElggEntity, ElggGroups supporte "
"également :"

#: ../../design/database.rst:176
msgid "``name`` The group's name (HTML escaped text)"
msgstr "``name`` Le nom du groupe (texte sans HTML)"

#: ../../design/database.rst:177
msgid "``description`` A description of the group (HTML)"
msgstr "``description`` Une description du groupe (HTML)"

#: ../../design/database.rst:179
msgid "``ElggGroup`` has addition methods to manage content and membership."
msgstr ""
"``ElggGroup`` a des méthodes additionnelles pour gérer le contenu et les "
"adhésions."

#: ../../design/database.rst:182
msgid "The Groups plugin"
msgstr "Le plugin Groups"

#: ../../design/database.rst:184
msgid ""
"Not to be confused with the entity type ``ElggGroup``, Elgg comes with a "
"plugin called \"Groups\" that provides a default UI/UX for site users to "
"interact with groups. Each group is given a discussion forum and a profile "
"page linking users to content within the group."
msgstr ""
"A ne pas confondre avec le type d'entité ``ElggGroup``, Elgg vient avec un "
"plugin appelé \"Groups\" qui fournit une UI/UX par défaut pour que les "
"utilisateurs du site interagissent avec les groupes. Chaque groupe dispose "
"d'un forum de discussion et d'une page de profil qui relient les "
"utilisateurs au contenu dans le groupe.."

#: ../../design/database.rst:189
msgid ""
"You can alter the user experience via the traditional means of extending "
"plugins or completely replace the Groups plugin with your own."
msgstr ""
"Vous pouvez modifier l'expérience utilisateur via les moyens traditionnels "
"d'extension de plugin, ou remplacer complètement le plugin Groups par votre "
"propre plugin."

#: ../../design/database.rst:193
msgid "Writing a group-aware plugin"
msgstr "Écrire un plugin conscient des groupes"

#: ../../design/database.rst:195
msgid ""
"Plugin owners need not worry too much about writing group-aware "
"functionality, but there are a few key points:"
msgstr ""
"Les développeurs de plugins ne devraient pas trop s'inquiéter d'écrire une "
"fonctionnalité consciente des groupes, mais il y a quelques points clefs :"

#: ../../design/database.rst:199
msgid "Adding content"
msgstr "Ajouter du contenu"

#: ../../design/database.rst:201
msgid ""
"By passing along the group as ``container_guid`` via a hidden input field, "
"you can use a single form and action to add both user and group content."
msgstr ""
"En passant le groupe en tant que ``container_guid`` via un champ de saisie "
"caché, vous pouvez utiliser un seul formulaire et une seule action pour "
"ajouter du contenu à la fois pour un utilisateur ou pour un groupe."

#: ../../design/database.rst:204
msgid ""
"Use ``ElggEntity->canWriteToContainer()`` to determine whether or not the "
"current user has the right to add content to a group."
msgstr ""
"Utilisez ``ElggEntity->canWriteToContainer()`` pour déterminer si "
"l'utilisateur actuel a ou n'a pas le droit d'ajouter du contenu dans un "
"groupe."

#: ../../design/database.rst:207
msgid ""
"Be aware that you will then need to pass the container GUID or username to "
"the page responsible for posting and the accompanying value, so that this "
"can then be stored in your form as a hidden input field, for easy passing to"
" your actions. Within a \"create\" action, you'll need to take in this input"
" field and save it as a property of your new element (defaulting to the "
"current user's container):"
msgstr ""
"Soyez attentif au fait que vous allez devoir passer le GUID du conteneur ou "
"le nom d'utilisateur à la page responsable de la publication et la valeur "
"associée, de sorte que ceci puisse être ensuite conservé dans votre "
"formulaire sous forme de champ de saisie caché, pour un passage plus aisé "
"vers vos actions. Au sein d'une action \"create\", vous allez avoir besoin "
"de récupérer ce champ de saisie et de l'enregistrer sous forme de propriété "
"de votre nouvel élément (la valeur par défaut est le conteneur actuel de "
"l'utilisateur) :"

#: ../../design/database.rst:238
msgid "Ownership"
msgstr "Propriété"

#: ../../design/database.rst:240
msgid ""
"Entities have a ``owner_guid`` GUID property, which defines its owner. "
"Typically this refers to the GUID of a user, although sites and users "
"themselves often have no owner (a value of 0)."
msgstr ""
"Les entités ont une propriété GUID ``owner_guid``, qui définit son "
"propriétaire. Typiquement ceci renvoie au GUID d'un utilisateur, quoique les"
" sites et les utilisateurs eux-même n'ont souvent pas de propriétaire "
"(valeur de 0)."

#: ../../design/database.rst:244
msgid ""
"The ownership of an entity dictates, in part, whether or not you can access "
"or edit that entity."
msgstr ""
"La propriété d'une entité détermine, d'une part, si vous pouvez ou non "
"accéder à, ou modifier cette entité."

#: ../../design/database.rst:248
msgid "Containers"
msgstr "Conteneurs (containers)"

#: ../../design/database.rst:250
msgid ""
"In order to easily search content by group or by user, content is generally "
"set to be \"contained\" by either the user who posted it, or the group to "
"which the user posted. This means the new object's ``container_guid`` "
"property will be set to the GUID of the current ElggUser or the target "
"ElggGroup."
msgstr ""
"Afin de rechercher aisément du contenu par groupe ou utilisateur, le contenu"
" est généralement défini comme \"contenu\" soit par l'utilisateur qui l'a "
"publié, soit par le groupe dans lequel l'utilisateur l'a publié. Ceci "
"signifie que la propriété ``container_guid`` des nouveaux objets sera "
"définie avec la valeur du ElggUser actuel ou du ElggGroup cible."

#: ../../design/database.rst:255
msgid ""
"E.g., three blog posts may be owned by different authors, but all be "
"contained by the group they were posted to."
msgstr ""
"Par ex., trois articles de blog peuvent avoir des propriétaires différentes,"
" mais être tous contenus dans le groupe où ils ont été publiés."

#: ../../design/database.rst:258
msgid ""
"Note: This is not always true. Comment entities are contained by the object "
"commented upon, and in some 3rd party plugins the container may be used to "
"model a parent-child relationship between entities (e.g. a \"folder\" object"
" containing a file object)."
msgstr ""
"Note : Ceci n'est pas toujours vrai. Les entités Commentaires sont contenues"
" par l'objet commenté, et dans certains plugins tierce-partie la conteneur "
"peut être utilisé pour modéliser des relations parents-enfants entre entités"
" (par ex. un objet \"dossier\" qui contient un objet fichier)."

#: ../../design/database.rst:264
msgid "Annotations"
msgstr "Annotations"

#: ../../design/database.rst:266
msgid ""
"Annotations are pieces of data attached to an entity that allow users to "
"leave ratings, or other relevant feedback. A poll plugin might register "
"votes as annotations."
msgstr ""
"Les annotations sont des éléments de données attachées à une entité qui "
"permet aux utilisateurs de laisser des évaluations, ou d'autres types de "
"réactions pertinentes. Un plugin de sondage pourrait enregistrer des votes "
"sous forme d'annotations."

#: ../../design/database.rst:270
msgid "Annotations are stored as instances of the ``ElggAnnotation`` class."
msgstr ""
"Les annotations sont stockées sous formes d'instances de la classe "
"``ElggAnnotation``."

#: ../../design/database.rst:272
msgid "Each annotation has:"
msgstr "Chaque annotation dispose de :"

#: ../../design/database.rst:274
msgid "An internal annotation type (like *comment*)"
msgstr "Un type d'annotation interne (tel que *comment*)"

#: ../../design/database.rst:275
msgid "A value (which can be a string or integer)"
msgstr "Une valeur (qui peut être une chaîne de caractères ou un entier)"

#: ../../design/database.rst:276
msgid "An access permission distinct from the entity it's attached to"
msgstr ""
"Un niveau d'accès distinct de celui de l'entité à laquelle il est attaché"

#: ../../design/database.rst:277
msgid "An owner"
msgstr "Un propriétaire"

#: ../../design/database.rst:279
msgid ""
"Like metadata, values are stored as strings unless the value given is a PHP "
"integer (``is_int($value)`` is true), or unless the ``$vartype`` is manually"
" specified as ``integer``."
msgstr ""
"Comme pour les métadonnées, les valeurs sont stockées sous forme de chaines "
"de caractères à moins que la valeur donnée soit un entier PHP "
"(``is_int($value)`` vaut true), ou à moins que ``$vartype`` soit spécifié "
"manuellement comme ``integer``."

#: ../../design/database.rst:283
msgid "Adding an annotation"
msgstr "Ajouter une annotation"

#: ../../design/database.rst:285
msgid ""
"The easiest way to annotate is to use the ``annotate`` method on an entity, "
"which is defined as:"
msgstr ""
"La manière la plus simple d'ajouter une annotation est d'utiliser la méthode"
" ``annotate`` sur une entité, qui est définie comme :"

#: ../../design/database.rst:298
msgid "For example, to leave a rating on an entity, you might call:"
msgstr ""
"Par exemple, pour donner une notation à une entité, vous pouvez appeler :"

#: ../../design/database.rst:305
msgid "Reading annotations"
msgstr "Lire les annotations"

#: ../../design/database.rst:307
msgid ""
"To retrieve annotations on an object, you can call the following method:"
msgstr ""
"Pour récupérer les annotations d'une entité, vous pouvez appeler la méthode "
"suivante :"

#: ../../design/database.rst:318
msgid ""
"If your annotation type largely deals with integer values, a couple of "
"useful mathematical functions are provided:"
msgstr ""
"Si votre type d'annotation utilise largement des valeurs entières, plusieurs"
" fonctions mathématiques utiles sont fournies :"

#: ../../design/database.rst:329
msgid "Useful helper functions"
msgstr "Fonctions d'aide utiles"

#: ../../design/database.rst:332
msgid "Comments"
msgstr "Commentaires"

#: ../../design/database.rst:334
msgid ""
"If you want to provide comment functionality on your plugin objects, the "
"following function will provide the full listing, form and actions:"
msgstr ""
"Si vous souhaitez fournir une fonctionnalité de commentaire sur les objets "
"de votre plugin, la fonction suivante va fournir le listing complet, le "
"formulaire et les actions :"

#: ../../design/database.rst:343
msgid "Metadata"
msgstr "Métadonnées"

#: ../../design/database.rst:345
msgid ""
"Metadata in Elgg allows you to store extra data on an ``entity`` beyond the "
"built-in fields that entity supports. For example, ``ElggObjects`` only "
"support the basic entity fields plus title and description, but you might "
"want to include tags or an ISBN number. Similarly, you might want users to "
"be able to save a date of birth."
msgstr ""
"Les métadonnées dans Elgg vous permettent de stocker les données "
"supplémentaires d'une ``entité`` au-delà des champs pré-définis que cette "
"entité supporte. Par exemple, ``ElggObjects`` ne supporte que les champs "
"d'entités basiques plus un titre et une description, mais vous pouvez "
"souhaiter inclure également des tags ou un numéro ISBN. De manière "
"similaire, vous pourriez souhaiter que les utilisateurs puissent enregistrer"
" une date de naissance."

#: ../../design/database.rst:351
msgid ""
"Under the hood, metadata is stored as an instance of the ``ElggMetadata`` "
"class, but you don't need to worry about that in practice (although if "
"you're interested, see the ``ElggMetadata`` class reference). What you need "
"to know is:"
msgstr ""
"Sous le capot, les métadonnées sont stockées sous forme d'instance de la "
"classe ``ElggMetadata``, mais vous n'avez pas à vous soucier de cela en "
"pratique (quoique si vous êtes intéressé, voyez la référence de la classe "
"``ElggMetadata``). Ce que vous avez besoin de savoir :"

#: ../../design/database.rst:356
msgid ""
"Metadata has an owner, which may be different to the owner of the entity "
"it's attached to"
msgstr ""
"Une métadonnée a un propriétaire, qui peut être différent du propriétaire de"
" l'entité à laquelle elle est attachée"

#: ../../design/database.rst:358
msgid ""
"You can potentially have multiple items of each type of metadata attached to"
" a single entity"
msgstr ""
"Vous pouvez potentiellement avoir plusieurs éléments de chaque type de "
"métadonnée attachés à la même entité"

#: ../../design/database.rst:360
msgid ""
"Like annotations, values are stored as strings unless the value given is a "
"PHP integer (``is_int($value)`` is true), or unless the ``$value_type`` is "
"manually specified as ``integer`` (see below)."
msgstr ""
"Comme pour les annotations, les valeurs sont stockées sous forme de chaîne "
"de caractères à moins que la valeur donnée soit un entier PHP "
"(``is_int($value)`` vaut true), ou à moins que le ``$value_type`` soit "
"défini manuellement comme ``integer`` (voyez ci-dessous)."

#: ../../design/database.rst:363
msgid "As of Elgg 3.0, metadata no longer have ``access_id``."
msgstr "A partir de Elgg 3.0, les métadonnées n'ont plus d'``access_id``."

#: ../../design/database.rst:366
msgid "The simple case"
msgstr "Le cas simple"

#: ../../design/database.rst:369
msgid "Adding metadata"
msgstr "Ajouter des métadonnées"

#: ../../design/database.rst:371
msgid "To add a piece of metadata to an entity, just call:"
msgstr "Pour ajouter une métadonnée à une entité, appelez simplement :"

#: ../../design/database.rst:377
msgid "For example, to add a date of birth to a user:"
msgstr "Par exemple, pour ajouter une date d'anniversaire à un utilisateur :"

#: ../../design/database.rst:383
msgid "Or to add a couple of tags to an object:"
msgstr "Ou pour ajouter des tags à un objet :"

#: ../../design/database.rst:389
msgid "When adding metadata like this:"
msgstr "Lorsque vous ajoutez une métadonnée de cette manière :"

#: ../../design/database.rst:391
msgid "The owner is set to the currently logged-in user"
msgstr "Le propriétaire est assigné à l'utilisateur actuellement identifié"

#: ../../design/database.rst:392
msgid "Reassigning a piece of metadata will overwrite the old value"
msgstr "Réassigner une métadonnée va remplacer l'ancienne valeur"

#: ../../design/database.rst:394
msgid ""
"This is suitable for most purposes. Be careful to note which attributes are "
"metadata and which are built in to the entity type that you are working "
"with. You do not need to save an entity after adding or updating metadata. "
"You do need to save an entity if you have changed one of its built in "
"attributes. As an example, if you changed the access id of an ElggObject, "
"you need to save it or the change isn't pushed to the database."
msgstr ""
"Ceci convient pour la plupart des objectifs. Faites attention à bien noter "
"quels attributs sont des métadonnées et lesquels sont natifs au type "
"d'entité avec lequel vous travaillez. Vous n'avez pas besoin d'enregistrer "
"une entité après avoir ajouté ou modifié des métadonnées. Vous devez "
"enregistrer une entité si vous avez changé l'un des ses attributs natifs. A "
"titre d'exemple, si vous avez changé l'id d'accès d'un ElggObject, vous "
"devez l'enregistrer, faute de quoi la modification ne sera pas conservée "
"dans la base de données."

#: ../../design/database.rst:402
msgid "As of Elgg 3.0, metadata's ``access_id`` property is ignored."
msgstr ""
"A partir de Elgg 3.0, la propriété ``access_id`` des métadonnées est "
"ignorée."

#: ../../design/database.rst:405
msgid "Reading metadata"
msgstr "Lire les métadonnées"

#: ../../design/database.rst:407
msgid "To retrieve metadata, treat it as a property of the entity:"
msgstr ""
"Pour récupérer une métadonnée, traitez-la comme une propriété d'une entité :"

#: ../../design/database.rst:413
msgid ""
"Note that this will return the absolute value of the metadata. To get "
"metadata as an ElggMetadata object, you will need to use the methods "
"described in the *finer control* section below."
msgstr ""
"Notez que ceci va retourner la valeur absolue de la métadonnée. Pour "
"récupérer des métadonnées sous forme d'objet ElggMetadata, vous aurez besoin"
" d'utiliser les méthodes décrites dans la section *contrôle plus fin* ci-"
"dessous."

#: ../../design/database.rst:417
msgid ""
"If you stored multiple values in this piece of metadata (as in the \"tags\" "
"example above), you will get an array of all those values back. If you "
"stored only one value, you will get a string or integer back. Storing an "
"array with only one value will return a string back to you. E.g."
msgstr ""
"Si vous stockez de multiples valeurs dans cette métadonnée (comme dans "
"l'exemple \"tags\" ci-dessus), vous obtiendrez un tableau de toutes ces "
"valeurs. Si vous stockez seulement une valeur, vous récupérerez une chaîne "
"de caractères ou un entier. Stocker un tableau avec seulement une valeur "
"vous retournera une chaîne de caractères. Par ex."

#: ../../design/database.rst:429
msgid "To always get an array back, simply cast to an array;"
msgstr ""
"Pour récupérer toujours un tableau, castez simplement vers un tableau ;"

#: ../../design/database.rst:436
msgid "Reading metadata as objects"
msgstr "Lire des métadonnées comme des objets"

#: ../../design/database.rst:438
msgid ""
"``elgg_get_metadata`` is the best function for retrieving metadata as "
"ElggMetadata objects:"
msgstr ""
"``elgg_get_metadata`` est la meilleure fonction pour récupérer les "
"métadonénes sous forme d'objets ElggMetadata :"

#: ../../design/database.rst:441
msgid "E.g., to retrieve a user's DOB"
msgstr "Par ex., pour récupérer la date de naissance d'un utilisateur"

#: ../../design/database.rst:450
msgid "Or to get all metadata objects:"
msgstr "Ou pour récupérer toutes les objets des métadonnées :"

#: ../../design/database.rst:462
msgid "Common mistakes"
msgstr "Erreurs courantes"

#: ../../design/database.rst:465
msgid "\"Appending\" metadata"
msgstr "\"Ajouter\" des métadonnées"

#: ../../design/database.rst:467
msgid ""
"Note that you cannot \"append\" values to metadata arrays as if they were "
"normal php arrays. For example, the following will not do what it looks like"
" it should do."
msgstr ""
"Notez que vous ne pouvez pas \"ajouter\" des valeurs aux tableaux de "
"métadonnées comme si c'étaient des tableaux php normaux. Par exemple, le "
"code suivant ne fera pas ce qu'il semblerait qu'il devrait faire."

#: ../../design/database.rst:476
msgid "Trying to store hashmaps"
msgstr "Essayer de stocker des tableaux indexés"

#: ../../design/database.rst:478
msgid ""
"Elgg does not support storing ordered maps (name/value pairs) in metadata. "
"For example, the following does not work as you might first expect it to:"
msgstr ""
"Elgg ne supporte pas le stockage de tableaux indexés (paires clef/valeur) "
"dans les métadonnées. Par exemple, le code suivant ne fonctionne pas comme "
"vous pourriez le penser de prime abord :"

#: ../../design/database.rst:487
msgid "You can instead store the information like so:"
msgstr ""
"Au lieu de cela, vous pouvez conserver cette information de cette manière :"

#: ../../design/database.rst:496
msgid "Storing GUIDs in metadata"
msgstr "Conserver des GUIDs dans des métadonnées"

#: ../../design/database.rst:498
msgid ""
"Though there are some cases to store entity GUIDs in metadata, "
"`Relationships`_ are a much better construct for relating entities to each "
"other."
msgstr ""
"Quoiqu'il existe certains cas pour stocker les GUIDs d'entités dans des "
"métadonnées, les relations `Relationships`_ sont une construction bien plus "
"adaptée pour relier les entités les unes aux autres."

#: ../../design/database.rst:503
msgid "Relationships"
msgstr "Relations"

#: ../../design/database.rst:505
msgid ""
"Relationships allow you to bind entities together. Examples: an artist has "
"fans, a user is a member of an organization, etc."
msgstr ""
"Les relations vous permettent d'associer des entités ensemble. Exemples : un"
" artiste a des fans, un utilisateur est membre d'une organisation, etc."

#: ../../design/database.rst:508
msgid ""
"The class ``ElggRelationship`` models a directed relationship between two "
"entities, making the statement:"
msgstr ""
"La classe ``ElggRelationship`` modélise une relation directe entre deux "
"entités, en faisant la déclaration :"

#: ../../design/database.rst:511
msgid "\"**{subject}** is a **{noun}** of **{target}**.\""
msgstr "\"**{subject}** est un **{noun}** de **{target}**.\""

#: ../../design/database.rst:514
msgid "API name"
msgstr "Nom de l'API"

#: ../../design/database.rst:514
msgid "Models"
msgstr "Modèles"

#: ../../design/database.rst:516
msgid "``guid_one``"
msgstr "``guid_one``"

#: ../../design/database.rst:516
msgid "The subject"
msgstr "Le sujet"

#: ../../design/database.rst:516
msgid "Which entity is being bound"
msgstr "Quelle entité est reliée"

#: ../../design/database.rst:517
msgid "``relationship``"
msgstr "``relationship``"

#: ../../design/database.rst:517
msgid "The noun"
msgstr "Le nom"

#: ../../design/database.rst:517
msgid "The type of relationship"
msgstr "Le type de relation"

#: ../../design/database.rst:518
msgid "``guid_two``"
msgstr "``guid_two``"

#: ../../design/database.rst:518
msgid "The target"
msgstr "La cible"

#: ../../design/database.rst:518
msgid "The entity to which the subject is bound"
msgstr "L'entité à laquelle le sujet est relié"

#: ../../design/database.rst:521
msgid ""
"The type of relationship may alternately be a verb, making the statement:"
msgstr ""
"Le type de relation peut également être un verbe, faisant la déclaration :"

#: ../../design/database.rst:523
msgid "\"**{subject}** **{verb}** **{target}**.\""
msgstr "\"**{sujet}** **{verbe}** **{cible}**.\""

#: ../../design/database.rst:525
msgid "E.g. User A \"likes\" blog post B"
msgstr "Par ex. Utilisateur A \"aime\" l'article de blog B"

#: ../../design/database.rst:527
msgid ""
"**Each relationship has direction.** Imagine an archer shoots an arrow at a "
"target; The arrow moves in one direction, binding the subject (the archer) "
"to the target."
msgstr ""
"**Chaque relation a une direction.** Imaginez un archer qui tire une flèche "
"vers une cible ; la flèche se déplace dans une direction, en reliant le "
"sujet (l'archer) à à la cible."

#: ../../design/database.rst:531
msgid ""
"**A relationship does not imply reciprocity**. **A** follows **B** does not "
"imply that **B** follows **A**."
msgstr ""
"**Une relation n'implique pas de réciprocité**. **A** suit **B** n'implique "
"pas que **B** suive **A**."

#: ../../design/database.rst:534
msgid ""
"**Relationships_ do not have access control.** They're never hidden from "
"view and can be edited with code at any privilege level, with the caveat "
"that *the entities* in a relationship may be invisible due to access "
"control!"
msgstr ""
"Les **Relations_ n'ont pas de contrôle d'accès.** Elles ne sont jamais "
"cachées d'une vue et peuvent être modifiées par le code à n'importe quel "
"niveau de privilège, avec l'avertissement que *les entités* d'une relation "
"peuvent être invisible en raison du contrôle d'accès !"

#: ../../design/database.rst:540
msgid "Working with relationships"
msgstr "Travailler avec des relations"

#: ../../design/database.rst:543
msgid "Creating a relationship"
msgstr "Créer une relation"

#: ../../design/database.rst:545
msgid ""
"E.g. to establish that \"**$user** is a **fan** of **$artist**\" (user is "
"the subject, artist is the target):"
msgstr ""
"Par exemple pour établir que \"**$utilisateur** est un **fan** de "
"**$artiste**\" (utilisateur est le sujet, artiste est la cible):"

#: ../../design/database.rst:556
msgid ""
"This triggers the event [create, relationship], passing in the created "
"``ElggRelationship`` object. If a handler returns ``false``, the "
"relationship will not be created and ``$success`` will be ``false``."
msgstr ""
"Ceci déclenche l'événement [create, relationship], en lui passant l'objet "
"``ElggRelationship`` créé. Si un gestionnaire retourne ``false``, la "
"relation ne sera pas créée et ``$success`` vaudra ``false``."

#: ../../design/database.rst:562
msgid "Verifying a relationship"
msgstr "Vérifier une relation"

#: ../../design/database.rst:564
msgid "E.g. to verify that \"**$user** is a **fan** of **$artist**\":"
msgstr ""
"Par exemple pour vérifier que \"**$utilisateur** est un **fan** de "
"**$artiste**\":"

#: ../../design/database.rst:572
msgid ""
"Note that, if the relationship exists, ``check_entity_relationship()`` "
"returns an ``ElggRelationship`` object:"
msgstr ""
"Notez que si la relation existe, ``check_entity_relationship()`` retourne un"
" objet ``ElggRelationship`` :"

#: ../../design/database.rst:583
msgid "Deleting a relationship"
msgstr "Supprimer une relation"

#: ../../design/database.rst:585
msgid ""
"E.g. to be able to assert that \"**$user** is no longer a **fan** of "
"**$artist**\":"
msgstr ""
"Par exemple pour pouvoir affirmer que \"**$utilisateur** n'est désormais "
"plus un **fan** de **$artiste**\":"

#: ../../design/database.rst:591
msgid ""
"This triggers the event [delete, relationship], passing in the associated "
"``ElggRelationship`` object. If a handler returns ``false``, the "
"relationship will remain, and ``$was_removed`` will be ``false``."
msgstr ""
"Ceci déclenche l'événement [delete, relationship], en lui passant l'objet "
"``ElggRelationship`` associé. Si un gestionnaire retourne ``false``, la "
"relation sera conservée, ``$was_removed`` vaudra ``false``."

#: ../../design/database.rst:596
msgid "Other useful functions:"
msgstr "Autres fonctions utiles :"

#: ../../design/database.rst:598
msgid "``delete_relationship()`` : delete by ID"
msgstr "``delete_relationship()`` : supprimer par ID"

#: ../../design/database.rst:599
msgid "``remove_entity_relationships()`` : delete those relating to an entity"
msgstr ""
"``remove_entity_relationships()`` : supprime ceux qui sont liés à une entité"

#: ../../design/database.rst:602
msgid "Finding relationships and related entities"
msgstr "Trouver des relations et des entités associées"

#: ../../design/database.rst:604
msgid ""
"Below are a few functions to fetch relationship objects and/or related "
"entities. A few are listed below:"
msgstr ""
"Voici ci-dessous quelques fonctions pour récupérer des relations entre "
"objets et/ou des entités reliées :"

#: ../../design/database.rst:606
msgid ""
"``get_entity_relationships()`` : fetch relationships by subject or target "
"entity"
msgstr ""
"``get_entity_relationships()`` : récupère les relations par entité sujet ou "
"entité cible"

#: ../../design/database.rst:607
msgid "``get_relationship()`` : get a relationship object by ID"
msgstr "``get_relationship()`` : récupère un objet relation par ID"

#: ../../design/database.rst:608
msgid ""
"``elgg_get_entities()`` : fetch entities in relationships in a variety of "
"ways"
msgstr ""
"``elgg_get_entities()`` : récupère les entités dans les relations de "
"différentes manières"

#: ../../design/database.rst:610
msgid "E.g. retrieving users who joined your group in January 2014."
msgstr ""
"Par ex. retrouver les utilisateurs qui ont rejoint votre groupe en janvier "
"2014."

#: ../../design/database.rst:626
msgid "Access Control"
msgstr "Contrôle d'accès"

#: ../../design/database.rst:628
msgid ""
"Granular access controls are one of the fundamental design principles in "
"Elgg, and a feature that has been at the centre of the system throughout its"
" development. The idea is simple: a user should have full control over who "
"sees an item of data he or she creates."
msgstr ""
"Les contrôle d'accès granulaires sont l'un des principes de design "
"fondamentaux dans Elgg, et une fonctionnalité qui a été au cœur du système "
"tout au long de son développement. L'idée est simple : un utilisateur "
"devrait avoir un contrôle total sur qui peut voir un élément de donnée qu'il"
" ou elle a créé."

#: ../../design/database.rst:634
msgid "Access controls in the data model"
msgstr "Niveau d'accès dans le modèle de données"

#: ../../design/database.rst:636
msgid ""
"In order to achieve this, every entity and annotation contains an "
"``access_id`` property, which in turn corresponds to one of the pre-defined "
"access controls or an entry in the ``access_collections`` database table."
msgstr ""
"Pour parvenir à cela, chaque entité et annotation contient une propriété "
"``access_id``, qui correspond à l'un des niveau d'accès prédéfinis ou à une "
"entrée dans la table ``access_collections`` de la base de données."

#: ../../design/database.rst:642
msgid "Pre-defined access controls"
msgstr "Niveaux d'accès pré-définis"

#: ../../design/database.rst:644
msgid "``ACCESS_PRIVATE`` (value: 0) Private."
msgstr "``ACCESS_PRIVATE`` (valeur : 0) Privé."

#: ../../design/database.rst:645
msgid "``ACCESS_LOGGED_IN`` (value: 1) Logged in users."
msgstr "``ACCESS_LOGGED_IN`` (value: 1) Logged in users."

#: ../../design/database.rst:646
msgid "``ACCESS_PUBLIC`` (value: 2) Public data."
msgstr "``ACCESS_PUBLIC`` (value: 2) Public data."

#: ../../design/database.rst:649
msgid "User defined access controls"
msgstr "Niveaux d'accès définis par l'utilisateur"

#: ../../design/database.rst:651
msgid ""
"You may define additional access groups and assign them to an entity, or "
"annotation. A number of functions have been defined to assist you; see the "
":doc:`/guides/access` for more information."
msgstr ""
"Vous pouvez définir des groupes d'accès additionnels et les assigner à une "
"entité, ou une annotation. Un certain nombre de fonctions ont été définies "
"pour vous y aider ; voyez :doc:`/guides/access` pour plus d'informations."

#: ../../design/database.rst:656
msgid "How access affects data retrieval"
msgstr "Comment les accès affectent la récupération de données"

#: ../../design/database.rst:658
msgid ""
"All data retrieval functions above the database layer - for example "
"``elgg_get_entities`` will only return items that the current user has "
"access to see. It is not possible to retrieve items that the current user "
"does not have access to. This makes it very hard to create a security hole "
"for retrieval."
msgstr ""
"Toutes les récupérations de données fonctionnent au-dessus de la couche de "
"la base de données - par exemple ``elgg_get_entities`` ne retournera que les"
" éléments que l'utilisateur actuel a l'autorisation de voir. Il n'est pas "
"possible de récupérer des éléments auxquels l’utilisateur actuel n'a pas "
"accès. Ceci rend très difficile de créer un trou de sécurité pour récupérer "
"des données."

#: ../../design/database.rst:665
msgid "Write access"
msgstr "Accès en écriture"

#: ../../design/database.rst:667
msgid "The following rules govern write access:"
msgstr "Les règles suivantes gouvernent les accès en écriture :"

#: ../../design/database.rst:669
msgid "The owner of an entity can always edit it"
msgstr "Le propriétaire d'une entité peut toujours la modifier"

#: ../../design/database.rst:670
msgid ""
"The owner of a container can edit anything therein (note that this does not "
"mean that the owner of a group can edit anything therein)"
msgstr ""
"Le propriétaire d'un conteneur peut modifier tout ce qui est dedans (notez "
"que cela ne signifie pas que le propriétaire d'un groupe peut modifier "
"toutes les publications dans ce groupe)"

#: ../../design/database.rst:672
msgid "Admins can edit anything"
msgstr "Les administrateurs peuvent tout éditer"

#: ../../design/database.rst:674
msgid ""
"You can override this behaviour using a :ref:`plugin hook <design/events"
"#plugin-hooks>` called ``permissions_check``, which passes the entity in "
"question to any function that has announced it wants to be referenced. "
"Returning ``true`` will allow write access; returning ``false`` will deny "
"it. See :ref:`the plugin hook reference for permissions\\_check <guides"
"/hooks-list#permission-hooks>` for more details."
msgstr ""
"Vous pouvez surcharger ce comportement en utilisant un :ref:`hook plugin "
"<design/events#plugin-hooks>` appelé ``permissions_check``, qui passe "
"l'entité en question à toute focntion qui a annoncé qu'elles veut être "
"référencée. Retourner ``true`` va autoriser l'accès en écriture ; retourner "
"``false`` va l'interdire. Voyez :ref:`les références des plugin hook pour "
"les permissions\\_check <guides/hooks-list#permission-hooks>` pour plus de "
"détails."

#: ../../design/database.rst:681
msgid "Schema"
msgstr "Schéma"

#: ../../design/database.rst:683
msgid ""
"The database contains a number of primary and secondary tables. You can "
"follow schema changes in ``engine/schema/migrations/``"
msgstr ""
"La base de données contient un certain nombre de tables primaires et "
"secondaires. Vous pouvez suivre les évolutions du schéma dans "
"``engine/schema/migrations/``"

#: ../../design/database.rst:685
msgid ""
"The character set of the database should be ``utf8mb4``, this will provide "
"full unicode character support when storing data."
msgstr ""
"L’ensemble de caractères de la base de données doit être ``utf8mb4``, ce qui"
" fournira une prise en charge complète des caractères unicode lors du "
"stockage des données."

#: ../../design/database.rst:688
msgid "InnoDB"
msgstr "InnoDB"

#: ../../design/database.rst:690
msgid ""
"As of Elgg 3.0 the database uses the InnoDB engine. In order for a correct "
"installation or migration some settings may need to be adjusted in the "
"database settings."
msgstr ""
"À partir d’Elgg 3.0, la base de données utilise le moteur InnoDB. Pour une "
"installation ou une migration correcte, certains paramètres peuvent devoir "
"être ajustés dans les paramètres de la base de données."

#: ../../design/database.rst:693
msgid "``innodb_large_prefix`` should be ``on``"
msgstr "``innodb_large_prefix`` devrait être ``on``"

#: ../../design/database.rst:694
msgid "``innodb_file_format`` should be ``Barracuda``"
msgstr "``innodb_file_format`` devrait être ``Barracuda``"

#: ../../design/database.rst:695
msgid "``innodb_file_per_table`` should be ``1``"
msgstr "``innodb_file_per_table`` devrait être ``1``"

#: ../../design/database.rst:698
msgid "Main tables"
msgstr "Tables principales"

#: ../../design/database.rst:700
msgid ""
"This is a description of the main tables. Keep in mind that in a given Elgg "
"installation, the tables will have a prefix (typically \"elgg\\_\")."
msgstr ""
"Voici la description des tables principales. Gardez à l'esprit que pour une "
"installation d'Elgg données les tables vont avoir un préfixe (typiquement "
"\"elgg\\_\")."

#: ../../design/database.rst:704
msgid "Table: entities"
msgstr "Table : entities (entités)"

#: ../../design/database.rst:706
msgid ""
"This is the main `Entities`_ table containing Elgg users, sites, objects and"
" groups. When you first install Elgg this is automatically populated with "
"your first site."
msgstr ""
"Ceci est la table principale `Entities`_ qui contient les utilisateurs, "
"sites, objets et groupes Elgg. Quand vous installez Elgg la première fois "
"elle est automatiquement peuplée avec votre premier site."

#: ../../design/database.rst:710
msgid "It contains the following fields:"
msgstr "Elles contient les champs suivants :"

#: ../../design/database.rst:712
msgid ""
"**guid** An auto-incrementing counter producing a GUID that uniquely "
"identifies this entity in the system"
msgstr ""
"**guid** Un compteur auto-incrémenté qui poduit un GUID qui identifie de "
"manière unique cette entité dans le système"

#: ../../design/database.rst:713
msgid "**type** The type of entity - object, user, group or site"
msgstr "**type** Le type d'entity - object, user, group ou site"

#: ../../design/database.rst:714
msgid "**subtype** A subtype of entity"
msgstr "**subtype** Le sous-type d'entité"

#: ../../design/database.rst:715
msgid "**owner\\_guid** The GUID of the owner's entity"
msgstr "**owner\\_guid** Le GUID de l'entité du propriétaire"

#: ../../design/database.rst:716
msgid ""
"**container\\_guid** The GUID this entity is contained by - either a user or"
" a group"
msgstr ""
"**container\\_guid** Le GUID dans laquelle cette entité est contenue - soit "
"un utilisateur (user) soit un groupe (group)"

#: ../../design/database.rst:717
msgid "**access\\_id** Access controls on this entity"
msgstr "**access\\_id** Contrôles d'accès sur cette entité"

#: ../../design/database.rst:718
msgid "**time\\_created** Unix timestamp of when the entity is created"
msgstr "**time\\_created** Le timestamp Unix de création de l'entité"

#: ../../design/database.rst:719
msgid "**time\\_updated** Unix timestamp of when the entity was updated"
msgstr ""
"**time\\_updated** Le timestamp Unix de la dernière modification de l'entité"

#: ../../design/database.rst:720
msgid ""
"**enabled** If this is 'yes' an entity is accessible, if 'no' the entity has"
" been disabled (Elgg treats it as if it were deleted without actually "
"removing it from the database)"
msgstr ""
"**enabled** Si oui ('yes') l'entité est accessible, si non ('no') l'entité a"
" été désactivée (Elgg traite cela comme si elle avait été supprimée sans "
"toutefois la supprimer réellement de la base de données)"

#: ../../design/database.rst:725
msgid "Table: metadata"
msgstr "Table : metadata"

#: ../../design/database.rst:727
msgid ""
"This table contains `Metadata`_, extra information attached to an entity."
msgstr ""
"Cette table contient des métadonnées `Metadata`_, des informations "
"supplémentaires attachées à une entité."

#: ../../design/database.rst:729 ../../design/database.rst:742
#: ../../design/database.rst:769
msgid "**id** A unique IDentifier"
msgstr "**id** Un IDentifiant unique"

#: ../../design/database.rst:730 ../../design/database.rst:743
msgid "**entity\\_guid** The entity this is attached to"
msgstr "**entity\\_guid** L'entité à laquelle cette métadonnée est attachée"

#: ../../design/database.rst:731 ../../design/database.rst:744
msgid "**name** The name string"
msgstr "**name** Le nom de la chaîne"

#: ../../design/database.rst:732 ../../design/database.rst:745
msgid "**value** The value string"
msgstr "**value** La valeur de la chaîne"

#: ../../design/database.rst:733 ../../design/database.rst:746
msgid "**value\\_type** The value class, either text or an integer"
msgstr ""
"**value\\_type** La classe de la valeur, soit texte (text) ou un entier "
"(integer)"

#: ../../design/database.rst:734
msgid "**time\\_created** Unix timestamp of when the metadata is created"
msgstr ""
"**time\\_created** Le timestamp Unix de la date de création de la métadonnée"

#: ../../design/database.rst:735 ../../design/database.rst:750
msgid ""
"**enabled** If this is 'yes' an item is accessible, if 'no' the item has "
"been disabled"
msgstr ""
"**enabled** Si oui ('yes') l'élément est accessible, si non ('no') l'élément"
" a été désactivé"

#: ../../design/database.rst:738
msgid "Table: annotations"
msgstr "Table : annotations"

#: ../../design/database.rst:740
msgid "This table contains `Annotations`_, this is distinct from `Metadata`_."
msgstr ""
"Cette table contient les `Annotations`_, ce qui est distinct des "
"`Metadata`_."

#: ../../design/database.rst:747
msgid "**owner\\_guid** The owner GUID of the owner who set this annotation"
msgstr "**owner\\_guid** Le GUID du propriétaire qui a défini cette annotation"

#: ../../design/database.rst:748
msgid "**access\\_id** An Access controls on this annotation"
msgstr "**access\\_id** Un Contrôle d'Accès sur cette annotation"

#: ../../design/database.rst:749
msgid "**time\\_created** Unix timestamp of when the annotation is created."
msgstr ""
"**time\\_created** Le timestamp Unix de la date de création de l'annotation."

#: ../../design/database.rst:753
msgid "Table: relationships"
msgstr "Table : relationships (relations)"

#: ../../design/database.rst:755
msgid ""
"This table defines `Relationships`_, these link one entity with another."
msgstr ""
"Cette table définit les `Relationships`_, qui relient une entité avec une "
"autre."

#: ../../design/database.rst:757
msgid "**guid\\_one** The GUID of the subject entity."
msgstr "**guid\\_one** Le GUID de l'entité sujet."

#: ../../design/database.rst:758
msgid "**relationship** The type of the relationship."
msgstr "**relationship** Le type de relation."

#: ../../design/database.rst:759
msgid "**guid\\_two** The GUID of the target entity."
msgstr "**guid\\_two** Le GUID de l'entité cible."

#: ../../design/database.rst:762
msgid "Secundairy tables"
msgstr "Tables secondaires"

#: ../../design/database.rst:765
msgid "Table: access_collections"
msgstr "Table : access_collections"

#: ../../design/database.rst:767
msgid ""
"This table defines Access Collections, which grant users access to "
"`Entities`_ or `Annotations`_."
msgstr ""
"Cette table définit les Collections d'Accès, qui donnent accès aux "
"utilisateurs aux `Entités`_ ou aux `Annotations`_."

#: ../../design/database.rst:770
msgid "***name**  The name of the access collection"
msgstr "***name**  Le nom de la collection d'accès"

#: ../../design/database.rst:771
msgid "**owner_guid** The GUID of the owning entity (eg. a user or a group)"
msgstr ""
"**owner_guid** Le GUID de l'entité propriétaire (par ex. un utilisateur ou "
"un groupe)"

#: ../../design/database.rst:772
msgid ""
"**subtype** the subtype of the access collection (eg. `friends` or "
"`group_acl`)"
msgstr ""
"**subtype** le sous-type de la collection d'accès (par ex. `friends` ou "
"`group_acl`)"

#: ../../design/events.rst:2
msgid "Events and Plugin Hooks"
msgstr "Événements et Hooks des plugins"

#: ../../design/events.rst:11
msgid ""
"Elgg has an event system that can be used to replace or extend core "
"functionality."
msgstr ""
"Elgg a un événement système qui peut être utilisé pour remplacer ou étendre "
"les fonctionnalités du noyau."

#: ../../design/events.rst:14
msgid ""
"Plugins influence the system by creating handlers (`callables "
"<http://php.net/manual/en/language.types.callable.php>`_ such as functions "
"and methods) and registering them to handle two types of events: "
":ref:`design/events#events` and :ref:`design/events#plugin-hooks`."
msgstr ""
"Les plugins influencent le système en créant des gestionnaires ou handlers "
"(`appelables <http://php.net/manual/en/language.types.callable.php>`_ tels "
"que des fonctions et des méthodes) et en les enregistrant pour gérer deux "
"types d'événements : :ref:`design/events#events` et :ref:`design/events"
"#plugin-hooks`."

#: ../../design/events.rst:18
msgid ""
"When an event is triggered, a set of handlers is executed in order of "
"priority. Each handler is passed arguments and has a chance to influence the"
" process. After execution, the \"trigger\" function returns a value based on"
" the behavior of the handlers."
msgstr ""
"Quand un événement est déclenché, un jeu des gestionnaires (handlers) est "
"exécuté par ordre de priorité. Les arguments sont passés à chaque "
"gestionnaire qui peut influencer le processus. Après exécution, la fonction "
"déclencheuse (\"trigger\") retourne une valeur qui dépend du comportement "
"des gestionnaires."

#: ../../design/events.rst:25
msgid ":doc:`/guides/events-list`"
msgstr ":doc:`/guides/events-list`"

#: ../../design/events.rst:26
msgid ":doc:`/guides/hooks-list`"
msgstr ":doc:`/guides/hooks-list`"

#: ../../design/events.rst:29
msgid "Elgg Events vs. Plugin Hooks"
msgstr "Evénements Elgg (Events) vs. Hooks des Plugins"

#: ../../design/events.rst:31
msgid ""
"The main differences between :ref:`design/events#events` and "
":ref:`design/events#plugin-hooks` are:"
msgstr ""
"Les principales différences entre :ref:`design/events#events` et "
":ref:`design/events#plugin-hooks` sont :"

#: ../../design/events.rst:33
msgid ""
"Most Elgg events can be cancelled; unless the event is an \"after\" event, a"
" handler that returns `false` can cancel the event, and no more handlers are"
" called."
msgstr ""
"La majorité des événements Elgg peuvent être annulé ; à moins que "
"l'événement soit un événement \"after\", un gestionnaire qui retourne "
"`false` peut annuler l'événement, et plus aucun autre gestionnaire n'est "
"appelé."

#: ../../design/events.rst:36
msgid "Plugin hooks cannot be cancelled; all handlers are always called."
msgstr ""
"Les hooks plugin ne peuvent pas être annulé ; tous les gestionnaires sont "
"toujours appelés."

#: ../../design/events.rst:37
msgid ""
"Plugin hooks pass an arbitrary value through the handlers, giving each a "
"chance to alter along the way."
msgstr ""
"Les hooks lugin passent une valeur arbitraire à travers les gestionnaires, "
"leur donnant à chacun une chance de la modifier en cours de route."

#: ../../design/events.rst:43
msgid "Elgg Events"
msgstr "Evénements Elgg (Events)"

#: ../../design/events.rst:45
msgid ""
"Elgg Events are triggered when an Elgg object is created, updated, or "
"deleted; and at important milestones while the Elgg framework is loading. "
"Examples: a blog post being created or a user logging in."
msgstr ""
"Les événements Elgg Events sont déclenchés quand un objet Elgg est créé, "
"modifié ou supprimé ; et à différentes étapes importantes du chargement du "
"framework Elgg. Exemples : lors de la création d'un article de blog ou de "
"l'identification d'un utilisateur."

#: ../../design/events.rst:49
msgid ""
"Unlike :ref:`design/events#plugin-hooks`, *most Elgg events can be "
"cancelled*, halting the execution of the handlers, and possibly cancelling "
"an some action in the Elgg core."
msgstr ""
"Contrairement aux :ref:`design/events#plugin-hooks`, *la plupart des "
"événements Elgg peuvent être annulé*, ce qui interrompt l'exécution des "
"gestionnaires, et potentiellement annulent certaines actions dans le noyau "
"d'Elgg."

#: ../../design/events.rst:53
msgid ""
"Each Elgg event has a name and an object type (system, user, object, "
"relationship name, annotation, group) describing the type of object passed "
"to the handlers."
msgstr ""
"Chaque événement Elgg a un nom et un type d'objet (system, user, object, nom"
" de relation, annotation, group) qui décrit le type d'objet passé aux "
"gestionnaires."

#: ../../design/events.rst:60
msgid "Before and After Events"
msgstr "Événements Avant (Before) et Après (After)"

#: ../../design/events.rst:62
msgid ""
"Some events are split into \"before\" and \"after\". This avoids confusion "
"around the state of the system while in flux. E.g. Is the user logged in "
"during the [login, user] event?"
msgstr ""
"Certains événements sont séparés en \"before\" (avant) et \"after\" (après)."
" Ceci évite la confusion autour de l'état fluctuant du système. Par ex. Est-"
"ce que l'utilisateur est identifié au cours de l'événement [login, user]?"

#: ../../design/events.rst:66
msgid ""
"Before Events have names ending in \":before\" and are triggered before "
"something happens. Like traditional events, handlers can cancel the event by"
" returning ``false``."
msgstr ""
"Les événements Avant ont des noms qui se terminent par \":before\" et sont "
"exécutés avant qu'il ne se passe quelque chose. Comme pour les événements "
"traditionnels, les gestionnaires peuvent annuler l'événement en retournant "
"``false``."

#: ../../design/events.rst:70
msgid ""
"After Events, with names ending in \":after\", are triggered after something"
" happens. Unlike traditional events, handlers *cannot* cancel these events; "
"all handlers will always be called."
msgstr ""
"Les événements Après, avec des noms qui se terminent par \":after\", sont "
"exécutés après qu'il se soit passé quelque chose. Au contraire des "
"événements traditionnels, ces gestionnaires *ne peuvent pas* annuler ces "
"événements ; tous les gestionnaires seront toujours appelés."

#: ../../design/events.rst:74
msgid ""
"Where before and after events are available, developers are encouraged to "
"transition to them, though older events will be supported for backwards "
"compatibility."
msgstr ""
"Là où des événements :before et :after sont disponibles, les développeurs "
"sont encouragés à faire la transition vers eux, même si d'anciens événements"
" resteront supportés pour des raisons de compatibilité descendante."

#: ../../design/events.rst:79
msgid "Elgg Event Handlers"
msgstr "Gestionnaires d'événement Elgg (Event Handlers)"

#: ../../design/events.rst:81
msgid ""
"Elgg event handlers are callables with one of the following prototypes:"
msgstr ""
"Les gestionnaires d'événement Elgg sont appelables avec l'un des prototypes "
"suivants :"

#: ../../design/events.rst:107
msgid ""
"In ``event_handler1``, the ``Event`` object has various methods for getting "
"the name, object type, and object of the event. See the ``Elgg\\Event`` "
"interface for details."
msgstr ""
"Dans ``event_handler1``, l'objet ``Event`` a diverses méthodes pour "
"récupérer le nom, le type d'objet, et l'objet de l'événement. Voyez "
"l'interface ``Elgg\\Event`` pour plus de détails."

#: ../../design/events.rst:110
msgid ""
"In both cases, if a handler returns ``false``, the event is cancelled, "
"preventing execution of the other handlers. All other return values are "
"ignored."
msgstr ""
"Dans tous les cas, si un gestionnaire retourne ``false``, l'événement est "
"annulé, ce qui empêche l'exécution des autres gestionnaires. Toutes les "
"autres valeurs de retour sont ignorées."

#: ../../design/events.rst:113
msgid ""
"If the event type is \"object\" or \"user\", use type hint "
"``\\Elgg\\ObjectEvent`` or ``\\Elgg\\UserEvent`` instead, which clarify the "
"return type of the ``getObject()`` method."
msgstr ""
"Si le type d'événement est \"object\" ou \"user\", utilisez le type de "
"données ``\\Elgg\\ObjectEvent`` ou ``\\Elgg\\UserEvent`` à la place, ce qui "
"clarifie le type de retour de la méthode ``getObject()``."

#: ../../design/events.rst:116
msgid "Register to handle an Elgg Event"
msgstr "Enregistrez un gestionnaire d'événement (Elgg Event)"

#: ../../design/events.rst:118
msgid ""
"Register your handler to an event using ``elgg_register_event_handler``:"
msgstr ""
"Enregistrez votre gestionnaire pour un événement en utilisant "
"``elgg_register_event_handler`` :"

#: ../../design/events.rst:126 ../../design/events.rst:205
#: ../../design/events.rst:232 ../../design/events.rst:301
#: ../../design/events.rst:333
msgid "Parameters:"
msgstr "Paramètres :"

#: ../../design/events.rst:128 ../../design/events.rst:207
#: ../../design/events.rst:234
msgid "**$event** The event name."
msgstr "**$event** Le nom de l'événement."

#: ../../design/events.rst:129
msgid ""
"**$object_type** The object type (e.g. \"user\" or \"object\") or 'all' for "
"all types on which the event is fired."
msgstr ""
"**$object_type** Le type d'objet (par ex. \"user\" ou \"object\") ou 'all' "
"pour tous les types pour lesquels l'événement est déclenché."

#: ../../design/events.rst:131 ../../design/events.rst:305
msgid "**$handler** The callback of the handler function."
msgstr "**$handler** Le callback ou la fonction gestionnaire."

#: ../../design/events.rst:132 ../../design/events.rst:306
msgid "**$priority** The priority - 0 is first and the default is 500."
msgstr ""
"**$priority** La priorité - 0 en premier et la valeur par défaut est 500."

#: ../../design/events.rst:134
msgid ""
"**Object** here does not refer to an ``ElggObject`` but rather a string "
"describing any object in the framework: system, user, object, relationship, "
"annotation, group."
msgstr ""
"**Objet** ne fait pas ici référence à un ``ElggObject`` mais plutôt à une "
"chaîne de caractères qui décrit n'importe quel objet dans le framework : le "
"système, un utilisateur, un objet, une relation, une annotation, un groupe."

#: ../../design/events.rst:137 ../../design/events.rst:311
msgid "Example:"
msgstr "Exemple :"

#: ../../design/events.rst:149
msgid ""
"If you handle the \"update\" event on an object, avoid calling ``save()`` in"
" your event handler. For one it's probably not necessary as the object is "
"saved after the event completes, but also because ``save()`` calls another "
"\"update\" event and makes ``$object->getOriginalAttributes()`` no longer "
"available."
msgstr ""
"Si vous gérez l'événement \"update\" d'un objet, évitez d'appeler ``save()``"
" dans votre gestionnaire d'événement. Tout d'abord ce n'est probablement pas"
" nécessaire car l'objet est enregistré après que l'événement soit terminé, "
"mais aussi parce que ``save()`` appelle un autre événement \"update\" et ne "
"rend plus disponible ``$object->getOriginalAttributes()``."

#: ../../design/events.rst:154
msgid "Invokable classes as handlers"
msgstr "Classes invocables comme gestionnaires"

#: ../../design/events.rst:156
msgid ""
"You may use a class with an ``__invoke()`` method as a handler. Just "
"register the class name and it will be instantiated (with no arguments) for "
"the lifetime of the event (or hook)."
msgstr ""
"Vous pouvez utiliser une classe avec une méthode ``__invoke()`` comme "
"gestionnaire. Enregistrez simplement le nom de la classe et elle sera "
"instanciée (sans argument) pour toute la durée de vie de l'événement (ou du "
"hook)."

#: ../../design/events.rst:175
msgid "Trigger an Elgg Event"
msgstr "Déclencher un événement (Elgg Event)"

#: ../../design/events.rst:177
msgid "You can trigger a custom Elgg event using ``elgg_trigger_event``:"
msgstr ""
"Vous pouvez déclencher un événement personnalisé en utilisant "
"``elgg_trigger_event`` :"

#: ../../design/events.rst:189
msgid ""
"For events with ambiguous states, like logging in a user, you should use "
":ref:`before-after` by calling ``elgg_trigger_before_event`` or "
"``elgg_trigger_after_event``. This makes it clear for the event handler what"
" state to expect and which events can be cancelled."
msgstr ""
"Pour les événements avec des états ambigus, tels que l'identification d'un "
"utilisateur, vous devriez utiliser :ref:`before-after` en appelant "
"``elgg_trigger_before_event`` ou ``elgg_trigger_after_event``. Ceci clarifie"
" pour le gestionnaire d'événement l'état auquel attendre et quels événements"
" peuvent être annulés."

#: ../../design/events.rst:208 ../../design/events.rst:235
msgid "**$object_type** The object type (e.g. \"user\" or \"object\")."
msgstr "**$object_type** Le type d'objet (par ex. \"user\" ou \"object\")."

#: ../../design/events.rst:209 ../../design/events.rst:236
msgid ""
"**$object** The object (e.g. an instance of ``ElggUser`` or ``ElggGroup``)"
msgstr ""
"**$object** L'objet (par ex. une instance de ``ElggUser`` ou ``ElggGroup``)"

#: ../../design/events.rst:211
msgid ""
"The function will return ``false`` if any of the selected handlers returned "
"``false`` and the event is stoppable, otherwise it will return ``true``."
msgstr ""
"La fonction va retourner ``false`` si n'importe lequel des gestionnaires "
"sélectionnés retourne ``false`` et si l'événement est interruptible, sinon "
"elle retournera ``true``."

#: ../../design/events.rst:217
msgid "Trigger an Elgg Event sequence"
msgstr "Déclenche une séquence Elgg Event"

#: ../../design/events.rst:219
msgid ""
"Instead of triggering the ``:before`` and ``:after`` event manually, it's "
"possible to trigger an event sequence. This will trigger the ``:before`` "
"event, then the actual event and finally the ``:after`` event."
msgstr ""
"Au lieu de déclencher manuellement l’événement ``:before`` et ``after``, il "
"est possible de déclencher une séquence d’événements. Cela déclenchera "
"l’événement ``:before``, puis l’événement réel et enfin l’événement "
"``:after``."

#: ../../design/events.rst:226
msgid ""
"When called with for example ``'cache:clear', 'system'`` the following three"
" events are triggered"
msgstr ""
"When called with for example ``'cache:clear', 'system'`` the following three"
" events are triggered"

#: ../../design/events.rst:228
msgid "``'cache:clear:before', 'system'``"
msgstr "``'cache:clear:before', 'system'``"

#: ../../design/events.rst:229
msgid "``'cache:clear', 'system'``"
msgstr "``'cache:clear', 'system'``"

#: ../../design/events.rst:230
msgid "``'cache:clear:after', 'system'``"
msgstr "``'cache:clear:after', 'system'``"

#: ../../design/events.rst:237
msgid "**$callable** Callable to run on successful event, before event:after"
msgstr ""
"**$callable** Appelable pour exécuter sur l’événement réussi, avant "
"event:after"

#: ../../design/events.rst:242
msgid "Plugin Hooks"
msgstr "Hooks des plugins"

#: ../../design/events.rst:244
msgid ""
"Plugin Hooks provide a way for plugins to collaboratively determine or alter"
" a value. For example, to decide whether a user has permission to edit an "
"entity or to add additional configuration options to a plugin."
msgstr ""
"Les Hooks Plugin fournissent un moyen pour les plugins de déterminer ou de "
"modifier collaborativement une valeur. Par exemple, pour décider si un "
"utilisateur a la permission de modifier une entité ou d'ajouter des options "
"de configurations supplémentaires à un plugin."

#: ../../design/events.rst:248
msgid ""
"A plugin hook has a value passed into the trigger function, and each handler"
" has an opportunity to alter the value before it's passed to the next "
"handler. After the last handler has completed, the final value is returned "
"by the trigger."
msgstr ""
"Un hook plugin a une valeur passée à la fonction déclencheuse (\"trigger\"),"
" et chaque gestionnaire a la possibilité de modifier cette valeur avant "
"qu'elle soit passée au prochain gestionnaire. Après que le dernier "
"gestionnaire a été exécuté, la valeur finale est retournée par le trigger."

#: ../../design/events.rst:254
msgid "Plugin Hook Handlers"
msgstr "Gestionnaires des Hooks plugin"

#: ../../design/events.rst:256
msgid "Hook handlers are callables with one of the following prototypes:"
msgstr ""
"Les gestionnaires de hooks sont appelables avec l'un des prototypes suivants"
" :"

#: ../../design/events.rst:283
msgid ""
"In ``plugin_hook_handler1``, the ``Hook`` object has various methods for "
"getting the name, type, value, and parameters of the hook. See the "
"``Elgg\\Hook`` interface for details."
msgstr ""
"Dans ``plugin_hook_handler1``, l'objet ``Hook`` a diverses méthodes pour "
"récupérer le nom, le type, la valeur et les paramètres du hook. Voyez "
"l'interface ``Elgg\\Hook`` pour plus de détails."

#: ../../design/events.rst:286
msgid ""
"In both cases, if the handler returns no value (or ``null`` explicitly), the"
" plugin hook value is not altered. Otherwise the returned value becomes the "
"new value of the plugin hook, and it will then be available as "
"``$hook->getValue()`` (or ``$value``) in the next handler."
msgstr ""
"Dans les deux cas, si le gestionnaire ne retourne aucune valeur (ou "
"explicitement la valeur ``null``), la valeur du hook plugin n'est pas "
"modifiée. Dans le cas contraire, la valeur retournée devient la nouvelle "
"valeur du hook plugin, et il deviendra alors disponible via "
"``$hook->getValue()`` (ou ``$value``) dans le prochain gestionnaire."

#: ../../design/events.rst:291
msgid "Register to handle a Plugin Hook"
msgstr "Enregistrez un gestionnaire de Hook plugin"

#: ../../design/events.rst:293
msgid ""
"Register your handler to a plugin hook using "
"``elgg_register_plugin_hook_handler``:"
msgstr ""
"Enregistrez votre gestionnaire pour un hook plugin en utilisant "
"``elgg_register_plugin_hook_handler`` :"

#: ../../design/events.rst:303 ../../design/events.rst:335
msgid "**$hook** The name of the plugin hook."
msgstr "**$hook** Le nom du hook plugin."

#: ../../design/events.rst:304 ../../design/events.rst:336
msgid "**$type** The type of the hook or 'all' for all types."
msgstr "**$type** Le type de hook, ou 'all' pour tous les types."

#: ../../design/events.rst:308
msgid ""
"**Type** can vary in meaning. It may mean an Elgg entity type or something "
"specific to the plugin hook name."
msgstr ""
"**Type** peut avoir des sens différents. Cela peut signifier un type "
"d'entité Elgg ou quelque chose de spécifique au nom du hook plugin."

#: ../../design/events.rst:322
msgid "Trigger a Plugin Hook"
msgstr "Déclencher un Hook plugin"

#: ../../design/events.rst:324
msgid ""
"You can trigger a custom plugin hook using ``elgg_trigger_plugin_hook``:"
msgstr ""
"Vous pouvez déclencher un plugin hook personnalisé en utilisant "
"``elgg_trigger_plugin_hook`` :"

#: ../../design/events.rst:337
msgid "**$params** Arbitrary data passed from the trigger to the handlers."
msgstr ""
"**$params** Des données arbitraires passées par le déclencheur aux "
"gestionnaires."

#: ../../design/events.rst:338
msgid "**$value** The initial value of the plugin hook."
msgstr "**$value** La valeur initiale du hook plugin."

#: ../../design/events.rst:340
msgid ""
"The `$params` and `$value` arguments are reversed between the plugin hook "
"handlers and trigger functions!"
msgstr ""
"Les arguments `$params` et `$value` sont inversés entre les gestionnaires de"
" hook plugin et les focntions de déclenchement !"

#: ../../design/events.rst:344
msgid "Unregister Event/Hook Handlers"
msgstr "Dé-enregistrer des gestionnaires d'événement ou de hook"

#: ../../design/events.rst:346
msgid ""
"The functions ``elgg_unregister_event_handler`` and "
"``elgg_unregister_plugin_hook_handler`` can be used to remove handlers "
"already registered by another plugin or Elgg core. The parameters are in the"
" same order as the registration functions, except there's no priority "
"parameter."
msgstr ""
"Les fonctions ``elgg_unregister_event_handler`` et "
"``elgg_unregister_plugin_hook_handler`` peuvent être utilisées pour retirer "
"des gestionnaires déjà enregistrés par un autre plugin ou le noyau d'Elgg. "
"Les paramètres sont dans le même ordre que pour les fonctions "
"d'enregistrement, excepté qu'il n'y a pas de paramètre de priorité."

#: ../../design/events.rst:356
msgid ""
"Anonymous functions or invokable objects cannot be unregistered, but dynamic"
" method callbacks can be unregistered by giving the static version of the "
"callback:"
msgstr ""
"Les fonctions anonymes ou les objets invocables ne peuvent pas être "
"enregistrés, mais des fonctions de rappel (callback) de méthode dynamique "
"peuvent être dé-enregistrés en donnant la version statique de la fonction de"
" rappel :"

#: ../../design/events.rst:370
msgid ""
"Even though the event handler references a dynamic method call, the code "
"above will successfully remove the handler."
msgstr ""
"Même si le gestionnaire d'événement référence un appel à une méthode "
"dynamique, le code ci-dessus va bien supprimer le gesitonnaire."

#: ../../design/events.rst:374
msgid "Handler Calling Order"
msgstr "Ordre d'appel des gestionnaires"

#: ../../design/events.rst:376
msgid ""
"Handlers are called first in order of priority, then registration order."
msgstr ""
"Les gestionnaires sont d'abord appelés par ordre de priorité, puis par ordre"
" d'enregistrement."

#: ../../design/events.rst:380
msgid ""
"Before Elgg 2.0, registering with the ``all`` keywords caused handlers to be"
" called later, even if they were registered with lower priorities."
msgstr ""
"Avant Elgg 2.0, l'enregistrement avec le mot-clef ``all`` provoquait un "
"appel tardif des gestionnaires, même s'ils avaient été enregistrés avec des "
"priorités plus faibles."

#: ../../design/i18n.rst:2
msgid "Internationalization"
msgstr "Internationalisation"

#: ../../design/i18n.rst:4
msgid ""
"Elgg 1.0+ departs from previous versions in that it uses a custom text array"
" rather than gettext. This improves system performance and reliability of "
"the translation system."
msgstr ""
"Elgg 1.0 et supérieur diffèrent des versions précédentes dans le sens où ces"
" versions utilisent un tableau de valeur texte personnalisé plutôt que "
"gettext. Ceci améliore la performance du système et la fiabilité du système "
"de traduction."

#: ../../design/i18n.rst:7
msgid "TODO: more plz"
msgstr "TODO : plus svp"

#: ../../design/index.rst:2
msgid "Design Docs"
msgstr "Docs de conception"

#: ../../design/index.rst:4
msgid ""
"Gain a deep understanding of how Elgg works and why it's built the way it "
"is."
msgstr ""
"Acquérez une compréhension profonde de comment fonctionne Elgg et de "
"pourquoi il est construit de cette manière."

#: ../../design/loggable.rst:2
msgid "Loggable"
msgstr "Loggable"

#: ../../design/loggable.rst:4
msgid ""
"Loggable is an interface inherited by any class that wants events relating "
"to its member objects to be saved to the system log. ``ElggEntity`` and "
"``ElggExtender`` both inherit ``Loggable``."
msgstr ""
"Loggable iest une interface héritée par toute classe qui veut que les "
"événements liés à ses objets membres soient enregistrés dans le journal "
"système. ``ElggEntity`` et ``ElggExtender`` héritent tous deux de "
"``Loggable``."

#: ../../design/loggable.rst:6
msgid ""
"Loggable defines several class methods that are used in saving to the "
"default system log, and can be used to define your own (as well as for other"
" purposes):"
msgstr ""
"Loggable définit plusieurs méthodes de classe qui sont utilisées pour "
"l'enregistrement du journal système par défaut, et peuvent être utilisées "
"pour définir vos propres journaux (ainsi que pour d'autres objectifs) :"

#: ../../design/loggable.rst:8
msgid ""
"``getSystemLogID()`` Return a unique identifier for the object for storage "
"in the system log. This is likely to be the object's GUID"
msgstr ""
"``getSystemLogID()`` Retourne un identifiant unique pour l'objet à des fins "
"de conservation dans le journal système. C'est généralement le GUID de "
"l'objet"

#: ../../design/loggable.rst:9
msgid "``getClassName()`` Return the class name of the object"
msgstr "``getClassName()`` Retourne le nom de la classe de l'objet"

#: ../../design/loggable.rst:10
msgid "``getType()`` Return the object type"
msgstr "``getType()`` Retournr le type d'objet"

#: ../../design/loggable.rst:11
msgid "``getSubtype()`` Get the object subtype"
msgstr "``getSubtype()`` Récupère le sous-type de l'objet"

#: ../../design/loggable.rst:12
msgid ""
"``getObjectFromID($id)`` For a given ID, return the object associated with "
"it"
msgstr ""
"``getObjectFromID($id)`` Pour un ID donné, retourne l'objet qui lui est "
"associé"

#: ../../design/loggable.rst:15
msgid "Database details"
msgstr "Détails de la base de données"

#: ../../design/loggable.rst:17
msgid ""
"The default system log is stored in the ``system_log`` :doc:`database table "
"<database>`. It contains the following fields:"
msgstr ""
"Le journal système par défaut est enregistré dans la table ``system_log`` de"
" la :doc:`base de données <database>`. Il contient les champs suivants :"

#: ../../design/loggable.rst:19
msgid "**id** - A unique numeric row ID"
msgstr "**id** - Un identifiant numérique unique de la ligne"

#: ../../design/loggable.rst:20
msgid "**object_id** - The GUID of the entity being acted upon"
msgstr ""
"**object_id** - Le GUID de l'entité sur laquelle l'action est effectuée"

#: ../../design/loggable.rst:21
msgid ""
"**object_class** - The class of the entity being acted upon (eg ElggObject)"
msgstr ""
"**object_class** - La classe de l'entitésur laquelle l'action est effectuée "
"(par ex. ElggObject)"

#: ../../design/loggable.rst:22
msgid "**object_type** - The type of the entity being acted upon (eg object)"
msgstr ""
"**object_type** - Le type d'entité sur laquelle l'action est effectuée (par "
"ex. object)"

#: ../../design/loggable.rst:23
msgid ""
"**object_subtype** - The subtype of the entity being acted upon (eg blog)"
msgstr ""
"**object_subtype** - Le sous-type d'entité sur laquelle l'action est "
"effectuée (par ex. blog)"

#: ../../design/loggable.rst:24
msgid "**event** - The event being logged (eg create or update)"
msgstr "**event** - L'événement enregistré (par ex. create ou update)"

#: ../../design/loggable.rst:25
msgid ""
"**performed_by_guid** - The GUID of the acting entity (the user performing "
"the action)"
msgstr ""
"**performed_by_guid** - Le GUID de l'entité agissante (l'utilisateur qui "
"réalise l'action)"

#: ../../design/loggable.rst:26
msgid ""
"**owner_guid** - The GUID of the user which owns the entity being acted upon"
msgstr ""
"**owner_guid** - Le GUID de l'utilisateur à qui appartient l'entité sur "
"laquelle l'action est effectuée"

#: ../../design/loggable.rst:27
msgid "**access_id** - The access restriction associated with this log entry"
msgstr ""
"**access_id** - Le niveau d'accès associé avec cette entrée de journal"

#: ../../design/loggable.rst:28
msgid ""
"**time_created** - The UNIX epoch timestamp of the time the event took place"
msgstr "**time_created** - Le timestamp UNIX de la date de l'événement"

#: ../../design/security.rst:2
msgid "Security"
msgstr "Sécurité"

#: ../../design/security.rst:4
msgid ""
"Elgg's approach to the various security issues common to all web "
"applications."
msgstr ""
"L'approche d'Elgg pour les diverses questions de sécurité est commune à "
"toutes les applications web."

#: ../../design/security.rst:8
msgid "To report a potential vulnerability in Elgg, email security@elgg.org."
msgstr ""
"Pour signaler une vulnérabilité potentielle dans Elgg, envoyez un email à "
"security@elgg.org."

#: ../../design/security.rst:15
msgid "Passwords"
msgstr "Mots de passe"

#: ../../design/security.rst:18
msgid "Password validation"
msgstr "Validation du mot de passe"

#: ../../design/security.rst:20
msgid ""
"The only restriction that Elgg places on a password is that it must be at "
"least 6 characters long by default, though this may be changed in ``/elgg-"
"config/settings.php``. Additional criteria can be added by a plugin by "
"registering for the ``registeruser:validate:password`` plugin hook."
msgstr ""
"La seule restriction qu'Elgg impose sur le mot de passe est qu'il doit "
"comporter au moins 6 caractères par défaut, quoique ceci puisse être changé "
"dans ``/elgg-config/settings.php``. Des critères additionnels peuvent être "
"ajoutés en enregistrant un plugin hook pour "
"``registeruser:validate:password``."

#: ../../design/security.rst:25
msgid "Password hashing"
msgstr "Hachage du mot de passe"

#: ../../design/security.rst:27
msgid ""
"Passwords are never stored in plain text, only salted hashes produced with "
"bcrypt. This is done via the standard ``password_hash()`` function. On older"
" systems, the ``password-compat`` polyfill is used, but the algorithm is "
"identical."
msgstr ""
"Les mots de passe ne sont jamais stockés en clair, seulement sous forme de "
"valeur de hachage avec sel produit par bcrypt. Ceci est effectué via la "
"fonction standard ``password_hash()``. Sur des systèmes plus anciens, le "
"polyfill ``password-compat`` est utilisé, mais l'algorithme est identique."

#: ../../design/security.rst:30
msgid ""
"Elgg installations created before version 1.10 may have residual \"legacy\" "
"password hashes created using salted MD5. These are migrated to bcrypt as "
"users log in, and will be completely removed when a system is upgraded to "
"Elgg 3.0. In the meantime we're happy to assist site owners to manually "
"remove these legacy hashes, though it would force those users to reset their"
" passwords."
msgstr ""
"Les installations Elgg créées avant la version peuvent avoir des chaînes de "
"hachage de mot de passe \"historiques\" résiduelles créées en utilisant MD5 "
"avec sel. Elles ont été migrées vers bcrypt lorsque les utilisateurs se "
"connectent, et seront totalement retirées lorsque le système est mis à "
"niveau vers Elgg 3.0. Dans le même temps, nous sommes heureux d'assister les"
" propriétaires de sites à retirer manuellement ces chaînes de hachage "
"historique, même si cela force ces utilisateurs à réinitialiser leur mot de "
"passe."

#: ../../design/security.rst:35
msgid "Password throttling"
msgstr "Mitigation du mot de passe"

#: ../../design/security.rst:37
msgid ""
"Elgg has a password throttling mechanism to make dictionary attacks from the"
" outside very difficult. A user is only allowed 5 login attempts over a 5 "
"minute period."
msgstr ""
"Elgg a un mécanisme de mitigation des mots de passe qui rend les attaques "
"par dictionnaire depuis l'extérieur très difficiles. Un utilisateur n'est "
"autorisé qu'à 5 tentatives de connexion par période de 5 minutes."

#: ../../design/security.rst:41
msgid "Password resetting"
msgstr "Réinitialisation du mot de passe"

#: ../../design/security.rst:43
msgid ""
"If a user forgets his password, a new random password can be requested. "
"After the request, an email is sent with a unique URL. When the user visits "
"that URL, a new random password is sent to the user through email."
msgstr ""
"Si un utilisateur oublie son mot de passe, la génération d'un nouveau mot de"
" passe aléatoire peut être demandée. Après la demande, un email est envoyé "
"avec une URL unique. Quand l'utilisateur visite cette URL, un nouveau mot de"
" passe est envoyé par email à l'utilisateur."

#: ../../design/security.rst:47
msgid "Sessions"
msgstr "Sessions"

#: ../../design/security.rst:49
msgid ""
"Elgg uses PHP's session handling with custom handlers. Session data is "
"stored in the database. The session cookie contains the session id that "
"links the user to the browser. The user's metadata is stored in the session "
"including GUID, username, email address."
msgstr ""
"Elgg utilise la gestion des session PHP avec des gestionnaires "
"personnalisés. Les données de sessions sont stockées dans la base de "
"données. Le cookie de session contient l'id de session qui lie l’utilisateur"
" au navigateur. Les métadonnées de l'utilisateur sont conservées dans la "
"session, notamment le GUID, le nom d'utilisateur et l'adresse email."

#: ../../design/security.rst:52
msgid ""
"The session's lifetime is controlled through the server's PHP configuration "
"and additionally through options in the ``/elgg-config/settings.php``."
msgstr ""
"La durée de vie de la session est contrôlée par la configuraiton PHP du "
"serveur et additionnellement à travers les options dans le fichier ``/elgg-"
"config/settings.php``."

#: ../../design/security.rst:55
msgid "Session fixation"
msgstr "Fixation de session"

#: ../../design/security.rst:57
msgid ""
"Elgg protects against session fixation by regenerating the session id when a"
" user logs in."
msgstr ""
"Elgg protège contre la fixation de session en régénérant l'id de session "
"lorsqu'un utilisateur se déconnecte."

#: ../../design/security.rst:60
msgid "\"Remember me\" cookie"
msgstr "Cookie \"Se souvenir de moi\""

#: ../../design/security.rst:62
msgid ""
"To allow users to stay logged in for a longer period of time regardless of "
"whether the browser has been closed, Elgg uses a cookie (default called "
"``elggperm``) that contains what could be considered a super session "
"identifier. This identifier is stored in a cookies table. When a session is "
"being initiated, Elgg checks for the presence of the ``elggperm`` cookie. If"
" it exists and the session code in the cookie matches the code in the "
"cookies table, the corresponding user is automatically logged in."
msgstr ""
"Afin de permettre aux utilisateurs de rester identifiés pour une période "
"plus longue que le navigateur ait été fermé ou pas, Elgg utilise un cookie "
"(nommé par défaut ``elggperm``) qui contient ce qui peut être considéré "
"comme un super identifiant de session. Cet identifiant est conservé dans la "
"tabel des cookies. Quand une session est initiée, Elgg vérifie la présence "
"du cookie ``elggperm``. S'il existe et que le code de session dans le cookie"
" correspond au code dans la table des cookies, l'utilisateur correspondant "
"est automatiquement connecté."

#: ../../design/security.rst:67
msgid ""
"When a user changes their password all existing permanent cookie codes are "
"removed from the database."
msgstr ""
"Lorsqu'un utilisateur change son mot de passe tous les cookies permanents "
"sont supprimés de la base de données."

#: ../../design/security.rst:69
msgid ""
"The lifetime of the persistent cookie can be controlled in the `/elgg-"
"config/settings.php` file. The default lifetime is 30 days. The database "
"records for the persistent cookies will be removed after the lifetime "
"expired."
msgstr ""
"La durée de vie des cookies persistants peut être contrôlée dans le fichier "
"`/elgg-config/settings.php`. La durée de vie par défaut est de 30 jours. Les"
" entrées de la base de données pour les cookies persistants seront "
"supprimées après l'expiration de la durée de vie."

#: ../../design/security.rst:73
msgid "Alternative authentication"
msgstr "Authentification alternative"

#: ../../design/security.rst:75
msgid "This section is very hand-wavy"
msgstr "Cette section est très lacunaire"

#: ../../design/security.rst:77
msgid ""
"To replace Elgg's default user authentication system, a plugin could replace"
" the default ``login`` action with its own. Better would be to register a "
"PAM handler using ``register_pam_handler()`` which handles the "
"authentication of the user based on the new requirements."
msgstr ""
"Pour remplacer le système d'authentification par défaut des utilisateurs "
"d'Elgg, un plugin pourrait remplacer l'action par défaut ``login`` par sa "
"propre action. Une meilleure alternative est d'enregistrer un gestionnaire "
"d'authentification (PAM) en utilisant ``register_pam_handler()`` qui gère "
"l'authentification des utilisateurs sur la base de nouvelles exigences."

#: ../../design/security.rst:81
msgid "HTTPS"
msgstr "HTTPS"

#: ../../design/security.rst:83
msgid ""
"You must enable SSL support on your server for any of these techniques to "
"work."
msgstr ""
"Vous devez activer le support de SSL sur votre serveur pour que chacune de "
"ces techniques fonctionne."

#: ../../design/security.rst:85
msgid ""
"You can serve your whole site over SSL by changing the site URL to include "
"\"https\" instead of just \"http\"."
msgstr ""
"Vous pouvez servir l'ensemble de votre site par SSL en changeant l'URL du "
"site pour inclure \"https\" au lieu de seulement \"http\"."

#: ../../design/security.rst:88
msgid "XSS"
msgstr "XSS"

#: ../../design/security.rst:90
msgid ""
"Filtering is used in Elgg to make XSS attacks more difficult. The purpose of"
" the filtering is to remove Javascript and other dangerous input from users."
msgstr ""
"Le filtrage est utilisé dans Elgg pour rendre les attaques XSS plus "
"difficiles. L'objectif du filtrage est de supprimer les JavaScript et autres"
" saisies dangereuses des utilisateurs."

#: ../../design/security.rst:93
msgid ""
"Filtering is performed through the function ``filter_tags()``. This function"
" takes in a string and returns a filtered string. It triggers a ``validate, "
"input`` plugin hook."
msgstr ""
"Le filtrage est assuré à travers la fonction ``filter_tags()``. Cette "
"fonction prend une chaîne de caractères et retourne une chaîne filtrée. Elle"
" déclenche le hook plugin ``validate, input``."

#: ../../design/security.rst:96
msgid ""
"By default Elgg comes with the htmLawed filtering code. Developers can drop "
"in any additional or replacement filtering code as a plugin."
msgstr ""
"Par défaut Elgg est fourni avec le code de filtrage htmLawed. Les "
"développeurs peuvent ajouter n'importe quel code additionnel ou de "
"remplacement sous forme de plugin."

#: ../../design/security.rst:98
msgid ""
"The ``filter_tags()`` function is called on any user input as long as the "
"input is obtained through a call to ``get_input()``. If for some reason a "
"developer did not want to perform the default filtering on some user input, "
"the ``get_input()`` function has a parameter for turning off filtering."
msgstr ""
"La fonction ``filter_tags()`` est appelée pour chaque saisie utilisateur dès"
" lors que la saisie est obtenue à travers un appel à ``get_input()``. Si "
"pour quelque raison un développeur souhaite ne pas appliquer le filtrage par"
" défaut sur certaines saisies utilisateur, la fonction ``get_input()`` a un "
"paramètre pour désactiver le filtrage."

#: ../../design/security.rst:102
msgid "CSRF / XSRF"
msgstr "CSRF / XSRF"

#: ../../design/security.rst:104
msgid ""
"Elgg generates security tokens to prevent `cross-site request forgery`_. "
"These are embedded in all forms and state-modifying AJAX requests as long as"
" the correct API is used. Read more in the :doc:`/guides/actions` developer "
"guide."
msgstr ""
"Elgg génère des jetons de sécurité pour empêcher `la contrefaçon de requêtes"
" inter-sites`_. Ceux-ci sont intégrés dans tous les formulaires et les "
"requêtes AJAX modificatrices d'état dès lors que la bonne API est utilisée. "
"Lisez-en plus dans le guide de développement :doc:`/guides/actions`."

#: ../../design/security.rst:108
msgid "Signed URLs"
msgstr "URLs signées"

#: ../../design/security.rst:110
msgid ""
"It's possible to protect URLs with a unique signature. Read more in the "
":doc:`/guides/actions` developer guide."
msgstr ""
"Il est possible de protéger les URLs avec une signature unique. Lisez-en "
"plus dans le the :doc:`/guides/actions` Guide de dévelopement."

#: ../../design/security.rst:113
msgid "SQL Injection"
msgstr "Injection SQL"

#: ../../design/security.rst:115
msgid ""
"Elgg's API sanitizes all input before issuing DB queries. Read more in the "
":doc:`/design/database` design doc."
msgstr ""
"L'API d'Elgg's assainit toutes les entrées avant d'effectuer des requêtes en"
" base de données. Lisez-en plus dans la documentation de design "
":doc:`/design/database`."

#: ../../design/security.rst:118
msgid "Privacy"
msgstr "Vie privée"

#: ../../design/security.rst:120
msgid ""
"Elgg uses an ACL system to control which users have access to various pieces"
" of content. Read more in the :doc:`/design/database` design doc."
msgstr ""
"Elgg utilise un système d'ACL pour contrôler quels utilisateurs ont accès à "
"divers éléments de contenu. Lisez-en plus dans la :doc:`/design/database` "
"documentation de design."

#: ../../design/security.rst:125
msgid "Hardening"
msgstr "Sécurisation"

#: ../../design/security.rst:127
msgid ""
"Site administrators can configure settings which will help with hardening "
"the website. Read more in the Administrator guide :doc:`/admin/security`."
msgstr ""
"Les administrateurs du site peuvent configurer les paramètres qui vont aider"
" à sécuriser le site. Lisez-en plus dans le Guide d'administration "
":doc:`/admin/security`."