Adding external processing to the database. Adding external processing to the database Reports and processing for 1s 8.2

Attention!
All processing from ITS disks is intended for informational purposes and exclusively for registered users of ITS.

Selection and processing of objects. (Universal)

Searches for objects in documents and directories that meet certain conditions. Processes the search results.

Information base rollup. (Universal)

Performs IB rollup of typical configurations:

SCP 3.1.
BP 1.6.
UT 10.3.

Registration of changes for exchange. (Universal)

Edits, in managed application mode, the registration of changes to exchange objects. Allows you to change the current registration on different nodes. Changes the numbers of received and sent messages.

User activity log conversion. (Universal)

Converts into a program, in the built-in language, a log of user actions.

Full text search in data. (Universal)

Indexing and searching in data.

Finding and replacing values. (Universal)

Searches for and replaces reference values in IS objects.

Setting up a technological log. (Universal)

Creates or edits a process log file. It has the ability to configure the creation of a crash dump, configure conditions and events, upon occurrence of which information will be written to this log.

Job console. (Universal)

Monitors background and scheduled jobs. Deletes, creates new ones.

Converting external processing. (Universal)

Changing confidential information. (Universal)

Selective change or cleaning of information security from certain information.

Group change of details. (Universal)

Changes details and tabular parts in documents and directories.

Unloading and loading users. (Universal)

Unloads and loads IB users into an XML file.

Uploading data to external databases. (Universal)

Unloads data structures to external DBMS using ADO in two modes:

Download all
Upload changes (used to synchronize changes in the working IB, with the receiver IB). This mode uses exchange plan mechanisms.

Supports the following DBMS:

Microsoft SQL
IBM DB2
Oracle
PostgreSQL
MySQL

Uploading and loading XML data. (Universal)

Unloads and loads data in IB, both completely and partially. It is used to transfer data between configurations that are similar in object composition.

Loading data from a spreadsheet document. (Universal)

Loads data into directories and tabular parts from spreadsheet documents.

Works in a thick client in a normal application mode.

Query Console. (Universal)

It is of great help in compiling reports and creating queries.

Consider creating an external report in 1s 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 the 62 accounting account 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, we will create an external report file, for this we will go to 1s 8 in the mode Configurator, go to the menu File -> New or click on the icon new document.

Select an item from the list External report. After creating an external report, give it a Name (for example SimplestReport) and save it to disk. We will also add two props: Beginning of period And EndPeriod type date, we will need them to limit the time interval for sampling data when generating a report.

2. Create an external report layout

To generate a report in 1s 8, you need a layout, this is a template for data output in which all the necessary parameters are set, tables are drawn, etc. Let's add a new layout, for this, in the report metadata tree, select the item Layouts and press the button Add, when creating, select the type for the layout spreadsheet document.

Our layout will have 4 areas:

Header - in this area we will display the name of the report, the period for which it was generated and the header of the table;
Counterparty data - in this area we will display data on the counterparty in the table;
Counterparty Agreement Data - in this area we will display data on the counterparty agreement in the table;
Footer - in this area we will display the total values for the entire report for the fields Income and Expense.

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 area A cap write the name of the report: Turnover 62 accounts, draw with the tool Borders report header, as well as set the parameters Beginning of period And EndPeriod. With the help of 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 program code of the report. 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 properties of the cell on the tab Layout select filling Parameter.

After that, in the cell, the parameter name will be enclosed in angle brackets (”<>“). As a result, the area A cap should look like this:

In area DataContractor 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 in the form of a table row.

In area DataAgreementContractor we will 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 draw up the area in the form of 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 Break cell), it is needed in order to show in the report that the contract line is lower in the hierarchy than the counterparty line.

In area Basement Let's create parameters for the totals for receipts and expenditures.

As a result, we should get a layout like this:

3. Create a report form

To display data, set the period of formation and buttons Form our report will need a form. To create a form, find the item in the metadata tree of the external report Forms and press the button Add. On the first page of the form builder, you don't need to make any changes, just click the button Further.

On the next page of the constructor, select both available props( Beginning of period, EndPeriod) for placement on the form.

As a result, we get this form:

But in this form it does not suit us, we will make some changes to it:

Drag button Form from the bottom panel of the report to the top one (this will be more convenient for the user);
Stretch the shape vertically and horizontally;
Arrange the fields Beginning of period And EndPeriod horizontally;
Add a Spreadsheet Document Field control to the form (our report will be displayed in it), give it a name TabDoc;
Let's create a period selection button (when it is pressed, a dialog will be displayed with a convenient selection of the desired period). We will not write the program code for it yet, so we will simply place the button next to the period fields.

As a result, our form will look like this:

4. Programming

After creating the report form, let's start programming. To begin with, 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 properties of the button go to the tab Events, where using the button with the 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 use the standard procedure Accounting 2.0 from the general module Working with Dialogs - HandlerPeriodSettingPressing, you need to pass the details of the report as parameters to it Beginning of period And EndPeriod.

Procedure Button1Press(Item) Working with Dialogs.HandlerSettingPeriodPress(StartPeriod,EndPeriod); EndProcedure

Now let's move on to writing the code that will generate and display our report. There is already a procedure in the form module ButtonFormPressing which will be executed when the button is clicked Form, then we will write our code there. Let's start by initializing the necessary variables. First, let's create a variable for spreadsheet fields to which we will output data, this is not necessary, just the recording of calls to it will become shorter, which means that the program code will be more understandable for reading.

TabDoc = FormElements.TabDoc;

Get the layout of the external report using the function GetLayout(<ИмяМакета>) , we will pass the name of the layout to the parameter, and if such a layout exists, then the function will find it.

Layout = GetLayout("Layout" );

After the layout is received, we will create variables for each of its areas, we will use the layout method for this GetRegion(<ИмяОбласти>) .

AreaHat = Layout.GetArea("Hat"); AreaDataAccount = Layout.GetArea( "DataContractor"); AreaDataAgreement = Layout.GetArea("DataAgreement" ); AreaFooter = Layout.GetArea("Basement" );

Clear the spreadsheet field. This is necessary so that with each new report generation, 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 hat. If you remember, we created two parameters in this area Beginning of period And EndPeriod, we will pass the values of the report generation period there, for this we will use the property Options layout area.

Header.Parameters.PeriodStart = PeriodStart; AreaHeader.Parameters.EndPeriod = EndPeriod;

No more scope action A cap the manufacturer is not needed, so we will display its field in a spreadsheet document.

TabDoc.Output(RegionHeader);

Next, let's write a query to the database, with the help of which we will take the turnover on the account 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, we will 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

Query.SetParameter("Account62" ,Charts of Accounts.Self-supporting.FindByCode("62" ));

It is also necessary to pass the period of report generation to the request. Do not forget that we have special report details for the generation period, and we pass them as parameters.

Query.SetParameter("StartPeriod",StartPeriod); Query.SetParameter("EndPeriod",EndPeriod);

Let's start writing the query text, we will do this using the query builder. Many tutorials say that you need to be able to write a query both manually and using the constructor, but in practice this is not the case. In tasks that are constantly faced by a 1C programmer, the priority is fast and high-quality writing of code, and when compiling a query to the database manually, this is almost impossible to achieve, you will spend a lot of precious time to correctly reproduce all query constructions, find typos which you did when writing, etc. So don't waste your time trying to write queries manually, but use the query constructor. It will save you time and allow you to write complex queries without much effort. To start writing the text of the request, let's write in the code:

Request.Text = "" ;

After that, put the cursor between the quotes, press the right mouse button and select the item 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 Turnovers accounting register self-supporting. Find it on the left side of the designer window

Let's move it to the area tables and let's fill in the parameters. For all virtual tables of the query, 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, the period that we passed to the request. In order to use a parameter in the request text, you must write a symbol before its name ampersand(&)

It remains to fill out the condition on the account. accounting. To do this, find the line in the parameters of the virtual table ConditionAccounts and write there

Score IN HIERARCHY (&Score62)

You can also use the condition builder by clicking on the button with three dots.

No more conditions need to be imposed on the virtual table, so press the button OK in the virtual table options window. Next, we need to select the fields we need from the table Self-supporting. Turnovers(namely: Counterparty, Counterparty Agreement, Income and Expenditure). To see the list of fields available in the table we have selected, press the “+” symbol next to its name. After that, drag the required fields to the rightmost area of the query builder, which is called: Fields. If we open the chart of accounts of accounting, we will see that for the account 62 analytics by To the counterparty - this is Subconto1, and by Contractor Contract — Subconto2.

Therefore, from the fields of the virtual table, 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 chosen, for this we will go to the tab Unions/Aliases and set the desired field names.

Since in our report the data will be displayed hierarchically (the Counterparty is on the first level, and all its contracts are on the second), we will set up the data output in the hierarchy using the Results. Let's go to the tab in the constructor Results. Drag and drop 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 appeared in the program code.

After we have finished writing the request, we will start filling in the areas DataContractor, DataAgreementContractor 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:

SelectionContractor = Query.Execute().Select(BypassingQueryResult.By Groupings);

Thus, we will receive records with totals for all counterparties.

Before bypassing the sample data using a loop, we initialize the variables intended for calculating the totals for the report:

TotalIncome = 0; TotalExpense = 0;

In order for the report data to be displayed with a hierarchy (and spreads by ”+”), set the start of autogrouping of spreadsheet document rows:

TabDoc.StartAutogroupRows();

All preparations are finished, now let's start bypassing the query results. The bypass will be carried out using the loop Bye

While SelectionContractor.Next() Cycle EndCycle ;

At the beginning of the loop, reset the parameters Coming And Consumption areas DataContractor. What is it for? Imagine a situation where the counterparty Uncle Vasya, income 10, and expense 5, and for the next counterparty Uncle Petya there is no income or expense, in this case, if we do not reset the parameters Coming And Consumption, then by in the line by counterparty Uncle Petya there will be an income of 5 and an expense of 10.

AreaDataAccount.Parameters.Incoming = 0; AreaDataAccount.Parameters.Expense = 0;

After that, fill in the area DataContractor sample item data

Fill inPropertyValues(AreaDataAccount.Parameters, SelectionAccount);

After filling with data, you can display the area in spreadsheet document, Since we use automatic grouping of lines, we need to specify the level of the line in the grouping (in our report there will be two levels, for counterparties the first for contracts the second).

TabDoc.Output(AreaDataAccount,1);

Now for this counterparty we will make a selection according to its contracts.

SelectAgentContract = SelectContractor.Select(BypassingQueryResult.By Groupings);

The bypass will be carried out using the loop Bye.

While SelectionAgreementContractor.Next() Cycle EndCycle ;

In the cycle for contracts of counterparties, we will reset the parameters Coming And Consumption, fill the area DataContract from the selection and display it in a spreadsheet document at the second level of records.

AreaDataAgreement.Parameters.Income = 0; AreaDataAgreement.Parameters.Expense = 0; Fill inPropertyValues(AreaDataContract.Parameters, SelectionContractorContract); 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.

TotalIncome = TotalIncome + SelectionAgreementContractor.Income; TotalExpense = TotalExpense + SelectionContractor's Agreement.Expense;

This concludes the data output in the area DataContractor, DataAgreementContractor completed, it remains to complete the auto-grouping of spreadsheet document rows.

TabDoc.EndAutoGroupRows();

Fully cycles responsible for outputting data to the area DataContractor And DataAgreementContractor look like this:

TabDoc.StartAutogroupRows(); While SelectionContractor.Next() Loop AreaDataContractor.Parameters.Incoming = 0 ; AreaDataAccount.Parameters.Expense = 0 ; Fill inPropertyValues(AreaDataAccount.Parameters, SelectionAccount); TabDoc.Output(AreaDataAccount,1 ); SelectAgentContract = SelectContractor.Select(BypassingQueryResult.By Groupings); While SelectionAgreementContractor.Next() Loop AreaDataAgreement.Parameters.Incoming = 0 ; AreaDataAgreement.Parameters.Expense = 0 ; Fill inPropertyValues(AreaDataContract.Parameters, SelectionContractorContract); TabDoc.Output(AreaDataAgreement,2 ); TotalIncome = TotalIncome + SelectionAgreementContractor.Income; TotalExpense = TotalExpense + SelectionContractor's Agreement.Expense; EndCycle ; EndCycle ; TabDoc.EndAutoGroupRows();

It remains to display the total data in the area Basement and display the area itself in spreadsheet document.

AreaBasement.Parameters.TotalIncome = TotalIncome; AreaBasement.Parameters.TotalExpense = TotalExpense; TabDoc.Output(RegionFooter);

This completes the process of writing an external report for 1C 8 without using ACS. Now it can be generated in 1C:Enterprise 8 mode and added to the directory ExternalProcessing You can download the report file discussed in the article by .

Watch the video on creating an external printable for a managed app:

To connect external processing, reports, print forms for the 1C:Enterprise 8.2 platform, a new standard has been developed for working in a managed application (a standard from the subsystem of standard libraries 8.2). There were "chips" 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 basis.

One processing can contain a list of several operations (commands) at once, 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 you didn’t need to) and you didn’t need to close it, or draw your own form, which had the necessary buttons to select the necessary operation)

You can enter on the basis and fill objects at once based on several objects, and not just one

You can schedule the execution of server commands (on the server).

You can set the mode to "Secure" or "Insecure", i.e. start processing taking into account the restriction of rights or ignore them (as under full rights)

You can set the usage mode: Do not use, debug, use. "Do not use" - not in work, "Debugging" - visible only to administrators, "Use in work".

Can include use in object forms and in list form

You can bind a processing or a report to all objects at once.

You can set up 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 the point of view of the platform, you can connect:

external processing (files with the extension “epf”) ;
external reports (files with the "erf" extension).

From the point of view of the application area (configuration), you can connect external processing and reports with the form *:

Additional processing

Just extra processing. It is possible to customize

Additional report

Just an additional report

Filling an Object

Own buttons for filling in objects (document), previously there were only buttons for filling in the tabular part.

Print form

Additional printable (the "Additional printables" button is added)

Report

A report attached to objects (to directories and documents).

Creating Linked Objects

Own input based on (in the menu item "Input based on" the button "Create related objects ..." is added)

*on the example of the editorial office “Management of a small firm 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 interacting with external processing and reporting, and there are general requirements for all types, and there are specific requirements 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 pluggable external processing or report, it is necessary to declare the export function InformationOnExternalProcessing() in the object module, which must fill in the structure describing the behavior. An example of this function:

Function DetailOnExternalProcessing() Export
RegistrationData = New Structure;
RegistrationData.Insert("Name", "Example of using external processing 8.2.");
RegistrationData.Insert("SafeMode", True);
RegistrationData.Insert("Version", "1.0");

//AdditionalProcessing
//AdditionalReport
//Filling the Object
//Report
//PrintForm
//Create AssociatedObjects
RegistrationData.Insert("View", "AdditionalProcessing");

RegistrationData.Insert("Information", "Processing is done according to the new standard for connecting external processing 8.2. An example of processing ""Hello Word"" ");

///////////// commands //////////////////////////
tsCommand = New ValueTable;
tzCommand.Columns.Add("Identifier");
tzCommand.Columns.Add("View");
tzCommand.Columns.Add("Modifier");
tzCommand.Columns.Add("ShowNotification");
tzCommands.Columns.Add("Use");

stringCommand.Identifier = "1";
stringCommands.View = "command ""Hello Word"" (OpenForm)";

commandstring.Usage = "OpeningForm";

CommandString = tzCommand.Add();
stringCommand.Identifier = "2";
stringCommand.View = "command ""Hello Word"" (ClientMethodCall)";
stringCommand.ShowAlert = true;
CommandString.Usage = "CallClientMethod";

CommandString = tzCommand.Add();
stringCommand.Identifier = "3";
stringCommand.View = "command ""Hello Word"" (ServerMethod Call)";
stringCommand.ShowAlert = true;
Commandstring.Usage = "CallServerMethod";

RegistrationData.Insert("Commands", tzCommands);

