Bonne journée tout le monde!
Je pense que les informations contenues dans ce sujet seront très utiles à de nombreux visiteurs de ce forum.
Pendant longtemps, je n'ai pas pu résoudre le problème : comment ouvrir le formulaire d'un nouveau document pour qu'il ne s'ouvre pas vide, mais déjà partiellement rempli par programme, alors que le document lui-même n'a pas encore été enregistré dans la base de données ? J'ai passé beaucoup de temps à chercher une solution à ce problème sur Internet, j'ai visité de nombreux forums où ce problème a été soulevé, mais seuls quelques-uns d'entre eux ont trouvé des solutions. Le plus simple consiste à créer d'abord par programme un nouveau document, à remplir par programme les détails nécessaires, à écrire le document dans la base de données, puis à l'ouvrir à l'utilisateur. Que faire si l'utilisateur ne souhaite pas l'enregistrer ? Et s'il change d'avis et ferme le formulaire ouvert ? Dans ce cas, le document déjà enregistré restera dans la base de données. Et qui a besoin de documents supplémentaires dans la base de données ?
Et si vous n'enregistrez pas le document, l'option la plus populaire consiste à utiliser la méthode GetForm (« Documents. Type de document requis. Formulaire de document »). Mais dans ce cas, vous pouvez obtenir un formulaire de document vide et simplement l'afficher à l'aide de la méthode Open(). Ce n'est pas non plus une option...
Après un certain temps, le problème a été résolu à l'aide de la fonction contextuelle globale « Remplir les valeurs de propriété ».

Contexte mondial
FillPropertyValues
Syntaxe:
Remplissez les valeurs de propriété (<Приемник>, <Источник>, <Список свойств>, <Исключая свойства>)
Description:
Copie les valeurs des propriétés<Источника>aux propriétés<Приемника>. La correspondance est effectuée par noms de propriété.

En utilisant ma tâche comme exemple, je voudrais expliquer comment vous pouvez utiliser cette fonction pour remplir un formulaire pour un nouveau document. La tâche était la suivante : Il existe un document (Ordre de travail), dont la partie tabulaire est un autre document (Prestation de services). Ainsi, il fallait s'assurer que lorsqu'un nouveau document « Prestation de services » était ajouté à la partie tabulaire du « Bon de travail », la forme du nouveau document « Prestation de services » s'affichait à l'écran avec les détails déjà renseigné, extrait du bon de travail à partir duquel la création a été provoquée. Parallèlement, le nouveau document lui-même, au moment où sa forme apparaît à l'écran, n'est pas encore enregistré dans la base de données. Cela devait être fait si l'utilisateur décidait soudainement de ne pas remplir le document et fermait simplement le formulaire.
Voici un fragment de code avec une solution au problème :

&Sur la procédure client EnterRecord()RecordForm = GetForm("Document.Provision of Medical Services.ObjectForm"); Fill inPropertyValues(RecordForm.Object,Object,"Date,Spécialiste,Spécialisation,Infirmière,Statut d'exécution",); // Renseignez les valeurs des détails dont les noms sont les mêmes dans les deux documents TextStr = Elements.Reception.CurrentData; //Données de la ligne courante du document sourceProperty Structure = New Structure; // La structure contient les valeurs des détails qui doivent être renseignés sur le formulaire du nouveau document, mais qui ne figurent pas dans le document source StructureProperties.Insert("Work Order", Object.Link); PropertyStructure.Insert("ReceptionTime",TexStr.ReceptionTime); RemplissezPropertyValues(RecordForm.Object,PropertyStructure,"RecordOrder,AppointmentTime",); EntryForm.Open(); Fin de la procédure

Autrement dit, nous effectuons toutes les opérations directement sur le client, sans contacter le serveur, dans le cadre d'une procédure créée indépendamment. En fait, vous pouvez ainsi remplir et ouvrir le formulaire de n’importe quel document ou ouvrage de référence. Tout d'abord, j'ai rempli les détails d'un formulaire à l'autre à l'aide d'objets de formulaire, puis, à l'aide de l'objet « Structure », dans lequel j'ai inséré les détails manquants, j'ai rempli quelques détails supplémentaires sur le formulaire en cours d'ouverture, puis j'ai ouvert le formulaire.
J'espère que ce sujet fera gagner du temps à beaucoup de personnes confrontées à une tâche similaire !

L'ouverture par programme de formulaires dans une application 1C gérée est très différente de leur ouverture dans une application standard. Regardons d'abord l'ancienne méthode. Elle consiste à recevoir un formulaire puis à l'ouvrir en mode normal ou modal (lorsqu'il est ouvert en mode modal, le formulaire bloque le programme).

GetForm() . Ouvrir()

Il s’agit de la méthode d’ouverture de formulaires la plus lente. Cependant, il vous permet de traiter le formulaire par programme avant de l'ouvrir. Pour traiter le code, vous devez modifier un peu :

Formulaire = ObtenirFormulaire( "Document. Réception des biens et services. Formulaire de document") ;
//Ici, nous effectuons des actions avec le formulaire
Formulaire. Ouvrir();

Il faut tenir compte du fait qu'à la réception du formulaire, une autre procédure événementielle sera exécutée QuandCrééSurServeur.

Examinons d'autres méthodes qui vous permettent d'ouvrir des formulaires dans une application 1C gérée plus rapidement et plus facilement. Selon la situation spécifique, différentes méthodes peuvent être utilisées.

1. Comment ouvrir un formulaire objet dans une application gérée s'il existe un lien vers celui-ci.

Dans ce cas, tout est extrêmement simple.

RefLink = Répertoires. Nomenclature. FindByCode("000000001" ) ;
OpenValue(RefLink) ;

2. Comment ouvrir le formulaire de sélection puis obtenir la valeur sélectionnée.

Il y a une fonction pour ça EntrezValeur(). La fonction a 3 paramètres :

• La variable dans laquelle la valeur sélectionnée sera écrite ;
• Un indice qui sera affiché dans la fenêtre de sélection ;
• Description des types de valeurs sélectionnées. Il peut y avoir plusieurs types, auquel cas vous serez invité à sélectionner un type avant de sélectionner une valeur spécifique.

À la suite de l'exécution de la fonction, le formulaire de sélection par défaut pour un objet du type spécifié s'ouvrira.

Valeur variable ;
Tableau= nouveau tableau ;
Tableau. Ajouter(Type( "RépertoireLink.Nomenclature") ) ;
Tableau. Ajouter(Type( "DirectoryLink. Contreparties") ) ;

TypeDescription= nouveau TypeDescription(Array) ;

Res = EnterValue(Valeur, "Indice", TypeDescription) ;

Les méthodes précédentes permettaient uniquement d'ouvrir les formulaires par défaut des objets (formulaire objet ou formulaire de sélection). Si vous devez ouvrir un formulaire personnalisé, vous pouvez utiliser la fonction OuvrirFormulaire().

Cette fonction a pas mal de paramètres. Examinons-en quelques-uns :

• Nom de forme— ici, vous pouvez sélectionner l'une des formes d'objet standard, par exemple, Formulaire de sélection ou Formulaire de liste. Ou un formulaire spécifique créé par les développeurs.
• Possibilités— vous permet de le transférer vers le formulaire dans le formulaire constructions certains paramètres avant de l'ouvrir, déterminant ainsi les données de sortie. Les paramètres peuvent être n'importe quelle donnée pouvant être transmise du client au serveur. Les paramètres passés à l'ouverture du formulaire peuvent être traités dans la procédure QuandCréationSurServeur() au formulaire en cours d'ouverture.
• Mode d'ouverture du formulaire— dispose de 3 options : indépendant, bloquer toute l'interface, bloquer le formulaire propriétaire.

Voyons comment la fonction est utilisée OuvrirFormulaire() dans diverses situations.

3. Comment ouvrir le formulaire d'un objet existant

Chaque formulaire possède un attribut clé. Il est mis en évidence en gras dans la liste des détails du formulaire et est généralement appelé Un objet sous forme d'éléments d'ouvrages et de documents de référence. D'autres objets peuvent avoir un nom différent. Pour ouvrir le formulaire d'un objet existant, vous devez passer un paramètre au formulaire en cours d'ouverture Clé avec la valeur comme référence à un objet.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;
Paramètre. Insérer("Clé" , FindC() ) ;
OpenForm(, Paramètre) ;
Fin de la procédure

&Sur le serveur
Fonction FindC();
Répertoires de retour. Contreparties. FindByRequisites ("TIN", "745107734623")
FinFonction

4. Comment ouvrir un nouveau formulaire d'objet

Une fonction simple fera l'affaire ici OuvrirFormulaire() sans aucun paramètre.

&SurClient
Procédure Command1 (Commande)
OuvrirFormulaire( "Répertoire. Contreparties. Forme d'objet") ;
Fin de la procédure

5. Comment ouvrir un nouveau formulaire d'objet et le remplir en fonction de quelque chose

Vous devez passer un paramètre Base, dont la valeur sera une référence à l'objet de base de remplissage. Cela lancera la procédure ProcessFill().

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;
Paramètre. Insérer("Base", LinkToBuyerAccount) ;
OuvrirFormulaire( "Document. Ventes de biens et services. Forme d'objet", Paramètre) ;
Fin de la procédure

Cet exemple créera un document Ventes de biens et services et rempli sur la base d'une facture de paiement à l'acheteur dont le lien a été transmis.

6. Comment ouvrir un formulaire et y définir une sélection

La sélection sur les formulaires 1C peut être simple ou complexe. Une sélection simple implique des expressions telles que Organisation = Cornes et sabots LLC. La sélection complexe implique d'autres types de comparaison, par ex. Sur la liste. Dans cet article, nous examinerons l'organisation de la sélection simple, et un article distinct sera consacré à la sélection complexe.

Pour organiser une sélection simple, il faut passer un paramètre avec une clé au formulaire en cours d'ouverture Sélection, la valeur sera une structure dans laquelle la clé est le nom du champ de liste dynamique et la valeur est la donnée recherchée.

Par exemple, ouvrons le formulaire de liste de répertoires Numéros GTD et faites-y une sélection par propriétaire - élément de répertoire Nomenclature.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;

Sélection= nouvelle Structure ;
Sélection. Insert("Propriétaire", LinkToNomenclature) ;

Paramètre. Insérer("Sélection", Sélection) ;

OuvrirFormulaire( "Répertoire.Numéros GTD.Formulaire de liste", Paramètre) ;
Fin de la procédure

7. Comment ouvrir le formulaire d'inscription au registre d'information

Pour ce faire, vous aurez besoin de la clé d’entrée au registre d’informations.

Clé d'enregistrement— ce sont les valeurs de toutes les mesures et la période (si le registre est périodique). Autrement dit, une clé d'enregistrement correspond aux paramètres par lesquels un enregistrement peut être identifié de manière unique.

L'algorithme d'ouverture est le suivant :

1. Nous entrons dans la structure les données clés de l'enregistrement avec les valeurs nécessaires.
2. Nous plaçons la structure résultante dans un tableau.
3. Nous créons une clé d'enregistrement à partir du tableau.
4. On passe un paramètre au formulaire qui s'ouvre Clé avec la clé d'enregistrement de l'étape 3 comme valeur.

&SurClient
Procédure Command1 (Commande)
Paramètre = nouvelle structure ;

KeyParameters= nouvelle structure ;
Paramètres clés. Insérer("Nomenclature", LinkToNomenclature) ;
Paramètres clés. Insérer("TypePrix", LinkToPriceType) ;
Paramètres clés. Insérer("Période", Date) ;

KeyArray = Nouveau tableau ;
Tableau de clés. Ajouter(KeyParameters) ;

EntryKey = Nouveau ( "Informations RegisterRecord Key.PrixNomenclature", KeyArray) ;

Paramètre. Insérer("Clé", CléEnregistrement) ;

OuvrirFormulaire( "Registre d'informations. Prix de la nomenclature. Formulaire d'enregistrement", Paramètre) ;
Fin de la procédure

Accueil Pour les développeurs débutants Apprendre à programmer

Comment ouvrir une fiche d'un objet existant ?

Lors de l'ouverture d'un formulaire d'un objet existant, en plus du nom du formulaire, vous devez également indiquer l'objet dont le formulaire doit être ouvert. Pour ce faire, utilisez le paramètre de formulaire Key et un lien vers l'objet qui nous intéresse.

Par exemple, si à partir du formulaire de liste des organisations vous devez ouvrir le formulaire de l'organisation sur laquelle se trouve le curseur, vous pouvez le faire de la manière suivante :

Nous transmettons les paramètres de formulaire sous la forme d'une structure, où le nom de l'élément de structure correspond au nom du paramètre de formulaire et la valeur est la valeur à laquelle nous voulons définir le paramètre de formulaire.

Si vous souhaitez ouvrir non pas la forme principale, mais une forme arbitraire d'un objet créé dans le configurateur, au lieu du nom standard du formulaire principal (ObjectForm), indiquez le mot Formulaire suivi d'un point - le nom du formulaire créé dans le configurateur.

Par exemple:

ReferenceToDirectoryElement = Elements.List.CurrentRow ; FormParameters = Nouvelle Structure("Clé", ReferenceToDirectoryElement); OpenForm("Directory.Organizations.Form.UniversalObjectForm",FormParameters);

A noter que dans le cas où, en plus d'un lien vers un objet, aucun paramètre n'a besoin d'être passé au formulaire en cours d'ouverture et que c'est le formulaire principal de l'objet existant qui est nécessaire, vous pouvez utiliser une méthode plus simple - ouvrir le formulaire en suivant la procédure Valeur Ouverte():

OpenValue(Items.List.CurrentRow);

Cette méthode est moins polyvalente, mais dans certains cas, elle permet d'économiser du temps et des efforts. Par exemple, dans le cas considéré, une de ces lignes peut remplacer toute la procédure à trois lignes que nous avons écrite précédemment.

Il faut cependant être prudent lors de l'utilisation de cette procédure. Dans certains cas, cela peut entraîner des appels supplémentaires au serveur, par exemple lorsque vous devez ouvrir un formulaire d'élément de répertoire hiérarchique. Lors de l'utilisation de cette procédure, la plateforme fera un appel supplémentaire au serveur pour déterminer si un élément est un groupe ou non, puisqu'il faut ouvrir des formulaires différents pour l'élément et pour le groupe.

Dans le même temps, ces informations peuvent être connues à l'avance du développeur au sein de son algorithme et, à l'aide de la fonction OpenForm(), le développeur peut ouvrir le formulaire souhaité sans appels supplémentaires au serveur, en spécifiant immédiatement le nom standard du formulaire principal. formulaire.