Creiamo una variabile nella funzione foglio di calcolo, in cui verrà visualizzato il modulo stampato, otteniamo disposizione e area di layout.

TabDoc = nuovo SpreadsheetDocument; Layout = GetLayout("Layout"); Area dell'intestazione = Layout.GetArea("Intestazione"); ScopeData = Layout.GetScope("Dati"); AreaFooter = Layout.GetArea("Seminterrato");

Compila i parametri cappelli e portalo a foglio di calcolo .

Header Area.Parameters.HeaderText = +ObjectReference.Number; HeaderScope.Parameters.Organization = LinkToObject.Organization; TabDoc.Output(HeaderArea);

Per ottenere le righe della tabella Prodotti usa query.

Richiesta = nuova richiesta; Query.SetParameter("Riferimento", ObjectReference); Query.Text = "SELEZIONA | Realizzazione di Beni, Servizi, Beni.Nomenclature, | Realizzazione di Beni, Servizi, Beni Importo, | Realizzazione di Beni, Servizi, Beni Prezzo, | Vendite di beni, servizi, beni Quantità| DA | Documento.Vendita di beniServizi.Merci AS Realizzazione di beniServiziBeni|DOVE | ImplementationProductsServicesProducts.Reference = &Riferimento";

Passiamo gli oggetti di scena al parametro di richiesta Riferimento all'oggetto da indicare nella condizione DOVE che abbiamo bisogno dei dati solo dal documento da cui visualizziamo il modulo stampato. Per ottenere una selezione di una query, prima la eseguiamo e quindi selezioniamo le righe.

Selezione = Query.Execute().Select();

Successivamente, nel ciclo, compila i parametri dell'area Dati per ogni riga della selezione del documento e visualizzarli in foglio di calcolo. Anche nel ciclo contiamo i valori totali le quantità e importi. Non compileremo ogni parametro separatamente, ma utilizzeremo la procedura FillPropertyValues((<Приемник>, <Источник>) da contesto globale, copia i valori della proprietà <Источника> alle proprietà <Приемника> . La corrispondenza avviene in base ai nomi delle proprietà. Puoi leggere di più su questo in assistente di sintassi 1C Enterprise 8.

Somma totale = 0 ; Numero totale = 0 ; While Selection.Next() Loop FillPropertyValues(DataArea.Parameters, Selection); SommaTotale = SommaTotale + Somma Campione; TotalQuantity = TotalQuantity + Sample.Quantity; TabDoc.Output(AreaDati); ciclo finale;

Riempi e visualizza l'area Seminterrato.

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

Restituiamo il documento del foglio di calcolo riempito dalla funzione Sigillo().

Se utilizzi una delle configurazioni tipiche, dopo aver restituito il documento del foglio di calcolo 1C visualizzerà automaticamente il modulo stampato. Puoi anche utilizzare il metodo del foglio di calcolo per l'output. Mostrare().

5. Collegamento del stampabile al documento

A configurazioni tipiche 1C 8 esiste una directory per la registrazione di moduli di stampa esterni Elaborazione esterna. Per connetterti, vai al menu in modalità aziendale Servizio-> Rapporti aggiuntivi ed elaborazione->Moduli di stampa esterni aggiuntivi.

Aggiunta nuovo elemento directory, caricare il modulo stampato dal disco e selezionare il tipo di documento.

Ora nel documento Vendita di beni e servizi apparirà un nuovo stampabile.

Stampa modulo di autoregistrazione

Per evitare la necessità di selezionare manualmente il tipo di documento quando si collega il stampabile, è possibile configurare registrazione automatica. Per fare ciò, aggiungiamo un nuovo layout e lo chiamiamo Parametri_Autoregistrazione(solo così) e nella sua prima cella scriviamo I documenti.<Наименование документа> (o Libri di riferimento.<Наименование справочника> ).

Ora, quando colleghiamo il modulo di stampa, ci verrà chiesto di utilizzare opzioni di registrazione automatica.

Tutti hanno visto più di una volta come in configurazioni tipiche costruite sulla base del BSP (Library of Standard Subsystems), i moduli stampati costruiti sulla base di un documento Spreadsheet vengono emessi in un modulo speciale "Printing Documents". Questo modulo fa parte del sottosistema "Stampa" del BSP. Durante lo sviluppo dei tuoi stampabili, a volte devi chiedere all'utente i dati aggiuntivi necessari per la stampa. Qui sorge la domanda, come in questo caso visualizzare il modulo stampato nel modulo "Stampa documento". In questo articolo, considererò come implementare l'output di un modulo stampabile nel modulo menzionato dal sottosistema "Stampa", se vogliamo richiedere dati aggiuntivi all'utente prima di emettere il modulo stampabile. In questa sede verranno presi in considerazione due casi: quando un stampabile viene implementato utilizzando il sottosistema "Report ed elaborazioni aggiuntive" e quando un stampabile viene aggiunto alla configurazione in modalità configuratore, ad es. vengono apportate modifiche alla configurazione predefinita.

Il modulo "PrintDocuments" ne fornisce alcuni funzioni aggiuntive quando si lavora con moduli stampati, come ad esempio:

• pulsante per stampare su stampante, direttamente nel modulo;
• indicazione del numero di copie, modulo cartaceo;
• modifica del modulo stampato generato;
• la possibilità di salvare il modulo stampato in vari formati dati (Excel, Word, PDF, ecc.);
• invio di un modulo cartaceo via e-mail;
• lavoro conveniente con una serie di documenti.

Questo modulo è ora utilizzato da 1C in tutte le configurazioni standard per visualizzare moduli stampati di documenti ed elementi di directory. E, naturalmente, quando sviluppiamo i nostri moduli di stampa, per non andare oltre la pratica accettata, dovremmo anche esporre i nostri moduli di stampa utilizzando gli strumenti forniti.

Quando si utilizzano metodi standard per l'aggiunta di moduli di stampa, il sottosistema "Stampa" farà tutto per noi e visualizzerà il modulo di stampa come dovrebbe. Per esempio:

