Intégration rapide avec 1C: Enterprise

Dans cet article, je parlerai de la manière la plus simple, à mon avis, d'intégrer des applications tierces avec des configurations 1C. L'article intéressera principalement les développeurs qui écrivent sur .Net Core , PHP et Python .

Il existe de nombreuses façons de s'intégrer à 1C, un excellent article de 1C lui-même y est même consacré. Vous en apprendrez en particulier que 1C prend en charge les mécanismes des services Web, ce qui signifie que nous pouvons implémenter notre propre service du côté 1C et, par conséquent, notre propre bibliothèque ORM du côté de l'application cliente. Une de ces bibliothèques sera discutée plus loin.

Description de la technique en termes généraux

Du côté de 1C

Tout commence par le fait que l'extension «Brom» est ajoutée à la configuration 1C, en ajoutant un nouveau service Web. L'extension est disponible gratuitement et sous licence (MIT). L'extension elle-même n'est pas liée à un modèle de données spécifique et peut donc être installée sur n'importe quelle configuration prenant en charge le mode de compatibilité 8.3.10 ou supérieur.

Une fois l'extension installée, vous devez configurer les droits des utilisateurs qui auront accès aux méthodes de service Web, ainsi que publier la configuration sur le serveur Web afin que le service ajouté soit accessible via le protocole http (s). Côté 1C, rien de plus n'est requis.

Côté client

Côté client, le package Brom est connecté, par exemple, pour .Net Core, cela peut être fait avec la commande:

Install-Package Brom -Version 1.0.1-beta08 

Ou pour Python:

 pip install brome 

Après avoir installé le package, il suffit de créer un objet client à travers lequel l'interaction avec la configuration 1C distante sera effectuée. Ci-après je donnerai le code en C #, mais en PHP et Python c'est similaire. Et donc, vous pouvez créer un client avec une seule commande:

 dynamic  = new (@"  = http://mydomain.com/publication_name;  = 1c_user_name;  = 1c_user_pass "); 

Dans le constructeur, il suffit d'indiquer l'adresse de la configuration 1C publiée, et les données de l'utilisateur à qui nous avons délivré les droits d'accès à l'extension. Dès que le client est créé, nous pouvons procéder au plus intéressant.

Appel des procédures et fonctions 1C

Grâce au client de brome créé, nous pouvons appeler les procédures et fonctions définies dans 1C. Dans ce cas, les méthodes appelées doivent être côté serveur et être contenues soit dans le contexte global, soit dans des modules serveur (modules généraux ou modules gestionnaire). Par exemple, voici à quoi ressemble l'appel de fonction du contexte global «Prescription numérique»:

 string  = .(2547, " = fr_FR"); 

Le deuxième paramètre est une chaîne de format indiquant la localisation (français). Les paramètres sont transférés sous une forme naturelle et ne nécessitent aucune conversion ou emballage supplémentaire.

Et voici à quoi ressemblera l'appel à la fonction Rechercher par code du module gestionnaire d'annuaire:

 var  = ...(840); 

Ici, nous avons appelé la fonction via le répertoire du gestionnaire de modules "Devises". Le résultat de l'appel sera un objet de type "DirectoryReference". Maintenant, le lien résultant vers l'objet peut être passé en tant que paramètre à une autre fonction:

 var  = ..(, DateTime.Today); 

Cette fois, nous nous sommes tournés vers le module général «Travailler avec des devises» et avons sauvé sa méthode «Obtenir des cours en devises».

La bibliothèque prend en charge le travail avec des types de données complexes, il est donc possible d'appeler des méthodes qui prennent ou retournent: Liens, Tableaux, Structures, Tables de valeurs, Arbres de valeurs, énumérations système, etc. ... Certaines classes sont spécialement implémentées dans la bibliothèque cliente pour simplifier le travail avec 1C.

La portée des méthodes distantes peut être configurée de manière flexible en les spécifiant dans les paramètres. Ainsi, par exemple, si vous spécifiez la zone "Répertoires. *. Rechercher par code", seule la méthode "Rechercher par code" sera disponible dans tous les répertoires de configuration. Ainsi, vous pouvez clairement indiquer les méthodes qu'une application intégrée peut utiliser.

Travailler avec des liens

Les références aux objets permettent non seulement de transférer le pointeur vers l'objet 1C, mais également de recevoir les données de l'objet lui-même. Travailler avec des liens côté client est aussi simple qu'en 1C. Par exemple:

 var  = ...("00-000018", new Date(2017, 1, 1)); var  = .; var  = .; var  = ..; foreach (var  in .) { Console.WriteLine((., .)); } 

Ici, nous avons trouvé un lien vers le document via le module gestionnaire et obtenu les valeurs des champs du document et de sa section tabulaire «Produits». Après le premier accès au champ objet, toutes ses données sont téléchargées depuis le serveur 1C et stockées sur le client jusqu'à ce que le lien soit supprimé par le garbage collector.

Un lien vers l'objet peut également être obtenu côté client sans accéder au serveur. Pour ce faire, il suffit de connaître l'identifiant unique de l'objet:

 var  = ...(new Guid("5a32b6ab-4661-11e9-912a-38d547755ef7")); 

Vous pouvez également simplement obtenir des liens vers des éléments de collection prédéfinis:

 var  = ...18_118; 

Modification d'objets

Ayant un lien vers l'objet, nous pouvons éditer les données de l'objet. Pour ce faire, créez simplement un contexte d'objet:

 var  = .(); . = DateTime.Today; . = "00-000055"; ..(); var  = ..() . = ...("000000104"); . = 3; .(.); 

Dans cet exemple, nous avons créé le contexte du document via un lien vers le document, rempli certains champs, ajouté une ligne à la section tabulaire «Produits» et enregistré le document en mode publication.

Si vous devez créer un nouvel objet, cela est également possible:

 //     var  = ...(); . = " "; .(); //     var  = ...(); . = .; . = " "; . = "T-00012321"; //    .(); //      var  = .; 

Ici, nous avons créé un nouveau groupe dans le répertoire «Nomenclature», puis créé un élément de répertoire et placé dans le groupe créé.

Échantillonnage

Comme tout ORM décent, le client brome vous permet de créer des échantillons à partir de diverses collections d'objets 1C. Une sélection est une collection de références à des objets de collection qui satisfont un ensemble de conditions de sélection. Pour créer une sélection, il suffit de créer l'objet «Sélecteur»:

 var  = ...(""); var  = ...(); . (", , , ."). ("", false). ("", , .). (""). ("", .); foreach (var  in ) { Console.WriteLine(": {0}; : {1}, : {2}; : {3}", ., ., ., .. ); } //         var  = .(); 

Dans cet exemple, nous avons obtenu un exemple qui contient des éléments du répertoire "Nomenclature", qui sont hiérarchiquement dans le groupe "Furniture". Nous avons souligné qu'en plus des liens eux-mêmes, il est nécessaire de charger les données de certains champs. Pour cette raison, les données de ces champs seront chargées avec une seule demande et leur accès ne conduira pas à des appels de serveur supplémentaires.

Exécution de requête

Le plus souvent, les données stockées dans une collection deviennent insuffisantes et nous devons obtenir les données générées par une requête complexe. Pour répondre aux demandes, une classe spéciale «Demande» est fournie dans la bibliothèque cliente. Le travail avec les demandes côté client est très similaire au travail du côté 1C:

 var  = .(@"  .  , .  , .    .    . = & "); .("", "-0001"); var  = .(); foreach (var  in ) { Console.WriteLine((., .)); } 

Ici, nous avons créé une requête simple avec un paramètre qui sélectionne les données du répertoire "Nomenclature". En tant que paramètre, nous avons passé l'article chaîne de l'élément. Dans le cas général, la valeur du paramètre peut également être des liens, des énumérations système et même des tableaux. À la suite de la requête, nous avons renvoyé la "table des valeurs", cette classe est implémentée côté client. Dans cet exemple, nous avons déduit les champs des lignes du tableau à l'aide d'une boucle.

Du côté 1C, toutes les demandes sont exécutées via le générateur de requêtes, vous pouvez donc spécifier non seulement une demande prête à l'emploi sous forme de texte, mais également un modèle de demande contenant du balisage pour le générateur:

 var = .(@"   5 .  , .  , .   { .*}  ..( {(&)}, { ().*, ().*} )   { .} {  .*, .*} "); //         .("..", ""); //      .("", 100, .); //       .("."); .("", .); var  = .(.); 

Dans cet exemple, nous avons spécifié une requête standardisée, dont les paramètres peuvent être modifiés dynamiquement côté client si nécessaire. Pour cette raison, les champs, sélections et tri peuvent être indiqués dans le corps du code de programme principal et non dans le corps de la demande.

La méthode Run accepte le paramètre facultatif «type d'analyse des résultats». Si vous spécifiez le type d'analyse "Par regroupement" ou "Par regroupement avec une hiérarchie", alors au lieu d'une table de valeurs, la méthode renvoie un arbre de valeurs.

En outre, au lieu de la méthode Run, vous pouvez appeler la méthode Run Package (pour exécuter plusieurs demandes à la fois). Dans ce cas, un tableau de tables ou un tableau d'arbres sera retourné, selon le type de traversée.

Exécution d'extraits de code

Dans certains cas exotiques, vous devrez peut-être exécuter un morceau de code spécifique directement du côté 1C. Pour ce faire, le client Brom fournit la méthode "Exécuter". La méthode prend un texte d'entrée contenant du code exécutable et un paramètre facultatif, qui sera disponible dans le code dans la variable «Paramètre»:

 var  = .(@"  = 0;        =  + ; ; ", new double[] { 45, 67, 12.56, 11.9 }); 

Dans cet exemple, nous avons exécuté un morceau de code qui additionne les nombres dans un tableau. Le tableau lui-même a été transmis en tant que paramètre et placé dans la variable "Parameter". Le résultat du calcul a été placé dans la variable "Résultat". Si une variable portant ce nom est remplie dans le code exécutable, sa valeur au moment où l'exécution se termine est renvoyée comme résultat de la fonction "Exécuter".

La possibilité d'exécuter des fragments de code est régie par un rôle d'accès distinct dans l'extension. Il est recommandé d'activer ce rôle uniquement à des fins de test, et assurez-vous de le désactiver dans le projet de travail, comme Il s'agit d'une vulnérabilité évidente.

Avantages inconvénients de la technique

Les avantages de la méthodologie décrite devraient certainement inclure:

• Multiplateforme . Toutes les interactions sont basées sur les protocoles SOAP et HTTP, et leur implémentation se fait sur toutes les plateformes de développement populaires;
• La simplicité du code . Le code côté application client est presque identique au code côté 1C;
• Mécanismes de sérialisation intégrés . Nous n'avons pas besoin d'emballer et de déballer les données pour les échanger avec 1C;
• Support pour travailler avec des liens . Nous avons un accès facile aux objets 1C via des liens;
• Prise en charge des types de données spécifiques à 1C . Nous pouvons échanger avec des tables 1C, des arbres, des structures et d'autres structures complexes;
• Accès au contexte de l'application . Nous avons accès non seulement aux données de la base de données, mais nous avons également la possibilité d'appeler des méthodes définies sur le côté 1C, et avons également accès à l'état de la session.

Les inconvénients de cette technique sont également disponibles:

• Faible débit de données . Étant donné que le protocole SOAP est basé sur la sérialisation XML, le transfert de grandes quantités de données nécessite du temps pour l'échange du trafic excédentaire, ainsi que pour l'emballage et le déballage des données. La communication via une connexion COM semble préférable dans ce contexte;
• Un client pratique n'est pas disponible sur toutes les plateformes . Si vous n'êtes pas un programmeur .Net Core, PHP ou Python, vous devrez implémenter le client brome vous-même à l'aide de mécanismes SOAP, ce qui, en général, prend beaucoup de temps;
• Limitations du langage de requête 1C . Étant donné que tout le travail avec la base de données s'effectue via le mécanisme de requête 1C, il existe certaines limitations. Par exemple, vous ne pouvez pas implémenter la pagination classique des données, car dans le langage de requête 1C, il n'y a aucun mécanisme de pagination.

Comparaison avec OData

À partir de l' article 1C susmentionné, vous pouvez découvrir que dans 1C: l'accès aux données d'entreprise est implémenté à l'aide du protocole OData normalisé. Pour cette raison, il serait stupide de ne pas le mentionner non plus.
Voici un bref tableau de comparaison:

On voit que ces méthodes ont leurs avantages et leurs inconvénients et, dans le cas général, ne sont pas interchangeables.

Conclusion

J'espère que cet article de revue vous aidera à l'avenir à créer rapidement et facilement des portails, des comptes personnels et des services qui sont étroitement intégrés aux systèmes comptables basés sur 1C: Enterprise. Vous pouvez trouver des informations détaillées sur les composants du brome dans la documentation officielle, voici juste un bref aperçu des principales fonctionnalités.