Transferring information from the server. Transferring information from the server Process status notification

In programs on the 1C:Enterprise platform, a message can be shown to the user in different ways.

1. Method ShowWarning.

ShowWarning(< ОписаниеОповещенияОЗавершении> , < ТекстПредупреждения> , < Таймаут> , < Заголовок> )

When using this design, a warning window appears in the center of the program interface.

Parameters:

DescriptionComplete Alerts(optional)
Type: DescriptionAlerts. Contains a description of the procedure that will be called after closing the alert window with the following parameters: Additional Parameters - the value that was specified when creating the Alert Description object. If the parameter is not specified, then upon completion no procedure will be called.

TextWarning(required)
Type: String; FormattedString. Warning text.

Timeout (optional)
Type: Number. The time interval in seconds during which the system will wait for a user response. When the interval expires, the warning window will be closed. If the parameter is not specified, then the waiting time is unlimited. If the parameter has negative value, an exception will be thrown. Default value: 0.

Title (optional)
Type: String. Contains the title of the warning window. Description: Displays a warning window, but does not wait for it to close.

Availability: Thin client, web client, thick client, mobile application (client).

Note: If any code must be executed after the user closes the warning window, it must be placed in a separate module procedure and described in a parameter.

2. Method Warning.

A warning window appears in the center of the program interface. However, if the configuration property Mode of UseModalities is set to Do Not Use , then the method does not work.

Availability: Thin client, web client, mobile client, thick client, mobile application (client).

3. Method ShowUserAlert.

ShowUserAlert(< Текст> , < ДействиеПриНажатии> , < Пояснение> , < Картинка> , < СтатусОповещенияПользователя> , < КлючУникальности> )

When using this method, a message appears in the lower right corner of the interface.

Availability: Thin client, web client, thick client.

4. Report method.

Report(< ТекстСообщения> , < Статус> )

Availability: Thin client, web client, mobile client, server, thick client, external connection, mobile application (client), mobile application (server).

5. Object Message to User.

Designed to store message parameters that need to be displayed to the user. If the message has not yet been shown to the user (this can happen when working on the server side, in a background job, external connection or Web services), you can get the accumulated messages using the method Receive Messages to User.

Properties: Destination ID(TargetID); DataKey; Field; DataPath(DataPath); Text.

Methods: Message; SetData(SetData).

The message appears at the bottom of the interface, in a line.

Message = New MessageToUser(); Message. Text = "Not enough nomenclature"; Message. Field = "Nomenclature. Quantity"; Message. SetData(DataObject) ; Message. Report() ;

Platform 8.2. Architecture - client-server. Task: the server needs to call a specific procedure on a specific client connected to the server.
Is it possible to implement this and how?
(This is something akin to the principle of operation of ICQ and similar software, when it is not the wait handler that periodically polls the server, but the server itself calls the event handler on the client).
It is impossible to call the client from the server, you can only call the server from the client; after executing the “server” code, control returns back to the client.

Or express the idea more clearly, what is needed and what purpose is being pursued.
It is impossible to call the client from the server, you can only call the server from the client; after executing the “server” code, control returns back to the client.
Sorry, this is the architecture, and it’s not clear why to call the client from the server. Understand the 8.2 architecture.
Or express the idea more clearly, what is needed and what purpose is being pursued.
Click to expand...

The task is to implement a mechanism for notifying users about the occurrence of certain events. For example, a manager creates a request for payment of an invoice or an invoice. The accountant (who is far from the manager) is tearing up the bank. And when the accountant makes a payment to pay the invoice manager to manager a message arrives (a window pops up) stating that the invoice has been paid (as for example in ICQ and other Internet messengers). This can be implemented in 2 ways:
1) through waiting processing, when the client “bumps” into the server after a certain time interval;
2) when the client simply listens to the server and when a message arrives from the server, a certain procedure is executed on the client.
If a couple of clients work with the system, then, in principle, the 1st solution option will not cause big problems. Problems begin to arise when the number of clients increases to several hundred, and sometimes even a few dozen can actually clog up the traffic and load the server. The mode of operation, when the client subscribes to the list of events on the server and then switches to “listening” mode, reduces useless traffic significantly and does not load the server with useless requests. For example, why periodically update the list form if no changes have occurred in it? Why periodically poll some information register or task when nothing has changed in it? Only the server knows whether it has changed or not. Therefore, it is logical that the client should not send a request to the server every 5 seconds and receive the same response, but the server, when subscribing to an event (for example, “when writing” for a task), would cause the processing of this event on the “interested” clients. Now events are processed only on those clients that directly initiated this event, but I would like the event to be processed on other clients (only by a different handler).
This principle of browser operation is ensured by WebSocket technology, which was already standardized last year (http://www.rfc-editor.org/info/rfc6455) and is supported by 4 browsers (except Internet Explorer). This technology is the future.
800 users. The flight is stable and normal. It all depends on how to choose the necessary data. Traffic, by the way, is minimal.
So that the server does not keep track of what selections users currently have in their list, for example.
Also, what if the user does not need to update the list ->
There can be many servers. As for the managed application, there is no permanent connection with the server. Your request may be processed by a process on another server in the cluster.

Therefore, it is logical that the client should not send a request to the server every 5 seconds and receive the same response, but the server, when subscribing to an event (for example, “when writing” for a task), would cause the processing of this event on the “interested” clients. Now events are processed only on those clients that directly initiated this event, but I would like the event to be processed on other clients (only by a different handler).
Click to expand...

1C is an ACCOUNTING, not a billing system. She doesn't need that. Therefore, the problem of 5 seconds can be solved in other ways (if it is needed at all).
Well, you didn’t even say something about notification by e-mail - but it’s simply organized using standard means.
Well, you can actually attach ICQ to 1Ske (Google libs, smoke mana, roll out code) - but IMHO the hassle is not worth the trouble.
But there is another way.

(b) just sits and listens to a dedicated port (it waits for data packets on the port)
2) In 1C, in processing when recording a document, we write a code that analyzes whether this is the first record, and whether something has changed significantly since the last record (otherwise the accountants can simply repost the document, and every time the manager receives a cheerful stent for this case message) and if it new document, or it is changed significantly (amount, payer, purpose) then:

Well, something like that.

