Attention!
All processing from ITS disks is intended for informational purposes and exclusively for registered ITS users.
Searches for objects in documents and directories that meet certain conditions. Processes search results.
Performs information security rollup of typical configurations:
Edits, in managed application mode, the registration of changes to exchanged objects. Allows you to change the current registration on different nodes. Changes the numbers of received and sent messages.
Converts a log of user actions into a program, in a built-in language.
Indexing and searching data.
Searches for and replaces reference values in information security objects.
Creates or edits a process log file. It has the ability to configure the creation of a crash dump, configure conditions and events, upon the occurrence of which information will be recorded in this log.
Monitors background and routine tasks. Deletes, creates new ones.
Selective change or clearing of information security from certain information.
Changes details and tabular parts in documents and reference books.
Uploads and loads information security users into an XML file.
Uploads data structures to external DBMSs using ADO in two modes:
Supports the following DBMS:
Uploads and loads data into information security, both completely and partially. Used to transfer data between configurations that are similar in object composition.
Loads data into directories and tabular parts from tabular documents.
Works in a thick client in normal application mode.
Provides great assistance in reporting and query creation.
Let's consider creating an external report in 1C 8 without using a data composition system. To create an external report, we will use the Accounting 2.0 configuration, the initial data: “Write a report on accounting account 62 in which the turnover for the specified period will be displayed in the context Counterparties And Contracts of counterparties.
1. Create a report
First of all, let's create an external report file; to do this, let's go to 1s 8 in the mode Configurator, let's go to the menu File -> New, or click on the icon new document.
Select the item from the list External report. After creating the external report, give it a Name (for example SimplestReport) and save it to disk. We will also add two details: Beginning of period And End of Period type date, we will need them to limit the time interval for data sampling when generating a report.
2. Create an external report layout
To generate a report in 1C 8, you need a layout, this is a template for displaying data in which all the necessary parameters are set, tables are drawn, etc. Let's add a new layout; to do this, select the item in the report metadata tree Layouts and press the button Add, when creating, select the type for the layout spreadsheet document.
Our layout will have 4 areas:
Let's start creating layout areas. In order to create an area in the layout, select the required number of lines and click Menu Table -> Names -> Assign name(Or Ctrl + Shift + N). To the region A cap Let's write the name of the report: Turnover 62 counts, draw using the tool Borders report header, and also set the parameters Beginning of period And End of Period. Using parameters, you can display the necessary data in the report; we will deal with this at the next stage of development, namely when writing the report code. To create a parameter in the layout, select the desired cell, write the name of the parameter in it (without spaces), right-click on it, select the item in the menu that opens Properties. In the cell properties on the tab Layout select padding Parameter.
After this, the parameter name in the cell will be enclosed in angle brackets("<>“). As a result, the area A cap should look like this:
In area DataCounterparty we will create parameters for displaying the name of the counterparty, as well as for income and expenses for account 62, using the tool Borders Let's design the area as a table row.
In area DataCounterparty Agreement Let's create parameters for displaying the name of the contract, as well as for income and expenses for account 62, using the Borders tool we will design the area as a table row. Let's make a small indent before the parameter Counterparty Agreement(this can be done by splitting and merging cells. Right-click on the cell -> Merge or Split cell), it is needed so that the report can see that the line for the contract is lower in the hierarchy than the line for the counterparty.
In area Basement Let's create parameters for income and expense totals.
As a result, we should get a layout like this:
3. Create a report form
To display data, set the formation period and button Form our report will require a form. To create a form, find the item in the external report metadata tree Forms and press the button Add. On the first page of the form designer, you don't need to make any changes, you just need to click the button Further.
On the next page of the designer, select both available details( Beginning of period, End of Period) for placement on the form.
As a result, we will get this form:
But we are not satisfied with it in this form; let’s make some changes to it:
As a result, our form will look like this:
4. Programming
After creating the report form, let's start programming. First, let's create a procedure for displaying a period selection dialog (we already created a button for this at the previous stage). Right-click on the button and select the menu item Properties, in the button properties go to the tab Events, where using the button with a magnifying glass icon we will create a procedure Button1Press in the form module.
You can switch between the form and its module using the tabs at the bottom of the form
To call the period selection form, we will use the standard procedure Accounting 2.0 from a common module Working with Dialogs - HandlerPeriodSettingPress, you need to pass the report details to it as parameters Beginning of period And End of Period.
Procedure Button1Press(Element) Working with Dialogs.PeriodSettingHandlerPressing(PeriodStart,PeriodEnd); End of ProcedureNow let's move on to writing the code that will generate and display our report. The form module already has a procedure ButtonGeneratePress, which will be executed when the button is pressed Form, that’s where we’ll write our code. Let's start by initializing the necessary variables. First of all, let's create a variable for spreadsheet document fields into which we will output data, this is not necessary, it’s just that the recording of calls to it will become shorter, which means the program code will be more understandable for reading.
TabDoc = FormElements.TabDoc;
Let's get the layout of the external report using the function GetLayout(<ИмяМакета>) , we will pass the name of the layout as a parameter, and if such a layout exists, the function will find it.
Layout = GetLayout("Layout" );
After the layout is received, let's create variables for each of its areas, use the layout method for this GetArea(<ИмяОбласти>) .
AreaHeader = Layout.GetArea("Header" ); AreaDataAccount = Layout.GetArea( "Contractor Data"); AreaDataContract = Layout.GetArea("DataContract" ); AreaFooter = Layout.GetArea("Footer" );
Let's clear the field of the spreadsheet document. This is necessary so that every time a new report is generated, the old data is deleted.
TabDoc.Clear();
Now that the initialization of the variables is complete, let's move on to filling and displaying the layout areas one by one. Let's start with the header. If you remember, we created two parameters in this area Beginning of period And End of Period, we will pass there the values of the report generation period, for this we will use the property Options layout areas.
AreaHeader.Parameters.PeriodStart = PeriodStart; AreaHeader.Parameters.EndPeriod = EndPeriod;
No more actions with the area A cap The manufacturer is not needed, so we will display its field in a spreadsheet document.
TabDoc.Output(AreaHead);
Next, we will write a query to the database, with which we will take the account turnover 62 from the accounting register Self-supporting. Let's define a variable in which our request will be located.
Request = new Request;
Before we start writing the request text, let’s pass the necessary parameters to it. Since we are writing a request for an invoice 62 accounting, then first of all we will create a parameter for it
Request.SetParameter("Account62", Charts of Accounts. Self-supporting. Find By Code("62" ));
It is also necessary to pass the report generation period into the request. Don’t forget that we have special report details for the generation period, and we pass them as parameters.
Request.SetParameter("Start of Period", Start of Period); Request.SetParameter("End of Period", End of Period);
Let's start writing the query text, we will do this using the query designer. Many tutorials say that you need to be able to write a query both manually and using a constructor, but in practice this is not the case. In the tasks that a 1C programmer constantly faces, the priority is to quickly and efficiently write code, and when writing a query to the database manually, this is almost impossible to achieve; you will spend a lot of precious time correctly reproducing all query structures and finding typos which you did when writing, etc. Therefore, do not waste your time trying to write queries manually, but use the query constructor. It will save your time and allow you to write complex queries without much effort. To start writing the request text, let’s write in code:
Request.Text = "" ;
After that, place the cursor between the quotes, right-click and select Constructor request. The query designer window will open.
Now we need to select the 1C 8 database table we need. We need a virtual table Revolutions accounting register Self-supporting. Let's find it on the left side of the designer window
Let's move it to the area Tables and let's start filling out the parameters. For all virtual query tables there is a special set of parameters that allow you to select the necessary data from the main table (in our case, the main table Accounting Register Self-supporting). Let's open the virtual table parameters window.
Let's fill in the parameters for the period that we passed to the request. To use a parameter in the request text, you should write the symbol before its name ampersand(&)
It remains to fill out the condition for the accounting account. accounting. To do this, find the line in the parameters of the virtual table Account Condition and we'll write there
Account IN HIERARCHY (&Account62)
You can also use the conditions constructor by clicking on the button with three dots.
There is no need to impose any more conditions on the virtual table, so let’s click the button OK in the virtual table parameters window. Next, we need to select the fields we need from the table Self-supporting.Turnover(namely: Counterparty, Counterparty Agreement, Income and Expense). To view the list of fields available in the table we have selected, click the “+” symbol next to its name. After that, drag the required fields to the rightmost area of the query designer, which is called: Fields. If we open the chart of accounts, we will see that for the account 62 analytics on For the counterparty this is Subconto1, and by Counterparty Agreement - Subconto2.
Therefore, from the fields of the virtual table we select Subconto1 And Subconto2. Since we need income and expenses by amount, we also select the fields AmountTurnoverDt And AmountTurnoverKt
Let's fill in the aliases of the fields we have selected; to do this, go to the tab Unions/Aliases and set the required field names.
Since in our report the data will be displayed hierarchically (the Counterparty is on the first level, and all of its contracts are on the second), we will configure the display of data in the hierarchy using Totals. Let's go to the tab in the designer Results. Drag into grouping fields sequentially Counterparty And Counterparty Agreement, and in the final Coming And Consumption.
This completes the work in the query constructor, click the button OK and we see that the text of our request appears in the program code.
Query.Text = "SELECT | Self-supportingTurnover.Subconto1 AS Counterparty, | Self-supportingTurnover.Subconto2 AS Counterparty Agreement, | Self-supportingTurnover.AmountTurnoverDt AS Receipt, | Self-supportingTurnover.AmountTurnoverKt AS Expense|FROM | Accounting Register. Self-accounting. Turnovers (&Beginning of Period, &End of Period, Account IN HIERARCHY (&Account 62),) AS Self-accountingTurnover|RESULTS | AMOUNT(Revenue), | AMOUNT(Expense) |PO | Counterparty, | Counterparty Agreement";
After we have finished writing the request, let's start filling out the areas DataCounterparty, DataAgreementCounterparty And Basement. We will fill all these areas with the data received when executing the request. Since our query contains groupings( Counterparty And Counterparty Agreement) select data from it as follows:
SelectionCounterpart = Request.Execute().Select(BypassQueryResult.ByGrouping);
This way we will receive records with totals for all counterparties.
Before traversing the sample data using a loop, we initialize the variables intended for calculating the overall results for the report:
TotalIncoming = 0; TotalConsumption = 0;
In order for the report data to be displayed with a hierarchy (and rotations along “+“), let’s set the beginning of the auto-grouping of the rows of the spreadsheet document:
TabDoc.StartAutoGroupingRows();
All preparations are completed, now let's start crawling the query results. We will perform the traversal using a loop Bye
While Select Account.Next() Cycle EndCycle ;At the beginning of the cycle, reset the parameters Coming And Consumption region DataCounterparty. What is it for? Let's imagine a situation where the counterparty Uncle Vasya, income is 10, and expense is 5, and for the next counterparty Uncle Petya there is neither income nor expenditure, in this case, if we do not reset the parameters Coming And Consumption, then in line by counterparty Uncle Petya there will be an income of 5 and an expense of 10.
AreaDataAccount.Parameters.Receipt = 0; AreaDataAccount.Parameters.Expense = 0;
After that we fill the area DataCounterparty sample element data
FillPropertyValues(AreaAccountData.Parameters,SelectionAccount);
After filling in the data, you can display the area in spreadsheet document, Since we are using auto-grouping of rows, we need to indicate the level of the row in the grouping (our report will have two levels, for counterparties the first for contracts).
TabDoc.Output(AreaDataAccount,1);
Now for this counterparty we will make a selection according to its contracts.
SelectionCounterparty Agreement = SelectionCounterparty.Select(BypassQueryResult.ByGroups);
We will perform the traversal using a loop Bye.
While SelectionCounterparty Agreement.Next() Loop EndCycle ;In the cycle for counterparty agreements, let’s reset the parameters Coming And Consumption, fill the area DataContract from the sample and display it in a spreadsheet document at the second level of records.
AreaDataContract.Parameters.Receipt = 0; AreaDataContract.Parameters.Expense = 0; Fill inPropertyValues(AreaContractData.Parameters,SelectionCounterpartyAgreement); TabDoc.Output(AreaDataContract,2);
Also in this cycle, we will add the current values to the variables for calculating the total values for income and expense.
TotalReceipt = TotalReceipt + SelectionCounterparty Agreement.Receipt; TotalExpense = TotalExpense + SampleCounterparty Agreement.Expense;
This concludes the output of data in the area DataCounterparty, DataAgreementCounterparty completed, all that remains is to complete the auto-grouping of the rows of the spreadsheet document.
TabDoc.FinishAutoGroupingRows();
Full cycles responsible for outputting data to the area DataCounterparty And DataAgreementCounterparty look like this:
TabDoc.StartAutoGroupingRows(); While SelectionAccount.Next() Loop AreaDataAccount.Parameters.Receipt = 0 ;
AreaDataAccount.Parameters.Expense = 0 ; Basement FillPropertyValues(AreaAccountData.Parameters,SelectionAccount); spreadsheet document.
TabDoc.Output(AreaDataAccount,1);
SelectionCounterparty Agreement = SelectionCounterparty.Select(BypassQueryResult.ByGroups); While SelectionCounterparty Agreement.Next() Loop AreaDataAgreement.Parameters.Receipt = 0 ; AreaDataContract.Parameters.Expense = 0 ;
Fill inPropertyValues(AreaContractData.Parameters,SelectionCounterpartyAgreement);
TabDoc.Output(AreaDataContract,2); TotalReceipt = TotalReceipt + SelectionCounterparty Agreement.Receipt; TotalExpense = TotalExpense + SampleCounterparty Agreement.Expense; EndCycle ; EndCycle ; TabDoc.FinishAutoGroupingRows(); It remains to display the final data in the area
and display the area itself in
The article will discuss the following options for additional external connectable objects:
✅
✅
✅
To begin with, I would like to talk in general about what are these external processing, reports and printed forms?. Quite often, when working with a standard configuration, be it 1C ZUP or 1C Enterprise Accounting or some other configuration, there is a need for some functionality that is not provided by 1C developers. For example, you may need printed form, which is not regulated, but is used for the internal needs of the organization. Or required in a certain way process (change, adjust) data available in the database. For example, changing certain details in documents for the required period, which is inconvenient to do manually with large volumes of information.
In this case, there are two options. First, we can modify the configuration itself, the program itself. After that, it will cease to be typical and it will not be possible to update it using the rather simple methods that I wrote about. Updating a non-standard configuration is a longer and more serious process, so with this approach you will most likely have to pay a 1C specialist monthly to update the program. Second An option is to develop or ask to develop an external processing or printed form (report). This is essentially an external module, which is also developed in the 1C programming language in the Configurator, but does not make changes to the standard configuration. It exists independently of the configuration itself. To store them, special directories are used: main menu item “Service” -> “Additional reports and processing”.
✅ Seminar “Lifehacks for 1C ZUP 3.1”
Analysis of 15 life hacks for accounting in 1C ZUP 3.1:
✅ CHECKLIST for checking payroll calculations in 1C ZUP 3.1
VIDEO - monthly self-check of accounting:
✅ Payroll calculation in 1C ZUP 3.1
Step-by-step instructions for beginners:
Now let's look individually at what capabilities each of the four available external modules will give us. Let's start with external processing of tabular parts. It seems to me that these processing of tabular parts of documents most fully illustrate how you can quite seriously modify a program without resorting to editing the standard configuration, but only get by with external processing.
To make it more clear, I will give a specific example from my practice, in which to solve the problem I used external processing of tabular parts. In the configuration "1C Salary and Personnel Management" edition 2.5 there is a document "Payment for holidays and weekends"(This document has been written about in detail). In its standard form, this document provides the ability to automatically fill out the tabular part by employees “Working on holidays”.
The accountant asked to implement the possibility of filling out this document by employees whose working days were scheduled to fall on weekends, i.e. "Working on the weekend".
This file has been uploaded to the directory "External processing of tabular parts"(menu item “Service” -> “Additional reports and processing” -> “Additional external processing of tabular parts”). When creating an element of this directory, it was indicated which document the downloaded processing relates to - “Payment for holidays and weekends of the organization”, as well as which tabular part - “Employees”. In our example, the document has one tabular part, but in other documents there may be several of them, so it is necessary to specifically indicate which of them the processing relates to.
As a result of adding this processing to the directory “Additional external processing for filling out tabular parts” in the “Payment for holidays and weekend parts” document itself, a “Fill” button will appear with a drop-down list in which it will be possible to start this processing. In our case, the “Filling Sundays” button is available in the drop-down list. Pressing it launches the algorithm contained in the processing. In this example, the tabular part will be filled in with employees whose working days fell on a day off. Please note that this button did not exist previously (screenshot above).
This mechanism allows you to solve a very wide range of issues without having to modify the configuration itself. Therefore, I quite often use this opportunity to implement clients’ tasks.
✅ Seminar “Lifehacks for 1C ZUP 3.1”
Analysis of 15 life hacks for accounting in 1C ZUP 3.1:
✅ CHECKLIST for checking payroll calculations in 1C ZUP 3.1
VIDEO - monthly self-check of accounting:
✅ Payroll calculation in 1C ZUP 3.1
Step-by-step instructions for beginners:
This option is very similar to the previous one. You most likely have seen and know that almost every document and even some elements of reference books have printed forms. They are, as a rule, located in the lower right corner of the form of a directory element or document. Sometimes standard printed forms are not enough. For example, an organization may have its own form of employment contract. Let me remind you that the standard printed form “Employment Contract” is included in the “Employees” directory form.
You can add your own to these printed forms of the directory. For this purpose, an external printed form is created with the extension “.epf”. Then a directory element is created for it "Additional external printing plates"(menu item “Tools” -> “Additional reports and processing”) and a file with the extension “.epf” is added to this directory element. It is also necessary to indicate for which document or reference book the processing is being added.
As a result, as part of the printed forms of the elements of the “Employees” directory, another form will appear - “Employment Agreement (Alpha LLC)”, which did not exist before. And its appearance and data filling is determined by the programmer in the “.epf” file.
This ability to add the necessary printed forms for documents and reference books is also very often in demand and is, in my opinion, a rather convenient functionality of programs on the 1C Enterprise platform.
In this case, you can develop external report. This is a file in “.erf” format. It is this file that will determine the appearance of the report, what configuration data it will use and which it will request from the user (for example, period, selection by employee or by department). The file is created in the 1C configurator in the 1C programming language.
An external report can be stored as part of the configuration using the “Additional external reports” reference book (menu item “Tools” -> “Additional reports and processing”). They are not related to a specific document or reference book; this information is not required.
With this storage option, the report is launched from the same directory (by double clicking).
You can also launch an external report using the menu item “File” -> “Open”. This option can be used if it is more convenient for you to store external reports not as part of the program, but simply in computer folders.
External treatments have approximately the same meaning as external reports. But unlike reports, which are used to view infobase data in a user-friendly format, processing is designed to change, edit or transform infobase data. The range of problems solved using external processing is quite wide.
For example, processing for uploading payroll statements. Despite the presence of standard processing in the ZUP (read about it), sometimes it may not be suitable for a particular bank and external processing is developed that converts and downloads information in the required format.
I'll bring you one more example a completely simple, but quite popular treatment. If in 1C ZUP you do not maintain the document “Transfer of personal income tax to the budget” during the year, then when generating 2-personal income tax for the year, the “Transferred” field for each employee will be zero, which is usually factually incorrect. Entering the document “Transfer of personal income tax to the budget” for the entire year can be quite tedious, given the specifics of the document itself. But you can do external processing, which in the generated 2-NDFL will simply fill in the “Listed” field for each employee, based on the values in the “Calculated” field. Accountants usually really like this option.
External processing has exactly the same two storage and launch options: either use the directory "Additional external processing"(menu item “Tools” -> “Additional reports and processing”), or the main menu item “File” -> “Open”.
That's all for today!
To be the first to know about new publications, subscribe to my blog updates:
To connect external processing, reports, and printed forms for the 1C:Enterprise 8.2 platform, a new standard has been developed for working in a managed application (a standard from the 8.2 standard library subsystem). “Chips” have appeared that were not there before, namely:
The type of processing has been expanded: filling an object, creating related objects. Now in documents you can add your own buttons for filling out the entire document, as well as your own buttons for entering on the base.
One processing can contain a list of several operations (commands), i.e. you can do one processing, where there will be several menu items at once: printing and delivery note, printing a sales receipt, printing a warranty card. (Author's note: earlier in the old standard, in order to do such things, you had to do everything at once (even if not necessary) and did not need to close, or draw your own form, which had the necessary buttons to select the required operation)
You can enter based on and fill objects based on several objects at once, rather than just one
You can set a schedule for executing server commands (on the server).
You can set the mode to “Safe” or “Unsafe”, i.e. run processing taking into account restricted rights or ignore them (as with full rights)
You can set the usage mode: Do not use, debugging, use. “Do not use” - not in operation, “Debugging” - visible only to administrators, “Use in operation”.
Can be used in object forms and in list forms
You can bind a processing or report to all objects at once.
You can configure quick access to certain external processing commands.
It is possible to specify in which sections of the interface additional processing and reports should appear.
So what can be connected to standard configurations?
From a platform point of view, you can connect:
From the point of view of the application area (configuration), you can connect external processing and reports with the form*:
*using the example of the editorial office “Management of a small company ed. 1.2"
Let's take a look at how it all works. To connect external processing and reporting, there is a standard that describes the interface for interaction with external processing and reporting, and there are general requirements for all types, and there are specific ones for each type of processing or report.
Let's start with the general requirements for all types of processing and reporting. In order to create a plug-in external processing or report, you must declare the export function InformationOnExternalProcessing() in the object module, which must fill in a structure that describes the behavior. An example of this function:
Function InformationOnExternalProcessing() Export
RegistrationData = New Structure;
Registration Data.Insert("Name", "Example of using external processing 8.2.");
RegistrationData.Insert("SafeMode", True);
RegistrationData.Insert("Version", "1.0");
//Additional Processing
//Additional Report
//Filling the Object
//Report
//PrintForm
//Creating Related Objects
RegistrationData.Insert("View", "AdditionalProcessing");
Registration Data.Insert("Information", "Processing done according to the new standard for connecting external processing 8.2. Example of processing ""Hello Word"" ");
///////////// commands /////////////////////////
tzCommand = New ValueTable;
tzCommand.Columns.Add("Identifier");
tzCommand.Columns.Add("View");
tzCommand.Columns.Add("Modifier");
tzCommand.Columns.Add("Show Alert");
tzCommand.Columns.Add("Usage");
stringCommands.Identifier = "1";
stringCommands.View = "command ""Hello Word"" (OpenForm)";
stringCommands.Use = "OpenForm";
CommandString = tzCommand.Add();
stringCommands.Identifier = "2";
stringCommands.View = "command""Hello Word""(CallClientMethod)";
stringCommands.ShowAlert = True;
stringCommand.Use = "CallClientMethod";
CommandString = tzCommand.Add();
stringCommands.Identifier = "3";
stringCommands.View = "command""Hello Word""(CallServerMethod)";
stringCommands.ShowAlert = True;
stringCommand.Use = "CallServerMethod";
RegistrationData.Insert("Commands", tzCommands);
////////////// purpose (in which objects it is used) /////////////////////////
//for printing forms, filling, entering related objects
//ArrayAssignments = New Array;
//Array of Assignments.Add("Document.*"); // all documents are assigned
//Array of Assignments.Add("Document.Advance Report");
//Array of Assignments.Add("Document.Buyer's Order");
//Registration Data.Insert("Destination", Array of Destination);
Return Registration Data;
EndFunction
So, as you can see, the function fills the Registration Data structure, which has the following elements (parameters):
Name – short name of the treatment
Version - information about the processing version
Safe mode – responsible for whether processing should be performed taking into account user rights. If set to False, processing or reporting will be performed without taking into account rights restrictions (as with full rights). This feature appeared precisely in 8.2, where when creating external processing and reports, the second parameter specifies the mode.
Type – type of processing or report. I listed the possible values at the beginning of the article, and the possible values to set in the code are indicated in the comments
Depending on the type of processing or report, as well as on the launch mode of the “Use” command, methods defined in the form module or object module are called. The list of passed parameters is also different. I attach examples of calls and use of all types of processing.
Go to the top menu Service->->.
The external processing directory list form appears. In the top menu press the button Add.
The Add New Object form will appear. Click the open button and select the file with the desired processing. After you have selected the desired file, if necessary, specify a processing name (Name field). After this, you need to click OK to save the changes made.
After this, the window for creating a directory item closes, and you are taken back to the list form, which already contains the new processing.
That's all! The process of adding processing to the configuration is complete. To open this processing later, go along the old path: Service->Additional reports and processing->Additional external treatments.
External processing for 1C:Enterprise 8 comes in several types. In this instruction, I will show you how to attach processing for group modification and processing for filling specific objects.
For the first case, we will add processing for filling out the nomenclature directory from Excel.
Let's go to the appropriate section of the program:
It is necessary that the flag for using additional reports and processing is set; follow the hyperlink to the list of external objects:
In the list click Create:
In the dialog box that opens, select the desired file for processing:
The card for a new external object in the program has been filled out, all that remains is to configure it accommodation(sections of the program from which processing will be available):
Select an arbitrary section (or several) for placement:
Write and close the external object card:
Now let's open processing from the interface:
The list is empty, click Customize the list:
Choose our processing:
It is now available for selection. To open processing, you need to click Execute:
Now let's see how processing for filling (modifying) specific objects is added. For example, let's take external processing, which attaches scans to selected elements of directories or system documents. The beginning of adding such processing is no different from the previous option. The difference is that in this case the placement is filled in automatically (and not by the program section, but by the types of database objects):
If desired, the placement list can be adjusted ( do not add additional placement, but remove unnecessary):
To accept the change, the external object card must also be written down.
In order to use processing, you need to go to a specific database object (from the placement list), click Fill in the command panel and select the command:
