Si l'écriture dans un serveur LDAP est simple avec les fonctions LDAP* du Wlangage, il n'en est pas de même dans le cas bien particulier ou l'on souhaite écrire un mot de passe !
Voici le code nécessaire à l'encodage du mot de passe pour qu'il soit "conforme" LDAP :
sMotDePasse est une chaîne = "secret"
sSel est une chaîne = "graindesel"
sHash est une chaîne = HashChaîne(HA_SHA_160, sMotDePasse+sSel)
sAttrib est une chaîne = "{SSHA}"+Crypte(sHash+sSel, "", crypteAucun, encodeBASE64)
Suite à une demande sur le forum, et intéressé par la fonctionnalité, j'ai recherché comment placer en fond d'un état les différentes pages d'un document PDF.
La méthode n'a rien d'immédiate, je pense que sa publication sera appréciée !
Si un état contient plusieurs pages, et qu'il a en fond un PDF contenant également plusieurs pages, les différentes pages de l'état ne peuvent pas prendre les différentes pages du PDF, mais une seule (et c'est vraiment dommage) :
Il faut donc jongler et créer plusieurs états qui vont être imbriqués les uns dans les autres :
- un premier état est associé à la page 1 du formulaire PDF,
- un deuxième état est associé à la page 2 du formulaire PDF,
- un troisième état est associé à la page 3 du formulaire PDF ....
L'application fera ainsi un iImprimeEtat() du premier état. Ce premier état fera dans son code après impression un iImprimeEtat() du deuxième état, qui appellera à son tour le troisième état...
J'ai testé la solution d'états internes, mais je n'ai pas eu de bons résultats. De façon générale il me semble que les états imbriqués sont à préférer aux états internes.
Gageons que PC SOFT saura faire évoluer la fonctionnalité pour plus de simplicité. Car cette solution s'applique si les pages de l'état sont différentes, mais pas dans le cas ou c'est le bloc corps d'un état qui va se dérouler sur différentes pages ...
Sans aucune programmation il est possible d'insérer des informations dans la barre de messages des applications : date, heure, depuis peu l'utilisateur en cours dans le cas ou l'application utilise le Groupware utilisateur !
Ce principe du "Zéro code" se développe, avec les actions prédéfinies et les FAA notamment, et c'est une bonne chose pour accélérer les développements, limiter les risques d'erreur, ajouter des fonctionnalités !
Ndlr : terminant une longue intervention sur site, je devrais retrouver avec plaisir un peu de temps pour le blog et le forum dans les semaines qui viennent !
Voici une fonctionnalité de la version 12 qu'il faudrait rendre obligatoire, par respect pour les utilisateurs des applications !
Un jour ou l'autre on se retrouve devant un champ, sans savoir où trouver l'information attendue. Dans le meilleur des cas une bulle d'aide est proposée, ou un bouton d'aide dans la fenêtre, mais il n'est pas rare de ne pas être assisté.
Alors que toute saisie respectueuse de l'utilisateur, devrait permettre instantanément de savoir de quoi il s'agit. Voici un exemple de mise en oeuvre de l'aide à la saisie avec WINDEV 12 (c'est également disponible pour les pages WEB des sites WEBDEV) :
Dès que le curseur est placé dans le champ, l'information d'aide s'efface progressivement avec un effet de fondu pour laisser place à la saisie.
Aucune programmation n'est requise, il suffit de fournir l'information qui guidera l'utilisateur dans la description du champ :
Deux fonctionnalités non documentées de WINDEV 12 découvertes après quelques minutes d'utilisation, certes avec l'aide du support, mais cela vaut un petit billet pour faire circuler l'information en attendant que la documentation rattrape la productivité des développeurs !
1. Recherche dans les styles et les options d'édition des champs, information sur le Blog du support. A vos claviers pour tester le Ctrl+F, il y en a peut être d'autres du même type à découvrir !
2. Afficher un PDF dans une image est enfantin :
IMG_TEST_PDF = fRepExe()+["\"]+"AideDépart.PDF"Le positionner sur une page précise est ... tout aussi simple, à condition d'avoir trouvé la bonne propriété (ce que l'aide ne donne pas par défaut pour le moment) :
IMG_TEST_PDF..NuméroPage = 4
Il n'est pas rare de lancer depuis une application le navigateur Web par défaut sur un site. Le traitement est de la forme :
LanceAppliAssociée("http://elianlacroix.blogspot.com")
Les temps de traitement pour des importations de données peuvent générer une attente importante si se cumulent des volumes importants, et des index nombreux. En effet, chaque ajout va nécessiter de mettre à jour les différents index correspondant aux données.
Une alternative permettant des traitements d'importations plus rapides, consiste à différer la mise à jour des index en s'appuyant sur le mécanisme de réindexation.
La phase d'importation se fait en utilisant la fonction "HEcrit" en lieu et place de "HAjoute". Elle permettra d'insérer les données à importer, sans aucune mise à jour des index. Cela permet un gain de temps, très significatif dans le cas d'un fichier ayant de nombreux index.
Une fois les données importées, il suffit d'utiliser la fonction "HRéindexe" qui va mettre à jour les index avec les nouvelles données. Dans bien des cas, cette méthode en deux temps est plus rapide qu'une importation traditionnelle avec la fonction "HAjoute".
Sur le même sujet :
Synthèse pour aller plus vite !
Accélérer le lancement des applications
Par facilité on place régulièrement la fonction "HCréationSiInexistant" au début des applications pour s'assurer de la création systématique de tous les fichiers de données. Le piège, la base grandissante, est d'avoir une attente importante lors de cet appel, car il provoque une ouverture de tous les fichiers de données. Et l'ouverture initiale des fichiers fait partie des opérations les plus coûteuses en temps.
Il y a une solution, presque miracle, c'est l'option "hOuvertureDifférée" de la fonction :
HCréationSiInexistant("*", hOuvertureDifférée)
Le champ onglet est pourvu d'un code de modification, appelé lorsque l'utilisateur change de volet. Ce code permet d'exécuter des traitements concernant le volet qui vient d'être affiché. Il s'exécute lorsque le changement de volet est déjà fait.
Pour toutes sortes de raisons, il peut être utile d'exécuter un traitement lorsque l'utilisateur clic sur un nouveau volet, mais avant même que le nouveau volet ne soit affiché. Il faudrait pour cela un code de modification sur l'onglet, mais avant changement !
Ce code n'étant pas proposé par défaut, il est possible d'utiliser en lieu et place le code optionnel "Bouton gauche enfoncé" du champ onglet. En effet ce code est bien appelé avant même que le changement de volet ne soit effectif. Il permet donc par exemple de faire un contrôle de saisie sur le volet sélectionné avant le clic, pour si besoin interdire le changement de volet en inhibant l'événement.
En créant un aperçu d'une image avec les fonctions "iAperçu", "iImprimeImage" et "iFinImprime", la fenêtre d'aperçu obtenue ne permet pas la sélection de l'imprimante. C'est pourtant bien utile notamment pour les applications qui s'exécutent depuis des postes portables qui changent régulièrement d'imprimante.
Une astuce permettant d'obtenir une impression d'image avec le choix de l'imprimante, consiste à utiliser un état créé par l'éditeur d'états, plutôt qu'une impression programmée. 
Il suffit ensuite de lancer l'aperçu avec la fonction "iImprimeEtat", et l'aperçu sera pourvu du choix de l'imprimante. L'état sera on ne peut plus simple, avec un champ image affecté par un paramètre de l'état, paramètre recevant le nom de de l'image à afficher à l'ouverture de l'état.
Les projets ont toujours des traitements, ou des champs, qui doivent se comporter de façon uniforme, ou provoquer d'autres actions obligatoires au domaine d'application.
Dans la précipitation quotidienne, il n'est pas rare de faire un oubli, préjudiciable en temps par la suite puisqu'il faut revenir sur le traitement ou l'interface, dans le pire des cas après un signalement de l'utilisateur final. 
Il y a une fonctionnalité que j'avais initialement sous-estimée, baptisée "règle métier" qui limite grandement les risques d'oublis. En effet, elles permettent d'indiquer pour des champs ou fenêtres, des actions obligatoires, qui seront automatiquement rappelées pendant les phases de développement qui suivront.
Une illustration en image maintenant que l'information circule en vidéo :
Le site de PC SOFT propose de nouvelles sources d'informations à ne pas négliger pour ne pas passer à côté de fonctionnalités précieuses (cf. prochain billet sur les règles métiers).
Tout d'abord un nouveau blog "Technologies et Marchés" de l'équipe commerciale, mais contenant surtout de l'information technique (tous les blogs).
D'autre part des vidéos en grande quantité pour présenter bon nombre de fonctionnalités. Sans rentrer dans le détail, elles permettent de découvrir de nombreux principes, qu'il est ensuite facile de mettre en œuvre grâce à la simplicité des éditeurs. On retrouve même ces vidéos sur Youtube !
Voyant apparaître sur les forums des demandes de conseils pour optimiser les accès aux données, j'ai regroupé ici les principaux éléments de réponse, et méthodes à employer. L'optimisation des accès est primordiale, surtout lorsqu'ils sont faits au travers d'Internet qui n'offre pas les débits d'un réseau local.
Privilégier les sélections par des requêtes :
Il est préférable d'effectuer les sélections de données au travers de requêtes. En effet, par opposition à des accès enregistrement par enregistrement, elles vont permettre de "ramener" sur le poste client les données sélectionnées, par "paquets" réseau bien remplis. Des lectures enregistrement par enregistrement vont au contraire générer du trafic avec à chaque fois peu de données. De plus la lecture d'un enregistrement impose de récupérer toutes ces rubriques, alors que la sélection d'une requête peut être affinée en ne prenant que les rubriques utiles à un moment donné. Ceci est d'autant plus vrai si la connexion se fait par Internet.
Optimisation des requêtes :
Le menu "Requête / Optimiser la requête" accessible en édition d'une requête doit finaliser la phase de création d'une interrogation. Il permet d'ajouter si besoin les clés dont la requête aura besoin pour un maximum de rapidité.
Statistiques des index à jour :
Les clés dans le fichier sont importantes, à condition que les statistiques des index soient régulièrement mis à jour (surtout après des ajouts en grand nombre).
Rester raisonnable :
La facilité avec laquelle on programme et accède aux données, le tout généralement dans l'urgence, provoque parfois une négligence de l'évaluation de ce que l'on demande. Chaque enregistrement à une taille bien précise, chaque interrogation va ramener un ensemble d'enregistrements, donc un volume précis. Il faut tenir compte, surtout en accès via Internet, de ce volume, afin d'évaluer avec le débit minimal si l'application ne demande pas trop par rapport à ce qu'elle peut recevoir.
Client/Serveur :
Privilégier un accès aux données au travers du moteur Hyper File Client/Serveur, il va permettre de soulager grandement le travail de chaque poste client, et donc de gagner en performances. Les procédures stockées vont offrir également des gains. Typiquement, un long calcul statistiques pourra être fait en "différé" de l'application, permettant à un utilisateur d'avoir un résultat immédiat en remplacement d'une attente.
Son mécanisme de "Log" pourra également permettre un suivi très fin des interrogations en vue de rechercher notamment des abus d'une station, ou d'un traitement.
Analyseur de performances :
Lorsque l'on a encore des attentes, il faut exécuter l'analyseur de performances qui va permettre de les localiser très précisément. Une fois que l'on sait où passe le temps, il devient possible de voir comment l'influencer (dans un programme uniquement à mon grand regret).
Cas particulier pour l'attente du matin, il faut garder dans un coin de tête le possible trouble que peut engendrer la restauration du système.
Ce billet n'a rien d'exhaustif le sujet étant si vaste, je tenterai de le compléter régulièrement. Mais pas trop vite tout de même, car il est temps pour moi de prendre quelques jours de repos en cette période estivale !
Sur le même sujet :
Accélérer le lancement des applications.
Accélérer les traitements d'importation de données
Description surprenante d'un utilisateur final :
Tous les matins le premier enregistrement d'une commande prend du temps, les suivants sont immédiats !?
La copie d'écran ci-contre donne une illustration, et ce lien donne une page de détail sur un site Microsoft.
Surprise après le déploiement d'une application déployée sur un serveur (aucun fichier sur les postes des utilisateurs à part un raccourci) : les aides au format CHM présentaient une erreur de "Navigation vers la page Web annulée".
Renseignement pris auprès du support, rien de plus normal avec un Windows XP à jour : ce n'est pas autorisé !!! Sécurité Microsoft oblige, les .CHM doivent être en local pour une visualisation directe. Il est cependant possible de passer outre cette "sécurité", en suivant les recommandations de cet article :
http://support.microsoft.com/default.aspx?scid=kb;fr;902225
"Tranche de vie", avec un long moment perdu à ne pas réussir à passer un paramètre à un état. Malgré un iImprimeEtat(NomEtat, Paramètre), j'avais systématiquement le message "on attendait 1 paramètres, on en a reçu 0".
Après de longues minutes à chercher, j'ai finalement trouvé mon erreur dans la description de l'état, ou par mégarde les bornes "min" et "max" étaient cochées je ne sais plus pour quelle raison. Le bon code d'appel de l'état avec des bornes et un paramètre aurait du être iImprimeEtat(NomEtat, ValeurBorneMin, ValeurBorneMax, Paramètre).
J'espère que ce billet pourra dépanner quelqu'un, un jour, ce qui me permettra de me sentir moins seul sur pareil bêtise !
Il est de plus en plus fréquent de devoir implémenter un suivi des emails dans les systèmes d'information, par exemple pour qu'une réponse soit directement dirigée vers le bon collaborateur.
L'exemple WD Suivi Email de la LST 68 donne le principe de base, en utilisant la variable Email.Référence. Mais j'ai eu besoin d'aller plus loin pour le cas ou l'on souhaite récupérer directement l'identifiant du dernier message que l'on a envoyé. En effet, le champ Email.Référence empile les identifiants des différents messages, il peut donc être utilise de faire un parcours en sens inverse de son contenu pour trouver l'identifiant du dernier message envoyé. D'autre part dans la structure des emails on peut trouver directement l'identifiant du dernier message, dans une section "In-Reply-To".
Voici donc deux fonctions permettant de parvenir au résultat attendu, n'hésitez pas à les réutiliser si elles répondent à vos attentes !
FONCTION ChercheRéférence(_SourceEmail)
// Recherche dans le code source d'un email reçu en paramètre
// s'il s'agit d'une réponse à un message envoyé précédemment
// On recherche d'abord la balise In-Reply-To, puis dans les
// références (en partant de la fin)
// MESSAGEID_DOMAINE est une constante du projet contenant
// le domaine donné lors de l'envoi des messages (partie droite du @)
sReference est une chaîne
sListeRéférence est une chaîne
sReference = :InReplyTo(_SourceEmail)
SI Position(sReference, MESSAGEID_DOMAINE, 1, SansCasse) ALORS
// Une référence a été trouvée, elle est renvoyée.
RENVOYER sReference
SINON
// Pas de "InReplyTo" dans ce message, on va regarder les références de l'email en partant de la fin.
SI Email.Référence <> "" ALORS
// On supprime les espaces entre les références pour les parcourir
sListeRéférence = Remplace(Email.Référence, " ", "")
POUR TOUT CHAINE sReference DE sListeRéférence SEPAREE PAR "><" DEPUISFIN
// On teste si la référence en cours nous appartient
// Si oui, on a retoure car c'est la plus récente et donc celle que l'on veut.
SI Position(sReference, MESSAGEID_DOMAINE, 1, SansCasse) ALORS
RENVOYER SansEspace(Remplace(Remplace(sReference, ">", ""), "<", ""))
FIN
FIN
// Pas de référence trouvée si on arrive jusque là
RENVOYER ""
SINON
// Par de référence non plus (nouveau message ou réception d'un Webmail qui ne les fait pas suivre)
RENVOYER ""
FIN
FIN
FONCTION InReplyTo(_SourceEmail)
// Retourne le In-Reply-To d'un email dont on reçoit
// le source complet en paramètre (par exemple Email.Source)
// Le In-Reply-To trouvé correspond à l'identifiant d'un email
// envoyé précédemment
sInReplyToBalise est une chaîne = RC+"In-REPLY-TO:"
sInReplyTo est une chaîne
nPosInReplyTo est un entier
nPosInReplyTo = Position(_SourceEmail, sInReplyToBalise, 1, SansCasse)
SI nPosInReplyTo > 0 ALORS
sInReplyTo = ExtraitChaîne(_SourceEmail[[(nPosInReplyTo+Taille(sInReplyToBalise)+1) A ]], 1, RC)
RENVOYER SansEspace(Remplace(Remplace(sInReplyTo, ">", ""), "<", ""))
SINON
// L'info n'est pas trouvée
RENVOYER ""
FIN
Dans l'ordre normal des choses, l'ouverture d'une fenêtre provoque l'enchaînement des traitements suivants :
- code de déclaration des globales de la fenêtres,
- code d'initialisation successives des différents champs,
- et enfin le code d'initialisation de la fenêtre.
Alors qu'elle peut être l'option qui provoque l'exécution du code de modification d'un des champs, avant le code d'initialisation de la fenêtre ? 
C'est l'option "Mémoriser la valeur" du détail de la description des champs. En effet, j'ai bataillé un moment pour trouver pourquoi j'avais un onglet dont le code était appelé de la sorte. C'est comme tout, une fois qu'on le sait, cela devient simple et évident. En effet, comme le système restaure un choix de l'utilisateur de l'application, il exécute également le code qui avait été provoqué par ce choix.
Les combinaisons d'installations d'une application WINDEV MOBILE sur un périphérique mobile sont nombreuses, il n'est pas évident de s'y retrouver au départ :
- Utiliser le Framework PC SOFT non renommé,
- Utiliser un jeu de DLL renommées,
- Utiliser un Framework commun renommé.
Le tout à combiner avec le type d'installation retenue : via un fichier MSI ou un fichier .CAB.
Pour faire un bon choix, il faut avoir les réponses aux questions suivantes qui vont dépendre du domaine d'activité, du matériel (...) :
- l'installation sera-t-elle faite sur un mobile directement, sans connexion à un PC ?
- le mobile dispose-t-il d'un espace de stockage important (carte mémoire additionnelle) ?
- plusieurs applications devront-elle être installées ?
Avec ces réponses, il est facile de s'orienter vers le choix le plus adapté, sachant qu'il s'agit de toute façon de compromis :
- installation sur mobile sans connexion à un PC ?
Dans ce cas il faut générer une installation en .CAB qui sera copiée sur le mobile (et automatiquement supprimée après exécution). Dans le cas contraire, un MSI sera préférable car exécuté au travers d'un installeur Microsoft avec lequel l'utilisateur est généralement familiarisé.
- le mobile dispose d'espace avec une carte additionnelle ?
Dans ce cas il est préférable d'utiliser un jeu de DLL renommées, unique pour l'application. De cette manière un .CAB unique sera créé facilitant l'installation. Dans le cas contraire, il faut limiter l'espace occupé en ayant un unique Framework sur le mobile. Si une seule application doit être installée, on garde un jeu de DLL renommées, unique pour l'application. Par contre s'il faut installer plusieurs applications, on retient le choix :
-- utiliser le Framework PC SOFT non renommé pour placer le Framework directement dans le mobile,
-- ou utiliser un Framework commun renommé pour placer le Framework directement sur une carte mémoire.
Dans ces deux cas, 2 fichiers .CAB sont générés : un pour l'application, l'autre pour le Framework.
J'espère que ce résumé pourra donner quelques orientations...
Quelques jours passés en Suisse le mois dernier, de nouveaux matériels répondants maintenant à des attentes réelles des utilisateurs, et une bonne promo à "1 euro de plus" comme PC SOFT en a le secret, ont eu raison de moi : me voilà tout fraîchement équipé d'un Smartphone (QTEK) HTC S710.
L'occasion donc d'ajouter une nouvelle catégorie dans le Blog : la mobilité ! J'espère prochainement vous faire partager mes premières astuces et conseils, mais il va falloir que je découvre auparavant ce "nouveau monde" ou l'ergonomie doit être sans cesse la priorité du Développeur !
Il ne faut pas se fier aux idées reçues, ces petits concentrés de technologies ne sont plus des gadgets !
Ndlr : ne vous méprenez pas en ce qui concerne la Suisse, j'ai simplement pu y observer une utilisation bien plus fréquente de ce type d'équipement qu'en France. Rien à voir avec ce qui pourrait fâcher un douanier !
Petite astuce lorsque l'on doit donner une forme hexadécimale à une chaine : utiliser la fonction "NumériqueVersChaine" qui permet la conversion simple d'une valeur décimale en hexadécimale. Exemple :
sChaine est une chaîne = "Bonjour, 27 juin 2007"Une application directe, visualiser le Hash d'un fichier par exemple, car sans conversion de ce type la valeur contient des signes cabalistiques peu lisibles.
sChaineHexa est une chaîne
POUR i = 1 A Taille(sChaine)
sChaineHexa += NumériqueVersChaîne(Asc(sChaine[[i]]), "2X")
FIN
Info(sChaineHexa)
Pour le déploiement des applications, il faut garder dans un coin de tête que les éléments (fenêtres, états, images ...) de la bibliothèque sont prioritaires à ceux localisés sur disque.
Exemple type, dans une application on propose à l'utilisateur de changer l'image de fond de sa fenêtre principale. Pour cela, on a dans le code de déclaration des globales de la fenêtre :
MaFenêtre..ImageFond = ComplèteRep(fRepExe())+"ImageFond.jpg"Il suffit de changer l'image "ImageFond.jpg" du répertoire de l'exécutable pour personnaliser l'image de fond de la fenêtre. Mais attention, cela ne fonctionne que si dans l'application aucune image "ImageFond.jpg" n'est utilisée par ailleurs. Dans le cas contraire, l'image utilisée par l'application est incluse dans la bibliothèque, elle est prioritaire, et une nouvelle image "ImageFond.jpg" dans le répertoire de l'exécutable est tout simplement ignorée.
Lorsqu'une colonne combo d'une table est chargée par programmation avec "ListeAjoute", et que chaque élément a un identifiant donné avec "gLien", la récupération de cet identifiant n'est pas immédiate.
D'abord il ne faut pas cocher l'option "retourner la valeur spécifiée avec la fonction gLien" dans le détail de la description de la colonne combo.
Ensuite il faut utiliser dans le code la syntaxe suivante :
Info(NomTable.NomColonneCombo[NuméroLigne][NomTable.NomColonneCombo[NuméroLigne]])
Pour faire patienter un utilisateur, l'utilisation d'un sablier est parfaitement adaptée. Mais dans la "vie" d'une application, un traitement simple au départ s'enrichie au fil du temps, fait appel à des composants, dialogues avec d'autres applications ... bref au final, il y a quelque part un Sablier(Vrai) qui persiste et ne veut plus s'enlever même avec un Sablier(Faux) dans le traitement.
Voici une méthode de contournement permettant de s'assurer de la disparition définitive d'un sablier laissé par un traitement.
Il faut créer une procédure globale "StopSablier", qui contiendra uniquement un appel de Sablier(Faux). Les automatismes de procédure feront le reste, comme le montre la copie d'écran du billet. Pour résumer, avec un seul appel de la procédure dans le code, on va appeler 3 fois Sablier(Faux), on est ainsi certain de reprendre le curseur de souris standard !
Pas forcément élégant, mais radicalement efficace !
Pendant longtemps le passage au Débogueur d'un code permettait :
- de suivre l'exécution en pas à pas (F7),
- de repérer le traitement à corriger,
- faire la correction,
- relancer un test pour s'assurer du résultat en ayant donc à refaire tout le processus permettant d'arriver au traitement...
Mais maintenant il y a le bouton que je surnomme le "bouton magique du Débogueur", qui permet de définir l'instruction suivante, tout en débogant. Il facilite en effet considérablement la mise au point et permet :
- de suivre l'exécution en pas à pas (F7),
- de repérer le traitement à corriger,
- faire la correction, et immédiatement rexécuter le code juste avant cette modification !!! Il n'est plus nécessaire de relancer le test et donc de refaire tout le processus permettant d'arriver au traitement.
Il est même possible de changer une fenêtre sous l'éditeur, et de réexécuter son ouverture. Mais là les cas d'usage sont moins fréquents.