When processing the payment document record, we write a code that, if necessary (so as not to disturb the manager when re-running the old document), places it in a third-party database
800 users. The flight is stable and normal. It all depends on how to choose the necessary data. Traffic, by the way, is minimal.
Try assigning all clients a call to a procedure that generates a request, for example, for a register of information in which notifications will be written or for user tasks. And so that this procedure is called by the wait handler at least every minute. How will the server and network connect?
So that the server does not keep track of what selections users currently have in their list, for example.
Also, what if the user does not need to update the list -> there is no need to drag the list data to the client (do not forget that the client only gets what he sees +2 lines below and above. Why does the server need all this?)
I am considering just the case when a bunch of users need to update the list. Then the customer subscription technologyto a recording event on the server (cluster) ensures the exclusion of useless requests and traffic.
There can be many servers. As for the managed application, there is no permanent connection with the server. Your request may be processed by a process on another server in the cluster.
Why does a cluster (which can have thousands of users) remember all the settings of all users? What would completely ruin the memory?
Cluster and so on for each connectionremembers everything open forms, otherwise it would be impossible to “recover” the session in the event of a connection failure. And the cluster does not need to remember all this. You can simply save event subscriptions in a special database service table.
1C is an ACCOUNTING, not a billing system. She doesn't need that. Therefore, the problem of 5 seconds can be solved in other ways (if it is needed at all).
Click to expand...

What, in accounting system keeping data up to date is number 105?! For example, in a large trading company whereDon’t you need a couple of hundred managers to see current balances and prices of goods? If this does not happen, then managers over the phone will promise goods that another manager has already sold, name outdated prices, etc. And by enabling periodic updating of the price list form, we get useless server load and a significant increase in useless traffic.
Are the managers so stupid that they can’t update the form themselves????????????
What are the advantages of this method? Only in transferring the load from the 1C server to the mail server? After all, the client will still have to periodically poll the server.
What is the difference between a letter and a telegram? Telegrams used to be carried by postmen and handed over personally. Lightning telegrams were generally distributed immediately after they arrived at the post office. And for a letter to the client you need to periodically look at mailbox. For example, 2 letters arrive during the day, and the client looks into the mailbox every 10 minutes. Of all the “looks”, only 2 are successful, and the rest are useless. But with the telegram everything is perfect. The client goes about his work, and when the postman brings a telegram, he stops and receives it without wasting time on useless running around.
I don’t need an ICQ specialist in 1C, I wrote about the principle of ICQ operation.
But there is another way.
1) We are writing our own simple client. Which provides either:
(a) regular reading of a database (third-party, for example) for the presence of records in the table with the “IsNew_Blead” attribute
Click to expand...

This method of operation is now implemented by the platform as a wait handler. But it is very suboptimal.
And this is exactly how the WebSockets protocol is implemented. This method is the most optimal, but is not implemented in 1C.
2) In 1C, in processing when recording a document, we write a code that analyzes whether this is the first record, and whether something has changed significantly since the last record (otherwise the accountants can simply repost the document, and every time the manager receives a cheerful stent for this case message) and if this is a new document, or it has been changed significantly (amount, payer, purpose) then:
For option A, we create a separate (or maybe not separate) entry in our table, with the same mark IsNew_Blead
For option B, we start VKshku (even if it’s a stupid EXE with parameters command line), which initializes the “pinner” to the same dedicated port.
Well, something like that.
But EMAIL is, IMHO, simpler and does not require writing additional crutches.
When processing the payment document record, we write a code that, if necessary (so as not to disturb the manager when re-running the old document), places it in a third-party database
Click to expand...

Well, the fact of the matter is that the platform for writing applications designed for very multi-user work does not work particularly optimally.
And about the VK-shku (that’s what the executable is for) from option (B), who can write it?
Of course they can! Moreover, they will guess that if in the form list settings you check the box “Update automatically every” and the period is 5 seconds, then you don’t have to press the “Update” button. Just how much will the load on the cluster (server) then increase and the stupid traffic on the network from 200 clients increase?!
It’s a completely different matter when the “UponRecord” handler is processed on the server and a notification is called from it to the necessary clients, and the clients are already generating requests and updating their forms. In this case, there will be surges in traffic and requests to the server not just at random, but only when it is really necessary.
Can you imagine if all 200 managers will take turns conducting, sending, and recording documents??????
Do these 200 managers really ruin your network with their “bugs”?

And so yes, alexburn Correctly noted, if you are afraid that 200 managers with background polling will stupidly load up your grid and cluster, then what will happen when they start working? When carrying out documents, requests are much more difficult.
Try assigning all clients a call to a procedure that generates a request, for example, for a register of information in which notifications will be written or for user tasks. And so that this procedure is called by the wait handler at least every minute. How will the server and network connect?
Click to expand...

I am considering just the case when a bunch of users need to update the list. Then the technology of client subscription to a recording event on the server (cluster) ensures the exclusion of useless requests and traffic.
Click to expand...

But it provides a bunch of hemorrhoids for synchronizing the server with the client. At the moment, the client is the initiator of the connection, and you propose to do the opposite
Let me explain one more thing: what should happen when the user has a document open in full screen and receives a notification from the server that this document needs to be updated?

The cluster already remembers all open forms for each connection, otherwise it would be impossible to “raise” the session in the event of a connection failure. And the cluster does not need to remember all this. You can simply save event subscriptions in a special database service table.
Click to expand...

Please clarify how a request to the database by the server (to receive subscriptions) differs from a request from the client? This is the same thing as what you were told from the very beginning.

Hence the conclusion - the remainder is NOT relevant after reading it.
Have you ever heard anything about optimizing application performance? For example, go to the website http://www.gilev.ru and see how a typical one works before and after optimization.
I’m just talking about how the method of “poking” clients into the server, in comparison with the method of the server notifying the necessary clients, is terribly not optimal. And if there is suboptimality in the application, then this will definitely come out as the load on the system increases.
This process cannot be eliminated, but the process of stupidly “poking” clients into the server to find out whether the list has been updated or not can be replaced by a much more progressive method of notifying the necessary clients by the server.
Do these 200 managers really ruin your network with their “bugs”?
If it’s strong, then it’s rubbish on you, not the mesh.
There's traffic there - ugh. Why invent lesapedes out of nowhere?
When you see “yes, the grid is barely crawling” and you are sure that it’s because of this auto poll every 5 seconds - that’s when you’ll start scratching your turnips.
And so yes, alexburn Correctly noted, if you are afraid that 200 managers with background polling will stupidly load up your grid and cluster, then what will happen when they start working? When carrying out documents, requests are much more difficult.
Click to expand...

