Les options d’extensibilité dont nous avons parlées jusqu’à présent concernent uniquement les contrôles intérieurs de POS. En cas de nécessité d’ajouter un nouveau contrôle gérable, nous pouvons utiliser le mécanisme d’extensibilité de la gestion d’interface. Ce mécanisme permet d’enregistrer de nouveaux types de contrôles et de définir lesquelles de propriétés seront gérables. À part de cela, il est également possible de rendre gérables les propriétés des contrôles existants et de masquer la gestion des propriétés sélectionnées.

Masquer les propriétés pour édition

Si une propriété est masquée, elle est supprimée de la gestion d’interface. L’utilisateur ayant accès à la gestion d’interface ne pourra pas modifier sa valeur. La valeur du contrôle dont la propriété sera masquée sera définie par défaut pour la valeur définie dans les styles. Pourtant, si la valeur par défaut a été définie dans le fichier ModernUI.xaml, elle sera ignorée (les différences dans la définition des valeurs par défaut ont été décrites dans le chapitre Définir les valeurs par défaut des propriétés gérables dans l’article Gestion de vues et de ses éléments).

Nous pouvons masquer des propriétés spécifiques sur un contrôle spécifique identifié de manière unique par son Layout Id. La méthode à masquer les propriétés est la méthode DisablePropertiesForLayoutElement dans la classe PropertiesManager. Paramètres de cette méthode :

• layoutId (string) – paramètre qui est l’identifiant du contrôle dont la propriété on veut masquer.
• properties (params DependencyProperty[]) – une ou plusieurs propriétés qui seront masquées pour un contrôle donné.

Exemple du masquage de la propriété Icône (ImageKey) de la mosaïque Nouvelle vente (layout id NewSalesDocument) :

PropertiesManager.Instance.DisablePropertiesForLayoutElement("NewSalesDocument", TileButton.ImageKeyProperty);

Exemple du masquage de la propriété Hauteur (Height) du bouton Valider (AcceptButton) de la configuration globale :

PropertiesManager.Instance.DisablePropertiesForLayoutElement("AcceptButton", FrameworkElement.HeightProperty);

Ajouter des nouvelles propriétés à modifier

Dans le cas où un contrôle existant ou un tout neuf contrôle a des propriétés personnalisées définies et nous voulons qu’elles soient gérables dans la gestion d’interface, il faut les enregistrer. Cela peut se faire de deux manières, selon que la propriété doit être visible uniquement pour un contrôle à un endroit spécifique ou globalement pour toutes les occurrences de ce contrôle.

Dans le premier cas (enregistrement visible uniquement pour un contrôle à un endroit spécifique), il faut utiliser la méthode AddPropertiesForLayoutElement de la classe PropertiesManager. Paramètres de la méthode :

• layoutId (string) – identifiant unique de contrôle (Layout Id),
• properties (params DependencyProperty[]) – propriétés de contrôle qui seront gérables

Dans le second cas (enregistrement visible globalement pour toutes les occurrences de contrôle), il faut utiliser la méthode RegisterControlProperties de la classe PropertiesManager. Paramètres de la méthode :

• controlType (Type) – type de contrôle,
• properties (params DependencyProperty[]) – propriétés qui seront visible pour le contrôle du type indiqué
• baseTypeProperties (Type) – type de contrôle de base à partir de laquelle seront téléchargées les propriétés enregistrées auparavant et utilisées à enregistrer les propriétés de ce contrôle

Gestion des attributs

L’application POS prend en charge les attributs à valeur unique synchronisés à partir du système ERP. Types d’attributs pris en charge : texte, nombre, répertoire, valeur logique, liste, date. Pour que la classe d’attribut donnée soit synchronisée vers un point de vente POS, elle doit être marquée dans le système ERP (Standard) à afficher et/ou à modifier dans la section Retail POS. Les attributs peuvent être affichés sous forme des colonnes dans la liste (contrôle datagrid) ou sous forme des contrôles (générés en fonction du type de classe d’attribut, par exemple pour la classe du type texte ça sera le TextBox, alors que pour le type répertoire ça sera le ComboBox).

Ajouter une nouvelle classe d’attribut à une vue existante dans POS

Dans l’application POS, chaque vue qui prend en charge les attributs est directement associé à un objet du système ERP. Par exemple, la vue Liste des clients affiche les attributs dans la liste sous forme des colonnes. Il est possible d’afficher les attributs avec leurs valeurs attribuées uniquement à l’objet Client dans le système ERP. Dans le cas de la vue du reçu, la liste (datagrid) affiche les classes d’attributs associées uniquement à l’objet Élément de reçu (REC), alors que les attributs affichés dans le coin inférieur droit sous forme des contrôles sont associés à l’objet Reçu (REC).

Liste des vues prenant en charge l’attribut avec les objets du système ERP associés

Pour ajouter à POS la classe d’attribut sélectionnée, il faut la marquer comme Retail POS (aperçu et/ou modification). L’option d’aperçu permettra à l’attribut de fonctionner en mode lecture seule dans l’application POS. En revanche, si l’option modification est sélectionnée, la valeur de l’attribut pourra être modifiée et après l’enregistrement cette information sera transférée au système ERP. Ensuite, il faut lier la classe d’attribut avec le type d’objet approprié qui est pris en charge par POS (voir le tableau ci-dessus). Après avoir ajouté et synchronisé les réglages, les nouveaux attributs apparaîtront dans l’application POS sur la vue appropriée et l’utilisateur POS pourra les gérer à partir du niveau de la configuration d’interface.

Par exemple, nous ajoutons une nouvelle classe d’attribut X qui est du type texte et nous la marquons comme modifiable dans la rubrique Retail POS. Ensuite, nous la lions avec l’objet Client dans le système ERP. Après la synchronisation des données, nous démarrons l’application POS et nous ouvrons la configuration de la vue Ajouter un client. Dans la configuration, nous cochons le conteneur approprié (CustomerItemsContainer) qui permet l’affichage des attributs. Ensuite, il faut sélectionner dans la liste disponible à droite le nouvel attribut X et le faire glisser dans l’endroit souhaité sur la vue.

Ajouter une nouvelle classe d’attribut à la nouvelle vue qui ne la prend pas en charge

La prise en charge des attributs peut être également ajoutée aux vues personnalisées créées dans le cadre de l’extension. Les attributs peuvent être affichés sous forme des colonnes générées dynamiquement dans la liste (contrôle DataGrid) ou sous forme des contrôles indépendants (le type de contrôle sera différent en fonction du type de classe d’attribut).

Attributs sous forme des colonnes dans la liste DataGrid

Afin d’implémenter dans les listes les attributs sous forme des colonnes générées dynamiquement, il faut dans un premier temps implémenter l’interface IAttributable pour l’entité de données. Cette interface fournit trois propriétés indispensables à la prise en charge correcte des attributs dans les listes. Les deux premières propriétés : Id et ObjectType doit être définies conformément à l’entité. L’Id est l’identifiant de l’entité et ObjectType est le type d’entité. La troisième propriété Attributes est un répertoire qui doit être rempli lors du téléchargement asynchrone des données pour la liste. Pour remplir ce répertoire, il faut utiliser la méthode FillAttributesForList qui est dans le service IAttributesService. Avant de pouvoir afficher les données du répertoire, la liste doit d’abord générer des colonnes supplémentaires. Pour que cela soit possible, lors du premier téléchargement des données (IsInitialization=true) il faut définir la propriété AttributeClasses dans la classe AsyncDataGridCollection. Pour définir cette propriété il faut utiliser la méthode GetAttributesClasses du service IAttributesService. Cette méthode adopte deux paramètres : le premier permet de définir quelles classes d’attributs doivent être affichées sur une liste donnée et le second filtre quelles classes seront visibles pour des groupes donnés. Dans le cas où le second paramètre est null, toutes les classes des groupes sélectionnés dans le premier paramètre sont téléchargées. L’implémentation doit être réalisée d’une façon qui permet la gestion du filtrage des classes d’attributs en mode design de vue. De ce fait, cette méthode doit être appelée dans le DesignViewModel d’une vue donnée avec le second paramètre définit sur null. Ceci permet de télécharger toutes les classes et de générer toutes les colonnes possibles (cachées par défaut). En revanche, dans le ViewModel de la vue, il faut transmettre au second paramètre la propriété VisibileAttributesClassesList qui contiendra une liste des classes d’attributs définie en mode design par l’utilisateur. Dans le cas de la méthode FillAttributesForList qui remplit le répertoire Attributes, il faut transmettre deux paramètres. Le premier c’est une liste des entités (une entité doit implémenter IAttribuable) et le second c’est une liste des identifiants des classes d’attributs dans laquelle il faut compléter chaque entité avec les valeurs de ces classes d’attributs. Aux fins d’optimisation et pour ne pas télécharger trop d’informations, le second paramètre est défini en transmettant la propriété VisibleAttributesClassesList.

Le tri des colonnes qui ont été générées pour les attributs n’est pas activé.

Les colonnes générées pour les attributs sont par défaut cachées. Afin de les afficher, il faut implémenter en mode design le téléchargement de tous les attributs possibles pour une liste donnée, pour que l’utilisateur puisse sélectionner cette colonne et définir sa visibilité, ainsi que ses autres propriétés.

Dans le cas où la liste est en mode lecture seule, les attributs sont affichés sous forme de texte. En revanche, en mode d’édition les attributs sont générés sous forme des contrôles appropriés, en fonction du type de données. Pour un type logique ça sera le CheckBox, pour une liste et pour un répertoire le ComboBox et pour les autres types le TextBox.

Un exemple complet d’implémentation peut être consulté dans le chapitre Vue d’un document commercial avec la gestion des attributs dans l’article Exemples.

Attributs comme contrôles indépendants

Une façon alternative d’affichage des attributs dans les vues créées est de les implémenter sous forme des contrôles dynamiquement générés qui dépend du type de classe d’attribut. Ces contrôles permettent également de modifier les valeurs des attributs. Leur implémentation est composée de trois étapes. La première étape consiste à télécharger les attributs et les afficher sous forme de contrôles visibles dans le conteneur défini. La seconde à implémenter la validation des valeurs dans les attributs. La troisième étape c’est l’enregistrement des modifications apportées aux valeurs des attributs. Un exemple complet d’implémentation peut être consulté dans le chapitre Vue d’un document commercial avec la gestion des attributs dans l’article Exemples.