1. Quando si aggiunge un comando di stampa a un documento utilizzando il sottosistema "Stampa", è necessario descrivere il comando di stampa nella procedura AddPrintCommands indicando il gestore di stampa in cui è implementata la procedura di Stampa;
2. Quando si creano Elaborazioni aggiuntive, occorre, nel modulo dell'oggetto Elaborazione nella funzione DetailOnExternalProcessing, descrivere un comando con il tipo di utilizzo Chiamando il metodo server e implementare immediatamente la procedura Print, che in un certo modo implementa la chiamata al form il modulo di stampa.

In questi casi, come ho già detto, il sottosistema di stampa visualizzerà il modulo stampato da noi stesso formato, secondo necessità. Tali metodi implicano la formazione diretta di un modulo di stampa, ad es. ha passato gli oggetti per la stampa alla procedura di stampa, ha formato un foglio di calcolo e lo ha visualizzato sullo schermo.

Ma cosa succede se, prima di iniziare la formazione di un foglio di calcolo, è necessario richiedere alcuni dati all'utente? Quelli. dobbiamo mostrare il modulo. In questo caso, l'ordine standard di formazione di un modulo di stampa viene violato e dobbiamo pensare a come trasferire il nostro modulo di stampa nel modulo "Stampa documenti".

In questo caso sono possibili due situazioni:

1. Quando viene creato un stampabile con una modifica della configurazione;
2. Quando viene creato un stampabile senza modificare la configurazione, ad es. Viene utilizzato il sottosistema "Report ed elaborazione aggiuntivi".

Creiamo uno stampabile aggiungendolo tramite il configuratore.

Prima variante. Attraverso la creazione di lavorazioni con il team.

Questa opzione prevede l'aggiunta dell'elaborazione direttamente agli oggetti metadati:

Consideriamo un'opzione quando dobbiamo implementare un modulo di stampa di un determinato oggetto, ad esempio un elemento di directory. Per fare ciò, dobbiamo lavorare in quattro aree di elaborazione:

1. Creare un comando che richiamerà il modulo del nostro stampabile;
2. Crea il modulo stesso;
3. Crea un layout stampabile;
4. Apporta modifiche al modulo Gestione elaborazione.

Creiamo una squadra

Specificare nelle proprietà del comando:

• Raggruppa dove vogliamo che il comando venga visualizzato nel form;
• Il tipo di parametro è solo il libro di riferimento o il documento di cui stiamo creando il modulo stampato;
• Modalità di utilizzo dei parametri - Multiplo. Per poter visualizzare moduli stampati, contemporaneamente per più elementi selezionati nell'elenco.

Nel modulo di comando, apriamo il form di elaborazione passandogli gli elementi selezionati della directory per i quali è necessario generare i moduli di stampa. Non filosofiamo qui di nascosto e correggiamo leggermente il tipico codice che viene sostituito dalla piattaforma nella procedura di elaborazione dei comandi:

&Nella procedura client Gestione dei comandi(Parametro comando, Parametri di esecuzione comando) //Inserire il contenuto del gestore. FormParameters = Nuova struttura("PrintData", CommandParameter); OpenForm("Processing.PrintForm.Form", FormParameters,CommandExecutionParameters.Source,CommandExecutionParameters.Uniqueness,CommandExecutionParameters.Window, CommandExecutionParameters.NavigationLink); EndProcedura

Il parametro della procedura, il parametro del comando, contiene solo gli elementi che abbiamo selezionato per la stampa.

Crea un modulo

Aggiungiamo un form all'elaborazione, creiamo un attributo form del tipo List of Values ​​e i dettagli di input necessari per noi opzioni aggiuntive per il modulo di stampa:

DataToPrint - digitare ValueList;

Numero di righe - digitare Numero.

Il mio esempio sarà puramente dimostrativo, quindi determiniamo condizionatamente qual è il mio obiettivo di visualizzare la rappresentazione dell'elemento selezionato nella riga stampata e il numero di righe che selezioniamo come parametro aggiuntivo sul modulo.

Vai al modulo del modulo e scrivi il seguente codice:

&OnServerCreateProcedureOnServer(Failure, StandardProcessing)PrintData.LoadValues(Parameters.PrintData); Fine della procedura e sul client Procedura Print(Command) ControlPrintClient.ExecutePrintCommand("Processing.PrintForm", //Print Manager "PrintForm", //Identifier GetObjectsToPrint(), //Print Objects ThisObject, //Proprietario del modulo da cui la stampa si chiama GetPrintParameters()); //Parametri di stampa - parametri arbitrari da passare al gestore di stampa Matrice di ritorno; Funzione End &AtServer Funzione GetPrintSettings() PrintSettings = Nuova struttura; PrintParameters.Insert("Intestazione modulo", "Stampa modulo"); //Uno dei parametri per il modulo "Stampa documento". //Specifica il titolo del modulo di output stampabile. //Qui aggiungiamo i nostri parametri che vogliamo trasferire ulteriormente al gestore di stampa. PrintParameters.Insert("Numero di righe", Quantità di righe); Restituisci parametriStampa; Funzioni finali

Definiamo la procedura OnCreateAtServer e in essa leggiamo dal parametro che abbiamo passato dal comando all'apertura del form, l'elenco degli oggetti per i quali dobbiamo generare un stampabile.

Creiamo il comando Stampa nel form e scriviamo il suo gestore, in cui chiamiamo la funzione modulo comune ManagePrintClient.RunPrintCommand, impostiamo i parametri necessari di questa funzione, ovvero:

• Print manager - il nome dell'oggetto nel modulo manager, che definisce la funzione Print che forma il nostro stampabile;
• Identificatore - identificatore del stampabile da stampare. Con questo identificatore, selezioneremo nella funzione Stampa del modulo manager quale modulo stampabile deve essere stampato;
• Gli oggetti di stampa sono direttamente quegli oggetti per i quali si formano i moduli di stampa;
• Titolare del modulo;
• Parametri di stampa: qui formiamo e passiamo una struttura con parametri di stampa, proprio lì passiamo i nostri parametri aggiuntivi che abbiamo richiesto all'utente nel modulo di elaborazione.

Infatti, richiamando la funzione ExecutePrintCommand dal form di elaborazione, risolviamo il nostro problema di visualizzare il form stampabile nel form "PrintDocuments". Successivamente, il sottosistema "Stampa" eseguirà le azioni standard e porterà l'esecuzione alla procedura Stampa, che dobbiamo definire nel gestore dei moduli della nostra elaborazione.

Creazione di un layout stampabile

Apportare modifiche al modulo Gestore elaborazione

Da questo momento, eseguiamo azioni standard per lo sviluppo di moduli di stampa utilizzando il sottosistema "Stampa" di BSP.

Aggiungi il seguente codice al modulo manager:

Procedura Print(ObjectsArray,PrintParameters,PrintFormCollection,PrintObjects,OutputParameters) ObjectsArray,PrintParameters), "Processing.PrintForm.PF_MXL_PrintForm",); Finisci se; EndProcedure &AtServer Function PrintLayout(ObjectArray,PrintSettings) SpreadsheetDocument = New SpreadsheetDocument; //Crea un foglio di calcolo ///////////////////////////////////////////////////////// / ////////////////////////////////////////////////////////////////////////////////// // //////////////// //PARTE DEL MODULO RIDETERMINATA // //Qui formiamo il nostro Layout stampabile = GetLayout("PF_MXL_PrintForm"); Per ogni oggetto da Objects Array Loop AreaHeader = Layout.GetArea("Header"); AreaObject = Layout.Get Area("Oggetto"); SpreadsheetDocument.Output(RegionHeader); AreaObject.Parameters["Oggetto"] = Oggetto; SpreadsheetDocument.Output(RegionObject); For Count = 1 ByPrintSettings["Numero di righe"] Loop AreaString = Layout.GetArea("String"); RegionString.Parameters["String"] = Conteggio; SpreadsheetDocument.Output(AreaString); ciclo finale; SpreadsheetDocument.OutputHorizontalPageSeparator(); ciclo finale; //PARTE RIDETERMINATA DEL MODULO ///////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////// /// ///////////////// Restituire SpreadsheetDocument; //Restituisce il documento del foglio di calcolo EndFunction

Seconda opzione. Attraverso l'implementazione del comando di stampa.

Questa opzione è molto simile alla prima in termini di stampa. La sua differenza sta nel modo di creare un comando che verrà inviato all'interfaccia e inizierà la nostra stampa.

In questo caso, quando si definisce il comando di stampa, utilizziamo anche il sottosistema "Stampa" del BSP. Invece di definire un comando per aprire l'elaborazione nell'elaborazione stessa, dobbiamo andare nel modulo manager, l'oggetto in cui vogliamo aggiungere un stampabile, e impostare la descrizione del comando di stampa nella procedura AddPrintCommands(PrintCommands):

Procedura AddPrintCommands(PrintCommands) ExportPrintCommand = PrintCommands.Add(); PrintCommand.Identifier = "PrintForm"; PrintCommand.View = НStr("ru = "Stampa modulo""); PrintCommand.Handler = "CommonModulePrintForm.ProcessingPrintFormCommand"; PrintCommand.Ordine = 100; EndProcedura

Qui aggiungiamo a tutti i form della directory (vi ricordo che stiamo lavorando con la directory della controparte), un comando di stampa chiamato "Stampa un modulo stampabile". Ed ecco il punto principale che deve essere preso in considerazione. È possibile aggiungere due tipi di comandi a un modulo:

1. Chiamando la procedura di Stampa dal modulo manager;

2. Chiamare il metodo client.

Questa è esattamente la chiamata al metodo client di cui abbiamo bisogno. Il metodo client ci consentirà di richiamare un modulo di elaborazione in cui chiederemo all'utente i dati di cui abbiamo bisogno prima della stampa.

Per implementare tale chiamata, quando si definisce un comando, impostare un gestore per esso (vedere il codice sopra). Una stringa contenente il percorso della funzione client viene passata al gestore dei comandi, ad es. il percorso alla funzione di esportazione del modulo condiviso sul client. Questa è la funzione che verrà chiamata quando si fa clic sul comando di stampa che aggiungiamo ai moduli.

Come capisci, affinché funzioni, devi creare questo CommonModule e definire una funzione di esportazione. Pertanto, scriviamo il seguente codice nel nostro modulo comune:

Function HandlingPrintCommandPrintForm(PrintParameters) Esporta //Inserisce il contenuto del gestore. FormParameters = Nuova struttura("PrintData",PrintParameters.PrintObjects); OpenForm("Elaborazione.PrintForm.Form", FormParameters); Funzioni finali

Qui facciamo come nella prima implementazione, apriamo il form stampabile, solo ora il nostro PrintData sarà contenuto nel parametro passato alla funzione PrintParameters, ovvero nel suo campo PrintObjects.

Dopo aver aperto il modulo di elaborazione, tutte le azioni sono simili alla prima opzione.

L'implementazione di tale opzione è riscontrabile nelle configurazioni tipiche, nei meccanismi associati alla stampa del consenso al trattamento dei dati personali.

Creiamo elaborazioni aggiuntive.

Ma cosa succede se questa non è la nostra configurazione ed è supportata? E in generale, non vogliamo arrampicarci nella configurazione e modificarla?

In questo caso, è necessario utilizzare il sottosistema "Report ed elaborazione aggiuntivi" del BSP.

Con questa soluzione, abbiamo bisogno di scrivere il codice solo in due posti, e tutti sono nella nostra futura elaborazione aggiuntiva:

1. Modulo oggetto di elaborazione;

2. Modulo di elaborazione.

Nel modulo oggetto, scrivi il seguente codice:

Ci sono due funzioni e una procedura.

La funzione standard per l'elaborazione aggiuntiva è ExternalProcessingInfo(), senza di essa il sistema non capirà che si tratta di un'elaborazione aggiuntiva. Qui il punto importante è l'indicazione che il comando implementato in questa elaborazione ha il tipo Apertura modulo. Quelli. apriremo il modulo di cui abbiamo bisogno. Segue la definizione della procedura di Stampa e della funzione che genera direttamente il nostro foglio di calcolo.

