Créons une variable dans la fonction feuille de calcul, dans lequel le formulaire imprimé sera affiché, on obtient disposition et zone de mise en page.

TabDoc = nouveau SpreadsheetDocument ; Mise en page = GetLayout("Mise en page" ); Zone d'en-tête = Layout.GetArea("En-tête" ); ScopeData = Layout.GetScope("Données" ); AreaFooter = Layout.GetArea("Basement" );

Remplissez les paramètres Chapeaux et apportez-le à feuille de calcul .

En-tête Area.Parameters.HeaderText = +ObjectReference.Number ; HeaderScope.Parameters.Organization = LinkToObject.Organization ; TabDoc.Output(HeaderArea);

Pour obtenir des lignes de tableau Des produits utiliser la requête.

Demande = nouvelle demande ; Query.SetParameter("Référence", ObjectReference); Requête.Texte = "SELECT | Réalisation de Biens, Services, Biens.Nomenclature, | Réalisation des Biens, Services, Biens Montant, | Réalisation de Biens, Services, Marchandises Prix, | Ventes de Biens, Services, Marchandises Quantité| DEPUIS | Document.Vente de BiensServices.Biens AS Réalisation de BiensServicesBiens| OÙ | ImplementationProductsServicesProducts.Reference = &Reference";

Nous passons les accessoires au paramètre de requête RéférenceVersObjetà préciser dans la condition OÙ que nous n'avons besoin que des données du document à partir duquel nous affichons le formulaire imprimé. Pour obtenir une sélection d'une requête, nous l'exécutons d'abord, puis sélectionnons les lignes.

Sélection = Query.Execute().Select();