////////////// purpose (in which objects it is used) /////////////////////////
//for printing forms, filling in, entering related objects
//AssignmentArray = New Array;
//ArrayAssignments.Add("Document.*"); // all documents are assigned
//ArrayAssignment.Add("Document.Advance Report");
//Assignment array.Add("Document.Buyer's order");
//RegistrationData.Insert("Destination", Array of Assignments);

Return Registration Data;

EndFunctions

So, as you can see, the function fills in the RegistrationData structure, which has the following elements (parameters):

Name - short name of the processing

Version - information about the processing version

Safe mode - is responsible for whether processing should be performed taking into account user rights. If set to "False", then the processing or report will be performed without taking into account the restrictions of rights (as under full rights). This feature appeared in 8.2, where when creating external processing and reports, the mode is specified as the second parameter.

View – type of processing or report. I listed the possible values \u200b\u200bin the beginning of the article, and the possible values \u200b\u200bfor setting in the code are indicated in the comment

Commands - a table of values that lists the commands used. Columns of the table of values:

Identifier - any string (command identifier)
View - command description
Modifier - string (used for additional printing forms)
ShowNotification – the notification window will appear before the start and after the end of the execution (for client and server commands without a form)
Usage - processing start mode:

Opening the Form - the processing form will open
CallClientMethod - call the client export method form
Calling ServerMethod - calling an export method from a processing module

Depending on the type of processing or report, as well as on the launch mode of the "Use" command, the methods defined in the form module, object module are called. The list of passed parameters is also different. Examples of calls and use of all types of processing are attached.

Go to the top menu Service->->.

The external processing directory list form appears. Click on the button in the top menu Add.

The form for adding a new object will appear. We press the open button, and select the file with the desired processing. After you have selected the desired file, if necessary, specify the processing name (Name field). After that, you need to click OK to save your changes.

After that, the directory element creation window closes, and you get back to the list form, in which the new processing is already present.

That's all! The process of adding processing to the configuration is now complete. To subsequently open this processing, go to the old path: Service->Additional reports and processing->Additional external processing.

For BP 3.0, ZUP 3.0, UT 11, ERP 2.0.

There are several types of external processing for 1C: Enterprise 8. In this tutorial, I will show you how to attach bulk modification and fill specific object processing.

For the first case, let's add processing for filling out the stock list reference from Excel.

Go to the appropriate section of the program:

It is necessary that the sign of using additional reports and processing be set, follow the hyperlink to the list of external objects:

Click on the list Create:

In the dialog box that opens, select the desired file with processing:

The card of a new external object in the program has been filled out, it remains only to configure accommodation(sections of the program from which processing will be available):

As a location, select an arbitrary section (or several):

Write and close the external object card:

Now let's open the processing from the interface:

The list is empty, click Customize List:

We choose our processing:

Now it is available for selection. To open processing, you need to click Run:

Now let's see how processing is added to fill (modify) specific objects. For example, let's take external processing that attaches scans to selected elements of directories or system documents. The beginning of adding such processing does not differ from the previous version. The difference is that in this case, the placement is filled in automatically (and not by the program section, but by the types of base objects):

If desired, the placement list can be adjusted ( do not add additional placement, but remove the excess):

To accept the change, the external object card must also be recorded.

In order to use the processing, you need to go to a specific object of the base (from the list of placement), click Fill in the command bar and select the command:

Quite often, when during a consultation it becomes necessary to solve some complex issue, I suggest that my clients implement it in the 1C program using either external processing, or external printing plate. And I often come across the fact that a person is simply not familiar with such a possibility of programs on the 1C Enterprise 8 platform. Sometimes they even swear at me, believing that the development and implementation of such processing into their configuration will make it impossible to automatically update the program. That you have to pay big money for updating the program.

To clarify such issues, as well as to talk about what useful features provide external processing and external printing forms, I decided to write this article. In the article, I will not consider the technical side of the process of creating processing. This will most likely be covered in another post. Here I will try to explain the very essence of the mechanism and give specific examples of cases where external processing and printing forms can benefit the user.

The article will discuss the following options for additional external pluggable objects:

Additional external processing of tabular parts;
Additional external printing forms;
Additional external reports;
Additional external processing.

What are additional external processing, reports and printing forms

✅

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 typical configuration, whether it be 1C ZUP or 1C Enterprise Accounting or some other configuration, there is a need for some kind of 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, correct) the data available in the database. For example, changing certain details in documents for the required period, which is inconvenient to do manually with large amounts 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 work to update it in those fairly simple ways that I wrote about. Updating a non-standard configuration is a longer and more serious process, therefore, 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. For their storage, special directories are used: the main menu item "Service" -> "Additional reports and processing".

Additional external processing for filling in tabular parts

✅ Seminar "Life hacks for 1C ZUP 3.1"
Analysis of 15 accounting life hacks in 1s zup 3.1:

✅ CHECK LIST for checking payroll in 1C ZUP 3.1
VIDEO - monthly self-check of accounting:

✅ Payroll in 1C ZUP 3.1
Step by step instructions for beginners:

Now let's take a look at what features 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 the tabular parts of documents most fully illustrate how you can seriously modify the program without resorting to editing the typical configuration, but using only 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 HR Management" edition 2.5 there is a document "Payment for holidays and weekends"(this document is written in detail). In a typical form, this document provides the ability to automatically fill in 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, according to the schedule, fell on weekends, i.e. "Working on the weekend".

This file has been uploaded to the directory "External processing of tabular parts"(menu item "Tools" -> "Additional reports and processing" -> "Additional external processing of tabular parts"). When creating an element of this directory, it was indicated to which document the downloaded processing belongs - "Payment for holidays and weekends of the organization", as well as to which tabular part - "Employees". In our example, the document has one tabular part, but in other documents there may be several, and therefore it is required to specifically indicate which of them the processing belongs to.

As a result of adding this processing to the directory "Additional external processing for filling tabular parts" in the “Payment for holidays and weekends” document itself, the “Fill” button will appear with a drop-down list in which it will be possible to start this processing. In our case, the "Fill Sundays" button is available in the drop-down list. Pressing it starts the algorithm contained in the processing. In this example, the tabular section will be filled with employees whose working days fell on a day off. Please note that this button did not exist before (screenshot above).

This mechanism allows you to solve a very wide range of issues without refining the configuration itself. Therefore, I quite often use this opportunity to implement client tasks.

Additional external printing plates

✅ Seminar "Life hacks for 1C ZUP 3.1"
Analysis of 15 accounting life hacks in 1s zup 3.1:

✅ CHECK LIST for checking payroll in 1C ZUP 3.1
VIDEO - monthly self-check of accounting:

✅ Payroll 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 directories have printed forms. They, as the rules are located in the lower right corner of the form element of the directory 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 part of the form of the reference book "Employees".

You can add your own to these printed forms of the directory. To do this, an external printing form is created with the “.epf” extension. Then a directory element is created for it "Additional external printing forms"(menu item "Service" -> "Additional reports and processing") and a file with the extension ".epf" is added to this element of the directory. It is also necessary to specify for which document or directory processing is added.

As a result, one more form will appear in the composition of printed forms of the elements of the "Employees" directory - "Employment contract (LLC Alfa)", 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 printing forms for documents and directories is also very often in demand and, in my opinion, is a rather convenient functionality of programs on the 1C Enterprise platform.

Additional external reports

In this case, one can develop external report. This is a “.erf” format file. It is this file that will determine the appearance of the report, which 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" directory (menu item "Tools" -> "Additional reports and processing"). They are not related to a specific document or directory, this information is not required.

With this storage option, the report is launched from the same directory (double-click).

You can also run 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 folders on your computer.

Additional external processing

External processing have roughly 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 tasks solved with the help of external processing is quite wide.

For example, processing for unloading 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 an external processing is being developed that converts and uploads information in the desired format.

I will bring one more example quite unpretentious, but quite popular processing. If in 1C ZUP during the year the document “Personal income tax transfer to the budget” is not maintained, then when forming 2-personal income tax for the year, the “Listed” field for each employee will be zero, which is usually actually incorrect. Entering the document “Personal income tax transfer to the budget” for the entire year can be quite tedious, given the peculiarities 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. Usually accountants really like this option.

External processing has exactly the same two storage and launch options: either use the reference "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: