- ZnetDK
- Téléchargements
- Installation
- Premiers pas
- Aller plus loin
- Doc de référence
- Forum de discussion
- Roadmap
- Prestations
- Me contacter
ZnetDK intègre une API simplifiant la communication entre le navigateur et le serveur web et offrant des services techniques de haut niveau qui contribuent à réduire le temps de développement de votre application.
Cette API est divisée en 2 grandes familles :
- L'API Serveur en langage PHP : elle est constituée de classes de services, de classes abstraites et de classes d'interface utilisées principalement pour coder la logique métier dans les contrôleurs applicatifs développés spécfiquement pour les besoins de votre activité.
- Constantes
ZnetDK
- Interface
\iMenu
- Classe
\AppController
- Classe
\AsyncExec
- Classe
\Convert
- Classe
\DAO
- Classe
\Database
- Classe
\General
- Classe
\Layout
- Classe
\MenuManager
- Classe
\Request
- Classe
\Response
- Classe
\SimpleDAO
- Classe
\UserSession
- Classe
\Validator
- Classe
\controller\Users
- Classe
\zdkmail\mod\Email
- Constantes
- L'API Client en langage JavaScript : elle est constituée de méthodes de services regroupées dans un objet unique
znetdk
faisant office d'espace de nom. Elle simplifie en particulier les appels AJAX émis en réponse aux actions utilisateurs et adressés aux contrôleurs applicatifs codés en PHP côté serveur.- Méthode
znetdk.getSelectedMenu()
- Méthode
znetdk.getUserConfirmation()
- Méthode
znetdk.getCurrentLanguage()
- Méthode
znetdk.getLocalSettings()
- Méthode
znetdk.initCommonWidgets()
- Méthode
znetdk.loaview()
- Méthode
znetdk.message()
- Méthode
znetdk.multiMessages()
- Méthode
znetdk.notifyUser()
- Méthode
znetdk.reducePhotoSize()
- Méthode
znetdk.reducePhotoSizePercent()
- Méthode
znetdk.request()
- Méthode
znetdk.storeLocalSettings()
- Méthode
znetdk.showMenuView()
- Méthode
znetdk.showModalDialog()
- Méthode
znetdk.useScriptFile()
- Méthode
znetdk.useStyleSheet()
- Evènements déclenchés par ZnetDK
- Méthode
API Serveur ZnetDK - PHP
Constantes ZnetDK
Constante | Description |
---|---|
ZNETDK_APP_ROOT |
Chemin absolu système d'accès au répertoire contenant les fichiers de l'application.
Pour l'application de démarrage installée dans le répertoire znetdk, cette constante contient par exemple le chemin système /home/hosting999/www/znetdk/applications/default . |
ZNETDK_APP_URI |
Chemin relatif d'accès au répertoire contenant les ressources web de l'application.
Pour l'application de démarrage installée dans le répertoire znetdk, cette constante contient le chemin /znetdk/applications/default/public/ . |
ZNETDK_ROOT_URI |
Chemin relatif d'accès au répertoire racine de ZnetDK.
Pour l'application de démarrage installée dans le répertoire znetdk, cette constante contient le chemin /znetdk/ . |
ZNETDK_VERSION |
Version installée de ZnetDK. |
Interface \iMenu
Classe d'interface implémentée par la classe \app\Menu
définie dans le script /applications/default/app/menu.php pour initialiser les éléments du menu de navigation dans l'application.
Méthode | Paramètres | Description |
---|---|---|
initAppMenuItems |
aucun | Méthode statique appelée par le constructeur de la classe \MenuManager pour disposer de la définition du menu de l'application. |
Classe \AppController
Classe abstraite dont doivent dériver tous les contrôleurs applicatifs développés spécifiquement pour les besoins de l'application.
Cette classe exécute les actions implémentées dans sa classe dérivée, à la demande du contrôleur de façade MainController
lorsque ce dernier reçoit une requête HTTP contenant les paramètres POST control
et action
.
La classe contrôleur dérivée de cette classe, doit être constituée d'autant de méthodes que d'actions supportées par le contrôleur applicatif.
Chaque méthode d'action doit être nommée selon le format action_<nom_de_l_action>
où <nom_de_l_action> doit correspondre exactement au nom de l'action transmis dans le paramètre POST action
.
La portée de la méthode d'action doit être protected
pour permettre à la classe mère \AppController
de l'appeler.
Enfin, la méthode d'action doit retourner obligatoirement un objet de type \Response.
Exemple d'appel : namespace app\controller; class MyController extends \AppController { static protected function action_store() { $response = new \Response(); // Action code... return $response; } static protected function action_getdata() { $response = new \Response(); // Action code... return $response; } static protected function action_remove() { $response = new \Response(); // Action code... return $response; } } |
Depuis la version 1.6 de ZnetDK, la méthode setAllowedActions
peut être ajoutée à la classe contrôleur pour restreindre les droits d'exécution de certaines actions du contrôleur aux seuls utilisateurs habilités.
Les habilitations sont définies à l'aide des profils utilisateurs.
Pour les profils autorisant l'exécution d'une action, appeler la méthode parent setRequiredProfileForAction($action, $profileName)
.
Pour les profils interdisant l'exécution d'une action, appeler la méthode parent setForbiddenProfileForAction($action, $profileName)
.
En version 3.0 de ZnetDK, appeler la méthode parent setRequiredMenuItemForAction($action, $menuItem)
pour indiquer l'identifiant de menu (le nom de la vue sans l'extension PHP) auquel l'utilisateur doit avoir droit à travers un profil pour autoriser l'exécution d'une action du contrôleur.
Dans l'exemple ci-dessous, l'action remove
n'est autorisée que si l'utilisateur dispose du profil nommé "Remove rows".
En revanche, l'action store
est interdite si l'utilisateur dispose du profil nommé "Read only".
Exemple d'appel : namespace app\controller; class MyController extends \AppController { static protected function setAllowedActions() { parent::setRequiredProfileForAction('remove', 'Remove rows'); parent::setForbiddenProfileForAction('save', 'Read only'); } static protected function action_store() { $response = new \Response(); // Action code... return $response; } static protected function action_getdata() { $response = new \Response(); // Action code... return $response; } static protected function action_remove() { $response = new \Response(); // Action code... return $response; } } |
Depuis la version 2.0 de ZnetDK, la méthode setAsynchronousActions
peut être ajoutée à la classe contrôleur pour déclarer les actions du contrôleur qui peuvent être exécutées de manière asynchrone par un appel de la méthode statique AsyncExec::submitActionToLaunch().
L'action du contrôleur une fois déclarée comme étant une action à exécuter en asynchrone, doit être implémentée avec les 2 paramètres suivants :
- $processId
: il s'agit de l'identifiant du processus asynchrone retourné à l'appel de la méthode AsyncExec::submitActionToLaunch().
- $stringParameters
: paramètres destinés à l'action de contrôleur et passés sous forme de texte à l'appel de la méthode AsyncExec::submitActionToLaunch().
Dans l'exemple ci-dessous, l'action de contrôleur nommée runasync
a été déclarée comment pouvant être exécutée de manière asynchrone.
Exemple d'appel : namespace app\controller; class MyController extends \AppController { static protected function setAsynchronousActions()() { return array('runasync'); } static protected function action_runasync($processId, $stringParameters) { // Batch processing... return 'OK'; } } |
Classe \AsyncExec
Classe statique en charge de l'exécution asynchrone d'actions de contrôleur.
L'exécution asynchrone n'est pas activée par défaut. Le paramètre CFG_ASYNCEXEC_PHP_BINARY_PATH doit être configuré au préalable pour bénéficier de cette fonctionnalité.
Méthode | Paramètres | Description |
---|---|---|
submitActionToLaunch |
$controllerName [string ]$actionName [string ]$stringParameters [string ]
|
Demande l'exécution asynchrone d'une action de contrôleur déclarée dans une application ou dans un module ZnetDK. Le paramètre obligatoire $controllerName indique le nom de la classe de contrôleur contenant l'action à exécuter.Le paramètre obligatoire $actionName indique le nom de l'action à exécuter.Le paramètre optionnel $stringParameters indique sous forme d'une chaîne texte, les paramètres à transmettre à l'action de contrôleur.La méthode retourne l'identifiant du processus exécuté pour lancer l'action de contrôleur. En revanche, la méthode retourne la valeur FALSE si la demande d'exécution échoue, notamment si le paramètre CFG_ASYNCEXEC_PHP_BINARY_PATH n'est pas configuré et si l'action de contrôleur n'est pas déclarée asynchrone (voir méthode setAsynchronousActions de la classe \AppController).
|
Exemple d'appel : $processId = \AsyncExec::submitActionToLaunch('mycontroller', 'runasync', 'myparam'); |
Classe \Convert
Classe statique intégrant plusieurs méthodes de conversion de dates et de nombres décimaux en fonction de la langue courante d'affichage de l'application, ainsi que de conversion aux formats UTF-8 et ISO-8859-1 de chaînes de texte.
La conversion des nombres décimaux et des dates est effectuée en fonction des paramètres de pays et de langue renseignés dans les scripts de traduction du répertoire /applications/default/app/lang
de l'application (voir Gestion multilingue).
Méthode | Paramètres | Description |
---|---|---|
base64UrlToBinary |
$base64Url [string ] |
Convertit en valeur binaire l'URL encodée en Base 64 spécifiée en paramètre.
Méthode disponible à partir de la version 2.6 de ZnetDK. |
Exemple d'appel : $binaryValue = \Convert::base64UrlToBinary($base64Url); |
Méthode | Paramètres | Description |
---|---|---|
binaryToBase64Url |
$binaryValue [string ] |
Convertit la valeur binaire spécifiée en paramètre, en URL encodée en Base 64.
Méthode disponible à partir de la version 2.6 de ZnetDK. |
Exemple d'appel : $base64Url = \Convert::binaryToBase64Url($binaryValue); |
Méthode | Paramètres | Description |
---|---|---|
toDecimalForDB |
$stringNumber [string|integer|float ]$numberOfDecimals [integer ] |
Convertit le nombre stringNumber au format texte en une valeur décimale.
Le paramètre |
Exemple d'appel : $myDecimalNumber = \Convert::toDecimalForDB("3451,7399", 2); |
Méthode | Paramètres | Description |
---|---|---|
toMoney |
$number [decimal ]$withCurrencySymbol [boolean ]$numberOfDecimals [integer ]
$forPdfPrinting [boolean ] |
Convertit le nombre décimal $number passé en paramètre en une valeur monétaire au format texte tenant compte de la langue courante sélectionnée pour l'application.
Le paramètre Le paramètre Le paramètre |
Exemple d'appel : $myMoney = \Convert::toMoney(3451.7399); |
Méthode | Paramètres | Description |
---|---|---|
toLocaleDate |
$dateTime [DateTime ] |
Convertit l'objet date $dateTime en une date au format texte correspondant à la langue courante d'affichage de l'application. |
Exemple d'appel : $myDate = \Convert::toLocaleDate(new \DateTime('now')); |
Méthode | Paramètres | Description |
---|---|---|
toW3CDate |
$dateTime [DateTime ] |
Convertit la date $dateTime en une date au format texte conforme au standard W3C ISO 8601 (format YYYY-MM-DD). |
Exemple d'appel : $myDate = \Convert::toW3CDate(new \DateTime('now')); |
Méthode | Paramètres | Description |
---|---|---|
toDecimal |
$value [string ] |
Convertit la chaîne texte $value en une valeur de type float pour des besoins de calcul. |
Exemple d'appel : // '5 677,12' => 5677.12 $myFloat = \Convert::toDecimal('5 677,12'); |
Méthode | Paramètres | Description |
---|---|---|
W3CtoLocaleDate |
$W3CDate [string ] |
Convertit la date $W3CDate au format W3C ISO 8601 en une date au format texte correspondant à la langue courante d'affichage de l'application.Si la date est suivie du détail de l'heure au format 'HH:MI:SS', cette heure est conservée en l'état et retournée par la méthode à la suite de la date dans sa version convertie. |
Exemple d'appel : $myDate = \Convert::W3CtoLocaleDate('2013-04-22'); |
Méthode | Paramètres | Description |
---|---|---|
toUTF8 |
$string [string ]$fromEncoding [string ] |
Convertit la chaîne de texte $string au format ISO-8859-1 en une chaîne de texte encodée en UTF-8.En version 2.9 de ZnetDK, le paramètre $fromEncoding peut être renseigné pour indiquer l'encodage (ISO-8859-1 par défaut) de la chaîne de texte à convertir en UTF-8
|
Exemple d'appel : $myUTF8String = \Convert::toUTF8($myString); |
Méthode | Paramètres | Description |
---|---|---|
valuesToAnsi |
$values [array ] |
Convertit les valeurs de type chaîne de texte encodée en UTF-8 du tableau $values dans un format texte encodé en ISO-8859-1. |
Exemple d'appel : $myAnsiString = \Convert::valuesToAnsi($values); |
Méthode | Paramètres | Description |
---|---|---|
toISO88591 |
$string [string ] |
Convertit la chaîne de texte encodée en UTF-8 dans un format de texte encodé en ISO-8859-1. |
Exemple d'appel : $iso88591String = \Convert::toISO88591($utf8String); |
Classe \DAO
Classe abstraite d'accès aux tables de base de données MySQL de l'application.
La classe \DAO
s'appuie complètement sur l'extension PHP Data Objects (ou PDO).
Exemple d'appel : namespace app\model; class CustomersDAO extends \DAO { protected function initDaoProperties() { $this->table = "customers"; $this->IdColumnName = "customer_id"; $this->query = "select customer_id, customer_name, address.* from customers "; $this->query .= "left join address using (address_id) "; $this->filterClause = "where address.country = ?"; } public function setCityAsFilter($cityName) { $this->filterClause = "where address.city = ?"; $this->setFilterCriteria($cityName); } } |
L'exemple ci-dessus illustre la déclaration d'une classe de type \DAO
permettant d'accéder à la table customers
.
Par défaut, le filtre appliqué dans la clause SQL where
initialisée dans la propriété $filterClause
, s'applique à la colonne address.country
.
Le point d'interrogation ?
correspond à la variable qui reçoit la valeur de filtre.
La methode personnalisée setCityAsFilter
lorsqu'elle est appelée avant la méthode getResult()
, applique un filtre sur les lignes de table dont la colonne address.city
est égale à la valeur $cityName
passée en paramètre de la méthode.
Propriété | Description |
---|---|
$query |
Requête SQL de sélection des données retournées par la méthode getResult() . |
$table |
Nom de la table de base données à mettre à jour à l'appel des méthodes store() et remove() .
Si la propriété $query n'est pas initialisée, la méthode getResult() retourne toutes les lignes et colonnes de la table indiquée. |
$IdColumnName |
Nom de la colonne correspondant à l'identifiant d'une ligne dans la table.
La valeur id est définie par défaut. |
$filterClause |
Condition SQL appliquée dynamiquement à l'appel de la méthode getResult() pour filtrer les lignes retournées en utilisant le critère défini à l'appel préalable de la méthode setFilterCriteria() . |
$groupByClause |
Clause SQL GROUP BY de la requête SQL du DAO.La clause SQL GROUP BY est à préciser en dehors de la propriété $query dans le cas où un filtre personnalisé est défini à travers la propriété $filterClause . |
$dateColumns |
Tableau contenant les colonnes de type date à formater selon la langue courante d'affichage.
Les dates spécifiées pour la propriété |
$moneyColumns |
Tableau contenant les colonnes de nombres décimaux à afficher sous une forme monétaire en fonction de la langue courante d'affichage.
Les nombres décimaux spécifiés pour la propriété |
$amountColumns |
Tableau contenant les colonnes de nombres décimaux à afficher sous forme de montant en fonction de la langue courante d'affichage.
Les nombres décimaux spécifiés pour la propriété |
$tableAlias |
Alias SQL de la table principale du DAO. L'alias est à préciser si la requête SQL définie pour la propriété $query emploie un alias SQL.A défaut de préciser l'alias, une erreur SQL est retournée à l'appel de la méthode getById() si un alias SQL est utilisé dans la requête SQL pour accéder à la table principale du DAO. |
Méthode | Paramètres | Description |
---|---|---|
beginTransaction |
aucun | Démarre une nouvelle transaction en base de données en vue de pouvoir la valider ou l'annuler explicitement.
L'exception DAO-010 est levée quand la méthode beginTransaction est appelée alors qu'une transaction SQL est déjà active.
|
Exemple d'appel : $myDao = new \app\model\Clients(); $myDao->beginTransaction(); |
Méthode | Paramètres | Description |
---|---|---|
commit |
aucun | Valide en base de données la transaction initiée explicitement par un appel à la méthode beginTransaction() du DAO. |
Exemple d'appel : $row = array('id'=>18,'name'=>'MARTIN','city'=>'Paris'); $myDao = new \app\model\Clients(); $myDao->beginTransaction(); $result = $myDao->store($row); $myDao->commit(); |
Méthode | Paramètres | Description |
---|---|---|
initDaoProperties |
aucun | Méthode abstraite implémentée par la classe dérivée pour initialiser les propriétés de l'objet DAO. |
Exemple d'appel : namespace app\model; class Customers extends \DAO { protected function initDaoProperties() { $this->query = "select id,customer_name from customers "; $this->filterClause = "where customer_name= ?"; } } |
Méthode | Paramètres | Description |
---|---|---|
getById |
$id [integer ] |
Retourne la ligne de données dont l'identifiant est celui précisé en paramètre. La ligne est retournée dans un tableau dont les index correspondent aux noms de colonne de la table ou de la requête. |
Exemple d'appel : $myDao = new \app\model\Clients(); $rowData = $myDao->getById(43); $clientName = $rowData['client_name']; |
Méthode | Paramètres | Description |
---|---|---|
getCount |
aucun | Retourne le nombre de lignes sélectionnées par le DAO. |
Exemple d'appel : $myDao = new \app\model\Clients(); $rowCount = $myDao->getCount(); |
Méthode | Paramètres | Description |
---|---|---|
getResult |
aucun | Retourne la ligne suivante sélectionnée par le DAO. L'accès à toutes les lignes sélectionnées par le DAO s'effectue par des appels successifs à la méthode Les propriétés |
Exemple d'appel : $myDao = new \app\model\Customers(); while($row = $myDao->getResult()) { $customers[] = $row['id']; } |
Méthode | Paramètres | Description |
---|---|---|
remove |
$id [integer ]$autocommit [boolean ] |
Supprime en base de données la ligne de table dont l'identifiant est spécifié en paramètre. Si Par défaut, la transaction est validée ou annulée automatiquement après suppression des lignes, à moins que le paramètre La méthode retourne le nombre de lignes supprimées. |
Exemple d'appel : $customerId = 52; $myDao = new \app\model\Customers(); $rowCount = $myDao->remove($customerId); |
Méthode | Paramètres | Description |
---|---|---|
rollback |
aucun | Annule en base de données la transaction initiée explicitement par un appel à la méthode beginTransaction() du DAO. |
Exemple d'appel : $row = array('id'=>18,'name'=>'MARTIN','city'=>'Paris'); $myDao = new \app\model\Clients(); $myDao->beginTransaction(); $result = $myDao->store($row); $myDao->rollback(); |
Méthode | Paramètres | Description |
---|---|---|
setSelectedColumns |
$columns [array ] |
Limite la liste de colonnes pour lesquelles les valeurs sont à retourner par le DAO à l'appel de la méthode DAO::getResult() .Le paramètre Cette méthode est particulièrement utile lorsque la définition du DAO se réduit à définir la seule propriété |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setSelectedColumns(array('id','name')); while($row = $myDao->getResult()) { $customers[] = $row; } |
Méthode | Paramètres | Description |
---|---|---|
setFilterCriteria |
$filterValue1 [mixed ]$filterValue2 [mixed ]... |
Fixe les critères de filtre à appliquer au DAO. Cette méthode ne s'applique que si la propriété Au minimum une valeur est attendue à l'appel de la méthode. |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setFilterCriteria('spain','france','uk'); while($row = $myDao->getResult()) { $customers[] = $row['id']; } |
Méthode | Paramètres | Description |
---|---|---|
setAmountColumns |
$column1 , $column2 , ... [string ] |
Indique les noms de colonne de table dont les valeurs sont à convertir en Montant selon les réglages liés à la langue d'affichage (voir les constantes LC_LOCALE_DECIMAL_SEPARATOR , LC_LOCALE_THOUSANDS_SEPARATOR , LC_LOCALE_NUMBER_OF_DECIMALS ).
Correspond à la modification de la propriété \DAO::$amountColumns .
|
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setAmountColumns('total', 'expenses'); $row = $myDao->getById(18) |
Méthode | Paramètres | Description |
---|---|---|
setMoneyColumns |
$column1 , $column2 , ... [string ] |
Indique les noms de colonne de table dont les valeurs sont à convertir en Monnaie selon les réglages liés à la langue d'affichage (voir les constantes LC_LOCALE_DECIMAL_SEPARATOR , LC_LOCALE_THOUSANDS_SEPARATOR , LC_LOCALE_NUMBER_OF_DECIMALS , LC_LOCALE_CURRENCY_SYMBOL , LC_LOCALE_CURRENCY_SYMBOL_PRECEDE , LC_LOCALE_CURRENCY_SYMBOL_SEPARATE ).
Correspond à la modification de la propriété \DAO::$moneyColumns .
|
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setMoneyColumns('total', 'expenses'); $row = $myDao->getById(18) |
Méthode | Paramètres | Description |
---|---|---|
setDateColumns |
$column1 , $column2 , ... [string ] |
Indique les noms de colonne de table dont les valeurs sont à convertir en Date selon les réglages liés à la langue d'affichage (voir constante LC_LOCALE_DATE_FORMAT ).
Correspond à la modification de la propriété \DAO::$dateColumns .
|
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setDateColumns('creation_date', 'birthday'); $row = $myDao->getById(18) |
Méthode | Paramètres | Description |
---|---|---|
setForUpdate |
$isForUpdate [boolean ]
|
Indique si les lignes sélectionnées doivent être verrouillées pour mise à jour. Appeler la méthode avec la valeur |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setForUpdate(TRUE); $row = $myDao->getById(18) |
Méthode | Paramètres | Description |
---|---|---|
setLimit |
$first [integer ]
$last [integer ] |
Restreint la sélection du DAO à la plage de lignes indiquée en paramètre. |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setLimit(20,40); while($row = $myDao->getResult()) { $customers[] = $row['id']; } |
Méthode | Paramètres | Description |
---|---|---|
setProfileCriteria |
$profiles [array ]$exclude [boolean ] |
Limite les lignes de résultat renvoyées par le DAO aux seules lignes correspondant aux profils indiqués dans le tableau $profiles .
Par défaut, la variable |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setProfileCriteria(array('Accountant','Manager')); while($row = $myDao->getResult()) { $customers[] = $row; } |
Méthode | Paramètres | Description |
---|---|---|
setSortCriteria |
$sortCriteria [string ] |
Définit les critères de tri des lignes retournées par le DAO. Ces critères sont indiqués sous la forme d'une chaîne texte telle que "colonne1 ASC, colonne2 DESC". Cette chaîne texte vient alors compléter sur la droite la clause SQL Cette méthode accepte également d'appliquer le tri aux colonnes disposant des suffixes |
Exemple d'appel : $myDao = new \app\model\Customers(); $myDao->setSortCriteria('name DESC, city ASC'); while($row = $myDao->getResult()) { $customers[] = $row; } |
Méthode | Paramètres | Description |
---|---|---|
setStoredProfiles |
$profiles [array ] |
Indique aux DAO les profils utilisateurs à associer aux prochaines lignes de table ajoutées ou modifiées par l'appel de la méthode store() . |
Exemple d'appel : $row = array('id'=>18,'name'=>'MARTIN','city'=>'Paris'); $myDao = new \app\model\Customers(); $myDao->setStoredProfiles(array('Buyer')); $result = $myDao->store($row); |
Méthode | Paramètres | Description |
---|---|---|
store |
$row [array ]
$autocommit [boolean ]
$emptyValuesToNull [boolean ] |
Enregistre en base de données les données de la ligne passées en paramètre. Les données sont transmises à la méthode dans une variable de type tableau dont les index correspondent aux noms de colonnes à mettre à jour dans la table définie pour le DAO. Par défaut, la transaction est validée ou annulée automatiquement après enregistrement des données, à moins que le paramètre Si le paramètre Si le nom de la colonne identifiant la ligne de données n'est pas transmise dans le tableau (propriété La méthode retourne |
Exemple d'appel : $row = array('id'=>18,'name'=>'MARTIN','city'=>'Paris'); $myDao = new \app\model\Customers(); $result = $myDao->store($row); |
Classe \Database
Classe ZnetDK dédiée à l'éxécution d'opérations spécifiques sur la base de données MySQL de l'application.
Méthode | Paramètres | Description |
---|---|---|
beginTransaction |
aucun | Démarre une transaction SQL en vue de réaliser une succession d'ajouts, modifications ou suppressions de lignes en base de données. |
Exemple d'appel : <?php \Database::beginTransaction(); ?> |
Méthode | Paramètres | Description |
---|---|---|
commit |
aucun | Valide les dernières opérations SQL d'ajout, modification ou suppression de lignes qui ont été réalisées dans la transaction SQL actuellement active. |
Exemple d'appel : <?php \Database::commit(); ?> |
Méthode | Paramètres | Description |
---|---|---|
inTransaction |
aucun | Indique si une transaction SQL a déjà été ouverte explicitement (retourne TRUE ) ou non (retourne FALSE );
|
Exemple d'appel : <?php echo \Database::inTransaction(); ?> |
Méthode | Paramètres | Description |
---|---|---|
rollback |
aucun | Annule les dernières opérations SQL d'ajout, modification ou suppression de lignes qui ont été réalisées dans la transaction SQL actuellement active. |
Exemple d'appel : <?php \Database::rollback(); ?> |
Classe \General
Classe utilitaire de ZnetDK permettant d'accéder à des fonctions généralistes au sein de l'application.
Méthode | Paramètres | Description |
---|---|---|
callRemoteAction |
$swUrl [string ]$method [string ]$controller [string ]
$action [string ]
$extraParameters [Array ]
|
Invoke l'action de contrôleur exposée en tant que service web par une application ZnetDK distante.
S'il s'agit de données au format JSON, elles peuvent être converties en objet ou tableau PHP par un appel de la fonction standard PHP json_decode() .
Pour exposer une action de contrôleur en service web, veuillez vous référer aux paramètres CFG_HTTP_BASIC_AUTHENTICATION_ENABLED et CFG_ACTIONS_ALLOWED_FOR_WEBSERVICE_USERS.
Méthode disponible à partir de la version 2.5 de ZnetDK. |
Exemple d'appel : <?php print_r(json_decode(\General::callRemoteAction('https://usr:pwd@mydomain.com/', 'POST', 'mycontroller', 'myaction', [my_param1 => 'val1', my_param2 => 'val2']))); ?> |
Méthode | Paramètres | Description |
---|---|---|
encrypt |
$plainText [string ]$password [string ]$isReturnedAsBase64 [boolean ] |
Crypte le texte $plainText par application de la méthode AES-256-CBC.
Le paramètre $password indique le mot de passe à utiliser pour son décryptage.
Le paramètre $isReturnedAsBase64 à la valeur TRUE par défaut indique que le texte une fois crypté est retourné encodé en Base 64.
Une fois crypté, le texte peut être décripté en appelant la méthode \General::decrypt(). Cette méthode utilise OpenSSL. |
Exemple d'appel : <?php echo \General::encrypt('my plain text', 'my password'); ?> |
Méthode | Paramètres | Description |
---|---|---|
getHttpErrorCode |
aucun |
Retourne le code 403 ou 404 de l'erreur HTTP déclenchée lorsque l'utilisateur tente de renseigner une URL d'accès à l'application qui n'existe pas ou qui n'est pas autorisée.
Cette méthode est uniquement destinée à être appelée depuis la vue |
Exemple d'appel : <?php echo \General::getHttpErrorCode(); ?> |
Méthode | Paramètres | Description |
---|---|---|
getMimeType |
$filename [string ] |
Retourne le type MIME du fichier renseigné en paramètre. Par exemple, si le fichier spécifié est une image de type GIF, le type MIME retourné est ' image/gif '.
|
Exemple d'appel : <?php echo \General::getMimeType(CFG_DOCUMENTS_DIR . DIRECTORY_SEPARATOR . 'mypicture.gif'); ?> |
Méthode | Paramètres | Description |
---|---|---|
getURIforDownload |
$controller [string ]$parameters [string ] |
Retourne l'URL de téléchargement d'un fichier.
Le paramètre obligatoire Le paramètre optionnel Depuis la version 2.6 de ZnetDK, les fichiers téléchargés sont stockés dans la mémoire cache du navigateur si le paramètre |
Exemple d'appel : <?php echo \General::getURIforDownload("mycontroller","file_id=54&cache=true"); ?> |
Méthode | Paramètres | Description |
---|---|---|
writeErrorLog |
$origin [string ]$textError [string ] |
Consigne dans le journal des erreurs ZnetDK errors.log, le message d'erreur $textError d'origine $origin .
|
Exemple d'appel : <?php \General::writeErrorLog("MYAPP","A severe error occurred while..."); ?> |
Méthode | Paramètres | Description |
---|---|---|
writeSystemLog |
$origin [string ]$information [string ] |
Consigne dans le journal système ZnetDK system.log, le message informatif $information d'origine $origin .
|
Exemple d'appel : <?php \General::writeSystemLog("MYAPP","Backup is terminated..."); ?> |
Classe \Layout
Classe contrôleur spécialisée ZnetDK qui prend à charge la création du modèle de page de l'application et l'alimente en données.
Ce contrôleur est appelé par le contrôleur principal MainController
pour traiter les requêtes HTTP de type GET adressées à l'application.
Méthode | Paramètres | Description |
---|---|---|
renderBreadcrumb |
aucun | Insère l'élément HTML <div id="zdk-breadcrumb-text"/> destiné à afficher l'intitulé d'élément de menu sélectionné. Cet intitulé est renseigné directement par la méthode renderBreadcrumb() si le paramètre CFG_VIEW_PAGE_RELOAD est renseigné à la valeur true .Cette méthode statique est destinée à être appelée depuis le modèle de page de l'application. |
Méthode | Paramètres | Description |
---|---|---|
renderCustomContent |
$controller [string ] |
Insère l'élément HTML <div id="zdk-content"/> destiné à afficher la vue de l'application correspondant à l'élément de menu sélectionné. La vue est insérée directement par la méthode renderCustomContent() si le paramètre CFG_VIEW_PAGE_RELOAD est renseigné à la valeur true .
La variable Cette méthode statique est destinée à être appelée depuis le modèle de page de l'application. |
Méthode | Paramètres | Description |
---|---|---|
renderLogoURL |
aucun | Retourne l'URL du lien hypertexte du logo d'entête de l'application. Cette méthode statique est appelée depuis le modèle de page de l'application et retourne l'URL racine de l'application si elle est configurée pour un rechargement de page à chaque clic de menu (paramètre CFG_VIEW_PAGE_RELOAD à la valeur |
Exemple d'appel : <a href="<?php self::renderLogoURL(); ?>">...</a> |
Méthode | Paramètres | Description |
---|---|---|
renderMetaTags |
$metaDescription [string ]
$metaKeywords [string ]
$metaAuthor [string ] |
Insère les balises HTML <meta> définies pour l'entrée de menu sélectionnée. Les variables
|
Exemple d'appel : <?php self::renderMetaTags($metaDescription,$metaKeywords,$metaAuthor);?> |
Méthode | Paramètres | Description |
---|---|---|
renderNavigationMenu |
$type [string ]
$controller [string ] |
Insère le menu de navigation de l'application. La variable La variable |
Exemple d'appel : <?php self::renderNavigationMenu('custom',$controller); ?> |
Classe \MenuManager
Classe concrète ZnetDK qui fournit au contôleur d'affichage \Layout
la définition du menu de navigation dans l'application.
Méthode | Paramètres | Description |
---|---|---|
addMenuItem |
$parentMenuItemID [string ]
$menuItemID [string ]
$menuItemLabel [string ]
$menuItemIcon [string ]
$menuItemSEOlink [string ]
$menuItemDescription [string ]
$menuItemKeywords [string ]
$menuItemAuthor [string ]
|
Ajoute un nouvel élément au menu de l'application. Les paramètres obligatoires de la méthode sont :
En option, si le modèle de page choisi est En option, dans le cas en particulier où le paramètre CFG_VIEW_PAGE_RELOAD est défini à la valeur
|
Exemple d'appel : \MenuManager::addMenuItem(NULL,'examples','Exemples'); \MenuManager::addMenuItem('examples','example1','Exemple 1'); \MenuManager::addMenuItem('examples','example2','Exemple 2'); |
Classe \Request
Classe d'accès aux paramètres POST de la requête HTTP adressée au script index.php
de l'application.
Propriété | Description |
---|---|
parameter |
Valeur du paramètre POST nommé parameter qui a été transmise dans la requête HTTP.Exemple d'appel : $request = new \Request(); /* The retrieved POST parameter is named "address" */ $requestedAddress = $request->address; |
Méthode | Paramètres | Description |
---|---|---|
getValuesAsMap |
$parameter1 [ $parameter2 [ ... |
Retourne les paramètres POST dont les noms sont indiqués en paramètres sous la forme d'un tableau de type Map, où chaque clé correspond au nom du paramètre POST. |
Exemple d'appel : $request = new \Request(); /* Return array('lastname'=>'value1','firstname'=>'value2') */ $row = $request->getValuesAsMap('lastname','firstname'); |
Méthode | Paramètres | Description |
---|---|---|
isUploadedFile |
$name [ |
Evalue si un fichier a été reçu (upload) par le serveur HTTP via le paramètre POST indiqué. Retourne TRUE si un fichier a bien été reçu par le serveur dans le paramètre POST dont le nom est indiqué dans la variable $name .
Autrement renvoie FALSE .
|
Exemple d'appel : $request = new \Request(); if ($request->isUploadedFile('the_uploaded_file')) { // A file has been uploaded in the POST parameter 'the_uploaded_file'... } else { // No file uploaded... } |
Méthode | Paramètres | Description |
---|---|---|
getUploadedFileInfos |
$name [ |
Retourne les informations du fichier envoyé au serveur (upload) à travers le paramètre POST dont le nom est celui indiqué par la variable $name de la méthode.
Les informations sont retournées dans un tableau dont les clés d'accès sont les suivantes :
|
Exemple d'appel : $request = new \Request(); $fileInfos = $request->getUploadedFileInfos('the_uploaded_file') $fileName = $fileInfos['filename']; $fileExtension = $fileInfos['extension']; $fileSize = $fileInfos['size']; $fileType = $fileInfos['type']; |
Méthode | Paramètres | Description |
---|---|---|
moveImageFile |
$name [ $targetFileName [ $fileMaxSize [ |
Déplace le fichier de type image reçu via la requête HTTP POST (upload) dans le répertoire cible spécifié. $name est le nom du paramètre POST à travers lequel le fichier a été envoyé.$targetFileName est le nom de fichier cible incluant son chemin d'accès complet.$fileMaxSize est la taille maximale autorisée du fichier image.Une exception \ZDKException est levée si le déplacement échoue.
|
Exemple d'appel : $request = new \Request(); $response = new \Response(); $POSTparamName = 'the_uploaded_file'; try { $fileInfos = $request->getUploadedFileInfos($POSTparamName); $targetFile = ZNETDK_APP_ROOT . DIRECTORY_SEPARATOR . 'app' . DIRECTORY_SEPARATOR . 'upload' . DIRECTORY_SEPARATOR . $fileInfos['basename']; $request->moveImageFile($POSTparamName, $targetFile, 100000); $response->setSuccessMessage("Uploading image", "File uploaded successfully!"); } catch(\ZDKException $ex) { $response->setFailedMessage('Uploading image...', $ex->getMessage()); } |
Méthode | Paramètres | Description |
---|---|---|
setTrimedCharacters |
$trimedCharacters [ |
Définit les caractères à supprimer en début et en fin de chaîne texte transmise en paramètre d'une requête HTTP. Par défaut, les caractères supprimés en début et fin de chaîne texte sont Méthode disponible à partir de la version 2.6 de ZnetDK. |
Exemple d'appel : $request = new \Request(); $request->setTrimedCharacters(" \r\t\v\x00"); |
Méthode | Paramètres | Description |
---|---|---|
setVariableFilteringLevel |
$level [ |
Définit le niveau de filtrage des données transmises dans les requêtes HTTP. Le niveau de filtrage est défini par défaut à la valeur La variable
Méthode disponible à partir de la version 2.6 de ZnetDK. |
Exemple d'appel : $request = new \Request(); $request->setVariableFilteringLevel('LOW'); |
Classe \Response
Classe de l'objet retourné par une action de contrôleur applicatif pour transmettre la réponse HTTP au contrôleur principal ZnetDK.
Le contrôleur principal est alors chargé de générer la réponse HTTP dans un format :
- HTML si la requête HTTP est de type GET et si l'objet
Response
retourné par le contrôleur applicatif est une vue, définie par un appel à la méthode Response::setView(). - Fichier si la requête HTTP est de type GET et si l'objet
Response
retourné par le contrôleur applicatif est un fichier à télécharger, défini par un appel à la méthode Response::setFileToDownload(). - PDF si la requête HTTP est de type GET et si l'objet
Response
retourné par le contrôleur applicatif est un document de type PDF, défini par un appel à la méthode Response::setPrinting(). - CSV si la requête HTTP est de type GET et si l'objet
Response
retourné par le contrôleur applicatif est un fichier CSV, défini par un appel à la méthode Response::setDataForCsv(). - JSON si la requête HTTP est de type POST. L'objet
Response
retourné par le contrôleur applicatif, contient alors les données initialisées à travers la définition directe de propriétés personnalisées ou par un appel à la méthode Response::setResponse(), Response::setSuccessMessage(), Response::setWarningMessage(), Response::setFailedMessage() ou Response::setCriticalMessage(). - Personnalisé si une réponse personnalisée est à retourner (XML, texte, ...) par appel de la méthode Response::setCustomContent().
Propriété | Description |
---|---|
custom property |
Valeur de la propriété personnalisée nommée ici property à retourner au format JSON dans la réponse HTTP.Le nom de la propriété est laissé au libre choix du développeur. |
Exemple d'appel : $response = new \Response(); $response->myFirstValue = 'value 1'; $response->myOtherValue = 'value 2'; |
Méthode | Paramètres | Description |
---|---|---|
setDataForCsv |
$rowData [
$fileName [
$header [
$forDisplayInline [ |
Fournit les caractéristiques et données du fichier CSV à retourner dans la réponse HTTP GET pour téléchargement.
Cette méthode doit être uniquement appelée depuis l'action /applications/default/app/lang de traduction de l'application indique quel est le caractère de séparation des valeurs du fichier CSV à générer (séparateur virgule ou point-virgule).
Le paramètre Le paramètre Le paramètre Le paramètre |
Exemple d'appel : static protected function action_download() { $response = new \Response(); $header = array('Column 1','Column 2','Column 3'); $data = array( array('Row 1 col. 1','Row 1 col. 2','Row 1 col. 3'), array('Row 2 col. 1','Row 2 col. 2','Row 2 col. 3'), array('Row 3 col. 1','Row 3 col. 2','Row 3 col. 3'), ); $response->setDataForCsv($data, 'myfile.csv', $header); return $response; } |
Méthode | Paramètres | Description |
---|---|---|
setFileToDownload |
$fileName [
$forDisplayInline [ |
Indique le nom du fichier à retourner dans la réponse HTTP GET pour téléchargement.
Cette méthode doit être uniquement appelée depuis l'action Le paramètre Le paramètre |
Exemple d'appel : static protected function action_download() { $response = new \Response(); $fileToDownload = CFG_DOCUMENTS_DIR . DIRECTORY_SEPARATOR . 'mydoc.pdf'; $response->setFileToDownload($fileToDownload, TRUE); return $response; } |
Méthode | Paramètres | Description |
---|---|---|
setPrinting |
$printingObject [
$filename [ |
Définit un objet de type FPDF comme réponse à la requête HTTP GET.
Cette méthode doit être uniquement appelée depuis l'action Le paramètre Le paramètre |
Exemple d'appel : static protected function action_download() { $response = new \Response(); $pdf = new \FPDF(); $pdf->AddPage(); $pdf->SetFont('Arial','B',16); $pdf->Cell(40,10,'PDF document generated from ZnetDK!'); $response->setPrinting($pdf, 'mydoc.pdf'); return $response; } |
Méthode | Paramètres | Description |
---|---|---|
setView |
$viewName [
$viewType [
$viewCaller [ |
Indique le nom de la vue et son type à retourner dans la réponse HTTP GET. Le nom de la vue
|
Exemple d'appel : $response = new \Response(); /* Return view "clients.php" */ $response->setView('clients','view'); |
Méthode | Paramètres | Description |
---|---|---|
setCustomContent |
$content [ |
Défini un contenu personnalisé (XML, texte, ...) en réponse à la requête HTTP. |
Exemple d'appel : $response = new \Response(); $response->setCustomContent('OK'); |
Méthode | Paramètres | Description |
---|---|---|
setResponse |
$viewName [ |
Permet d'initialiser à l'aide d'un tableau PHP les données à retourner au format JSON dans la réponse HTTP POST. |
Exemple d'appel : $response = new \Response(); $myArray = array('status'=>'KO','message'=>'An error occurred!'}; $response->setResponse($myArray); |
Méthode | Paramètres | Description |
---|---|---|
setSuccessMessage |
$summary [ $message [ |
Initialise le message à retourner au format JSON à l'utilisateur dans la réponse HTTP POST, pour lui confirmer que l'action demandée a été exécutée avec succès. |
Exemple d'appel : $response = new \Response(); $response->setSuccessMessage("Add an item","The item has been added successfully."); |
Méthode | Paramètres | Description |
---|---|---|
setWarningMessage |
$summary [ $message [ |
Initialise le message à à retourner au format JSON à l'utilisateur dans la réponse HTTP POST, pour l'informer que l'action demandée a réussi mais avec un message d'alerte. Cette méthode est similaire à la méthode setSuccessMessage() excepté que l'icône affichée par le
composant graphique puigrowl est de type warn. |
Exemple d'appel : $response = new \Response(); $response->setWarningMessage("New item","Item has been added but it is incomplete."); |
Méthode | Paramètres | Description |
---|---|---|
setFailedMessage |
$summary [ $message [
$field [string] |
Initialise le message à retourner au format JSON à l'utilisateur dans la réponse HTTP POST, pour l'informer que l'action demandée a échoué. La variable optionnelle $field (valeur NULL par défaut) permet d'indiquer l'identifiant du champ en erreur dans le formulaire HTML. |
Exemple d'appel : $response = new \Response(); $response->setFailedMessage("Add an item","An error occurred while adding the item."); |
Méthode | Paramètres | Description |
---|---|---|
setCriticalMessage |
$message [ $exception [ |
Initialise le message à retourner au format JSON à l'utilisateur dans la réponse HTTP POST, pour l'informer que l'action demandée a échoué en raison d'un incident critique survenu (par exemple en cas d'exception levée par un objet \DAO). Le message $message et le code de l'exception $exception sont consignés dans le journal des erreurs ZnetDK et également retournés dans la réponse HTTP (erreur 500) pour affichage à l'utilisateur à l'aide du composant graphique puinotify. |
Exemple d'appel : try { $myDao->getResult(); } catch (\PDOException $ex) { $response = new \Response(); $response->setCriticalMessage("Unable to store the item data",$ex); } |
Classe \SimpleDAO
Classe d'accès simplifié aux données d'une table MySQL.
Cette classe dérivée de la classe \DAO permet de consulter et mettre à jour le contenu d'une table MySQL sans avoir besoin de créer au préalable dans le sous-dossier modele
de l'application, une classe DAO personnalisée.
D'autre part, elle est capable de tenir compte directement des valeurs de paramètres POST des requêtes AJAX adressées à un contrôleur d'application (par exemple first
, count
, sortfield
...) et de ne retourner que les données correspondantes.
Méthode | Paramètres | Description |
---|---|---|
__construct |
$tableName [ |
Constructeur de la classe \SimpleDAO à appeler pour instancier un objet d'accès à la table MySQL spécifiée en paramètre.Un objet \SimpleDAO une fois instancié permet d'accéder à l'ensemble des méthodes publiques de la classe \DAO. |
Exemple d'appel : $dao = new \SimpleDAO('persons'); |
Méthode | Paramètres | Description |
---|---|---|
getRows |
&$rowsFound [ $defaultSortField = NULL[
|
Retourne les lignes de la table MySQL indiquée à l'instanciation de l'objet \SimpleDAO .
Les lignes trouvées sont retournées dans la variable
Les lignes retournées dans la variable
La valeur retournée par la méthode (affectée à la variable |
Exemple d'appel : /* POST parameters: first='0', count='10', keyword='blue,red' */ $dao = new \SimpleDAO('persons'); /* keywords searched into the table's column 'name' */ $dao->setKeywordSearchColumn('name'); $persons = array(); /* Rows found are sorted by 'name' (sorting POST parameters not set) */ $total = $dao->getRows($persons, 'name ASC'); |
Méthode | Paramètres | Description |
---|---|---|
getRowsForCondition |
$condition [ $value1 [ $value2 [ ... $valueN [ |
Retourne les lignes de table correspondant à la condition et aux valeurs de condition spécifiées en paramètres de la méthode.
La variable Les autres variables Les lignes trouvées sont retournées dans un tableau de tableaux indexés comme illustré ci-dessous : |
Exemple d'appel : $dao = new \SimpleDAO('persons'); $condition = 'LOWER(name) LIKE LOWER(?)'; $value = 'jean'; $result = $dao->getRowsForCondition($condition, "%{$value}%"); |
Méthode | Paramètres | Description |
---|---|---|
getSuggestions |
$count = 10 [ |
Retourne la liste de suggestions trouvées dans la table spécifiée pour l'objet \SimpleDAO et dont le mot-clé transmis via le paramètre POST query correspond.
La méthode setKeywordSearchColumn() doit être appelée au préalable pour indiquer la colonne de table dans laquelle les suggestions doivent etre recherchées. Les suggestions trouvées sont retournées dans un tableau PHP à 1 dimension. |
Exemple d'appel : /* POST parameter: query='blue' */ $dao = new \SimpleDAO('persons'); $dao->setKeywordSearchColumn('name'); $suggestions = $dao->getSuggestions(20); |
Méthode | Paramètres | Description |
---|---|---|
setKeywordSearchColumn |
$columnName [ |
Indique le nom de la colonne dans la table spécifiée pour l'objet \SimpleDAO , dans laquelle doivent être recherchés le ou les mots-clés indiqués pour le paramètre POST keyword ou query .
Cette méthode est à invoquer juste avant l'appel de la méthode getRows() ou getSuggestions(). |
Exemple d'appel : $dao = new \SimpleDAO('persons'); $dao->setKeywordSearchColumn('name'); |
Classe \UserSession
Classe d'accès aux données stockées dans la session de l'utilisateur.
Méthode | Paramètres | Description |
---|---|---|
setCustomValue |
$variableName [
$value [
$sanitize = FALSE [
|
Initialise la valeur $value dans la variable de session utilisateur $variableName .
La variable créée dans la session utilisateur est automatiquement supprimée après déconnexion de l'utilisateur. Si |
Exemple d'appel : \UserSession::setCustomValue('myVarInSession',18); |
Méthode | Paramètres | Description |
---|---|---|
getCustomValue |
$variableName [
$sanitize = FALSE [
|
Retourne la valeur initialisée pour la variable de session utilisateur $variableName .
La valeur Si |
Exemple d'appel : $myValueInSession = \UserSession::getCustomValue('myVarInSession'); |
Méthode | Paramètres | Description |
---|---|---|
removeCustomValue |
$variableName [ |
Supprime de la session utilisateur la variable $variableName spécifiée.
Retourne la valeur |
Exemple d'appel : \UserSession::removeCustomValue('myVarInSession'); |
Méthode | Paramètres | Description |
---|---|---|
getUserId |
aucun | Retourne l'identifiant en base de données (colonne user_id ) de l'utilisateur actuellement connecté. Si l'utilisateur n'est pas connecté, la valeur NULL est retournée.
Méthode disponible à partir de la version 2.5 de ZnetDK. |
Exemple d'appel : $userId = \UserSession::getUserId(); |
Méthode | Paramètres | Description |
---|---|---|
getUserName |
aucun | Retourne le nom en base de données (colonne user_name ) de l'utilisateur actuellement connecté. Si l'utilisateur n'est pas connecté, la valeur NULL est retournée.
Méthode disponible à partir de la version 2.9 de ZnetDK. |
Exemple d'appel : $userName = \UserSession::getUserName(); |
Méthode | Paramètres | Description |
---|---|---|
getUserEmail |
aucun | Retourne l'adresse email en base de données (colonne user_email ) de l'utilisateur actuellement connecté. Si l'utilisateur n'est pas connecté, la valeur NULL est retournée.
Méthode disponible à partir de la version 2.9 de ZnetDK. |
Exemple d'appel : $userEmail = \UserSession::getUserEmail(); |
Méthode | Paramètres | Description |
---|---|---|
hasFullMenuAccess |
aucun | Retourne l'indicateur d'accès à la totalité du menu de navigation de l'application (colonne full_menu_access en base de données) de l'utilisateur actuellement connecté. Si l'utilisateur n'est pas connecté, la valeur NULL est retournée.
Méthode disponible à partir de la version 2.9 de ZnetDK. |
Exemple d'appel : $hasFullMenuAccess = \UserSession::hasFullMenuAccess(); |
Méthode | Paramètres | Description |
---|---|---|
getUserProfiles |
aucun | Retourne dans un tableau (type array ) la liste des profils utilisateur accordés à l'utilisateur actuellement connecté. Si l'utilisateur n'est pas connecté, un tableau vide est retourné.
Méthode disponible à partir de la version 2.9 de ZnetDK. |
Exemple d'appel : $userProfiles = \UserSession::getUserProfiles(); |
Méthode | Paramètres | Description |
---|---|---|
hasUserProfile |
$profileName [ |
Indique si l'utilisateur actuellement connecté dispose du profil utilisateur specifié en paramètre (valeur TRUE retournée) ou non (valeur FALSE retournée).
Méthode disponible à partir de la version 2.9 de ZnetDK. |
Exemple d'appel : $isAllowed = \UserSession::hasUserProfile('Suppression'); |
Classe \Validator
Classe de validation des données transmises par requête HTTP depuis un formulaire HTML à destination d'un contrôleur de l'application.
Cette classe est abstraite et ne peut être instanciée qu'à travers sa classe dérivée.
La classe dérivée implémente :
- La méthode
initVariables
pour préciser le nom des paramètres HTTP à contrôler, - En option, la méthode
initOptionalVariables
pour indiquer le nom des paramètres HTTP dont la valeur n'est pas obligatoire, - Une méthode de contrôle
check_[paramname]
pour chaque donnée de la requête HTTP à contrôler. Par exemple elle se nommeracheck_email()
pour vérifier la donnée du paramètre POST transmis sous le nomemail
.
Méthode | Paramètres | Description |
---|---|---|
initVariables [ protected ] |
aucun | Méthode abstraite à surcharger par la classe dérivée pour indiquer sous forme de tableau la liste des noms de paramètres HTTP dont les valeurs sont à contrôler.
Les paramètres HTTP renseignés uniquement depuis cette méthode (non renseignés dans la méthode Le message d'erreur retourné est celui défini pour la constante de localisation |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_id','user_name','user_email'); } } |
Méthode | Paramètres | Description |
---|---|---|
initOptionalVariables [ protected ] |
aucun | Méthode pouvant être surchargée par la classe dérivée pour préciser sous forme de tableau, les paramètres HTTP dont les valeurs sont optionnelles. |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_id','user_name','user_email'); } protected function initOptionalVariables() { return array('user_email'); } } |
Méthode | Paramètres | Description |
---|---|---|
check_[nomparam] [ protected ] |
$value [string ] |
Méthode implémentée par la classe dérivée pour contrôler la valeur $value du paramètre HTTP nommé nomparam. Retourne la valeur |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_name'); } protected function check_user_name($value) { // 100 characters maximum if (strlen($value) > 100) { $this->setErrorMessage('User name is too long!'); return FALSE; } return TRUE; } } |
Méthode | Paramètres | Description |
---|---|---|
getValue [ public ] |
$variable [string ] |
Appelée depuis la méthode check_[paramname] , permet d'obtenir la valeur d'un autre paramètre en jeu dans la validation de la donnée, par exemple pour connaître la valeur de confirmation de saisie d'un mot de passe lorsque le mot de passe lui-même est contrôlé. |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_name','login_password','login_password2'); } protected function check_login_password2($value) { if ($this->getValue('login_password')!==$value) { $this->setErrorMessage('Entered passwords are not the same!'); return FALSE; } return TRUE; } // Other checking methods... } |
Méthode | Paramètres | Description |
---|---|---|
setErrorMessage [ protected ] |
$errorMessage [string ] |
Permet depuis la méthode check_[paramname] d'initialiser le libellé du message d'erreur à retourner par l'objet de validation en cas d'erreur détectée (voir methode getErrorMessage). |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_name'); } protected function check_user_name($value) { // 100 characters maximum if (strlen($value) > 100) { $this->setErrorMessage('Name too long!'); return FALSE; } return TRUE; } } |
Méthode | Paramètres | Description |
---|---|---|
setErrorVariable [ protected ] |
$variable [string ] |
Appelée à l'intérieur de la méthode check_[paramname] , indique la variable en erreur si validation des données échoue (voir méthode getErrorVariable ).
Si la variable en erreur n'est pas spécifiée par un appel explicite de cette méthode, c'est le nom de la variable contrôlée par la méthode check_[paramname] qui est retourné. |
Exemple d'appel : <?php namespace app\validator; class UserValidator extends \Validator { protected function initVariables() { return array('user_name','login_password','login_password2'); } protected function check_login_password2($value) { if ($this->getValue('login_password')!==$value) { $this->setErrorVariable('login_password'); $this->setErrorMessage('Entered password are not the same!'); return FALSE; } return TRUE; } // Other checking methods... } |
Le contrôleur applicatif, à l'origine de la demande de vérification des données, instancie un objet dérivé de la classe Validator
et évalue la qualité des données HTTP avant leur traitement par l'appel de :
- La méthode
validate()
pour demander que soient vérifiées les données, - La méthode
getErrorVariable()
pour obtenir le nom du premier paramètre POST détecté en erreur, - La méthode
getErrorMessage()
pour disposer du message d'erreur retourné par la méthodecheck_[paramname]
ayant détecté l'erreur, - La méthode
getValues()
pour disposer des valeurs des paramètres POST qui ont été vérifiés.
Méthode | Paramètres | Description |
---|---|---|
validate [ public ] |
aucun | Contrôle la validité des données de la requête HTTP renseignées dans la classe dérivée de validation par appels successifs à ses méthodes check_[paramname] . |
Exemple d'appel : $userValidator = new \validator\UserValidator(); if ($userValidator->validate()) { echo 'Data validated.'; } else { echo 'Invalid data!'; } |
Méthode | Paramètres | Description |
---|---|---|
getErrorVariable [ public ] |
aucun | Retourne le nom du premier paramètre HTTP dont la valeur a été détectée invalide. |
Exemple d'appel : $userValidator = new \app\validator\UserValidator(); if ($userValidator->validate()) { echo 'Data validated.'; } else { echo 'Error detected for the variable' .$userValidator->getErrorVariable(); } |
Méthode | Paramètres | Description |
---|---|---|
getErrorMessage [ public ] |
aucun | Retourne le message d'erreur de validation du premier paramètre HTTP détecté en erreur est initialisé depuis la méthode check_[paramname] par appel de la méthode setErrorMessage() . |
Exemple d'appel : $userValidator = new \app\validator\UserValidator(); if ($userValidator->validate()) { echo 'Data validated.'; } else { echo $userValidator->getErrorMessage(); } |
Méthode | Paramètres | Description |
---|---|---|
getValues [ public ] |
aucun | Retourne un tableau des paramètres HTTP et de leur valeur associée qui ont été contrôlées par l'objet de validation. |
Exemple d'appel : <?php $userValidator = new \app\validator\UserValidator(); $userRow = $userValidator->getValues(); |
Méthode | Paramètres | Description |
---|---|---|
setCheckingMissingValues [ public ] |
aucun | Indique que le contrôle des valeurs manquantes (variable à NULL ou non définie) est délégué aux méthodes de validation des données check_[paramname] .
Par défaut, si cette méthode n'est pas appelée, c'est le validateur qui vérifie directement si la valeur est manquante pour toute variable déclarée dans la méthode |
Exemple d'appel : <?php $userValidator = new \app\validator\UserValidator(); $userValidator->setCheckingMissingValues(); $userValidator->validate(); |
Méthode | Paramètres | Description |
---|---|---|
setValues [ public ] |
values [array] |
Définit à partir du tableau values les valeurs à vérifier par le validateur.
Chaque valeur du tableau est renseignée avec un index correspondant à un nom de variable défini dans la méthode initVariables .
Cette méthode est utile pour valider des données provenant d'une autre source qu'une requête HTTP POST, par exemple lorsqu'elles proviennent d'un fichier importé dans l'application. |
Exemple d'appel : <?php $userValidator = new \app\validator\UserValidator(); $userValidator->setValues(array('name'=>'Alford', 'birthdate'=>'2016-10-12')); $userValidator->validate(); |
Classe \controller\Users
Classe de contrôleur secondaire chargée de traiter les actions relatives aux utilisateurs de l'application.
Méthode | Paramètres | Description |
---|---|---|
hasMenuItem |
$menuItem [string ] |
Méthode statique permettant d'évaluer si l'utilisateur connecté dispose d'un profil autorisant l'accès à l'élément de menu $menuItem (nom de la vue PHP sans l'extension de fichier).
La méthode retourne |
Exemple d'appel : if (\controller\Users:hasMenuItem('myview') { echo "The connected user has access to 'myview'"; } else { echo "The connected user has not access to 'myview'"; } |
Méthode | Paramètres | Description |
---|---|---|
hasProfile |
$profileName [string ] |
Méthode statique permettant d'évaluer si l'utilisateur connecté dispose ou non du profil utilisateur $profileName .
Le nom du profil renseigné dans la variable La méthode retourne |
Exemple d'appel : if (\controller\Users:hasProfile('Administrator') { echo 'The connected user is an Administrator'; } else { echo 'The connected user is not an Administrator'; } |
Méthode | Paramètres | Description |
---|---|---|
notify |
$isNewUser [boolean ]$passwordInClear [string ]$otherUserData [array ] |
Méthode statique à surcharger dans le contrôleur app\controller\Users de l'application pour notifier l'utilisateur déclaré dans ZnetDK (voir Authentification et Habilitations), que son compte utilisateur a été créé ou modifié.
|
Exemple d'implémentation : static public function notify($isNewUser, $passwordInClear, $otherUserData) { $appURI = \General::getApplicationURI(); $connectedUserName = \MainController::execute('Users', 'getUserName'); $connectedUserEmail = \MainController::execute('Users', 'getUserEmail'); $emailTemplate = $isNewUser ? 'new-user' : 'password-change'; $email = new \zdkmail\mod\Email($emailTemplate); $email->addAddress('FROM', $connectedUserName .' <' . $connectedUserEmail . '>'); $email->addAddress('TO', $otherUserData['user_email']); $email->setSubjectValues($otherUserData['login_name']); $email->setMessageValues($otherUserData['user_name'], $appURI, $otherUserData['login_name'], $passwordInClear, $connectedUserName); if (!$email->send()) { throw new \Exception(LM_MSG_WARN_EMAIL_NOT_SENT_TO_USER); } } |
Méthode | Paramètres | Description |
---|---|---|
getUserTheme |
aucun | Méthode statique à surcharger dans le contrôleur app\controller\Users de l'application pour indiquer le thème des composants graphiques à afficher pour l'utilisateur actuellement connecté à l'application. |
Exemple d'implémentation : static public function getUserTheme() { return 'asphalt'; } |
Classe \zdkmail\mod\Email
La classe \zdkmail\mod\Email
encapsule la fonction PHP standard mail()
destinée à l'envoi d'emails.
Elle supporte l'envoi d'emails au format texte ou HTML à partir d'un modèle d'email, ainsi que l'attachement de pièces jointes.
Les modèles d'email doivent être créés dans le répertoire znetdk/applications/default/app/email/ et consistent à initialiser les propriétés subject
et message
de la classe \zdmail\mod\Email
, comme illustré ci-dessous.
<?php // Email subject $this->subject = '[' . LC_PAGE_TITLE . '] New user account \'%1\''; // Email message body $this->message = '<p>Hello %1,</p>'; $this->message .= '<p>A new user account has been created for you.<br>' . 'Here is your credentials for connecting to the <strong>' . LC_PAGE_TITLE . '</strong> application from your web browser:</p>'; $this->message .= '<ul>' . '<li>Internet address: <a href="%2" target="_blank">%2<a></li>' . '<li>' . LC_FORM_LBL_LOGIN_ID . ': <strong>%3</strong></li>' . '<li>' . LC_FORM_LBL_PASSWORD .': <strong>%4</strong></li>' . '</ul>'; $this->message .= '<p>For security purpose, your password <em>will have to be' . ' renewed</em> after your first connection to the application.</p>'; $this->message .= '<p>Regards,<br>%5</p>';
Sous Windows uniquement, les 3 paramètres ZnetDK
MOD_EMAIL_SMTP
,
MOD_EMAIL_SMTP_PORT
et MOD_EMAIL_FROM
permettent de configurer
le serveur SMTP en charge de l'envoi des emails et d'indiquer l'adresse email de l'expéditeur.
En complément, les paramètres PHP mail.add_x_header
et mail.log
peuvent être spécifiés dans le fichier racine .htaccess comme illustré ci-dessous :
# No header sent by the mail() method php_flag mail.add_x_header off # emails log file php_value mail.log engine/log/emails.log
Le tableau ci-dessous décrit les méthodes publiques de la classe \zdkmail\mod\Email
.
Méthode | Paramètres | Description |
---|---|---|
__construct |
$templateName [string ]$format [string ] = 'AUTO' |
Constructeur de la classe Email à invoquer pour instancier un nouvel objet de type email.
Le paramètre Le paramètre |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); |
Méthode | Paramètres | Description |
---|---|---|
addAddress |
$type [string ]$address [string ] |
Ajoute un destinataire de l'email. Cette méthode est à appeler autant de fois que de destinataires différents de l'email. L'émetteur, l'auteur ou le destinataire de la réponse à l'email peuvent également être précisés par l'appel de cette méthode. Le paramètre
Le paramètre |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); $email->addAddress('FROM','admin@email.com'); $email->addAddress('TO','john.peer@email.com'); $email->addAddress('CC','lisa.halo@email.com'); $email->addAddress('CC','erick.arrow@email.com'); |
Méthode | Paramètres | Description |
---|---|---|
attach |
$fileName [string ] |
Ajoute une pièce jointe à l'email. Cette méthode est à appeler autant de fois que de fichiers à joindre à l'email.
Le paramètre |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); $email->addAddress('TO','john.peer@email.com'); $documentDirectory = ZNETDK_APP_ROOT . DIRECTORY_SEPARATOR . 'app' . DIRECTORY_SEPARATOR . 'document' . DIRECTORY_SEPARATOR; $email->attach($documentDirectory . 'mydocument.pdf'); |
Méthode | Paramètres | Description |
---|---|---|
send |
aucun | Envoie l'email correspondant au modèle d'email spécifié dans le constructeur. Au moins un destinataire doit être renseigné. Retourne |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); $email->addAddress('TO','john.peer@email.com'); $status = $email->send; |
Méthode | Paramètres | Description |
---|---|---|
setMessageValues |
$valeur1 [string ]$valeur2 [string ]$valeur3 [string ]... |
Remplace dans le corps de l'email les motifs %1 , %2 , %3 , ... par les valeurs spécifiées en paramètre. |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); $email->addAddress('TO','john.peer@email.com'); $email->setMessageValues('John Deer','12/01/2015', '100,00€', 'The Administrator'); $status = $email->send; |
Méthode | Paramètres | Description |
---|---|---|
setSubjectValues |
$valeur1 [string ]$valeur2 [string ]$valeur3 [string ]... |
Remplace dans le sujet de l'email les motifs %1 , %2 , %3 , ... par les valeurs spécifiées en paramètre. |
Exemple d'appel : $email = new \zdkmail\mod\Email('new-user'); $email->addAddress('TO','john.peer@email.com'); $email->setSubjectValues('John Deer','12/01/2015'); $status = $email->send; |
API Locale ZnetDK - Javascript
Objet znetdk
Méthode | Paramètres | Description |
---|---|---|
initCommonWidgets |
Objet jQuery de l'élément HTML parent. | Instancie les composants graphiques PrimeUI à partir des éléments HTML contenus à l'intérieur de l'élément HTML parent indiqué en
paramètre sous la forme d'un objet jQuery. Les éléments HTML instanciés en composant graphique PrimeUI sont les suivants :
|
Exemple d'appel : znetdk.initCommonWidgets($('#mon_formulaire')); |
Méthode | Paramètres | Description |
---|---|---|
message |
severity [string]summary [string]detail [string]
|
Affiche le message informatif, d'alerte ou d'erreur à partir des caractéristiques renseignées en paramètres.
La variable severity accepte les valeurs :
critical ) qui lui est affiché à l'aide du composant Notify.
Les variables |
Exemple d'appel : znetdk.message('info','Adding a customer','Customer added successfully.'); |
Méthode | Paramètres | Description |
---|---|---|
multiMessages |
messages [array] |
Affiche les messages de type informatif, alerte ou erreur passés en paramètres sous forme d'objets JavaScript dans le tableau messages .
Les messages sont affichés à l'aide du composant graphique Growl. |
Exemple d'appel : znetdk.multiMessages([ {severity:'info',summary:'Info...',detail:'Info detail...'}, {severity:'warn',summary:'Warning...',detail:'Warning detail'}, {severity:'error',summary:'Error...',detail: 'Error detail'} ]); |
Méthode | Paramètres | Description |
---|---|---|
request |
Objet Javascript aux propriétés suivantes :
control [string]
action [string]
data [object]
callback [function]
|
Emet une demande d'exécution d'une action auprès du contrôleur spécifié.
Cette demande correspond à une requête AJAX de type POST adressée à la page
En option, des données peuvent être transmises à l'action du contrôleur sous la forme de paramètres POST, en renseignant la propriété Pour finir, une fonction à exécuter une fois l'action traitée avec succès par le contrôleur peut être définie pour la propriété |
Exemple d'appel : znetdk.request({ control:'fournisseurctrl', action:'supprimer', data:{numero_fournisseur:18}, callback:function(response){ if (response.success) { console.log( "Suppression réussie" ); } else { console.log( "Erreur à la suppression" ); } } }); |
Méthode | Paramètres | Description |
---|---|---|
showMenuView |
viewName [string]options [object]
|
Affiche la vue correspondant à l'élément spécifié du menu de navigation.
Cette méthode est appelée par exemple en réponse au clic d'un lien hypertexte ou d'un bouton, pour naviguer vers la vue de l'application indiquée.
|
Exemple d'appel : znetdk.showMenuView('myview',{parameter1:'value1',parameter2:'value2'}); Exemple d'interception de l'évènement $('#zdk-office-menu').bind('zdkofficemenuinitview', function(event, parameters) { alert('View displayed with parameters: ', parameters.parameter1, parameters.parameter2); }); |
Méthode | Paramètres | Description |
---|---|---|
showModalDialog |
dialogId [string]viewName [string]beforeShow [function]afterShow [function]
|
Affiche la boîte de dialogue Modal d'identifiant HTML dialogId définie dans la vue PHP viewName et exécute si elles sont renseignées, les fonctions de rappel beforeShow et afterShow avant et après son affichage.
Si la boîte de dialogue n'existe pas encore dans le DOM de la page de l'application, alors la vue PHP Depuis la version 2.6 de ZnetDK, si la function |
Exemple d'appel : var beforeShow = function(dialogElement) { alert('Before...'); }, afterShow = function(dialogElement) { alert('After...'); } znetdk.showModalDialog('mydialog', 'myview', beforeShow, afterShow); |
Evènements déclenchés par ZnetDK
ZnetDK déclenche des évènements JavaScript en réponse à des actions de l'utilisateur sur l'interface graphique.
Ces évènements peuvent être interceptés par l'application pour réaliser des actions complémentaires ou modifier le comportement standard de l'application.
Ces évènements JavaScript sont documentés dans le tableau ci-dessous.
Evènement | Paramètres transmis | Description |
---|---|---|
disconnected |
aucun | Evènement déclenché après que l'utilisateur se soit déconnecté en cliquant sur le lien de déconnexion disponible dans l'entête de l'application ou au clic du bouton "Annuler" depuis la fenêtre de connexion. |
Exemple de code : $('body').on('disconnected', function() { alert('User is disconnected!'); }); |
©réation 2014-2023 | Tous droits réservés | Mentions légales Licence ZnetDK | Projet PMC Logiciels |