Ensuite, dans la boucle, renseignez les paramètres de la zone Données pour chaque ligne de la sélection de documents et les afficher dans feuille de calcul. Toujours dans la boucle, nous comptons les valeurs totales quantités et les montants. Nous ne remplirons pas chaque paramètre séparément, mais nous utiliserons la procédure FillPropertyValues((<Приемник>, <Источник>) de contexte global, il copie les valeurs de propriété <Источника> aux propriétés <Приемника> . La correspondance est effectuée par les noms de propriété. Vous pouvez en savoir plus à ce sujet dans assistant de syntaxe 1C Entreprise 8.

TotalSum = 0 ; NombreTotal = 0 ; While Selection.Next() Boucle FillPropertyValues(DataArea.Parameters, Selection); TotalSum = TotalSum + Sample.Sum ; TotalQuantity = TotalQuantity + Sample.Quantity ; TabDoc.Output(DataArea); FinCycle ;

Remplir et afficher la zone Sous-sol.

AreaBasement.Parameters.TotalQuantity = TotalQuantity ; RegionBasement.Parameters.TotalAmount = TotalAmount ; TabDoc.Output(RegionFooter);

Nous renvoyons le document de feuille de calcul rempli à partir de la fonction Sceller().

Si vous utilisez l'une des configurations typiques, après avoir renvoyé le document de feuille de calcul 1C affichera automatiquement le formulaire imprimé. Vous pouvez également utiliser la méthode du tableur pour la sortie. Spectacle().

5. Connecter l'imprimable au document

À configurations typiques 1C 8 il existe un répertoire pour l'enregistrement des formulaires d'impression externes TraitementExterne. Pour vous connecter, rendez-vous dans le menu en mode entreprise Service-> Rapports supplémentaires et traitement-> Plaques d'impression externes supplémentaires.

Ajouter nouvel élément répertoire, chargez le formulaire imprimé à partir du disque et sélectionnez le type de document.

Maintenant dans le document Vente de biens et services un nouvel imprimable apparaîtra.

Imprimer le formulaire d'inscription automatique

Afin d'éviter d'avoir à sélectionner manuellement le type de document lors de la connexion de l'imprimable, vous pouvez configurer enregistrement automatique. Pour ce faire, nous ajoutons une nouvelle mise en page et l'appelons Paramètres_Enregistrement automatique(seulement ainsi) et dans sa première cellule nous écrivons Les documents.<Наименование документа> (ou Livres de référence.<Наименование справочника> ).

Maintenant, lors de la connexion du formulaire d'impression, nous serons invités à utiliser options d'enregistrement automatique.

Tout le monde a vu plus d'une fois comment, dans des configurations typiques construites sur la base de la BSP (Library of Standard Subsystems), les formulaires imprimés construits sur la base d'un document de feuille de calcul sont affichés dans un formulaire spécial "Documents d'impression". Ce formulaire fait partie du sous-système "Imprimer" du BSP. Lors du développement de vos imprimables, vous devez parfois demander à l'utilisateur des données supplémentaires nécessaires à l'impression. Ici, la question se pose, comment dans ce cas afficher le formulaire imprimé dans le formulaire "Imprimer le document". Dans cet article, j'examinerai comment implémenter la sortie d'un formulaire imprimable vers le formulaire mentionné à partir du sous-système "Imprimer", si nous voulons demander des données supplémentaires à l'utilisateur avant de sortir le formulaire imprimable. Deux cas seront considérés ici : lorsqu'un imprimable est mis en place à l'aide du sous-système "Etats et traitements complémentaires" et lorsqu'un imprimable est ajouté à la configuration en mode configurateur, c'est-à-dire des modifications sont apportées à la configuration par défaut.

Le formulaire "PrintDocuments" fournit quelques fonctions supplémentaires lorsque vous travaillez avec des formulaires imprimés, tels que :

• bouton pour imprimer sur une imprimante, directement dans le formulaire ;
• indication du nombre d'exemplaires, sous forme imprimée;
• éditer le formulaire imprimé généré ;
• la possibilité d'enregistrer le formulaire imprimé dans différents formats données (Excel, Word, PDF, etc.) ;
• envoyer un formulaire imprimé par e-mail ;
• travail pratique avec un ensemble de documents.

Ce formulaire est maintenant utilisé par 1C dans toutes les configurations standards pour afficher les formulaires imprimés des documents et des éléments de répertoire. Et bien sûr, lors de l'élaboration de nos formulaires d'impression, afin de ne pas aller au-delà des pratiques acceptées, nous devons également afficher nos formulaires d'impression à l'aide des outils fournis.

Lorsque vous utilisez des méthodes standard pour ajouter des formulaires d'impression, le sous-système "Imprimer" fera tout pour nous et affichera le formulaire d'impression comme il se doit. Par exemple:

1. Lors de l'ajout d'une commande d'impression à un document à l'aide du sous-système "Imprimer", nous devons décrire la commande d'impression dans la procédure AddPrintCommands en indiquant le gestionnaire d'impression dans lequel la procédure d'impression est implémentée ;
2. Lors de la création d'un traitement supplémentaire, nous devons, dans le module de l'objet de traitement de la fonction DetailOnExternalProcessing, décrire une commande avec le type d'utilisation Server Method Call et implémenter immédiatement la procédure Print, qui implémente d'une certaine manière l'appel de génération de formulaire d'impression.

Dans de tels cas, comme je l'ai déjà dit, le sous-système d'impression affichera le formulaire imprimé formé par nous-mêmes, selon les besoins. De tels procédés impliquent la formation directe d'une forme d'impression, c'est-à-dire a transmis les objets à imprimer à la procédure d'impression, a formé un document de feuille de calcul et l'a affiché à l'écran.

Mais que se passe-t-il si, avant de commencer la formation d'un document de feuille de calcul, vous devez demander des données à l'utilisateur ? Ceux. nous devons montrer le formulaire. Dans ce cas, l'ordre standard de formation d'un formulaire d'impression est violé et nous devons réfléchir à la manière de transférer notre formulaire d'impression vers le formulaire "Impression de documents".

Dans ce cas, deux situations sont possibles :

1. Lorsqu'un imprimable est créé avec un changement de configuration ;
2. Lorsqu'un imprimable est créé sans modifier la configuration, c'est-à-dire Le sous-système "Rapports et traitement supplémentaires" est utilisé.

Nous créons un imprimable en l'ajoutant via le configurateur.

Première variante. Grâce à la création de traitement avec l'équipe.

Cette option permet d'ajouter un traitement directement aux objets de métadonnées :

Considérons une option lorsque nous devons implémenter une forme d'impression d'un certain objet, par exemple, un élément de répertoire. Pour ce faire, nous devons travailler dans quatre domaines de traitement :

1. Créez une commande qui appellera le formulaire de notre imprimable;
2. Créez le formulaire lui-même ;
3. Créer une mise en page imprimable ;
4. Apportez des modifications au module du gestionnaire de traitement.

Nous créons une équipe

Spécifiez dans les propriétés de la commande :

• Groupe où nous voulons que la commande soit affichée dans le formulaire ;
• Le type de paramètre est simplement le livre ou le document de référence dont nous créons la forme imprimée ;
• Mode d'utilisation des paramètres - Multiple. Pouvoir afficher des formulaires imprimés, à la fois pour plusieurs éléments sélectionnés dans la liste.

Dans le module de commande, on ouvre le formulaire de traitement en lui passant les éléments sélectionnés du répertoire pour lesquels il faut générer des formulaires d'impression. Ne philosophons pas sournoisement ici et corrigeons légèrement le code typique qui est substitué par la plateforme dans la procédure de traitement des commandes :

&Sur la procédure client Traitement des commandes (paramètre de commande, paramètres d'exécution de la commande) //Insère le contenu du gestionnaire. FormParameters = Nouvelle Structure("PrintData", CommandParameter); OpenForm("Traitement.PrintForm.Form", FormParameters,CommandExecutionParameters.Source,CommandExecutionParameters.Uniqueness,CommandExecutionParameters.Window,CommandExecutionParameters.NavigationLink); FinProcédure

Le paramètre de la procédure, le Paramètre de la Commande, contient juste les éléments que nous avons sélectionnés pour l'impression.

Créer un formulaire

Ajoutons un formulaire au traitement, créons un attribut de formulaire de type Liste de valeurs et les détails d'entrée nécessaires pour nous options additionelles pour le formulaire d'impression :

DataToPrint - type ValueList ;

Nombre de lignes - tapez Nombre.

Mon exemple sera purement démonstratif, alors déterminons conditionnellement quel est mon objectif d'afficher la représentation de l'élément sélectionné dans la ligne imprimée et le nombre de lignes que nous sélectionnons comme paramètre supplémentaire sur le formulaire.

Accédez au module de formulaire et écrivez le code suivant :

&OnServerCreateProcedureOnServer(échec, traitement standard)PrintData.LoadValues(Parameters.PrintData); Fin de procédure &Sur la procédure cliente Print(Command) ControlPrintClient.ExecutePrintCommand("Processing.PrintForm", //Print Manager "PrintForm", //Identifier GetObjectsToPrint(), //Print Objects ThisObject, //Propriétaire du formulaire à partir duquel l'impression s'appelle GetPrintParameters( )); // Paramètres d'impression - paramètres arbitraires à transmettre au gestionnaire d'impression Tableau de retour ; EndFunction &AtServer Fonction GetPrintSettings() PrintSettings = Nouvelle structure ; PrintParameters.Insert("En-tête de formulaire", "Imprimer le formulaire"); //Un des paramètres du formulaire "Imprimer le document". //Spécifie le titre du formulaire de sortie imprimable. // Ici, nous ajoutons nos paramètres que nous voulons également transférer au gestionnaire d'impression. PrintParameters.Insert("Nombre de lignes", nombre de lignes); Paramètres de retourImprimer ; EndFunctions

Nous définissons la procédure OnCreateAtServer et nous y lisons à partir du paramètre que nous avons passé de la commande lors de l'ouverture du formulaire, la liste des objets pour lesquels nous devons générer un imprimable.

Nous créons la commande Print dans le formulaire et écrivons son gestionnaire, dans lequel nous appelons la fonction module commun ManagePrintClient.RunPrintCommand, on fixe les paramètres nécessaires de cette fonction, à savoir :

• Gestionnaire d'impression - le nom de l'objet dans le module gestionnaire, qui définit la fonction d'impression qui forme notre imprimable ;
• Identifiant - identifiant de l'imprimable à imprimer. Par cet identifiant, nous sélectionnerons dans la fonction Imprimer du module gestionnaire quel formulaire imprimable doit être imprimé ;
• Les objets d'impression sont directement les objets pour lesquels des formes d'impression sont formées ;
• Propriétaire du formulaire ;
• Paramètres d'impression - ici, nous formons et passons une structure avec des paramètres d'impression, là nous passons nos paramètres supplémentaires que nous avons demandés à l'utilisateur dans le formulaire de traitement.

En effet, en appelant la fonction ExecutePrintCommand depuis le formulaire de traitement, nous résolvons notre problème d'affichage du formulaire imprimable dans le formulaire "PrintDocuments". Ensuite, le sous-système "Print" effectuera des actions standards et amènera l'exécution à la procédure Print, que nous devons définir dans le module manager de notre traitement.

Création d'une mise en page imprimable

Apporter des modifications au module gestionnaire de traitement

A partir de ce moment, nous effectuons des actions standards pour le développement de formulaires d'impression en utilisant le sous-système "Print" de BSP.

Ajoutez le code suivant au module du gestionnaire :

Procédure Print(ObjectsArray,PrintParameters,PrintFormCollection,PrintObjects,OutputParameters) ObjectsArray,PrintParameters), "Processing.PrintForm.PF_MXL_PrintForm",); Fin si; EndProcedure &AtServer Fonction PrintLayout(ObjectArray,PrintSettings) SpreadsheetDocument = Nouveau SpreadsheetDocument ; //Créer une feuille de calcul /////////////////////////////////////////// / /////////////////////////////////////////////// // //////////////// //PARTIE REDÉTERMINÉE DU MODULE // //Nous formons ici notre mise en page imprimable = GetLayout("PF_MXL_PrintForm"); Pour chaque objet From Objects Array Loop AreaHeader = Layout.GetArea("Header"); AreaObject = Layout.Get Area("Objet"); SpreadsheetDocument.Output(RegionHeader); AreaObject.Parameters["Objet"] = Objet ; SpreadsheetDocument.Output(RegionObject); For Count = 1 ByPrintSettings["Nombre de lignes"] Loop AreaString = Layout.GetArea("String"); RegionString.Parameters["String"] = Nombre ; SpreadsheetDocument.Output(AreaString); FinCycle ; SpreadsheetDocument.OutputHorizontalPageSeparator(); FinCycle ; //PARTIE REDÉTERMINÉE DU MODULE ////////////////////////////////////////// // /////////////////////////////////////////////// /// //////////////// Retour SpreadsheetDocument ; //Renvoie le document de feuille de calcul EndFunction

Deuxième option. Grâce à la mise en œuvre de la commande d'impression.

Cette option est très similaire à la première en termes d'impression. Sa différence réside dans la manière de créer une commande qui sera envoyée à l'interface et démarrera notre impression.

Dans ce cas, lors de la définition de la commande d'impression, nous utilisons également le sous-système "Imprimer" du BSP. Au lieu de définir une commande pour ouvrir le traitement dans le traitement lui-même, nous devons aller dans le module gestionnaire, l'objet dans lequel nous voulons ajouter un imprimable, et définir la description de la commande d'impression dans la procédure Ajouter des commandes d'impression (commandes d'impression):

Procédure AddPrintCommands(PrintCommands) ExportPrintCommand = PrintCommands.Add(); PrintCommand.Identifier = "PrintForm" ; PrintCommand.View = ÝStr("ru = "Imprimer le formulaire""); PrintCommand.Handler = "CommonModulePrintForm.ProcessingPrintFormCommand" ; PrintCommand.Order = 100 ; FinProcédure

Ici nous ajoutons à tous les formulaires du répertoire (je vous rappelle que nous travaillons avec le répertoire contrepartie), une commande d'impression appelée "Imprimer un formulaire imprimable". Et voici le point principal qui doit être pris en compte. Vous pouvez ajouter deux types de commandes à un formulaire :

1. Appel de la procédure Print depuis le module gestionnaire ;

2. Appel de la méthode client.

C'est exactement l'appel à la méthode client dont nous avons besoin. La méthode client nous permettra d'appeler un formulaire de traitement dans lequel nous demanderons à l'utilisateur les données dont nous avons besoin avant d'imprimer.

Pour implémenter un tel appel, lors de la définition d'une commande, définissez un gestionnaire pour celle-ci (voir le code ci-dessus). Une chaîne contenant le chemin d'accès à la fonction client est transmise au gestionnaire de commandes, c'est-à-dire le chemin d'accès à la fonction Shared Module Export sur le client. C'est la fonction qui sera appelée en cliquant sur la commande d'impression que nous ajoutons aux formulaires.

Comme vous l'avez compris, pour que cela fonctionne, vous devez créer ce CommonModule et définir une fonction d'exportation. Par conséquent, nous écrivons le code suivant dans notre module commun :

Fonction HandlingPrintCommandPrintForm(PrintParameters) Export //Insère le contenu du gestionnaire. FormParameters = Nouvelle Structure("PrintData",PrintParameters.PrintObjects); OpenForm("Traitement.PrintForm.Form", FormParameters); EndFunctions

Ici on fait la même chose que dans la première implémentation, on ouvre le formulaire imprimable, seulement maintenant notre PrintData sera contenu dans le paramètre passé à la fonction PrintParameters, ou plutôt dans son champ PrintObjects.

Après avoir ouvert le formulaire de traitement, toutes les actions sont similaires à la première option.

La mise en œuvre de cette option se retrouve dans des configurations typiques, dans les mécanismes associés à l'impression du consentement au traitement des données personnelles.

Nous créons des traitements supplémentaires.

Mais que se passe-t-il si ce n'est pas notre configuration et qu'elle est prise en charge ? Et en général, on n'a pas envie de monter dans la configuration et de la modifier ?

Dans ce cas, nous devons utiliser le sous-système "Rapports et traitements supplémentaires" du BSP.

Avec cette solution, nous n'avons besoin d'écrire du code qu'à deux endroits, et tous sont dans notre futur traitement supplémentaire :

1. Module d'objet de traitement ;

2. Module de formulaire de traitement.

Dans le module objet, écrivez le code suivant :

Il y a deux fonctions et une procédure.

La fonction standard pour le traitement supplémentaire est ExternalProcessingInfo(), sans elle le système ne comprendra pas qu'il s'agit d'un traitement supplémentaire. Ici le point important est l'indication que la commande implémentée dans ce traitement est de type Ouverture du formulaire. Ceux. nous ouvrirons le formulaire selon nos besoins. Vient ensuite la définition de la procédure Print et de la fonction qui génère directement notre document tableur.

Ici, vous devez faire attention au fait que la commande d'impression dans ce cas ne doit contenir que 4 paramètres, et non 5 comme c'est le cas avec la définition habituelle de la commande d'impression dans le module gestionnaire. Dans ce cas, il n'y a pas d'option pour passer les options d'impression. Il va donc falloir faire preuve d'ingéniosité pour passer, en plus des objets eux-mêmes, pour lesquels le formulaire imprimé est formé, mais aussi les paramètres que l'on demande à l'utilisateur dans le formulaire.

Et nous avons donc défini un traitement supplémentaire, dont la commande ouvrira le formulaire de traitement. Par conséquent, l'étape suivante consiste à créer un formulaire de traitement.

Dans ce formulaire, nous devons créer trois attributs pour stocker les valeurs dont nous aurons besoin à l'avenir. Appelons ces détails comme suit :

CommandID - type chaîne

Objets de destination - type ValueList

Dans le module de ce formulaire, écrivez le code suivant :

&AtServer Procedure WhenCreatingAtServer(Failure, StandardProcessing) //Lors de la création sur le serveur, rappelez-vous les paramètres standard passés par le sous-système AdditionalReportsAndProcessing AdditionalProcessingReference = Parameters.AdditionalProcessingReference; CommandId = Paramètres.CommandId ; DestinationObjects.LoadValues(Parameters.DestinationObjects); EndProcedure &AtClient Procedure Print(Command) // Récupère la clé d'unicité du formulaire ouvert. UniqueKey = String(New UniqueIdentifier); //Définir et remplir paramètres standards pour la forme générale PrintDocumentsOpenParameters = New Structure("DataSource, SourceParameters"); OpenParameters.DataSource = AdditionalProcessingReference ; OpenParameters.SourceParameters = Nouvelle Structure("CommandIdentifier, Destination Objects"); OpenParameters.SourceParameters.CommandId = CommandId ; //Les objets à imprimer et les paramètres saisis dans le formulaire de traitement //seront passés par le paramètre SourceParameters.DestinationObjectsOpeningParameters.SourceParameters.DestinationObjects = GetDestinationObjectsAndPrintParameters(); OpenForm("CommonForm.PrintingDocuments",OpenParameters,FormOwner,UniqueKey); EndProcedure &AtServer Function GetDestinationObjectsAndPrintParameters()PrintData = DestinationObjects.Copy(); //////////////////////////////////////////////// / /////////////////////////////////////////////// // //////////// //PARTIE REDÉTERMINÉE DU MODULE // //Nous créons ici la structure PrintParameters et la remplissons avec les paramètres //qui doivent être passés à la fonction d'impressionPrintParameters = New Structure; PrintParameters.Insert("Nombre de lignes", nombre de lignes); PrintData.Insert(0, PrintSettings); //PARTIE REDÉTERMINÉE DU MODULE ////////////////////////////////////////// // /////////////////////////////////////////////// /// //////////////// ReturnPrintData ; EndFunctions

Dans la procédure OnCreateOnServer, nous renseignons nos trois coordonnées que nous avons créées pour stocker les paramètres passés au formulaire de traitement.

Ensuite, nous définissons le gestionnaire du bouton d'impression sur le formulaire. Dans ce gestionnaire, nous devons ouvrir nous-mêmes le formulaire "Imprimer des documents", pour cela nous devons préparer les options d'ouverture d'une certaine structure. Dans cette structure, au moins deux champs doivent être définis :

SourceParameters, qui incluent CommandId et DestinationObjects :

Identifiant de commande - également enregistré lors de la création sur le serveur, il s'agit de l'identifiant de la commande qui a appelé le formulaire de notre traitement. Par conséquent, l'identifiant, nous déterminerons ce que nous devons imprimer dans la procédure d'impression du module objet.

Objets de destination - c'est dans ce champ que nous devons passer un tableau d'objets pour lesquels le formulaire imprimé est formé, ainsi que les paramètres demandés à l'utilisateur dans le formulaire.

Comment je définis les objets de destination peut être vu dans la fonction GetDestinationObjectsAndPrintParameters. Ici, je copie nos destinations à partir du formulaire prop, à la place de l'élément de tableau à l'index 0, je colle nos options d'impression.

A l'avenir, le tableau ainsi défini sera passé du formulaire "Imprimer des documents", comme premier paramètre de la procédure d'impression du module objet, que nous avons défini précédemment.

Si nous revenons à la définition du module d'objet de traitement et examinons la fonction PrintLayout, dans les trois premières lignes de la fonction, vous pouvez voir comment j'extrait nos paramètres et objets des données transmises à la procédure Print, puis je travaille avec eux.

De telles manipulations avec le paramètre DestinationObjects sont dues aux spécificités de l'appel de la procédure Print du module objet. Vous pouvez suivre la façon dont les paramètres sont passés et les appels de fonction sont effectués en ouvrant le module du formulaire PrintDocuments.

Résultat.

À la suite de telles manipulations, nous obtiendrons trois commandes sur le formulaire à partir duquel nous voulons afficher le formulaire imprimé :

La numérotation des commandes correspond à l'ordre des options d'implémentation.

Toutes ces commandes feront la même chose :

Afficher le formulaire de demande de paramètres supplémentaires

Afficher les imprimables générés dans le formulaire "Imprimer les documents". Juste ce que nous voulions :

PS En tant que modèles, pour mettre en œuvre mes imprimables avec une demande de paramètres supplémentaires, je décharge les deux traitements qui participent aux trois méthodes de formation d'un imprimable.

Cet article décrira en détail comment un débutant qui ne connaît pas bien 1C 8 peut créer un imprimable. Par exemple, prenons l'une des configurations 1C 8 les plus courantes - Comptabilité 2.0. Création d'un imprimable 1C étapes d'écriture :

• Création d'un fichier imprimable externe ;
• Création d'une mise en page de formulaire imprimé;
• Écriture d'un code de programme pour afficher les données d'un formulaire imprimé sur l'écran ;
• Création de paramètres pour l'enregistrement automatique d'un formulaire imprimé ;
• Connexion d'un formulaire d'impression externe à la base Entreprises 1C.

Création d'un formulaire imprimé 1C. Formulation du problème

Nous sommes requis dans la configuration Comptabilité 2.0 créer un imprimable pour un document Réception des biens et services. Dans l'en-tête du formulaire imprimé, affichez les données suivantes :

• Organisme;
• contrepartie ;
• accord de contrepartie ;
• Date de réception.

Afficher les données du tableau sous forme de tableau Des produits document. Le tableau doit inclure les colonnes suivantes :

• Nomenclature;
• Quantité;
• Prix;
• Somme;
• Ainsi que le prix de l'article pour la date du jour (par type de prix du document).

Dossier de traitement externe

Passons à la résolution du problème. Pour commencer, ouvrez 1C 8 en mode Configurateur. C'est dans ce mode que tous les développements sont effectués sur la plate-forme 1C 8. Il nous faut maintenant créer un fichier de traitement externe. Pour cela, cliquez sur le menu Fichier -> Nouveau... ou par l'icône du nouveau fichier.

Dans la fenêtre qui s'ouvre, sélectionnez l'élément Traitement externe.

Plus loin sur le terrain Nom vous devez entrer le nom du traitement externe. Dans notre cas, appelons-le simplement : "Formulaire d'impression", le champ synonyme sera rempli automatiquement. Veuillez noter que dans le champ Nom, traitement externe, le nom doit être écrit sans espaces ni signes de ponctuation.

Ajouter un attribut de traitement externe ObjectReference et sélectionnez pour lui taper DocumentReference.Receipt of GoodsServices. Pour ce faire, dans l'arborescence des métadonnées du traitement externe 1C, sélectionnez l'élément Conditions requises et appuyez sur le bouton Ajouter(bouton plus vert). Dans la partie droite de l'écran, la fenêtre des propriétés de l'attribut s'ouvrira, dans le champ Nomécrivez - LienVersObjet. À champ Type de appuyez sur le bouton avec trois points.

Développer la branche dans l'arborescence des types DocumentLink, et recherchez l'élément Réception des biens et services, cochez la case à côté et cliquez sur D'ACCORD.

Enregistrez le fichier de traitement externe dans Disque dur, pour cela nous utilisons le menu Fichier -> Enregistrer, icône sauvegarder(disquette bleue) ou un raccourci clavier ctrl+s. Nommons le fichier enregistré "PrintForm".

Créer une mise en page imprimable

Commençons à créer une mise en page imprimable 1C. La mise en page sert de modèle pour la sortie de l'imprimable, donc si vous voulez que votre imprimable soit beau, vous devez y prêter attention.

Ajoutons une nouvelle mise en page dans l'arborescence des métadonnées de traitement externe, nous ne changerons rien dans la fenêtre du concepteur de mise en page et appuyez sur le bouton Prêt.

Dans la nouvelle mise en page qui s'ouvre, créons plusieurs zones nécessaires à l'affichage du formulaire imprimé. Toutes les zones de mise en page dont nous avons besoin seront horizontales, donc pour créer une nouvelle zone, nous devons sélectionner quantité requise lignes de mise en page et allez dans le menu Tableau -> Noms -> Attribuer un nom ou utilisez le raccourci clavier Ctrl+Maj+N puis entrez le nom de la région dans la case. Lors de la création d'une zone de mise en page, n'ayez pas peur de vous tromper de nombre de lignes, vous pouvez toujours en ajouter ou en supprimer. Pour supprimer une ligne de mise en page 1C, sélectionnez la ligne souhaitée et sélectionnez dans menu contextuel paragraphe Effacer. Pour ajouter nouvelle ligneà la mise en page, sélectionnez n'importe quelle ligne de la mise en page et sélectionnez l'élément dans le menu contextuel écarter.

Ajout d'un en-tête de mise en page

Commençons par créer une zone. Chapeau, il affichera les données de l'en-tête du formulaire imprimé. Pour cette zone, nous avons besoin de sept lignes de mise en page. Sélectionnez-les et, comme je l'ai écrit ci-dessus, appuyez sur le raccourci clavier Ctrl+Maj+N, dans le champ Nomécrivez "Chapeau" et appuyez sur le bouton D'ACCORD.

Remplissons la zone de mise en page avec les données dont nous avons besoin. Habituellement, aucun formulaire imprimé n'est complet sans en-tête, nous le créerons donc également dans notre en-tête de mise en page. Étant donné que dans l'en-tête, en plus du nom du formulaire imprimé, nous afficherons également le numéro du document à partir duquel il a été imprimé, nous définirons le texte de l'en-tête dans la mise en page en tant que paramètre. Un paramètre de mise en page est une cellule de mise en page spécialement désignée dans laquelle diverses données peuvent être affichées à l'aide du langage 1C 8 intégré. Le titre doit être affiché sur toute la largeur du formulaire imprimé, alors décidons combien de cellules de mise en page nous suffiront pour imprimer sur un standard orientation paysage feuille.

Généralement treize ou quatorze cellules de mise en page suffisent, sélectionnez-les en première ligne de la zone Chapeau et fusionner en une seule cellule ( Menu contextuel -> Fusionner). Après cela, double-cliquez sur la grande cellule résultante et écrivez le nom du paramètre, dans notre cas "HeaderText". Pour que le texte saisi devienne un paramètre à part entière, faites un clic droit sur la cellule et sélectionnez l'élément dans le menu contextuel Propriétés. Signet Disposition trouver un terrain remplissage et choisissez la valeur Paramètre. Les paramètres de la disposition 1C sont indiqués par des crochets "<>».

Le titre du formulaire imprimé doit se démarquer du reste du texte. Sélectionnez donc à nouveau la cellule et utilisez les icônes du panneau de mise en forme de la mise en page pour définir l'alignement du texte. Centré et taille de police 14.

Après le texte du titre, nous afficherons dans la zone Chapeau données sur l'organisation, la contrepartie, l'accord de contrepartie et la date de réception des marchandises. Étant donné que toutes ces données sont également extraites du document, nous allons également les décorer avec des paramètres. De plus, avant chaque paramètre, vous devez écrire un texte explicatif afin que l'utilisateur puisse facilement comprendre où se trouve l'organisation, où se trouve la contrepartie, etc. Toutes ces actions sont similaires à la création d'un en-tête, donc je ne m'y attarderai pas en détail, je donnerai seulement une image avec ce qui devrait se passer à la fin.

La figure montre comment les options de mise en page diffèrent du texte brut.

Ajout d'un en-tête de tableau de disposition

La dernière chose que nous devons créer dans cette zone de mise en page est l'en-tête du tableau, dans lequel les données de la partie tabulaire seront affichées. Des produits. Les colonnes requises pour le tableau ont été décrites dans la section « Énoncé du problème ». Nous allons également créer un en-tête de tableau en fusionnant des cellules et en écrivant du texte (noms de colonnes). Sélectionnez les bordures de l'en-tête du tableau à l'aide de l'outil Cadre, qui se trouve dans la barre de mise en forme de la mise en page.

Ajouter un tableau à une mise en page

Créons une autre zone dans la mise en page - Données. Il affichera le tableau de données de la partie tabulaire Des produits. Nous n'avons besoin que d'une seule ligne de mise en page pour cette zone. Pour afficher toutes les lignes de la partie tabulaire dans un formulaire imprimé, nous allons remplir et afficher cette zone le nombre de fois requis. Conférenciers de la région Données doit correspondre aux colonnes de l'en-tête du tableau, il ne sera donc pas difficile de le remplir. La seule différence est dans la zone Données nous avons besoin d'options, pas seulement de texte. Notez également que par défaut, les paramètres numériques sont formatés sur la marge de droite et les paramètres de texte sur la gauche. Pour sélectionner des colonnes, vous devez également utiliser l'outil Cadre.

Ajouter un pied de page à une mise en page

Le dernier domaine de la mise en page dont nous avons besoin est Sous-sol. Il affichera les totaux par quantité et montant. La création est similaire à la création d'une zone Données, mais en plus, les résultats doivent être mis en évidence en gras.

Le résultat devrait être une mise en page qui ressemble à ceci :

Création d'un formulaire imprimé 1C. Programmation

Commençons la programmation - c'est l'étape la plus importante dans la création d'un formulaire imprimé. Passons tout d'abord au module de l'objet plaque d'impression externe, c'est là que nous allons programmer. Pour cela, dans la fenêtre principale du traitement externe, appuyez sur Actions -> Ouvrir le module objet.

Dans le module d'objet de formulaire d'impression externe, vous devez créer une fonction d'exportation Sceller().

Fonction Print() Exporter EndFunction

Notez que fonction donnée est obligatoire pour les formulaires d'impression externes dans les configurations utilisant application régulière. Nous écrirons tout le code de programme ultérieur nécessaire pour afficher le formulaire imprimé à l'intérieur de cette fonction.

Initialisation des variables de base

Créons une variable TabDoc, qui contiendra un document de feuille de calcul - c'est lui qui est le formulaire imprimé dans lequel nous afficherons les zones remplies de la mise en page.

TabDoc = nouveau SpreadsheetDocument ;

dans une variable Disposition nous recevrons la mise en page du formulaire imprimé que nous avons créée. Pour ce faire, nous utilisons la fonction intégrée GetLayout(<ИмяМакета>).

Mise en page = GetLayout("Mise en page");

Nous obtiendrons toutes les zones de la mise en page dans des variables. Pour ce faire, nous utilisons la méthode de mise en page ObtenirRégion(<ИмяОбласти>) .

Zone d'en-tête = mise en page. GetArea("En-tête"); AreaData = Layout.GetArea("Données"); AreaFooter = Layout.GetArea("Basement");

Affichage de l'en-tête imprimable dans une feuille de calcul

Toutes les variables nécessaires sont initialisées. Commençons à remplir et à afficher les zones de mise en page dans un document de feuille de calcul. Tout d'abord, remplissons le titre du formulaire imprimé, pour cela nous devons passer le paramètre Texte du titre, que nous avons créé dans la mise en page, le texte dont nous avons besoin. Pour remplir les valeurs des paramètres, la zone de mise en page a une collection spéciale, qui s'appelle - Options. D'où par le "." vous pouvez obtenir n'importe quel paramètre. Dans le texte du titre nous passerons le texte : « Formulaire d'impression », ainsi que le numéro du document.

Header Area.Parameters.HeaderText = "Formulaire d'impression"+ReferenceToObject.Number;

Les paramètres restants de l'en-tête seront remplis de la même manière, toutes les valeurs requises pour eux seront obtenues à partir des accessoires RéférenceVersObjet, qui contient un lien vers le document à imprimer.

HeaderScope.Parameters.Organization = LinkToObject.Organization ; Zone d'en-tête.Parameters.Account = LinkToObject.Account ; En-tête Area.Parameters.IncomingDate = ObjectReference.Date ; En-tête Area.Parameters.Counterparty Agreement = LinkToObject.Counterparty Agreement ;

Tous les paramètres d'en-tête sont renseignés, nous l'afficherons dans le document tableur que nous avons créé, pour cela nous utilisons la méthode production(<Область>) .

TabDoc.Output(HeaderArea);

Rédiger une demande de handicap imprimé

Commençons à remplir et à afficher la zone Données. Créer un imprimable 1C implique également d'écrire une requête, nous en avons besoin pour obtenir les données de la partie tabulaire Des produits et prix Nomenclatures pour la date actuelle nous utiliserons Demande. Le langage de requête 1C 8 est similaire à SQL, ou plutôt copie pratiquement ses capacités. instruction SELECT, mais toute la demande est rédigée en russe. Par conséquent, si vous êtes au moins familiarisé avec SQL, vous comprendrez facilement le langage de requête 1C 8.

Dans ce formulaire imprimé, la demande sera assez simple et beaucoup diront que l'on pourrait s'en passer, mais la connaissance du langage de requête et la capacité de l'utiliser correctement est l'une des principales compétences d'un programmeur 1C. Les requêtes permettent d'utiliser moins de ressources pour obtenir les échantillons de données les plus complexes, et il est également beaucoup plus facile de comprendre le texte de la requête que dans le code du programme écrit sans utiliser la requête (ou avec une utilisation minimale de celle-ci). De plus, en 1C 8 il y a très bon concepteur requêtes, ce qui vous permet de collecter de manière interactive une requête à partir des tables nécessaires.

Créons une variable qui contiendra la requête.

Demande = Nouvelle demande ;

Le texte de la requête sera composé à l'aide du générateur de requêtes. Commençons par écrire :

Requête.Texte = "" ;

Placez le curseur de la souris entre les guillemets, appuyez sur le bouton droit de la souris. Dans le menu contextuel qui s'ouvre, sélectionnez l'élément Requête constructeur, cela nous aidera beaucoup à créer un imprimable 1C. Après cela, la fenêtre du concepteur de requêtes s'ouvrira, elle contient de nombreux onglets, mais notre requête n'en aura besoin que de quatre : "Tables et champs", "Relations", "Conditions", "Joins/Alias".

Pour notre requête, nous avons besoin de deux tables : la partie tabulaire Des produits document Réception des biens et services et une tranche des dernières informations sur la date actuelle du registre Prix ​​des articles.

Dans la partie gauche de la fenêtre du concepteur, recherchez la colonne Base de données. Il contient une arborescence de tous les objets de métadonnées, trouvons ceux dont nous avons besoin. Pour ce faire, ouvrez la branche Les documents et trouver le document Services de réception des marchandises, ouvrez-le et trouvez partie tabulaire Des produits, faites-le glisser vers la colonne du concepteur de requêtes les tables. Il existe trois manières de glisser-déposer : en faisant glisser, en double-cliquant sur le tableau, ou en le sélectionnant et en cliquant sur le bouton ">". Ouvrons une succursale RegistresInformations et y trouver une table PrixItems.SliceLast, faites-le également glisser vers la colonne les tables. Ces deux tables suffisent à notre requête.

Sélectionnons les champs dont nous avons besoin dans les tables résultantes. Pour cela, dans la colonne les tables ouvrir la table et recherchez les champs : Nomenclature, Montant, Prix, Quantité et faites-les glisser vers la troisième colonne du constructeur - des champs. Ouvrons la table , trouvez le champ Prix et faites-le également glisser vers des champs.

La structure des tables et des champs de notre requête est prête, occupons-nous maintenant des conditions. Nous avons besoin des données de la partie tabulaire Des produits n'ont pas été prélevés sur tous les reçus, mais uniquement sur celui que nous imprimons. Pour ce faire, nous imposons une condition sur la table Marchandises entrantes Services Marchandises. Passons à l'onglet "Conditions" du générateur de requêtes. Dans une colonne des champs les tables que nous avons sélectionnées précédemment sont localisées, pour la condition nous avons besoin du champ Lien de la table Réception des Biens, Services, Marchandises, faites-le glisser vers la fenêtre Conditions.

Dans les requêtes 1C, vous pouvez utiliser des paramètres, ils sont nécessaires pour transférer des données vers la requête. Par exemple, si nous voulons limiter la sélection de documents à un document spécifique, nous pouvons utiliser un paramètre pour transmettre un lien vers ce document à la requête et utiliser ce paramètre dans la condition. C'est exactement ce que nous ferons dans notre demande.

Une fois par la fenêtre Conditions nous avons ajouté un champ Lien, le générateur de requête créera un paramètre avec le même nom et le placera après le signe "=". Ce paramètre peut être renommé si désiré. Dans le texte de la requête, les paramètres sont marqués du signe "&", mais dans ce cas ce n'est pas nécessaire, car on suppose que la deuxième partie de la condition contient un paramètre, il suffit de s'en souvenir. Comment passer une valeur à un paramètre de requête 1C sera discuté ci-dessous.

Étant donné que dans la requête, nous n'utilisons pas le tableau complet des prix des articles, mais un tableau virtuel (une tranche de ce dernier dans ce cas), nous devons définir les conditions de formation de ce table virtuelle, dans notre cas, il s'agit de la date limite et d'une condition pour le type de prix (les prix avec un type de prix strictement défini doivent être sélectionnés - celui qui est spécifié dans le document de réception que nous imprimons).

Pour renseigner les paramètres de la table virtuelle, rendez-vous dans l'onglet Tables et champs constructeur de requête, dans la colonne les tables sélectionner un tableau PrixArticlesSliceLatest et appuyez sur le bouton Options de table virtuelle situé au sommet. Dans la fenêtre qui s'ouvre, dans le champ Période vous devez définir le paramètre auquel sera transmise la date pour laquelle la baisse de prix sera effectuée. Dans notre cas, ce sera la date actuelle (c'est-à-dire aujourd'hui), nous nommerons donc le paramètre "&CurrentDate". Dans le champ condition, nous écrirons les conditions pour le type de prix, nous le passerons également dans le paramètre, que nous appellerons "&PriceType". La condition résultante ressemblera à ceci (où Type de prix- enregistrer la mesure Prix ​​des articles):

TypePrix = &TypePrix

Les paramètres de la table virtuelle sont renseignés, cliquez sur le bouton D'ACCORD.

Maintenant que nous avons limité la sélection au seul document dont nous avons besoin, créons des relations entre les tables de requête. Si cela n'est pas fait, les prix de la table PricesItemsSliceLast ne seront pas associés à l'article de la réception. Passons à l'onglet Connexions générateur de requêtes. Créons un lien par champ Nomenclature entre nos deux tables. Pour cela, appuyez sur le bouton Ajouter, dans le champ Tableau 1 choisir un tableau Marchandises entrantes Services Marchandises, et dans le champ Table 2 - PricesItemsSliceLast. Dans les conditions de connexion, sélectionnez les champs Nomenclature des deux tableaux.

Il convient également de noter que dans la sélection de la requête, nous devons obtenir toutes les lignes de la partie onglet Des produits et les prix uniquement s'ils sont disponibles pour la date du jour par type de prix de document. Ainsi, ces tabparts Des produits sont obligatoires, mais les données de coupure des prix ne le sont pas. Par conséquent, dans les liens entre ces tables, il est nécessaire d'utiliser le soi-disant LEFT JOIN, et la table de gauche (ou obligatoire) sera Marchandises entrantes Services Marchandises, et le droit (ou facultatif) PriceItemSliceLast. À joint gauche les tables de requête ont fonctionné comme je l'ai décrit ci-dessus, vous devez cocher la case Tout après le terrain Tableau 1.

La requête est presque prête, il ne reste plus qu'à travailler un peu sur le champ alias. Aller au signet Syndicats / Alias et définir un alias pour le champ PriceItemsSliceLast.Price. Le nom d'alias sera - PrixPourAujourd'hui, il est nécessaire pour que les noms des champs de sélection de la requête et les noms des paramètres dans la mise en page du formulaire imprimé correspondent.

Le travail dans le concepteur de requêtes est terminé, appuyons sur le bouton OK. Une fois la fenêtre du constructeur fermée, vous verrez que la ligne avec le texte de la requête est remplie et ressemble à ceci :

Requête. Texte = "Choisir | réception de services. Nomenclateurs, | réception de services. Sommaire marchandises, | réception de services. Regroupement de marchandises. Produits, | Services d'enquête. Complexités, | prix des prisonniers du lendemain. (| &CurrentDate , PriceType = &PriceType) AS PricesItemsSliceLast | BY Incoming GoodsServicesGoods.Nomenclature | = PricesItemsSliceLast.Nomenclature |WHERE | Incoming GoodsServicesGoods.Reference = &Reference" ;

Exécution d'une demande

Nous passerons les paramètres nécessaires à la requête, pour cela nous utiliserons la méthode request setParameter(<ИмяПараметра>,<Значение>). Pour obtenir date actuelle utiliser la fonction intégrée La date actuelle(), il renvoie la date et l'heure de l'ordinateur.

Exécutons une requête pour obtenir une sélection avec les données dont nous avons besoin. Pour ce faire, nous utilisons d'abord la méthode de requête Exécuter(), puis la méthode Choisir().

Sélection = Query.Execute().Select();

Remplir le tableau imprimable

En conséquence, dans la variable Goûter contiendra une sélection de résultats de requête, vous pouvez y naviguer en utilisant la méthode Prochain(), et pour contourner le tout il faudra une boucle Au revoir. La structure ressemblera à ceci :

While Selection.Next() Loop EndCycle ;

C'est dans ce cycle que nous allons remplir et afficher la zone de mise en page Données. Mais d'abord, initialisons deux variables de type numérique. En eux, nous collecterons les totaux par le nombre et le montant que nous devons afficher dans la zone Sous-sol.

TotalSum = 0 ; NombreTotal = 0 ;

À l'intérieur de la boucle, nous remplirons la zone Données données de l'élément de sélection actuel en variables Somme totale et Nombre total ajoutez des valeurs de somme et de quantité, et enfin, affichez la zone dans un document de feuille de calcul en utilisant la méthode qui nous est déjà familière Production(). Étant donné que les noms de champ de notre requête sont exactement les mêmes que les noms de paramètre de champ Données, alors pour le remplissage nous utiliserons la procédure intégrée FillPropertyValues(<Приемник>, <Источник>) qui copie les valeurs de propriété<Источника>aux propriétés<Приемника>.

While Selection.Next() Boucle FillPropertyValues(DataArea.Parameters, Selection); TotalSum = TotalSum + Sample.Sum ; TotalQuantity = TotalQuantity + Sample.Quantity ; TabDoc.Output(DataArea); FinCycle ;

Sortie du pied de page du formulaire d'impression dans un document tableur

Il reste à remplir et à afficher la dernière zone de la mise en page - Sous-sol. Nous avons déjà préparé les données pour le remplissage, le remplissage et la sortie sont effectués selon le même schéma.

AreaBasement.Parameters.TotalQuantity = TotalQuantity ; RegionBasement.Parameters.TotalAmount = TotalAmount ; TabDoc.Output(RegionFooter);

Le document tableur est complètement rempli, il reste à l'afficher à l'écran pour que l'utilisateur puisse visualiser le formulaire imprimé et, si nécessaire, l'imprimer. Mais dans les configurations typiques 1C 8, les procédures des modules spéciaux sont responsables de la sortie des formulaires d'impression externes. Il suffit donc de revenir de la fonction Sceller() feuille de calcul complétée.

Retour TabDoc ;

A ce stade, la programmation est terminée et la création du formulaire imprimable 1c est presque terminée. Texte complet de la fonction Sceller() Je ne le donnerai pas ici, vous pouvez le voir dans un fichier imprimable, que vous pouvez télécharger en bas de l'article.

Création d'un formulaire imprimé 1C. Options d'enregistrement automatique

Lors de la connexion d'un imprimable externe à la base de données, le système ne détermine pas automatiquement à quel document ou répertoire particulier l'imprimable est destiné, vous devez le sélectionner manuellement. Et si une autre personne a écrit le formulaire imprimé et que vous n'êtes invité qu'à le connecter, le choix peut devenir ambigu. Afin d'éviter de tels problèmes, dans tous les imprimables externes, il est nécessaire de créer une mise en page avec des paramètres d'enregistrement automatique. S'il est créé et correctement formaté, le système détermine automatiquement à quel document ou répertoire le formulaire imprimé est destiné.

Il se fait comme suit :

• Dans le traitement externe, nous créons une nouvelle mise en page. Nous l'appelons "Parameters_Autoregistration" (important de ne pas se tromper !).
• Dans la première cellule de la mise en page, nous écrivons Les documents.(ou Livres de référence.) et le nom du document auquel vous souhaitez associer l'imprimable.

Connexion à la base d'un formulaire d'impression externe

• Exécutez 1C 8 en mode Compagnie;
• Aller au menu Service -> Rapports et traitement supplémentaires -> Formulaires d'impression externes supplémentaires;
• Cliquez sur le bouton Ajouter;
• Dans la fenêtre qui s'ouvre, cliquez sur l'icône Remplacer le fichier de traitement externe;
• Si vous avez créé des paramètres d'enregistrement automatique, nous acceptons de les utiliser ;
• Si vous n'avez pas créé de paramètres d'enregistrement automatique, dans la section tabulaire Accessoire de la plaque d'impression ajouter le document ou le répertoire requis ;
• Nous appuyons sur le bouton D'ACCORD.

Après cela, l'imprimable externe sera disponible dans le menu Sceller document Livraison de biens et de services. La création d'un imprimable 1C sur celui-ci peut être considérée comme terminée.