Do you remember that platform 8.2 can still work in thin client mode and also work on slow connections?! Now think about it, if you exclude some of the stupid traffic on a slow connection, will the client run faster?
Do you remember that platform 8.2 can still work in thin client mode and also work on slow connections?! Now think about it, if you exclude some of the stupid traffic on a slow connection, will the client run faster?
Click to expand...

And what? Traffic can also be generated from stupid use of the program. YOU still haven’t given the usage pattern (I already said about the leftovers, by the way - look at large online stores, how they are structured. They don’t have any notification from the server)
Don't confuse Slava's methods for configuration with his platform offerings. It is Slava who makes the server-client exchange process minimal.
I’m just talking about how the method of “poking” clients into the server, in comparison with the method of the server notifying the necessary clients, is terribly not optimal. And if there is suboptimality in the application, then this will definitely come out as the load on the system increases.
This process cannot be eliminated, but the process of stupidly “poking” clients into the server to find out whether the list has been updated or not can be replaced by a much more progressive method of notifying the necessary clients by the server.
Click to expand...

Once again: give a pattern. On general question you got a general answer. When a specific task is visible, it makes sense to discuss it.
I have already described the disadvantages of pulling from the client’s server in a nutshell.
Look at the standard ones - that’s how it’s done. By the way, this is also the case in our corporate database.
Nothing, everyone is alive and well. The question here is how to construct this data. If you're being crazy, I'll set up a server for you on an empty base without straining too much.
Click to expand...

The typical ones are written this way because:
1) this is how the platform is written and you cannot jump over its capabilities without using VK.
2) in standard codes they sometimes write code for which 1C would never pass an exam.
No hemorrhoids are expected and not everything is completely the other way around. The client opens the connection, and then the concept of “client” and “server” is erased. The transfer is initiated by the one who needs to do it. Please read http://ru.wikipedia.org/wiki/WebSocket. Did the dummies really come up with this?
Let me explain one more thing: what should happen when the user has a document open in full screen and receives a notification from the server that this document needs to be updated?
You will run into the fact that you will need to process such an event, think about what the user has changed and how to connect it all into one. To put it simply, you'll be dumbfounded.
And one more thing: it is useless to consider the case in a vacuum. We need specifics.
Click to expand...

Do you know that if a processing procedure is not assigned to an event, then this event is not processed? It is up to the developer to decide whether or not to update the document form if someone has changed it. And you don’t need to think about what the user changed at all! Try opening the same document on different clients and changing the details on one of them. What's happening? That's right, the recording is automatically blocked! And until the blocking is lifted, another client will not be able to write anything to the database. And after recording, another client, even if he changed something, will also not be able to record it, because. The data version has changed.
Well, this is generally the “deepest” understanding of the 3-tier structure of 1C: Enterprise 8.2.
The difference is that the client does not work with the database, but works with the 1C application server, and the application server works with the database. For serious systems, the speed of exchange between the 1C client-server and the 1C-SQL server differs by several orders of magnitude. This is why an application server was invented to reduce the amount of data transferred from the server to the client. Therefore, the speed of request execution and processing of the result by the application server is several times or even orders of magnitude higher than if the client does the same.
Understand that the current balance is the one that is blocked from changing. As soon as you read it and did not block it, it is no longer relevant.
Therefore, no matter how often you update the list - until you block a specific quantity from changing (put it in reserve, sell it) - it’s all a piece of cake.
And you can promise only after the document has been completed - these are the basics of accounting.
Thus, you don’t even have an update task
Think about what will happen in your scenario for 1000 users.
Your balance form will be updated endlessly (the quantity will change constantly - because there are 1000 users!)
Hence the conclusion - the remainder is NOT relevant after reading it.
Click to expand...

It all depends on the specific system. If the frequency of recording increases, then you can notify clients less often. All this can be “settled” by the developer, if only the 1C platform allowed the implementation of this technique. The WebSocket protocol does not exclude the use of the http protocol, but complements it. It is up to the developer to decide whether to use the method of “poking” the client into the server or use the server to notify clients. In the meantime, the platform provides only a single option for the application.
Okay, let's go from the other side.
How many clients and how many servers????
There can be as many clients as you like, but the server is a repository, and in theory there should be one (there are exceptions, of course, but you have a long way to go)

Next. What call to the server handler on the client??? Who is the client for the server - yes, no one, and his name is nothing, no homeland, no flag, today he is - tomorrow he is not. Or, send a notification to Vasya Pupkin, it’s true that he’s slow, and everything gets to him the third time, I’ll send him three notifications, he’ll suddenly wake up, and Mashenka, she’s a smart girl, understands everything perfectly, so I’ll send her half a notification , let her think it out on her own, she’s already an adult.
So, what are you saying here - this is empty water, in 1C they are also not trainees, they know what they get money for.)
To the point. Have you ever been bothered by an ICQ pop-up message when watching a movie??? Although this can be disabled, then how will I know when exactly the contact I need will appear on the network? Well, these are lyrics, so to speak.
Click to expand...

Let me draw an analogy: a web server and client browsers. Who is there more? WEB servers + SQL (which is often very dense) are not the same storage? Physically, WEB servers and SQL servers can also be combined into a cluster. What, all this does not implement the WebSocket protocol, which implements real duplex communication between the client and the server (where not only the client, but also the server initiates the transfer). As for the stress of the pop-up window, if I don’t want to receive messages, I simply go offline or disable the pop-up window.
Next. What call to the server handler on the client??? Who is the client for the server - yes, no one, and his name is nothing, no homeland, no flag, today he is - tomorrow he is not. Or, send a notification to Vasya Pupkin, it’s true that he’s slow, and everything gets to him the third time, I’ll send him three notifications, he’ll suddenly wake up, and Mashenka, she’s a smart girl, understands everything perfectly, so I’ll send her half a notification , let her think it out on her own, she’s already an adult.
So what are you saying here - this is empty water, in 1C they are also not trainees, they know what they get money for.
Everything you say can be done on the client, and at minimal cost.
I see no point in discussing further. I propose to close the topic.
Click to expand...