Qui è necessario prestare attenzione al fatto che il comando di stampa in questo caso dovrebbe contenere solo 4 parametri e non 5 come è con la consueta definizione del comando di stampa nel modulo manager. In questo caso, non c'è alcuna opzione per passare le Opzioni di stampa. Pertanto, dovremo mostrare ingegno per trasmettere, oltre agli oggetti stessi, per i quali è formato il modulo stampato, ma anche i parametri che richiediamo all'utente nel modulo.

E così abbiamo definito l'elaborazione aggiuntiva, il comando da cui si aprirà il modulo di elaborazione. Pertanto, il passaggio successivo consiste nel creare un modulo di elaborazione.

In questo modulo, dobbiamo creare tre attributi per memorizzare i valori di cui avremo bisogno in futuro. Chiamiamo questi dettagli come segue:

CommandID - digitare Stringa

Oggetti di destinazione: digitare ValueList

Nel modulo di questo modulo, scrivi il seguente codice:

&AtServer Procedura WhenCreatingAtServer(Failure, StandardProcessing) //Durante la creazione sul server, ricordare i parametri standard passati dal sottosistema AdditionalReportsAndProcessing AdditionalProcessingReference = Parameters.AdditionalProcessingReference; CommandId = Parametri.CommandId; DestinationObjects.LoadValues(Parameters.DestinationObjects); EndProcedure &AtClient Procedure Print(Command) // Ottieni la chiave di univocità del modulo aperto. UniqueKey = String(Nuovo UniqueIdentifier); //Definisci e riempi parametri standard per la forma generale PrintDocumentsOpenParameters = New Structure("DataSource, SourceParameters"); OpenParameters.DataSource = AdditionalProcessingReference; OpenParameters.SourceParameters = Nuova struttura ("CommandIdentifier, Oggetti di destinazione"); OpenParameters.SourceParameters.CommandId = CommandId; //Gli oggetti per la stampa ei parametri inseriti nel modulo di elaborazione //verranno passati attraverso il parametro SourceParameters.DestinationObjectsOpeningParameters.SourceParameters.DestinationObjects = GetDestinationObjectsAndPrintParameters(); OpenForm("CommonForm.PrintingDocuments",OpenParameters,FormOwner,UniqueKey); Funzione EndProcedure &AtServer GetDestinationObjectsAndPrintParameters()PrintData = DestinationObjects.Copy(); /////////////////////////////////////////////////////////////////////////////////// / ////////////////////////////////////////////////////////////////////////////////// // /////////// //PARTE REDETERMINATA DEL MODULO // //Qui creiamo la struttura PrintParameters e la riempiamo con i parametri //che devono essere passati alla funzione printPrintParameters = New Structure; PrintParameters.Insert("Numero di righe", Quantità di righe); PrintData.Insert(0, PrintSettings); //PARTE RIDETERMINATA DEL MODULO ///////////////////////////////////////// // ///////////////////////////////////////////////////////////////////////////////// /// ///////////////// ReturnPrintData; Funzioni finali

Nella procedura OnCreateOnServer inseriamo i nostri tre dettagli che abbiamo creato per memorizzare i parametri passati al modulo di elaborazione.

Successivamente, definiamo il gestore per il pulsante di stampa sul modulo. In questo gestore, dobbiamo aprire noi stessi il modulo "Stampa documenti", per questo dobbiamo preparare le opzioni di apertura di una determinata struttura. In questa struttura devono essere definiti almeno due campi:

SourceParameters, che includono CommandId e DestinationObjects:

Command Identifier - salvato anche durante la creazione sul server, questo è l'identificatore del comando che ha chiamato il modulo della nostra elaborazione. Pertanto, l'identificatore, determineremo cosa dobbiamo stampare nella procedura di stampa nel modulo oggetto.

Oggetti di destinazione - è in questo campo che dobbiamo passare un array di oggetti per i quali è formato il modulo stampato, nonché i parametri richiesti dall'utente nel modulo.

Il modo in cui definisco gli oggetti di destinazione può essere visto nella funzione GetDestinationObjectsAndPrintParameters. Qui copio le nostre destinazioni dal form prop, al posto dell'elemento array all'indice 0, incollo le nostre opzioni di stampa.

In futuro, l'array così definito verrà passato dal form "Stampa documenti", come primo parametro della procedura di stampa del modulo oggetto, che abbiamo definito in precedenza.

Se torniamo alla definizione del modulo oggetto di elaborazione e guardiamo la funzione PrintLayout, nelle prime tre righe della funzione puoi vedere come estraggo i nostri parametri e oggetti dai dati passati alla procedura Print e poi lavoro con loro.

Tali manipolazioni con il parametro DestinationObjects sono dovute alle specifiche della chiamata alla procedura Print del modulo oggetto. Puoi tenere traccia di come vengono passati i parametri e come vengono effettuate le chiamate di funzione aprendo il modulo del modulo PrintDocuments.

Risultato.

Come risultato di tali manipolazioni, otterremo tre comandi sul modulo da cui vogliamo visualizzare il modulo stampato:

La numerazione dei comandi corrisponde all'ordine delle opzioni di implementazione.

Tutti questi comandi faranno la stessa cosa:

Mostra modulo di richiesta parametri aggiuntivi

Visualizza gli stampabili generati nel modulo "Stampa documenti".. Proprio quello che volevamo:

PS Come modelli, per implementare i miei stampabili con una richiesta di parametri aggiuntivi, scarico entrambe le elaborazioni che partecipano a tutti e tre i metodi di formazione di un stampabile.

Questo articolo descriverà in dettaglio come un principiante che non conosce bene 1C 8 per creare un stampabile. Ad esempio, prendiamo una delle configurazioni 1C 8 più comuni - Contabilità 2.0. Creazione di una fase di scrittura 1C stampabile:

• Creazione di un file stampabile esterno;
• Creazione di un layout di modulo stampato;
• Scrivere un codice di programma per visualizzare sullo schermo i dati dei moduli stampati;
• Creazione di parametri per l'autoregistrazione di un modulo cartaceo;
• Collegamento di un modulo di stampa esterno alla base 1C Imprese.

Creazione di un modulo cartaceo 1C. Formulazione del problema

Siamo richiesti nella configurazione Contabilità 2.0 creare un stampabile per un documento Ricevimento di beni e servizi. Nell'intestazione del modulo stampato, visualizzare i seguenti dati:

• Organizzazione;
• Controparte;
• contratto di controparte;
• Data della ricevuta.

Visualizza i dati della tabella in forma tabellare Prodotti documento. La tabella dovrebbe includere le seguenti colonne:

• Nomenclatura;
• Quantità;
• Prezzo;
• Somma;
• Oltre al prezzo dell'articolo per la data corrente (per tipo di prezzi dal documento).

File di elaborazione esterno

Passiamo alla soluzione del problema. Per iniziare, apri 1C 8 in modalità Configuratore. È in questa modalità che tutti gli sviluppi vengono eseguiti sulla piattaforma 1C 8. Ora dobbiamo creare un file di elaborazione esterno. Per fare ciò, fare clic sul menu File -> Nuovo... o dall'icona del nuovo file.

Nella finestra che si apre, seleziona l'elemento Elaborazione esterna.

Più in campo Nomeè necessario inserire il nome del trattamento esterno. Nel nostro caso chiamiamola semplicemente: "Modulo da stampare", il campo del sinonimo verrà compilato automaticamente. Si prega di notare che nel campo Nome, elaborazione esterna, il nome deve essere scritto senza spazi e segni di punteggiatura.

Aggiungi un attributo di elaborazione esterno ObjectReference e selezionare per lui tipo DocumentReference.Ricevimento merciServizi. Per fare ciò, nell'albero dei metadati dell'elaborazione esterna 1C, selezionare l'elemento Requisiti e premere il pulsante Aggiungere(pulsante più verde). Nella parte destra dello schermo si aprirà la finestra delle proprietà degli attributi, nel campo Nome scrivere - Collega all'oggetto. A campo Tipo di premere il pulsante con tre punti.

Espandi il ramo nell'albero dei tipi DocumentLink, e trova lì la voce Ricevimento di beni e servizi, seleziona la casella accanto ad essa e fai clic OK.

Salva il file di elaborazione esterno in disco fisso, per questo utilizziamo il menu File -> Salva, icona Salva(disco floppy blu) o una scorciatoia da tastiera ctrl+s. Diamo il nome al file salvato "PrintForm".

Crea un layout stampabile

Iniziamo a creare un layout stampabile 1C. Il layout funge da modello per l'output del stampabile, quindi se vuoi che il tuo stampabile abbia un bell'aspetto, dovresti prestare attenzione ad esso.

Aggiungiamo un nuovo layout nell'albero dei metadati di elaborazione esterna, non cambieremo nulla nella finestra del designer del layout e premiamo il pulsante Pronto.

Nel nuovo layout che si apre, creiamo diverse aree necessarie per visualizzare il modulo stampato. Tutte le aree di layout di cui abbiamo bisogno saranno orizzontali, quindi per creare una nuova area, dobbiamo selezionare importo richiesto linee di layout e vai al menu Tabella -> Nomi -> Assegna nome o usa la scorciatoia da tastiera CTRL+MAIUSC+N quindi inserire il nome della regione nella casella. Quando crei un'area di layout, non aver paura di sbagliare con il numero di righe: puoi sempre aggiungerle o rimuoverle. Per eliminare una linea di layout 1C, selezionare la linea desiderata e selezionare menù contestuale paragrafo Elimina. Per aggiungere nuova linea al layout, selezionare una riga qualsiasi del layout e selezionare la voce nel menu contestuale spingere a parte.

Aggiunta di un'intestazione di layout

Creiamo prima un'area. Cappello, visualizzerà i dati per l'intestazione del modulo stampato. Per quest'area, abbiamo bisogno di sette linee di layout. Selezionali e, come ho scritto sopra, premi la scorciatoia da tastiera CTRL+MAIUSC+N, in campo Nome scrivi "Cappello" e premi il pulsante OK.

Riempiamo l'area del layout con i dati di cui abbiamo bisogno. Di solito, nessun modulo stampato è completo senza un'intestazione, quindi lo creeremo anche nell'intestazione del nostro layout. Poiché nell'intestazione, oltre al nome del modulo stampato, visualizzeremo anche il numero del documento da cui è stato stampato, imposteremo come parametro il testo dell'intestazione nel layout. Un parametro di layout è una cella di layout appositamente designata in cui è possibile visualizzare vari dati utilizzando il linguaggio 1C 8 integrato. Il titolo dovrebbe essere visualizzato su tutta la larghezza del modulo stampato, quindi decidiamo quante celle di layout saranno sufficienti per stampare su uno standard orientamento orizzontale foglio.

Di solito sono sufficienti tredici o quattordici celle di layout, selezionarle nella prima riga dell'area Cappello e unisciti in una cella ( Menu contestuale -> Unisci). Successivamente, fai doppio clic sulla cella grande risultante e scrivi il nome del parametro, nel nostro caso "HeaderText". Affinché il testo inserito diventi un parametro a tutti gli effetti, fare clic con il tasto destro sulla cella e selezionare la voce nel menu contestuale Proprietà. Segnalibro Disposizione trova un campo Riempimento e scegli il valore Parametro. I parametri nel layout 1C sono indicati tra parentesi "<>».

Il titolo del modulo stampato dovrebbe risaltare tra gli altri testi, quindi seleziona ancora una volta la cella e usa le icone sul pannello di formattazione del layout per impostare l'allineamento del testo Centrato e dimensione del carattere 14.

Dopo il testo del titolo, verrà visualizzato nell'area Cappello dati sull'organizzazione, controparte, contratto di controparte e data di ricevimento della merce. Poiché tutti questi dati sono presi anche dal documento, li decoreremo anche con parametri. Inoltre, prima di ogni parametro, dovresti scrivere un testo esplicativo in modo che l'utente possa capire facilmente dove si trova l'organizzazione, e dove si trova la controparte, ecc. Tutte queste azioni sono simili alla creazione di un'intestazione, quindi non mi soffermerò su di esse in dettaglio, fornirò solo un'immagine con ciò che dovrebbe risultare alla fine.

La figura mostra come le opzioni di layout differiscono dal testo normale.

Aggiunta di un'intestazione di tabella di layout

L'ultima cosa che dobbiamo creare in questa area di layout è l'intestazione della tabella, in cui verranno visualizzati i dati della parte tabellare. Prodotti. Le colonne richieste per la tabella sono state descritte nella sezione "Problem Statement". Creeremo anche un'intestazione di tabella utilizzando l'unione di celle e la scrittura di testo (nomi di colonna). Seleziona i bordi dell'intestazione della tabella utilizzando lo strumento Telaio, che si trova nella barra di formattazione del layout.

Aggiunta di una tabella a un layout

Creiamo un'altra area nel layout - Dati. Verrà visualizzata la tabella dati della parte tabellare Prodotti. Abbiamo solo bisogno di una linea di layout per quest'area. Per visualizzare tutte le righe della parte tabellare in forma stampata, compileremo e visualizzeremo quest'area il numero di volte richiesto. Relatori della zona Dati deve corrispondere alle colonne dell'intestazione della tabella, quindi compilarla non sarà difficile. L'unica differenza è nella zona Dati abbiamo bisogno di opzioni, non solo di testo. Si noti inoltre che per impostazione predefinita i parametri numerici sono formattati sul margine destro e i parametri di testo a sinistra. Per selezionare le colonne, devi anche utilizzare lo strumento Telaio.

Aggiunta di un piè di pagina a un layout

L'ultima area del layout di cui abbiamo bisogno è Seminterrato. Visualizzerà i totali per quantità e importo. La creazione è simile alla creazione di un'area Dati, ma in aggiunta i risultati dovrebbero essere evidenziati in grassetto.

Il risultato dovrebbe essere un layout simile a questo:

Creazione di un modulo cartaceo 1C. Programmazione

Iniziamo a programmare: questa è la fase più importante nella creazione di un modulo stampato. Prima di tutto, andiamo al modulo dell'oggetto lastra di stampa esterna, è qui che andremo a programmare. Per fare ciò, nella finestra principale del trattamento esterno, premere Azioni -> Apri modulo oggetto.

Nel modulo oggetto modulo di stampa esterno, è necessario creare una funzione di esportazione Sigillo().

Funzione Stampa() Esporta EndFunction

notare che data funzioneè obbligatorio per i moduli di stampa esterni nelle configurazioni che utilizzano applicazione regolare. Scriveremo tutto il codice di programma successivo necessario per visualizzare il modulo stampato all'interno di questa funzione.

Inizializzazione delle variabili di base

Creiamo una variabile TabDoc, che conterrà un foglio di calcolo: è lui il modulo stampato in cui visualizzeremo le aree riempite del layout.

TabDoc = nuovo SpreadsheetDocument;

in una variabile Disposizione riceveremo il layout del modulo stampato da noi creato. Per fare ciò, utilizziamo la funzione integrata Ottieni Layout(<ИмяМакета>).

Disposizione = GetLayout("Layout");

Otterremo tutte le aree del layout in variabili. Per fare ciò, utilizziamo il metodo di layout GetRegion(<ИмяОбласти>) .

Area dell'intestazione = Layout.GetArea("Intestazione"); AreaData = Layout.GetArea("Dati"); AreaFooter = Layout.GetArea("Seminterrato");

Visualizzazione dell'intestazione stampabile in un foglio di calcolo

Tutte le variabili necessarie vengono inizializzate. Iniziamo a riempire e visualizzare le aree di layout in un foglio di calcolo. Prima di tutto, compiliamo il titolo del modulo stampato, per questo dobbiamo passare il parametro Testo del titolo, che abbiamo creato nel layout, il testo di cui abbiamo bisogno. Per compilare i valori dei parametri, l'area del layout ha una raccolta speciale, chiamata - Opzioni. Da cui attraverso il "." puoi ottenere qualsiasi parametro. Nel testo del titolo passeremo il testo: "Modulo di stampa", oltre al numero del documento.

Header Area.Parameters.HeaderText = "Modulo di stampa"+ReferenceToObject.Number;

I restanti parametri dell'intestazione verranno compilati in modo simile, tutti i valori per essi richiesti saranno ottenuti dai props Riferimento all'oggetto, che contiene un collegamento al documento da stampare.

HeaderScope.Parameters.Organization = LinkToObject.Organization; Area di intestazione.Parameters.Account = LinkToObject.Account; Header Area.Parameters.IncomingDate = ObjectReference.Date; Header Area.Parameters.Counterparty Agreement = LinkToObject.Counterparty Agreement;

Tutti i parametri di intestazione sono compilati, lo visualizzeremo nel documento del foglio di calcolo che abbiamo creato, per questo utilizziamo il metodo produzione(<Область>) .

TabDoc.Output(HeaderArea);

Scrivere una richiesta per un handicap stampato

Iniziamo a riempire e visualizzare l'area Dati. Creare un stampabile 1C implica anche scrivere una query, ci serve per ottenere i dati della parte tabulare Prodotti e prezzi Nomenclatura per la data corrente che useremo Richiesta. Il linguaggio di query 1C 8 è simile a SQL, o meglio, praticamente ne copia le capacità. Istruzione SELEZIONA, ma l'intera richiesta è scritta in russo. Pertanto, se hai una familiarità almeno remota con SQL, capirai facilmente il linguaggio di query 1C 8.

In questo modulo cartaceo la richiesta sarà abbastanza semplice e molti diranno che se ne potrebbe fare a meno, ma la conoscenza del linguaggio di interrogazione e la capacità di usarlo correttamente è una delle abilità principali di un programmatore 1C. Le query consentono di utilizzare meno risorse per ottenere le selezioni di dati più complesse ed è anche molto più facile comprendere il testo della query rispetto al codice del programma scritto senza utilizzare la query (o con un utilizzo minimo di essa). Inoltre, in 1C 8 ci sono molto buon progettista query, che consente di raccogliere interattivamente una query dalle tabelle necessarie.

Creiamo una variabile che conterrà la richiesta.

Richiesta = Nuova Richiesta;

Il testo della richiesta verrà composto utilizzando il generatore di query. Iniziamo scrivendo:

Testo.Richiesta = "";

Metti il ​​cursore del mouse tra le virgolette, premi il tasto destro del mouse. Nel menu contestuale che si apre, seleziona la voce Richiedi il costruttore, ci aiuterà molto nella creazione di un stampabile 1C. Successivamente, si aprirà la finestra di progettazione query, che contiene molte schede, ma la nostra query ne richiederà solo quattro: "Tabelle e campi", "Relazioni", "Condizioni", "Unisci / Alias".

Per la nostra query, abbiamo bisogno di due tabelle: la parte tabulare Prodotti documento Ricevimento di beni e servizi e una fetta delle ultime informazioni sulla data corrente del registro Prezzi degli articoli.

Nella parte sinistra della finestra di progettazione, trova la colonna Banca dati. Contiene un albero di tutti gli oggetti di metadati, troviamo quelli di cui abbiamo bisogno. Per fare ciò, apri il ramo I documenti e trova il documento Servizi in entrata merci, aprilo e trova parte tabellare Prodotti, trascinalo nella colonna di Query Designer tavoli. Esistono tre modi per trascinare e rilasciare: trascinando, facendo doppio clic sulla tabella o selezionandola e facendo clic sul pulsante ">". Apriamo una filiale Informazioni sui registri e trova un tavolo lì PrezziArticoli.SliceLast, trascinalo anche nella colonna tavoli. Queste due tabelle sono sufficienti per la nostra query.

Selezioniamo i campi di cui abbiamo bisogno dalle tabelle risultanti. Per fare questo, nella colonna tavoli apri il tavolo e trova i campi: Nomenclatura, Importo, Prezzo, Quantità e trascinali nella terza colonna del costruttore - campi. Apriamo il tavolo , trova il campo Prezzo e trascinalo anche su campi.

La struttura delle tabelle e dei campi della nostra richiesta è pronta, ora occupiamoci delle condizioni. Abbiamo bisogno dei dati della parte tabellare Prodotti non sono stati prelevati da tutte le ricevute, ma solo da quella che stampiamo. Per fare ciò, imponiamo una condizione sul tavolo Merci in entrata Servizi Merci. Andiamo alla scheda "Condizioni" del generatore di query. In una colonna campi le tabelle che abbiamo selezionato in precedenza si trovano, per la condizione abbiamo bisogno del campo Collegamento dal tavolo Ricevimento di merci, servizi, merci, trascinalo nella finestra Condizioni.

Nelle query 1C è possibile utilizzare i parametri, necessari per trasferire i dati alla query. Ad esempio, se vogliamo limitare la selezione dei documenti a un documento specifico, possiamo utilizzare un parametro per passare un collegamento a questo documento alla richiesta e utilizzare questo parametro nella condizione. Questo è esattamente ciò che faremo nella nostra richiesta.

Una volta fuori dalla finestra Termini abbiamo aggiunto un campo Collegamento, il generatore di query creerà un parametro con lo stesso nome e lo posizionerà dopo il segno "=". Questo parametro può essere rinominato se lo si desidera. Nel testo della richiesta i parametri sono contrassegnati dal segno “&”, ma in questo caso non è necessario, poiché si presume che il parametro sia nella seconda parte della condizione, basta ricordarlo. Come passare un valore a un parametro di richiesta 1C verrà discusso di seguito.

Poiché nella query non utilizziamo la tabella completa dei prezzi degli articoli, ma una virtuale (una fetta di quest'ultima in questo caso), è necessario impostare le condizioni per la formazione di questa tavola virtuale, nel nostro caso, questa è la data limite e una condizione per il tipo di prezzo (devono essere selezionati i prezzi con un tipo di prezzo rigorosamente definito, quello specificato nel documento di ricevuta che stampiamo).

Per compilare i parametri della tabella virtuale, vai alla scheda Tabelle e campi costruttore di query, nella colonna tavoli seleziona la tabella PrezziArticoliSliceUltimo e premere il pulsante Opzioni del tavolo virtuale situato in alto. Nella finestra che si apre, nel campo Periodoè necessario impostare il parametro a cui verrà trascorsa la data per la quale verrà effettuato il taglio del prezzo. Nel nostro caso, questa sarà la data corrente (cioè oggi), quindi chiameremo il parametro "&CurrentDate". Nel campo condizione scriveremo le condizioni per il tipo di prezzo, lo passeremo anche nel parametro, che chiameremo “&PriceType”. La condizione risultante sarà simile a questa (dove Tipo di prezzo- registrare la misurazione Prezzi degli articoli):

PrezzoTipo = &TipoPrezzo

I parametri della tabella virtuale sono compilati, fare clic sul pulsante OK.

Ora che abbiamo limitato la selezione al solo documento di cui abbiamo bisogno, creiamo relazioni tra le tabelle di query. In caso contrario, i prezzi della tabella PriceItemsSliceLast non verranno associati all'articolo dello scontrino. Andiamo alla scheda Connessioni costruttore di query. Creiamo un collegamento per campo Nomenclatura tra i nostri due tavoli. Per fare ciò, premere il pulsante Aggiungere, in campo Tabella 1 scegli un tavolo Merci in entrata Servizi Merci e nel campo Table 2 - PricesItemsSliceLast. Nelle condizioni di connessione, seleziona i campi Nomenclatura da entrambi i tavoli.

Va anche notato che nella selezione della query dobbiamo ottenere tutte le righe dalla tab-part Prodotti e prezzi solo se disponibili per la data corrente per tipo di prezzo del documento. Quindi, queste schede Prodotti sono obbligatori, ma i dati sulla riduzione dei prezzi non lo sono. Pertanto, nei collegamenti tra queste tabelle, è necessario utilizzare il cosiddetto LEFT JOIN, e la tabella di sinistra (o obbligatoria) sarà Merci in entrata Servizi Merci e il diritto (o facoltativo) PriceItemSliceLast. Per unisciti a sinistra le tabelle di query hanno funzionato come descritto sopra, è necessario selezionare la casella Tutto dopo il campo Tabella 1.

La richiesta è quasi pronta, non resta che lavorare un po' sugli pseudonimi in campo. Vai al segnalibro Sindacati/alias e imposta uno pseudonimo per il campo PrezziArticoliSliceLast.Price. Il nome alias sarà − Prezzo per oggi, è necessario affinché i nomi dei campi di selezione della query ei nomi dei parametri nel layout del modulo stampato corrispondano.

Il lavoro nella finestra di progettazione delle query è terminato, premiamo il pulsante OK. Dopo la chiusura della finestra del costruttore, vedrai che la riga con il testo della richiesta è compilata e si presenta così:

Richiesta. Text = "Scegli | ricezione di servizi. Nomenclaturatori, | ricezione di servizi. Riepilogo beni, | ricezione di servizi. Raggruppamento merci. Prodotti, | ricevuta di servizi. Complessità, | prezzi dei detenuti del giorno successivo | Certificati documentali. Prodotti (| &CurrentDate, PriceType = &PriceType) AS PrezziItemsSliceLast | By Incoming GoodsServicesGoods.Nomenclature | = PrezziItemsSliceLast.Nomenclature |WHERE | Incoming GoodsServicesGoods.Reference = &Reference";

Esecuzione di una richiesta

Passeremo i parametri necessari alla richiesta, per questo utilizzeremo il metodo di richiesta setParameter(<ИмяПараметра>,<Значение>). Per ottenere data odierna utilizzare la funzione incorporata La data corrente(), restituisce la data e l'ora del computer.

Eseguiamo una query per ottenere una selezione con i dati di cui abbiamo bisogno. Per fare ciò, utilizziamo prima il metodo query Eseguire(), e poi il metodo Scegliere().

Selezione = Query.Execute().Select();

Compilazione della tabella stampabile

Di conseguenza, nella variabile Campione conterrà una selezione di risultati della query, è possibile navigare attraverso di essa utilizzando il metodo Prossimo() e per bypassare l'intero sarà necessario un loop Ciao. La struttura sarà simile a questa:

While Selection.Next() Ciclo EndCycle;

È in questo ciclo che riempiremo e visualizzeremo l'area del layout Dati. Ma prima inizializziamo due variabili di tipo numerico. In essi raccoglieremo i totali in base al numero e all'importo che dobbiamo visualizzare nell'area Seminterrato.

Somma totale = 0; Numero totale = 0;

All'interno del ciclo, riempiremo l'area Dati dati dall'elemento di selezione corrente in variabili Somma totale e Numero totale aggiungere valori di somma e quantità e, infine, visualizzare l'area in un foglio di calcolo utilizzando il metodo a noi già familiare produzione(). Poiché i nomi dei campi della nostra richiesta sono esattamente gli stessi dei nomi dei parametri dei campi Dati, quindi per il riempimento useremo la procedura integrata FillPropertyValues(<Приемник>, <Источник>) che copia i valori della proprietà<Источника>alle proprietà<Приемника>.

While Selection.Next() Loop FillPropertyValues(DataArea.Parameters, Selection); SommaTotale = SommaTotale + Somma Campione; TotalQuantity = TotalQuantity + Sample.Quantity; TabDoc.Output(AreaDati); ciclo finale;

Output del piè di pagina del modulo di stampa in un foglio di calcolo

Resta da riempire e visualizzare l'ultima area del layout - Seminterrato. Abbiamo già preparato i dati per il riempimento, il riempimento e l'uscita vengono eseguiti secondo lo stesso schema.

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

Il documento del foglio di calcolo è completamente compilato, resta da visualizzarlo sullo schermo in modo che l'utente possa visualizzare il modulo stampato e, se necessario, stamparlo. Ma nelle tipiche configurazioni 1C 8, le procedure dei moduli speciali sono responsabili dell'output di moduli di stampa esterni. Pertanto, è sufficiente tornare dalla funzione Sigillo() foglio di calcolo completato.

Ritorna TabDoc;

A questo punto la programmazione è completata e la creazione del modulo stampabile 1c è quasi completata. Testo completo della funzione Sigillo() Non lo darò qui, lo potete vedere in un file stampabile, che potete scaricare in fondo all'articolo.

Creazione di un modulo cartaceo 1C. Opzioni di registrazione automatica

Quando si collega un stampabile esterno al database, il sistema non determina automaticamente a quale particolare documento o directory è destinato il stampabile, è necessario selezionarlo manualmente. E se un'altra persona ha scritto il modulo stampato e ti viene solo chiesto di collegarlo, la scelta può diventare ambigua. Per evitare tali problemi, in tutti gli stampabili esterni è necessario creare un layout con parametri di autoregistrazione. Se viene creato e formattato correttamente, il sistema determina automaticamente a quale documento o directory è destinato il modulo stampato.

Si fa come segue:

• Nella lavorazione esterna, creiamo un nuovo layout. Lo chiamiamo “Parameters_Autoregistration” (importante per non sbagliare!).
• Nella prima cella del layout scriviamo I documenti.(o Libri di riferimento.) e il nome del documento a cui si desidera collegare il stampabile.

Collegamento alla base di un modulo di stampa esterno

• Esegui 1C 8 in modalità Azienda;
• Vai al menù Servizio -> Rapporti ed elaborazione aggiuntivi -> Moduli di stampa esterni aggiuntivi;
• Fare clic sul pulsante Aggiungere;
• Nella finestra che si apre, fai clic sull'icona Sostituisci il file di elaborazione esterno;
• Se hai creato parametri di registrazione automatica, accettiamo di utilizzarli;
• Se non hai creato parametri di registrazione automatica, nella sezione tabellare Accessorio del piatto di stampa aggiungere il documento o la directory richiesti;
• Premiamo il pulsante OK.

Successivamente, lo stampabile esterno sarà disponibile nel menu Sigillo documento Consegna di beni e servizi. La creazione di un 1C stampabile su questo può considerarsi conclusa.