Do you think there are trainees at Google who invented the WebSocket protocol?! If this ideology were utopian, irrational, etc., then WebSocket (described in RFC 6455) would not have received the status of a “proposed standard” from the IETF. The next status is “draft standard”, which has the vast majority of standards used on the Internet.
And as for the client, without a client it’s just a server and no one calls him anything; A completely useless accumulation of software and hardware. A client is to a server what a buyer is to a seller. The server provides the client with the necessary data, the server generates managed forms for the client, in general, the server exists for the sake of the client, and not vice versa! In version 8.2, the server even remembers the user's session. Read: http://v8.1c.ru/overview/Term_000000805.htm#1 section “Resistance to communication channel interruption”.
So who exists for whom?
Maybe they don't understand me quite correctly? I propose not to change the exchange method between clients and the server from request-response to duplex, I propose to add a mechanism for duplex notification of some clients by others, about other clients performing certain actions through the server. Developers can use this mechanism at their discretion. How, for example, did the developer want to bypass the directory elements through the object model instead of a request - please. And on small reference books, this method sometimes significantly increases the speed of work.
And so, programmatically, you can only get a list of all connections to the database and cause a user to disconnect from the database (if you have rights to do so). But it is impossible to send a notification to the user and have a call to a specific procedure trigger.

The article continues the series of articles “First steps in development on 1C”.

In it we will look at the methods of informing the user that are present in the 1C:Enterprise platform 8, and also focus your attention on some of the features of the operation of these mechanisms; these features are related to the mode of use of the modality.

Applicability

The article discusses the functionality:

Interface in the “Version 8.2” version for the configuration developed on the 1C:Enterprise platform 8.2.19.130
Taxi interface for configuration developed on the 1C:Enterprise platform 8.3.4.496 to 8.3.9+
Taxi interface for a configuration developed on the 1C:Enterprise platform 8.3.10-8.3.11

How to display a message to the user in 1C

Displaying messages in user mode solves a number of problems:

reflection of the progress of the current process (showing the stage of the process; showing the calculated values obtained during the operation of the algorithm);
displaying errors to the user for possible correction;
issuing recommendations;

Message types:

Terminators, which stop the execution of the program and do not allow it to continue until the user reads this message and performs certain actions. For example, the user will be presented with a question on the screen that will need to be answered Yes or No. Until the user responds, the program does not perform further actions;
introductory messages that are simply displayed to the user and allow further work (i.e., used in alert mode).

Termination messages should be error messages, and introductory messages: recommendations, messages about the current stage of the process and display of calculated values (debug print).

Introductory messages are intended to provide the user with some information.

It is necessary that the user familiarize himself with it and, possibly, take some actions that are described in this message.

It is very important that the user actually reads these messages, so they should only contain important information.

Test and debugging messages should not be issued to the user, because sooner or later he will begin to ignore absolutely all messages.

In the concept of a managed interface, the approach to issuing a message has changed somewhat. It is now tied to the form in which it originated. It can no longer be closed so that the text is completely invisible.

You cannot unpin a message box from a form.

Function syntax:

Report (<Текст сообщения>, <Статус>)

Those. the first parameter is the text itself.

The second parameter (message status) is optional. You can specify values for the status: Normal, Important, VeryImportant etc.

This value determines which icon will be located next to the message. However, this only works in the normal interface.

In the managed interface concept, the icon is always in the form exclamation point, it cannot be redefined.

The fact is that if a message is generated at the time of writing a directory element, the following situation may occur.

User clicks on a button Save and close, in this case the message is displayed in the corresponding window (on the right of the form).

But the form closes instantly, and the user will not see that any information was displayed for him.

Therefore, in the concept of a managed application, it is recommended to display introductory messages using so-called alerts. An example of incorrect use of a function Report presented in the figure.

However, the function Report can be used to display information about certain errors, for example, at the time of document posting.

In this case, the system can be informed that the form does not need to be closed and show the user what errors occur when posting the document.

Function Report fully supported in Platform 8.3. It can be used, and it will work (both in the file version and in the client-server version).

But it should also be noted that the function Report There is further development– this is a message class for the user, which allows, in addition to displaying a message, to bind it contextually to any form elements.

For example, an error message can be tied to a form element, which is very clear to the user. We will return to consider this issue a little later. Function Report there is an interesting feature.

Thus, the program code in Platform 8.3 can be executed both on the Client side and on the Server side.

In this case, the client program code is responsible for interaction with the user, i.e. On the client side, forms are opened and reports are displayed.

Various dialog documents are also displayed only on the client. They cannot be executed on the server because the server does not have the ability to interact with users.

But the function Report can be executed both on the Client side and on the Server side. In this case, the use of the method Report on the Server does not mean at all that the message will be displayed on the Server, there is simply nowhere to display them.

This means that if we display a message in the server procedure using this method, they will accumulate in some buffer and they will be displayed on the screen only when the server procedure ends and returns to the Client.

At this point, the system will request data from the buffer and display it on the screen.

The same feature applies to the class Message to User. The figure shows an example of using the method Report on the Server side.

As a result of using the method Report on the Server side, messages were displayed on the screen on the Client side.

An alert mechanism is needed to inform the user that “something” has happened in the system and that “something” requires the user’s attention. Alerts are generated by two scenarios:

By the platform itself when interactively recording or changing an object
By the developer when calling a method in the code .

The notification itself is a small window that appears, as a rule, in the lower right corner and informs about the completed action. Within a few seconds it gradually fades and disappears. At the same time, if you hover your mouse cursor over the notification, it does not go away and you can read it carefully.

In addition, alerts can be accessed in the corresponding area of the information panel (the “History” button at the bottom left of the application form in the “Version 8.2” interface option).

To create your own alerts you must use the global context method ShowUserAlert(). Its syntax before version 8.3.10 is presented below:

ShowUser Alert (<Текст>, <НавигационнаяССылка>, <Пояснение>, <Картинка>)

The first parameter contains the text that will be displayed in the notification.

Then, as the second parameter, you can pass a certain navigation link to any element of the information base (the element that corresponds to the text of our message). When a user clicks on an alert, the link will be followed.

Using the third parameter, you can pass an explanation for the message, i.e. some extended description.

You can also assign a picture that displays the notification status.

It should be noted that all these parameters are optional. Below is an example of using this method (in the configurator and in user mode in the “Version 8.2” interface option).

In the version of the platform 8.3.10.216 for the “Taxi” interface, the notification mechanism was significantly improved in order to improve the usability of both the thin and web clients. For this reason, the parameters passed to the method have also changed ShowUserAlert(). Now the syntax looks like this:

ShowUserAlert(<Текст>, <ДействиеПриНажатии>, <Пояснение>, <Картинка>, <СтатусОповещенияПользователя>, <КлючУникальности>)

It can be seen that the second parameter, previously called Navigational Link, got a new name ActionWhenClicked. This is due to the fact that it is now possible to send not only a string with a navigation link, but also a description of the alert. This is illustrated in the screenshot below:

As you can see from the example, we now have the ability to programmatically process a click on a notification window, according to the logic that is necessary.

Next parameter User Alert Status appeared for the first time. It indicates the status of the alert (Information or Important).

In the case of the Important option, if the user has not responded to the message, then after it is hidden from the screen, it can be read through the Notification Center (more about it below). In the case of the Information option, the notification is deleted without being stored in this center. Let's rewrite the code from our example as below:

After executing the command, we get approximately this view of the application window:

A button with a bell icon has appeared in the toolbar, which calls up the above-mentioned Notification Center. It accumulates new important alerts to which the user has not yet responded.

If there are any alerts in the Center, a small orange dot appears next to it to attract the user's attention. The user can open the Notification Center, read the text and, if necessary, take some actions.

From the Center, the alert is cleared by clicking on the clear button, but if there is some action associated with the alert, then as soon as the user clicks on the text of the message, it will also disappear.

And finally, the last parameter added was Key of Uniqueness. You can use it to find the alert displayed on the screen and change it. If there is no alert with this parameter, a new alert will be shown.

As you can see, the possibilities provided by the corresponding method have become even greater! But these are not all the changes in the notification mechanism.

As you may have already noticed, their appearance has changed. Alerts now look more modern and ergonomic, but they cannot be moved around the screen or resized. Please note that in our example, the notification text simply did not fit entirely in the window itself, and the user will be able to read it in full only by opening the Notification Center. Therefore, you should not write a large amount of text in the notification text.

New features also include simultaneous display of up to three alerts on the screen.

This concludes our acquaintance with the software generation of alerts. However, remember that alerts are generated not only by the developer programmatically, but also by the platform itself at the time of interactive recording or changing an object. And often this fact causes misunderstanding primarily among novice users: why are these service alerts needed, which, by the way, cannot be turned off?

Let's imagine this simple situation: The user has set a filter in some list for convenience. Let's say he did this in the form of a list in the Nomenclature directory. Then, after some time, I decided to introduce a new element called “Chair”, which does not correspond to the previously installed filter. Enters it, writes it down and...? And he doesn't see it on the list. What will the average user do? Of course, he will enter it a second time, but will not see it again. This may be followed by a third, fourth, fifth time. When he gets tired of entering the same thing over and over again, he will finally ask you: where does everything go?

This is precisely why the platform displays these service alerts, informing the user that their action has been completed. In our example, at the time of interactive recording, the user will see the following notification:

Termination messages

Termination messages are those messages that will not allow work until the user performs certain actions, i.e. until it processes the message.

We will talk about the possibility of using termination messages in Platform 8.3 a little later (in lately They try not to use them, so the example considered is more relevant to Platform 8.2).

There are two methods for issuing termination messages Warning And Question. Warning different from Question because it has a single button OK.

A question may specify different sets of answer options ( Not really, YesNoCancel, OK, OKCancel, RepeatCancel, AbortRepeatSkip), which are specified using the parameter.

Let's display some warning using the line (for example, in a managed application module):

Warning(“The base will now be open”);

To open a managed application module, select the object in the configuration tree Configuration, call context menu and select item Open a managed application module.

In this case, when the application is launched, a window will be displayed that is modal. A modal window overlaps all windows that exist in the application. Until we process this window, no further actions are possible.

The function works in a similar way Question.

Syntax:
Question(<ТекстВопроса>,<Кнопки>,<Таймаут>,<КнопкаПоУмолчанию>,<Заголовок>,
<КнопкаТаймаута>);

Only the first two parameters are required. For the second parameter, the data type is composite ( Dialogue ModeQuestion or ListValues). Third parameter ( <Таймаут> ) characterizes the time interval in seconds during which the system will wait for a user response.

When the interval expires, the question window will be closed. Similar parameter( <Таймаут> ) is also available for the function Warning.

As an example of using the function Question You can use the following code, written in a managed application module:

Please note that these methods ( Warning And Question) are not available on the Server. And this is logical, because interface methods cannot be executed on a Server where there is no user.

Features of using modal windows in Platform 8.3

In platform 8.3, there are operating modes with and without modality. The default setting is Do not use modality mode.

In this case, the use of termination messages is impossible. If it is necessary to use termination messages (functions Warning And Question) you should change the value of the configuration property on Use.

The modal window is displayed at the very top and blocks work with other windows until the actions with the modal window are completed. In addition, the execution of the program code stops at the point where this window is called. Code execution will continue only after the modal window is closed.

Firstly, problems with using modal windows arise for mobile application. Secondly, in the browser, window modality is implemented using separate pop-up windows.

Pop-up windows are often disabled by default browser settings. The user has to be forced to set the permission for these windows.

Browsers for tablet computers and phones in most cases do not support pop-up windows at all.

To replace functions Question And Warning new methods have been developed: ShowQuestion, ShowWarning.

These methods allow you to call a window, but do not stop the execution of the program code. Technically, this is achieved by forming a pseudo-window inside the parent window. The pseudo-window does not overlap the parent window. After opening such a window, the code continues to execute.

Receiving and processing user-entered values is carried out in a separate procedure, which is called when the dialog box is closed.

Function syntax ShowWarning:

ShowWarning(<ОписаниеОповещенияОЗавершении>, <ТекстПредупреждения>, <Таймаут>, <Заголовок>)

Parameter <ОписаниеОповещенияОЗавершении> (optional)

Data type: DescriptionAlerts.

Contains a description of the procedure that will be called after the warning window is closed.

Function syntax ShowQuestion:

ShowQuestion(<ОписаниеОповещенияОЗавершении>, <ТекстВопроса>, <Кнопки>, <Таймаут>, <КнопкаПоУмолчанию>, <Заголовок>, <КнопкаТаймаута>)

The first three parameters are required.

Below is an example of using the function.

Class MessageToUser

Basic convenience of the message class Message to User is that this is a contextual message (unlike methods Warning And Question).

Messages can be tied to a specific screen element. This object is also available on the Server.

Please note that, firstly, this object must be created. For example: Message = New MessageToUser;

Thus we create an instance of this object.

Secondly, you need to specify the message text in a separate property.

Thirdly, in the property Field You can specify which form element this message should be attached to.

Attention! To bind to the desired form field, pay attention to the initialization of properties PathToData And DataKey. For a document, when placing code in an object module, you can write:

Message.DataPath = “Object”;
Message.DataKey = ThisObject.Link;

To open the document module, in the object (document) editing window, go to the tab Other press the button Object module.

For the experiment, we will place the code in the object module of a document.

Below is the result obtained in user mode for Platform 8.3.

It should be noted that messages output using the new system object Message to User in the general case they are not terminating. Those. the system will allow the user to continue further actions without responding to the displayed messages.

But, firstly, these messages are quite noticeable. Secondly, messages are usually displayed to the user at the time of recording elements of directories or processing documents, i.e., when some checks are performed. And if errors were detected, the user will see these same messages.

Accordingly, when errors are detected, the transaction is canceled, i.e. writing a directory element is prohibited, or posting a document is prohibited.

Thus, a kind of emulation of the termination message occurs. Because the action is canceled until the user reacts to the entered message, it will be impossible to complete the action, for example, posting a document.

But, on the other hand, it is possible to close the document without conducting it, without reacting to the message in any way. Therefore, these messages to the user are not terminating.

Process status notification

There is a special function with which you can display the approximate progress of a process.

Syntax: State(<ТекстСообщения>, <Прогресс>, <Пояснение>, <Картинка>)
Parameters:<ТекстСообщения>And<Пояснение>– optional, type – Line.
The text is displayed on a special status bar.
<Прогресс>The parameter is also optional, but visual.
Type: Number. Progress indicator value (from 1 to 100).
<Картинка>also an optional parameter.
When processing any event, periodic calls of a function like:

In this case, the labels may change, and the values of the Progress parameter may change.

A function can be called from one procedure (function) or from several. This way you can track the execution status of the process.

If you want to take a closer look at the notification mechanism, stop right now and read our new article Displaying the progress of long-running operations in 8.3.10. It explains, no longer at the level of a beginner, all the subtleties and pitfalls of the operation of this mechanism.

We are finishing our introduction to ways to inform the user. We hope that you have an understanding of in what situations one or another method should be used.

I would like to once again draw your attention to the fact that if your configuration (version 8.3.3+) involves working using a web client, then:

at the configuration level the modality mode setting must be set to “Do not use”
The code must use methods of the asynchronous user interaction model. Such methods begin with the words Show or Begin.

You can read more about refusing to use modal windows in the 1C:Enterprise 8.3 platform in the final article of the series. And we move on and, finally, begin to study the long-awaited Taxi interface, which has already been mentioned more than once in our materials.

This article is an announcement of new functionality.
It is not recommended to use the contents of this article to learn new functionality.
Full description new functionality will be provided in the documentation for the corresponding version.
Full list changes in new version is provided in the v8Update.htm file.

Implemented in version 8.3.11.2867.

During a long server operation, the user always wants to see the progress of its execution on the client. In order to estimate how much time is left until it is completed, or how quickly it is completed. To implement this, it is necessary to somehow transfer information from the server to the client. But both before and now, interaction between the client and server parts of 1C:Enterprise occurs only at the initiative of the client. The 1C:Enterprise server itself, at its own discretion, cannot call any client application and transfer information to it.

First things first. For “normal” IT services this issue does not exist. People with experience find out in practice why it is bad to place other tasks on terminal servers and do not do so. But we all understand perfectly well that there are small companies, and there are always those who are just starting out and therefore do not have this experience. Therefore, it is possible that even someone else may find the explanation banal, but it needs to be voiced.
Let's consider combining the terminal with other server roles on “both” sides.

1. “For combination.”
Main REAL reason combining roles means saving money. And to be precise - APPEARING savings at the start of operation.
Of course, many supporters make other arguments. But as a rule, in the end they are still “converted” into cheapness. By the way, what will happen next after the start of operation at this moment the proponents of the combination do not calculate well - the position is simple - “we will break through somehow.”

Before we move on to the opposing side's arguments, let's delve a little deeper into the theory.

There is such a thing as equipment power reserve at peak moments. Unfortunately, it is not obvious to many administrators that when he looks at the task manager, he sees a snapshot (several minutes) of the current workload and does not see “peaks”. And he won't see it.
For different server roles, the maximum amplitude between the “peak” and the average value can vary greatly. On average for a hospital, the terminal server role is characterized by the greatest difference between peak load and average load. You can give a conditional explanation, but it is conditional: manually entering data (one document every five minutes) is very difficult to load anything at all on the 1C client side, since data manipulation, calculation, etc. runs on another server (1C server and DB). Those. Users doing something by hand, and this is most of the working day, do not load the terminal server much. But when some local task arises not for the whole day - copy a movie, download a distribution, download data to a client, or even download porn via torrent - all this eats up resources quite well, albeit not for a long time, but often several processor cores are loaded entirely. There is also an antivirus, which should not be on the 1C server (where users do not have local access), but the antivirus must be on the terminal server. Also on the terminal server in good form recent years there must be an anti-encryptor installed. Such “things”, although not all the time, sometimes start checking something - a new file, a port attack, etc. In general, call it what you want, but from time to time there are situations on terminals, especially when the hardware is overloaded. This is a terminal terminal pull - only experienced administrators do this, balancing connections and load. I’m not talking about dfss, resource quotas, virtualization, etc. cutting off the maximum speed of any flow.

1. “For demolition.” It turns out that we not only need to talk about regulating the load between roles. The load needs to be regulated between terminal users. And if the number exceeds what is reasonable for one server, it is necessary to build several terminal servers, scattering users between them.
Not exactly a theory, but also interesting fact. Our practice has shown (and we do about 100 audits a year) that peaks in the load of terminal servers when combined with a 1C server is a very popular option, and it turned out that terminal servers are not monitored at all or this is done conditionally, but most importantly they greatly affect the work of other roles server (1C server in this case). Moreover, this is not a theoretical reasoning - they transferred the load to a separate server and the client confirmed the positive result.
2. “For demolition.” Another factor is licensing. For the same number of users (it is clear that we are not talking about three people), taking into account big difference In terms of cost between standard and enterprise, it is more profitable to pool several inexpensive servers than one powerful piece of hardware. For example, if you are licensing MS SQL Server, then you need to license ALL cores of the server, and not those that you assign the affinity mask to use. It turns out that you will overpay for users who will eat up processors with terminal sessions.

3. “For demolition.” The real argument is safety. Moreover, this is a multifaceted thing. Terminal servers should be actively monitored with antivirus. This is the most likely attack point for Trojans, ransomware, brute force attacks, etc. But it’s better not to log into a server with the role of 1C server and DB locally at all. It is better to run board consoles from another server. Actively check 1C servers with antivirus, their connections - brrrr. You will most likely regret it. And even more so, it’s a “sin” to arrange a “file dump” on a 1C server or database. However, in Russia they don’t take the bait yet – they don’t deal with security, so we move on.

4. “For demolition.” Usually, at the time of purchasing a server, the task of “who will deal with the problems of competition for resources” is not taken seriously. But in practice, you can still understand those who put the role of the 1C server and database on “physics”, and put a virtual machine next to it and put a “terminal server” in it, so at least terminal users have less priority in the struggle for resources, and it’s easier to quota them . But why is it not obvious that in order to set quotas you need to understand, BASED ON WHAT METRICS, WHAT RULES TO APPLY. Who seriously monitors the load of terminal users? And those who can configure, for example, Zabbix, still cannot interpret the correctly collected values. In other words, laziness is a normal trait of an administrator, but you need to correctly assess your strengths. Isolating the load physically is much more realistic than thinking that during operation you will suddenly get a second wind and find secret ticks that will return the load to normal.
Take the analogy with ships. They have “bulkheads” so that in the event of a breakdown below the waterline, the water that gets inside does not spread throughout the entire volume of the ship and does not lead to flooding. It is naive to think that when this breakdown occurs, you will start creating these same partitions. There's no way in hell you'll have the time/money/knowledge/desire for this activity.

And if you are a small company, then next to the client-server option there is often a file version, for example, 1C: Accounting. And this database should be placed not on the DB server, but on the terminal server on local disks, and not over the network. Otherwise, you will worsen the performance of the file version.

If you want to do the right thing, it’s better to spend money on a separate terminal.
Well, if you want to dive deeper into this topic, come to our training http://www..
If you don’t agree with the material, write to slava@site with your arguments. We will include both positions in the review material above.

The mechanism for resource consumption counters has been improved - the ability to select based on usage has been implemented safe mode work and security profile (new types of filters added). For resource consumption counter selection expressions, the ability to compare for inequality has been implemented.For resource consumption counter selection expressions, the ability to combine “AND” several conditions for one filter type has been implemented.

Implemented batch mode for thin and thick client applications. Batch mode extends from the start of the client application to the end of the handlerBefore Starting the Systemapplication module. After the handler finishes its work, the batch mode is automatically disabled. In batch startup mode, the output of any system dialogs is suppressed.A sign of the batch mode of operation of a client application is the launch command line command/DisableStartupDialogs.

Interface 8.2 is no longer supported

The time for complete recalculation of totals for accounting and accumulation registers has been reduced in the following cases:

recalculation of totals during the operation Testing and fixing from the configurator;
using the method RecalculateTotals() subject to the following conditions:
- exclusive access to the information base;
- the presence of administrative rights for the user on whose behalf the results are recalculated;
- the method is executed in a session in which no delimiter is used.

The restructuring of the information base has been accelerated when using Microsoft SQL Server and IBM DB2 DBMS.

The likelihood of closing multiple connections to Microsoft SQL Server at the same time has been reduced, which has a positive effect on the performance of working with TempDB.

A cluster index on the registrar has been implemented for the calculation register. The index rebuild will be performed when the calculation register is restructured or when re-indexing during a test and update operation. If, when deleting records from the actual validity period table, the selection by register dimensions is not set, then a connection to the main register table is not formed for the deletion request. Reduced the likelihood of table locking when deleting records of the actual validity period of the calculation register.

In thin, thick and web clients, the form unlocks the object 1 minute after the modification flag is removed. (previously it was removed when the form was closed) When working under the PostgreSQL DBMS, in the technological log (event ) Query plans for UPDATE, DELETE and INSERT queries are placed. (Previously there was only SELECT)

Implemented display of critical errors of the optimized mechanism for updating the database configuration in the configurator and in the event technology magazine.

The technology log implements the Dbms, Database, DBCopy properties for DBMS access events (DB2, DBMSSQL, DBPOSTGRS, DBORACLE), EXCP and SDBL events.

Category: , | Tags: ,

Optimizing work with PostgreSQL
The operation of virtual tables of turnover of accumulation and accounting registers has been optimized when using groupings by day, month or year, as well as when using the query language function BeginPeriod(). Optimization is used for any version of supported DBMS, except for Microsoft SQL Server, where optimization is effective starting from version 2012.

facts of exceeding the counter are recorded in the technological log (event )

Implemented the ability to evaluate CPU usage during a session:

for the current server call;
in the last 5 minutes;
for the entire duration of the session.

For an event implemented the CpuTime property, which contains the duration of the completed server call, in microseconds.

Change of structure.
For information registers, the formation of a cluster index by dimensions has been implemented for the physical tables of the first slice and the last slice. Description of the index structure (see). Index uniqueness control is disabled.Queries for obtaining data from slice tables have been optimized.New indexes are built when the corresponding information register is restructured or when a database restructuring is performed during a test and repair operation.

New query designs. The ability to create a field with unique (within one table) and sequentially increasing values has been implemented. Query language feature implemented AUTONUMBERRECORD(), which can only be used when creating a temporary table. The use of the function is not supported AUTONUMBERRECORD():

in queries containing JOIN at the top level;
in queries that do not form a temporary table;
outside the selection list;
in expressions.

Object implemented ConstantKeyValues.Methods have been implemented for the constant manager CreateKeyValue().

If the query uses operator B with a subquery, then instead of the subquery, a connection to the table that is used in operator B will be used. This replacement is applied only if the replacement does not change the query result. In compatibility mode with version 8.3.12, the behavior has not changed.

Cloud Optimized.
Reduced the size of temporary files created by the platform when updating the full-text search index. This change is most noticeable in information bases with a large number of separators. The new temporary file format will be used after compatibility mode is disabled.In compatibility mode with version 8.3.12, the behavior has not changed.

Backgrounders.
Implemented the ability to wait for one or more background jobs to complete for a specified period of time. Implemented methodWaitCompleteExecution() for objects Fo newTask and BackgroundTask Manager. Method WaitComplete()is considered obsolete and is not recommended for use.It is recommended to analyze the application solution and change the algorithms for working with background jobs.
Optimized starting and waiting for background jobs to complete

Client start.
Implemented the ability to disable the display of the splash screen when starting the client application. Implemented the DisableSplash client application launch command line option. The option is available for thin client, thick client and web client.

The rendering of page titles (bookmarks) when working in the web client has been optimized and accelerated.

Updating used libraries

The LibEtPan library has been updated to version 1.8.
The WebSocket library has been updated to version 0.7.0.
Micosoft JDBC Driver for SQL Server has been updated to version 6.2.

Category: ,

The curl library has been updated to version 7.57.0.
OpenSSL library updated to version 1.1.0h

Improved updating of full-text search: The ability to control the number of background jobs that update the full-text search index when working in the client-server version of the infobase has been implemented. The placement of background full-text index update jobs can be controlled through functionality assignment requirements.
For the Full-Text Search Manager object, the SetNumber of Indexing Jobs() and GetNumber of Indexing Jobs() methods are implemented.

For the FTEXTUpd technology log event, the following properties are implemented: MinDataId, MemoryUsed, BackgroundJobCreated, JobCanceledByLoadLimit, TotalJobsCount, FailedJobsCount.

Cluster diagnostics have been improved: The session and connection properties now have values that indicate the time spent making calls to cluster services on behalf of the session or connection. These values are implemented for all administration tools: cluster console, COM connection, administration interface from the Java language, administration server.
The following properties are implemented for the IInfoBaseConnectionInfo and ISessionInfo objects:

durationCurrentService — current operating time of the cluster service;
CurrentServiceName — name of the executing service;
durationLast5MinService — operating time of cluster services over the last 5 minutes;
durationAllService — duration of operation of cluster services from the beginning of the session or connection.
Similar properties are implemented in the cluster console for the list of sessions, the list of connections and the connection properties dialog.

For the server cluster command line utility (rac), the parameters duration-current-service, current-service-name, duration-last-5min-service and duration-all-service of the connection list and session list commands are implemented.

Linux: To run a client application running Linux OS, the webkitgtk-3.0 library version 1.4.3 and older must be installed.

Support for Microsoft SQL Server 2017 DBMS has been implemented

The ability to use external providers to perform OpenID authentication has been implemented.

Category: , | Tags:

New functionality “Interaction system”

It has become possible to inform the client application about events on the 1C:Enterprise server side, including asynchronously.
The ability to deploy your own interaction system server has been implemented. The server is supplied as a separate distribution and requires separate installation.

.

The event is intended to investigate events related to errors in checking the validity of certificates using the Windows API. The event is generated only when running under Windows OS.

It is now possible to launch more than one web client session from one web browser.

The speed of searching by the beginning of a string in the query language has been increased when working with the PostgreSQL DBMS.

When working with the PostgreSQL DBMS, the conversion of a query language operation LIKE `TEXT%` into a more optimal SQL query operation has been implemented. In compatibility mode with version 8.3.10, the behavior has not changed.

Improved performance and scalability when using HTTPConnection and FTPConnection objects on the 1C:Enterprise server side when multiple connections from different sessions are used.

Work with temporary tables has been accelerated when using the Microsoft SQL Server DBMS

following versions:

2012, version 11.0.5548.0 and older.
2014, version 12.0.2430.0 and older.
2016.

The speed of the 1C:Enterprise server has been increased when documents containing a large number (tens of thousands) of lines are simultaneously processed.

Work with large temporary tables running the PostgreSQL DBMS has been optimized.

Operations for deleting records from temporary tables have been optimized when performing some operations in the PostgreSQL and IBM DB2 DBMS.

Clarifying display in Linux

When running under Linux OS, the workflow parameter Memory occupied is calculated based on the VmRSS (resident set size) value. The value of the Memory occupied parameter has become smaller in absolute terms and more accurately corresponds to reality. It is recommended to re-evaluate the parameters for restarting work processes in the properties of the working server.

Added platform option for data versioning (for auditing) https://wonderland.v8.1c.ru/blog/istoriya-dannykh/

Category: , | Tags: ,

The technological log reflects events related to:

obtaining and releasing licenses (both software and HASP keys);
obtaining licenses for basic versions;
regular monitoring of the compliance of real equipment and the list of equipment recorded in the license.

Implemented process log event .

Technology log event provides the ability to analyze only the technological aspects of working with HASP keys (calls to the interface for working with HASP), without providing the ability to track the receipt and release of licenses obtained from HASP keys.

Logging of events that occur during the first connection of the 1C:Enterprise server to the Microsoft SQL Server DBMS has been implemented in a technological log. Logging is done using an event .

This change is described in the documentation.

The approach to storing the execution history of background and routine tasks has been changed. In the client-server version, history is stored in the context of information databases. For each information base, a history is stored:

up to 1,000 background jobs, created from the built-in language;
up to 1,000 routine tasks;
up to 1,000 system background jobs (generated by the system itself).

For each job (background, system background and scheduled) an attempt will be made to store information about at least the three most recent runs. This number (three runs) will be reduced if the limit of 1,000 records for a particular type of task is exceeded.

Category: , | Tags: , Category: , | Tags: Category: , | Tags: , Category: ,

The ability to use logical expressions in the description of the selection field and in expressions for filtering query results (WHERE clause) has been implemented.

The ATTN process log event has been implemented. Monitoring analyzes some cluster parameters and allows you to forcefully terminate problematic processes. Monitoring is performed by the cluster central server agent. The monitoring results are recorded in the technological log.

In the technological log, in the SCALL and CALL events, new fields IName and MName are implemented, which contain additional information about internal system calls. The information can be used by 1C specialists when analyzing requests sent to the support service.

Implemented reflection of full-text search index update operations in the technological log. Technological log events FTEXTCheck and FTEXTUpd have been implemented. The ftextupd technology log element has been implemented.

On large quantities Users may find it worse than the old mode of operation. To return to the old recording mode - for this (with the 1C server stopped):

Find in the database folder (...\srvinfo\reg_ \) log folder (1Cv8Log),

in the 1Cv8Log folder create an empty file 1Cv8.lgf.

Repeat these steps for each base.

To reduce the load, it is useful to reduce the detail of logging of the technical documentation (for example, leave only errors)
Can be used to store a log book

The failure of the new format for large scales is recognized by 1C as the fact that since version 8.3.12 it is possible to interactively select the log format (i.e., experienced people choose the old format).

Heading: