The article is included in the cycle "First steps in development on 1C". It continues the topic covered in the previous article and covers in detail the innovations that have appeared in the configurator of the 1C:Enterprise 8 platform.
After reading the article, you will know:
- What is context help and how does it help when writing code?
- What are text templates for and how to apply them in practice?
- Why use code line grouping?
- How can highlighting improve the usability of the code editor?
- What is the convenience of the new search in the configuration tree?
- How to quickly display the objects of the desired subsystem?
- What refactoring and modality deprecation tools are there and how do you use them?
Applicability
The article discusses the capabilities of the configurator using the example of the 1C:Enterprise platform, editions 1C 8.3.5 - 8.3.11, so all the information is up-to-date.
Improvements in the 1C:Enterprise 8.3 platform configurator
With the release of the new version of the 1C:Enterprise 8.3 platform, the developers added several interesting and useful innovations to it to simplify the daily work of hundreds of developers across the country.
Now, when writing the program code of a module in the configurator editor, the context tooltip displays not only the names of variables and procedures allowed in the given context, but also the parameters of the procedure or function being edited at the moment.
The new functionality is available for both built-in procedures and developer's own procedures.
A tooltip with a list of options looks like this:
The procedure parameter to be entered now is in bold. Below the horizontal line is the description of the current parameter. If it is mandatory, it is emphasized with text in brackets.
If there are multiple syntax options for an inline procedure, arrows are available in the header to switch between these options.
Context hint for procedure and function parameters is called by pressing Ctrl + Shift + Space. It can also be called automatically when typing the characters “(“ and “, ”. This behavior can be enabled in the configurator settings dialog (menu item Tools - Options, tab Modules - Context hint):
Another useful feature of the new context tooltip is the ability to display the parameters of user-defined procedures and functions.
Click on the image to enlarge.
Recall that there is a document “System of standards and methods for developing configurations for the 1C: Enterprise 8 platform”, which describes the recommendations of the 1C company for the developed program code.
Thus, the “Parameters” section describes the parameters of a procedure (function). If none are present, the section is skipped.
It is preceded by the line “Parameters:”, then descriptions of all parameters are placed on a new line. The parameter description starts on a new line, followed by the parameter name, followed by a hyphen and a list of types, followed by a hyphen and a textual description of the parameter.
For example:
// Prepare a response form for an existing email.
// Options:
// IncomingMail - DirectoryLink.IncomingMails - the letter to be answered.
// OutgoingMail - DirectoryLink.OutgoingMail - form data for type DirectoryLink.OutgoingMail,
// located in the form of the outgoing letter editor.
// Text - FormattedDocument - the text editor field of the letter, located in the form
// outgoing mail editor.
Procedure Fill in the Response to the Letter (Incoming Letter, Outgoing Letter, Text) Export
And the configurator analyzes comments written according to such rules and uses them to display a contextual hint!
Click on the image to enlarge.
To avoid manually writing a comment according to the given format, the platform provides text templates, which can be viewed by pressing the key combination Ctrl + Shift + T.
The template with the name “Procedure (with title)” just forms the correct comment.
For this template to work, it is enough to type the characters “Proc” in the editor, press Ctrl + Q and select the desired template from the list offered by the system.
Grouping code lines
Modules of standard solutions on the platform "1C:Enterprise 8" are quite voluminous, contain enough a large number of lines of code.
To improve the readability and analysis of the program code, the functions of grouping conditional and cyclic statements, as well as procedures, were implemented.
The 8.3 platform provides another possibility - to group arbitrary module lines into one group in a logical way, and then collapse it so that it takes up less space on the screen to improve the readability of the text.
To select a text area, two new preprocessor instructions #Area and #EndArea have been introduced.
During the execution of the program code, these instructions are ignored. They are only needed to indicate lines of code that are being folded.
Click on the image to enlarge.
You need to make sure that the grouped areas do not intersect with each other, because in this case they will not collapse on the screen.
A text template has been added to the configurator to abbreviate #Area, which will automatically add instructions for creating a new area to the module text.
In the configurator settings dialog (menu item Tools - Options, tab Modules - Grouping) you can configure grouping and folding of text areas.
Design color highlighting
Now, in the 1C:Enterprise language text editor, the syntax constructs on which the cursor is currently positioned are highlighted in color. For example, the beginning and end of a procedure (function), a conditional statement, and a loop statement:
Click on the image to enlarge.
Another innovation of the platform is the highlighting of opening and closing brackets. This is very useful when writing long expressions when the syntax control reports an error and the developer needs to find the extra or missing parenthesis.
Click on the image to enlarge.
In the configurator's parameters dialog (menu item Tools - Options, tab Modules - Editing) you can set the highlighting of several more useful constructions.
If you select the “Current ID” parameter and assign a color to it that is different from the color of the editing background (white by default), then when you place the cursor on any identifier of the program code, it will be highlighted in the selected color, and in addition, all the same identifiers will be highlighted, occurring in the module, and string constants with the same identifier enclosed in quotes:
Click on the image to enlarge.
Also of interest is the “Selected ID” parameter. If a color is set for it that does not match the edit background color, then double-clicking on an identifier will highlight it and all matching identifiers in the module text.
Click on the image to enlarge.
When performing a search in the module text using the search bar or after pressing the Ctrl + F key combination, the found word is highlighted, and all the same found words are highlighted.
Click on the image to enlarge.
Merging Spreadsheet Document Cells
Previously, spreadsheet document cells could only be merged using a menu item or the corresponding command bar button.
Now the keyboard shortcut Ctrl + M has appeared, when pressed, the cells of the spreadsheet document are merged. The “Merge” operation is also available in the context menu of a spreadsheet document.
We hope that in the next releases of the 1C:Enterprise 8 platform, developers will pay attention to improving the convenience of working with the configurator.
New opportunities for developers in 1C:Enterprise 8.3.5
Search in the configurator
You have to constantly use search when configuring. As long as the configuration contains a relatively small number of metadata objects, it is possible to search visually - with the eyes, scrolling through the configuration tree.
However, typical configurations are quite voluminous, and with this approach, the search will take a long time.
Prior to platform 8.3.5, you could search through the metadata tree like this:
- type the name of the object from the keyboard, while the system will search by matching the name with the first letter of the name, but only in expanded lines of the configuration tree;
- using the keyboard shortcut Ctrl + F to open the search window:
The found objects will be displayed in the Search Results window, from which you can double-click to go to the required metadata object in the configuration tree.
Platform 8.3.5 has a new search field above the configuration tree:
The search is performed by the occurrence of a string, analyzed by the properties of the configuration objects Name, Synonym and Comment.
Moreover, the configuration tree is filtered “on the fly”: only objects that satisfy the entered filter remain in it.
Let's consider what the colors mean for the objects that remain in the tree after applying the filter.
If the search string was found, then the name of such an object is highlighted in black in the configuration tree.
If, in addition, the search string is present in the object name (not in a synonym, not in a comment), then such occurrences are highlighted in red.
Objects are highlighted in gray that do not themselves match the entered filter, but have subordinate (child) objects in their composition that satisfy the specified filter.
In the above picture props UserIdIB directory Users is displayed in the tree because its synonym contains the substring “post”:
It is permissible to enter several substrings for searching, separated by spaces:
A similar search string appeared in the window containing the set of properties of the selected object (properties palette):
The found properties will be displayed as a general list, without categorization.
The search will be done either by property names or property views (the difference is shown in the two screenshots above).
You can switch between name/view modes using the “Show property names” command of the context menu:
The same search string has been added to the data type selection window:
And in the window for selecting a metadata object (for example, selecting an information register that will be used as a graph for the calculation register):
To quickly display objects included in one specific subsystem, a new item “Subsystem objects” has appeared in the context menu:
Recall how this could be achieved in previous versions of the platform.
It was necessary to open the window for selecting by subsystems, check the box for the required subsystem, uncheck all other subsystems:
Now you can get the same result faster. In addition, the selection is most often used and most in demand for just one subsystem.
And, therefore, this small convenient innovation will save the developer time.
Quick display of objects captured in storage
If the configuration is connected to the repository, then the Captured objects button is available in the command panel above the configuration tree itself:
Now filtering is performed directly in the configuration tree, there is no need to open a separate window for working with the repository, it is necessary to set filters for captured objects in it.
Refactoring Tools
When a group of several developers is working on a configuration, it is necessary to monitor the understandability of the code, following common standards.
It is not always possible to control this constantly, therefore, work is periodically carried out to improve the readability of the code, to revise already implemented fragments.
Such actions are called code refactoring. This is the process of changing the internal structure of a program, without affecting its external behavior, and with the aim of making it easier to understand how it works.
In addition, developers have to do work in their configurations to abandon the modality - the elimination of modal calls.
Therefore, in the 8.3.5 platform configurator, code refactoring mechanisms and tools for working with modal calls appeared.
They are available in the context menu of the configurator text editor in a separate Refactoring menu.
Click on the image to enlarge.
Let's take a closer look at the implemented refactoring tools.
1. Select a fragment
This command converts the selected section of code into a separate procedure or function.
If the procedure inside which the selection is located contains a compilation directive (&OnClient, &OnServer, etc.), then the procedure or function being created will have the same compilation directive.
If the highlighted section of code can be located on the right side of the assignment statement, then a function will be created. Consider an example. Let's have a code snippet:
&AtClient
Procedure GoodsItemOnChange(Element )
Str = ;
Page Price = GetItemPrice(Object.Date , Str.Product );
EndProcedure
If you apply the “Select Fragment” command to the selected section of code, the system will generate the following program code (create a new function):
&AtClient
Procedure GoodsItemOnChange(Element )
Str = Items.Products.CurrentData;
Page Price = GetItemPrice(Object.Date , Str.Product );
Str.Sum = CalculateSum(Page);
EndProcedure
&AtClient
Function CalculateSum(Value Str )
Return Page Quantity * Page Price ;
EndFunctions
Also, the function will be created if one variable is assigned in the selected code section, which is used below in the code. For example:
&AtClient
Procedure GoodsPriceWhenChanged(Element )
Str = Items.Products.CurrentData;
Str.Amount = Str.Quantity * Str.Price ;
EndProcedure
The selected area will be transformed as follows:
&AtClient
Procedure GoodsPriceWhenChanged(Element )
Str = CurrentLineProducts();
Str.Amount = Str.Quantity * Str.Price ;
EndProcedure
&AtClient
Function CurrentLineProducts()
Variable Str ;
Str = Items.Products.CurrentData
Return Page ;
EndFunctions
2. Rename
This command allows you to change the name of a variable or procedure (function) in all places where they are actually used.
If all occurrences of a variable or method are uniquely defined, the system will prompt for a new name and will replace wherever that identifier occurs.
If all uses of a variable or method cannot be uniquely identified, then the system displays the question and displays the occurrences:
Consider a situation where the system cannot automatically replace the procedure name.
Let there be a procedure in the document module:
Procedure Recalculate () Export
For each TekStringProducts From Goods Cycle
TekRowProducts.Amount=
TekStringProducts.Quantity*
TekStringProducts.Price;
EndCycle ;
EndProcedure
And in the form module of this document - the following handler:
&On server
Procedure RecalculateOnServer()
Document = PropsFormVValue("An object" );
Document.Recalculate();
ValueVPropsForm(Document , “Object” );
//further processing...
EndProcedure
An icon with a red exclamation mark in the search results window means that you can unambiguously and accurately identify the usage in the procedure code line Recalculate() the system failed.
This is because the system cannot automatically determine the type of the variable. Document after executing the function FormAttributeToValue().
The context tooltip mechanism in this case also does not offer possible options when pressing the dot after the variable Document or by pressing the Ctrl+Space key combination.
Click on the image to enlarge.
Renaming a procedure in a form module using a refactoring command also changes the handler reference in form element properties and commands.
3. Create a description of the function
The command creates a comment before the procedure or function, which will be correctly perceived by the context help mechanism.
// Procedure - Fill out a letter according to the template
// Options:
// Outgoing mail - -
// Text - -
Procedure Fill LetterBy Template(Outgoing mail, Text ) Export
//…
EndProcedure
The system creates a comment template in which you need to insert parameter types and explanations.
Then it will be possible to use the extended hint when writing the code.
4. Create an alert processing
This command becomes available in the context menu when the cursor is positioned on a method name followed by an opening parenthesis.
Moreover, these methods are ShowQuestion(),ShowWarning(), ShowInputNumbers() and other blocking analogues of modal methods.
Consider an example. Let's start writing a client command handler, set the cursor to the encountered method ShowQuestion(), call the command “Create notification handler”:
&AtClient
Procedure Fill inMaterials(Team )
ShowQuestion (
EndProcedure
As a result, the system will generate the following program code:
&AtClient
Procedure Fill inMaterials(Team )
ShowQuestion (New DescriptionAlerts(“FillMaterialsFinish”, ThisObject ));
EndProcedure
&AtClient
Procedure Fill inMaterialsFinish(ResultQuestion,
Extra options) Export
EndProcedure
5. Convert modal call
This command converts the code snippet containing the modal method to its asynchronous counterpart. Let's look at a few examples.
Let's transform the call to the Warning() method:
&AtClient
Procedure NewHandler()
A = 1;
Warning("Text" );
A = 2;
EndProcedure // NewHandler()
After applying the specified command, the program code will take the following form:
&AtClient
Procedure NewHandler()
A = 1;
ShowWarning(New DescriptionAlerts(“NewHandlerCompletion”, ThisObject ),
"Text" );
EndProcedure
&AtClient
Procedure NewHandlerCompletion(Extra options) Export
A = 2;
EndProcedure
Let's complicate the example. Consider using a modal function and a conditional operator:
&AtClient
Procedure NewHandler()
answer = question(,
Dialogue ModeQuestion.YesNo);
If Answer = DialogReturnCode.Yes Then
//filling algorithm
EndIf ;
EndProcedure
After transforming the modal call, we get:
&AtClient
Procedure NewHandler()
Answer = Undefined ;
ShowQuestion (New DescriptionAlerts(“NewHandlerCompletion”, ThisObject ),
“The tabular section will be cleared. Continue?",
Dialogue ModeQuestion.YesNo);
EndProcedure
&AtClient
Procedure NewHandlerCompletion(ResultQuestion,
Extra options) Export
Answer = ResultQuestion;
If Answer = DialogReturnCode.Yes Then
//filling algorithm
EndIf ;
EndProcedure
It should be emphasized in the resulting fragment the initialization of the Response variable.
6. Convert to an asynchronous procedure
In the examples discussed above, methods that have their asynchronous counterparts were subjected to transformation. For example, Question() And ShowQuestion(), Warning() And ShowWarning().
However, if a modal call is located inside a procedure, which in turn is located inside another procedure, then the entire procedure call with a modal method inside will be modal.
This means that it must be replaced with an “asynchronous analogue”, only not the one that exists in the built-in language, but with our own, developed method.
For this, another command of the “Refactoring” submenu is intended - “Convert to an asynchronous procedure”. Let's explain using the example of a procedure that calls another procedure with a modal function inside:
&AtClient
Procedure NewHandler()
A = 1;
NestedProcedure();
A = 2;
EndProcedure &AtClient
Procedure NestedProcedure()
Warning("Text" );
EndProcedure
Set cursor to procedure declaration NestedProcedure(), we convert to an asynchronous procedure. The system builds us the following code:&AtClient
Procedure NewHandlerCompletion(Result , Extra options) Export
Alert = ;
A = 2;
ExecuteProcessingAlerts(Alert );
EndProcedure &AtClient
Procedure NestedProcedure(Alert value )
Warning("Text" );
ExecuteProcessingAlerts(Alert );
EndProcedure
Pay attention to the method added by the system ExecuteNotificationProcessing(), which is used in the implementation of procedures that can open blocking windows internally, but must return their result to the calling procedures.
Keep in mind that the immediate task of converting to an asynchronous procedure is to convert the sequence of calls to the selected procedure to asynchronous form, but the calls located in the procedure itself are not changed.
That is why the method Warning() has not been replaced. This must be done after converting to an asynchronous procedure by calling the “Convert modal call” command separately.
If in the original code snippet on the line containing Warning(), execute the command “Transform modal call”, then the system will ask:
The result will be the following:
&AtClient
Procedure NewHandler(Alert value )
A = 1;
NestedProcedure(New DescriptionAlerts(“NewHandlerCompletion”,
ThisObject, New Structure("Notification", Notification)));
EndProcedure &AtClient
Procedure NewHandlerCompletion(Result , Extra options) Export
Alert = Additional Options.Alert;
A = 2;
ExecuteProcessingAlerts(Alert );
EndProcedure &AtClient
Procedure NestedProcedure(Alert value )
ShowWarning(New DescriptionAlerts(“NestedProcedureCompletion”,
ThisObject , New Structure (“Alert” , Alert )), “Text” );
EndProcedure
&AtClient
Procedure NestedProcedure Completion ( Extra options) Export
Alert = Additional Options.Alert;
ExecuteProcessingAlerts(Alert );
EndProcedure
7. Allocate to an asynchronous procedure
This command converts the selected piece of code into a procedure or function, while converting the selected method to an asynchronous form.
Unlike the previous paragraph, this command is a “composite” one: first, the selected code section is transferred to a new procedure, the name of which the user enters in the dialog box.
It then performs the same actions as if the user had right-clicked on the title of the newly created procedure and then clicked Convert to Asynchronous Procedure.
8. Find modal module calls
The commands described above work with a single method or a selected section of code.
Procedures were implemented that process the module as a whole, for example, searching for modal calls within the entire module.
The found lines of code will be displayed in the search results window:
Click on the image to enlarge.
9. Convert Modal Module Calls
This command performs transformations in the open module, but only those calls that do not require the participation of the developer.
Also in the main menu is the command (Configuration - Refactoring - Analyze configuration modal calls).
It also searches for modal calls, only within the whole configuration, checks if modal calls can be converted automatically.
Click on the image to enlarge.
Conclusion
In conclusion, in chronological order, we briefly note what other additional useful features the configurator has acquired:
- Added lists of bookmarks in module texts that can be saved between work sessions (8.3.6+)
- In the case of dynamic update, there is no need to restart the configurator when working in the client-server version of the infobase (8.3.7+)
- Implemented the ability to develop configurations for OS X 10.8 and higher (8.3.7+). Now both the configurator and the client application (thick and thin clients) are available in this operating system
- Significantly expanded operations that can be performed in batch mode (8.3.8+). This greatly simplifies the automated configuration update process.
- The administrative console utility has been implemented, with the help of which it became possible to fix some of the problems that arise with the infobase without launching the configurator (8.3.8+)
- Added functionality to check for problems connecting the extension to the configuration. Previously, there was no such functionality, and diagnostics were displayed in the message window when the extension was connected (8.3.9+)
- Implemented support for 64-bit configurator. This feature has eliminated memory shortage problems for compare and merge operations during configuration updates and other resource-intensive operations (8.3.9+)
- Significantly accelerated the first opening of a managed form in the configurator (8.3.9+)
- Now you can partially upload the edited configuration to XML files. Now you can unload only those objects that have changed since the last unload. This significantly speeded up the process of exporting to XML files, in the case when changes are made to large configurations (8.3.10+)
- Improved the ability to combine modules by taking into account the location of methods in areas specified by preprocessor instructions (8.3.10+)
- Increased speed of frequently used operations during development (8.3.11).
In addition, platform developers from release to release improve the performance and ergonomics of the configurator, so we recommend that you, if possible, develop on the platform of current releases.
So, let's move on - in the next article we will return to programming and analyze the concept of the context of the program code.
Today, the reader is offered a review of a publication that is not new, but deserving of attention, if only because it remains a model of real interactive educational programs to this day. Programs in which printed text is witty and professionally combined with the possibilities of audio, 3-D animation, animation, graphics. The publisher was a well-known Russian company "1C" .
The publication belongs to the series "1C: Cognitive Collection". The set includes two discs.
- Alice's World based on Lewis Carroll's Alice`s Adventures in Wonderland.
- Through the Looking Glass by Lewis Carroll.
The reviewers were: Elena Belyaeva, art critic, editor of T / O "M-studio" Kirov, and Vera Buldakova, philologist, teacher of the highest category. The expert was invited Lyubov Georgievna Zubareva, teacher of English of the highest category (Kirov Regional College of Culture)
"Magic Computer Book"
On the cover of the disc we are informed (among other things, among other remarks about the product): "This is a magical computer book." And this is true! The journey that you embark on not with Alice, but completely on your own, becomes more interesting with each new step. The space unfolds, each new one you meet is really new and does not at all resemble others living in this country. Discoveries are at every turn, you look forward to them with hidden delight. Just think, all this was invented in the century before last, and the requirement of novelty for the art of postmodernism is absolutely satisfied! The book, the condition for reading which was the ability of the mind to play intellectually, inspires people to creativity for the second century. But creativity is magic.
The introduction to the first part of "Alice's World" was made by the most popular translator of "Alice in Wonderland" into Russian - Boris Zakhoder, who admits that the text "Alice`s Adventures in Wonderland" belongs to the category of fundamentally untranslatable. This prompted him at one time to make his own version of the retelling of the book. On the disc, Boris Zakhoder talks to you, and you can choose whether to read his preface or see and hear the writer. Andrei Tarkovsky liked to repeat that cinema is a canned time. You click the mouse button - and the magic jar of time is opened!
The idea of multi-variant translation becomes the main one for the developers of this educational program. The whole range of authors-translators is presented here: V. Nabokov, V. Orel, B. Balter, B. Zakhoder - in the first part; V. Orel, L. Yakhnin, V. Azov - in the second. The picture is complemented by a system of quotations from classical translations by N. Demurova, O. Sedakova, D. Orlovskaya, A. Shcherbakov, S. Marshak. Translation options awaken the reader-traveler's imagination, involuntarily ideas of their own interpretation not of the text, but of situations, heroes and events appear.
The principle of operation is simple. Before us are two windows with synchronously moving English and Russian text (in "Through the Looking Glass" any translation is easily replaced by another). Under each English word opens its Russian equivalent.
You can turn on the soundtrack: the text is read on an impeccable English language. If desired, each paragraph can be repeated to the extent of assimilation or indefinitely.
When setting up, you can leave the text in one page in English or in Russian.
The system of transitions from layer to layer is multivariant and functional at the same time. So, you can replace the text of the translation under the picture, or you can choose another author of illustrations for this translation. By the way, among illustrators and classics from J. Tenniel to Carroll himself...
The book can be read in English or Russian (or listened to in English) chapter by chapter, or you can get carried away with notes (it is known that in terms of the number of tricky words said about him, Carroll is only inferior to Shakespeare).
Here the integrity of the text is not violated, and numerous comments and interpretations are hidden behind a witty system of references, language remarks, reasoning and reflections, facts and explanations, and even a commentary by a chess player.
You can study the "Biography of Oxford University professor, mathematics teacher Charles Lutwidge Dodgson", or the mirrored "Biography of the writer Lewis Carroll - the creator of Alice".
And you can immediately go to a page with a concise but selective bibliography of Carroll's publications and books about him.
In addition, the disc "Through the Looking Glass" makes it possible to copy any part of the text to the clipboard.
Game for all ages
You can wander through the back streets of this game for a long time, but it is impossible to get lost in it.
The study of navigation is part of the journey through Wonderland and Through the Looking Glass proposed by the authors.
You will find a lot of entertaining trifles and precise, funny details here: from pots and plates flying along the page (they can be broken with a mouse click), flying insects and cats that can be used to move pages, to grunting babies and caterpillars that become butterfly chrysalis, etc. d. The inserted cartoon passages are not just an illustration, but part of a multidimensional space in the spirit of Carroll.
Here, every detail is part of a multi-layered construction, in which the main thing is the books of Lewis Carroll. Immersed in a visible and audible context, they become voluminous. Playing with the WORD, playing with the WORD itself awakens the reader's imagination and provokes further steps towards independent work with the TEXT. This is real educational program, exciting and allowing you to make independent decisions; full of interesting and accurate details, historical and philosophical comments. You can work with it alone, or you can work together or with a whole company. The program, like the book, is made, as they say, "for growth", the more you learn, the more interesting.
"Very useful gift!"
If you have a computer, this CD will be the crown jewel of your CD collection. It doesn’t matter what age you are, whether you know English or not, it doesn’t matter what field you work in. Very good if you are still in school. This good old book, read in a new way, will give you moments of relaxation and enjoyment, almost endless knowledge, since the text is so dense that it can be read endlessly. And play with it. After all, it is known that any text is interactive, by and large, penetration into the depth of the text corresponds to the level of your development, and the pursuit of perfection is endless. Today, many teachers, schoolchildren, parents are just getting access to a computer. The educational laboratory of the site sees its task not only in presenting the latest electronic products, but also in revealing to the user the best publications that do not become obsolete with time and with the development of telecommunication technologies. There are not many such publications. A computer book about Alice in one of the first places. An amazing example of not rivalry, but the connection of the "Gutenberg galaxy" with new inventions of man!
We have repeatedly presented to our readers the products of the company "1C". This is a chance to see once again how high the level of educational electronic products published by this company is. "Alice in Wonderland and Through the Looking Glass" received many well-deserved awards and prizes.
The editors thank the company "1C" for the provided program.
This article is an announcement of new functionality.
It is not recommended to use the content of this article to learn new functionality.
A full description of the new functionality will be provided in the documentation for the respective version.
The full list of changes in the new version is given in the v8Update.htm file.
Implemented in version8.3.12.64 mobile platform.
We have implemented new technology- mobile client. It allows you to create applications for mobile devices that combine a user-friendly interface of a mobile platform and online work with an infobase, similar to a thin client.
Mobile work scenarios
Until recently, the 1C:Enterprise platform offered the only technology with which it was possible to work with its applications using mobile devices. This is a mobile platform.
This technology allows you to create specialized off-line mobile applications with a convenient and functional mobile interface. Mobile applications are developed to solve specific mobile tasks, optimized for them as much as possible in terms of architecture and interface. Such applications implement exactly mobile work scenarios, it is convenient to work with them both on tablets and smartphones.
By their architecture, such applications are very similar to the file version of the 1C:Enterprise system. The mobile device has its own database, "inside" the mobile application there is both a client that provides interaction with the user, and a server that provides interaction with the database.
Such mobile applications can interact with the "main" application installed in the office. But this is not an online interaction, but a periodic exchange of data with the back office. The main work in the mobile application is carried out offline. And when an Internet connection appears, data is synchronized.
Thus, the mobile platform is well suited for the development of autonomous workplaces for employees who are outside the company and do not have a reliable Internet connection to the office. However, these workstations tend to have limited functionality, less than the functionality of the "main" application. In addition, they do not provide online interaction with the infobase.
It turns out that a significant range of tasks is not covered, which has the following characteristic features:
- Interaction with the infobase must be performed online;
- On a mobile device, all the functionality of the "main" application solution, even such a large one as, for example, "1C: ERP Enterprise Management" should be available;
- The interface should provide comfortable work on any mobile devices with any screen size and location.
Mobile client
To solve this class of problems, we have developed a mobile client. A mobile client is a thin client for mobile devices that has an interface similar to a mobile platform. The mobile client distribution kit contains all the necessary executable files from which a developer can build an application for a mobile device in the same way as mobile applications are built from a mobile platform.
Such an application, on the one hand, can directly interact with a 1C:Enterprise server cluster in the same way as a thin client does. On the other hand, the mobile client provides automatic transformation of the forms declaratively described in the configuration into an interface similar to that of the mobile platform.
Forms developed for the desktop version of 1C:Enterprise are automatically arranged in such a way as to ensure the convenience of working with them on small screens of mobile phones at an acceptable level.
Of course, in order for this transformation to be performed even better, it is necessary to specify some new properties of form elements specifically for the mobile client, get rid of some special and non-standard interface solutions. That is, some processing of the applied solution is required specifically for a mobile client. But this redesign is much easier than building a dedicated full-featured mobile app.
Potential Users
In our opinion, this technology will be in demand in those implementations that require online access to the system from mobile devices. So that the data entered on the mobile device gets directly into the "common" database, bypassing the intermediate synchronization steps.
Also, the mobile client will be in demand in small companies that have neither the budget nor the time to develop specialized mobile applications. Indeed, according to our estimates, the most difficult stage in the development of mobile applications is the creation of a data exchange system.
In addition, the mobile client will be useful for users of services based on 1Сfresh technology. These are 1Cfresh.com and Accounting services supported by 1C, as well as any other services deployed using this technology.
Functionality
If we compare the functionality of a mobile client with what a thin client “can do”, then there are not only limitations, but also advantages.
An important advantage of the mobile client is that it contains all the functionality of the mobile platform, determined by the devices themselves. That is, it allows, for example, to take photos, dial a subscriber's number, receive PUSH messages, and much more.
Another advantage of the mobile client is that it works not only with the version of the server for which it was built. It will work with almost any version of the server until there is some significant change in the exchange protocol or platform architecture. We did this because the publication of mobile applications is a rather laborious and lengthy process, which is almost impossible to perform simultaneously with the transfer of a server cluster to a new version of the platform.
If we talk about limitations, the most obvious of them is that the mobile client interacts with the server cluster only via the HTTP (HTTPS) protocol.
Another limitation, however, as for the mobile platform, is the inaccessibility of some objects of the built-in language and some interface elements. But we will try to minimize these differences as the mobile client develops.
Automating Form Interface Building
When creating the mobile client, we paid a lot of attention to ensuring that the adaptation of the configuration for the mobile client requires minimal effort. We have developed several technologies and approaches to ensure that large forms designed for the desktop version automatically adapt to the small screens of mobile devices.
For example, we found that large forms tend to have few important elements. That is, such elements, work with which is ongoing. And at the same time, there are many less important elements in them, work with which work is done from time to time.
For example, important elements are a dynamic list table in the form of a list, a spreadsheet document in the form of a report. Important columns are, for example, the "Name" and "Date" columns.
Accordingly, in order to provide a sufficient level of convenience for working with the form, the mobile client gives more space to important elements on the form, and less space to less important elements, removing them, for example, in a collapsible group.
Second, the mobile client expands horizontal groups vertically if they don't fit the width of the screen. On mobile devices, it is not customary and inconvenient to scroll the form horizontally, so this solution is quite convenient and justified.
Adapting configurations to the mobile client
Despite all the automation, some effort will still be required from the configuration developer to adapt the application solution for the mobile client.
Without going into details, we can say that all such improvements fit into two main directions.
The first is to get rid of special and specific interface solutions, relying more on automatic form layout performed by the platform based on data type information. Such specific solutions can be fixed field sizes, rigidly set horizontal grouping of elements, and the like.
Another direction is to prompt the mobile client with additional information about the form elements. We have taught the mobile client to easily recognize elements in standard or small forms and determine their importance. But if the form is non-standard or large, then it will be useful to manually indicate which of its elements are more and less important. To do this, you can use the new element property - ImportanceOnDisplay: high, normal, low, etc.
Also, it will probably be necessary to analyze those places in the application solution in which the operation algorithms for the thin client and for the web client differ. This must be done in order to specify which of the algorithms will be used when working in the mobile client. To do this, we have added a new compilation directive MobileClient.
Distribution, build and publish
A mobile client, in fact, is a kind of “shell” that can launch one or another application solution. At the same time, the functionality of launched application solutions can differ greatly from each other. At the same time, the AppStore requires that an application published in the store does not significantly change its functionality after publication.
Therefore, we do not publish the mobile client as a standalone universal app. The mobile client is delivered together with the mobile platform as a set of executable files. Based on these files, the developer must build an application that will run on a mobile device. The procedures for building and publishing applications, both for the mobile platform and for the mobile client, are similar. The same tool is used - the assembler of mobile applications.
In order for a mobile client published to the app store to have fixed functionality, you must specify the specific configurations that the app will work with when you build it. During operation, the mobile client checks that only one of the specified configurations is used and without significant changes. This is a special protection so that a mobile client that is published for certain configurations cannot work with other configurations. As practice shows, it is convenient for users that one mobile application corresponds to any one configuration, or similar configurations.
Dear and beloved customers, we strive to become better for you!
In this regard, we begin the transformation Center beauty on Tulskaya from 15 July. The renovation will take 2 weeks. The renovated and modernized center will open its doors for you on July 29th.
For this period we will be glad to see you in the Center on Kantemirovskaya, as well aswe want to inform you that some specialists from Tulskaya will work at Kantemirovskaya during the repair.
We apologize for the inconvenience caused.
More informationYou can clarifyin a single CALL center+7 495 134 22 22.
Subscribe to our Instagram and follow the process, it will be interesting!
Cryolipolysis - NEW!!!
BENEFITS TO 54 400*!
ABSOLUTE HIT EUROPEAN CLINICS -CRYOLIPOLIS COCCON :
✔️ PAINLESS;
✔️ QUICK RESULT;
✔️ UNIFORM REDUCTION OF FAT TISSUE;
✔️ NO SIDE EFFECTS;
✔️ WIDE AREA OF APPLICATION - FROM ABDOMEN AND THIGH TO CHIN.
*For more information about the promotion, ask administrators or call.
Revolutionary emulsion PRX-T33 NOW WITH US!
PRX-T33 is a unique patented product that revolutionized cosmetology in Italy, and after 10 years of clinical trials entered the Russian market. PRX-T33 - chemical peeling for skin revitalization (rejuvenation). Procedure for controlled skin damage to stimulate and restore it, without damaging the epidermis, without causing peeling. Most peels are recommended to be done in the autumn-winter period, but PRX-T33 - all season.
NEW BARBER!
Now in network centers beauty "Through the Looking Glass" (metro Kantemirovskaya, metro Tulskaya) appeared Barbers - these are masters to whom a modern man can safely entrust his image: a haircut, mustache, beard shaping or treat himself to a royal shave. The barber will help you choose hair care and styling, recommend styling suitable for the type of appearance and the perfect beard. Hairstyles for men have a wide variety. A young man with a haircut can express his character, mood, image!Choose your lifestyle!
Babor - "The Art of Purification"
In the beauty centers "Through the Looking Glass" a new line of cosmetics for home care has appeared - "The Art of Cleansing", from the German company Babor.
The line includes:
Purifying Enzyme Powder, Skin Cleansing Trio Set, Gentle Peeling, Thermal Water Tonic Essence, Rose Water Tonic Essence, Cleansing Milk.
The perfect manicure with Luxio is now in the Looking Glass on Kantemirovskaya
Beauty Salon Through the Looking Glass presents a modern line for manicure and pedicure - LUXIO.
Recently, articles on 1C have begun to appear more and more often on Habré. application development environment. Articles are more conceptual than applied; The authors review the 1C:Enterprise 8 platform as a whole, trying to understand whether the technology for creating business applications offered by 1C is good or bad.
I will not discuss whether each of the authors is right or not; The 1C platform, like any technology, has its advantages and disadvantages. And it has its own interesting features, its own developments and mechanisms. That's what I want to talk about. And also - I want to write an article about 1C for people who are unfamiliar with 1C, an article that shows what place 1C occupies among similar software products. I personally really missed such an introductory review article when I was not yet familiar with 1C, but I was familiar with a number of other ERP products.
So, let's begin!
What does 1C company produce?
I think the general public will answer this question: "1C: Accounting". Someone will remember tutorials or the famous IL-2 Sturmovik series of games.Habr participants, of course, are aware that 1C is not only 1C: Accounting, that there is a whole system of 1C: Enterprise programs that includes business application development tools and business applications created using these tools. And with the help of 1C development tools, accounting, CRM, and ERP were written (with implementations for thousands and tens of thousands of users), and much more.
ERP systems are the most interesting and functional business applications; let's look at their example, what place do 1C:Enterprise technologies occupy among analogues.
What are ERP
What is the most valuable property of ERP systems (and any business applications)? In my opinion, this is flexibility, the ability to adapt to the business processes of the end user at the lowest possible cost.It is clear that when programming an ERP system, it is impossible to foresee all options for business processes. Parametrization comes to the rescue; By introducing parameters into the system that can be changed in the system settings by the user (consultant, administrator), we increase the flexibility of the system at a relatively low cost. The first ERP systems were parameter-driven. configurable via parameters.
Not all business cases can be foreseen in parameterizable systems. When one parameter setting is not enough, you need to change the source code. Here, the ERP manufacturer faces the question of changing the code to meet the needs of consumers and releasing updates or supplying the system in source codes so that users can rewrite the system to suit their needs (which, by the way, does not exempt the manufacturer from releasing updates - the system must develop, support the new functionality to be competitive).
A separate issue is the choice of a programming language for writing an ERP system. Most of the ERP system is business logic, for which conventional programming languages like C++ are not always best suited. Ideally, it would be good to program business logic in a high-level language that can provide the business programmer with maximum comfort when writing business logic, abstracting it from low-level details (database features, the file I/O and printing subsystem, the user interface window subsystem, and etc.). Of course, in this case, you also need to create a compiler / interpreter for this language and a development environment.
We have a matrix of possible combinations:
- open or closed application code (here I mean not open source in its usual sense, but the possibility of supplying the source code of the application, including for a fee).
- business logic programming language – “normal” (С/Java/Perl/…) or specially developed, proprietary.
Business applications created using 1C: Enterprise technologies are systems with open application source code written in a proprietary language that does not have a short name; officially it is called "Built-in programming language 1C: Enterprise", unofficially and briefly - "1C language".
Most of the leaders of the modern ERP market are open source systems. The ability to change the source code "on the spot" provides tremendous flexibility and a competitive advantage. Closed-source products are forced to use other tricks; The most common move is an analogue of CallBacks, the ability to attach custom code to predefined events, both visual (opening and closing a form, selecting from a list of values, ...), and business events (order processing, entering a sales invoice, ...). Some systems have the ability to write their own handlers in C# (or other common languages), others have Visual Basic for Applications licensed from Microsoft, and so on.
How are ERPs arranged?
ERP systems with open source applications consist of the actual source code that implements the business logic, and the execution environment for this business code (the so-called platform).The platform is usually written in a low-level language (C, C++), often the source code of the platform is closed to end users. The task of the platform is to allow the programmer to abstract from low-level details (features of the OS and DBMS, etc.) and focus on writing the actual business logic. The platform is also often referred to as business application development tools and system administration tools (and I agree with this approach). By the way, they do not do without a platform and a system where the business logic is written in “ordinary” programming languages. It is not necessary to interpret the application code there, but the need for platform functionality remains (for example, "wrappers" around the database or unified access to the list of users and their rights).
The platform as a business application execution environment can be described as a virtual machine. As a rule, the platform should emulate three main things for ERP:
- Business logic execution environment.
- Database.
- Graphics subsystem for displaying the client application. The client application can be a graphical one rendered by standard OS tools (including a mobile OS), or it can be a web application. In the case of a web application, the platform either implements its own web server or provides support for standard web servers (IIS, Apache, etc.)
The 1C platform in terms of OS and DBMS support offers the following:
- Business logic execution environment: failover cluster of application servers with load balancing; OS - Windows or Linux
- Database: own file DBMS (recommended for development and small installations), MS SQL, Oracle, IBM DB2, PostgreSQL
- Client:
- thin client (only display and input of information on the client) - Windows and Linux. Can work with an application server via a local network or via web services (in this case, Microsoft IIS or Apache must be deployed on the server side)
- Web client - on the server side of Microsoft IIS or Apache, on the client side - any of the four browsers - Internet Explorer, Chrome, Firefox, Safari
- thick client (with the ability to execute part of the business logic on the client) - Windows and Linux. It has a number of limitations (for example, it can only work within the same local network with the application server). It is considered obsolete, 1C does not plan to develop it further.
- Mobile offline client (with the possibility of periodic synchronization) - iOS and Android.
ERP Application Language
A separate topic is the language in which business logic is written. For a business programmer to work effectively, this language should be as close as possible to the business domain (ideally, DSL, Domain Specific Language) and away from the technical details of the OS and DBMS.Let's take a typical business task: we need to add in the system the ability to enter and process a new type of document (for example, a work order). In a system written in a "regular" programming language, this requires:
- Create tables in the database where information about the document will be stored.
- Write a class (or classes) that implement the business logic of working with a document. In addition to business logic, classes must also implement interaction with the database - reading and writing document data.
- Create a user interface for editing a new document type. Often you also need to create a form that displays a list of documents with the ability to search in different fields, etc.
In a number of ERP systems using proprietary languages, it is also necessary to go through all three of the steps described above, as a rule, within the same development environment.
These 3 steps will provide the bare minimum; but you still need to create a user interface for working with a document, make it available in reports, be able to register changes made by users in documents of a new type, in the journal (log) of the system, etc.
In 1C, it is necessary to describe in the graphic designer the fields of a new type of document and write a code that implements document-specific business logic (for example, to which accounts to write the amounts of money passing in the document). Everything else necessary for full-fledged work with a document in the system will be done by the platform:
- Creates structures in the DBMS to store data.
- Create forms for editing a document, displaying a list of documents of this type, etc. If the automatically created forms do not suit us, you can make your own by expanding and / or changing the standard ones.
- The document will become available in reports.
- The document and its fields will become available for distribution of read/write rights in the application's security system.
- Document fields will become available for full-text search throughout the system (taking into account synonyms, transliteration support, fuzzy search, etc.).
- All changes to documents of the new type will be logged in the application log.
- Methods will be automatically created to save and read the document to/from XML and JSON.
- The document will become available via the REST interface (via the OData protocol).
- And much more
A feature of development in 1C is that there are about 20 built-in types of objects in the system, and all new objects that the developer creates must belong to one of these types. Most of these types describe objects from the scope of the enterprise's accounting activities - directories, documents, charts of accounts, etc. The other part of the object types are technological, such as Web and HTTP services; they allow 1C programs to communicate with the outside world.
1C Configurator - applied solutions are created in it. On the left - a tree of built-in types 1C; under each branch - applied objects of this type.
The development of applied solutions is done in the Configurator (Designer in the English version). A trial version of the 1C:Enterprise Development Tools tool has recently been released, which allows you to develop 1C solutions in the popular Eclipse environment. Industrial development in "1C: Enterprise Development Tools" is not yet possible, but it is quite possible to understand where the company is moving in terms of technology, according to this version. In particular, team development is supported using popular version control systems (Git, SVN and any others for which there are plug-ins for Eclipse); it is also possible to write your own plugins for the Eclipse IDE that expand the capabilities of the development environment for working with 1C.
Enterprise Development Tools - 1C application development in Eclipse IDE
Actually, the 1C programming language in syntax resembles most of all JavaScript. The language, strictly speaking, is not object-oriented. It has no inheritance; but, since all 1C program objects belong to one of the built-in object types, this can be called simplified inheritance: built-in object types implement predefined functionality that an application programmer can redefine in their child objects. Such inheritance is single-level, it is no longer possible to inherit from application objects; a similar approach to inheritance is adopted in the concept of prototype programming (prototype-based programming); JavaScript is one of the most popular representatives of this concept.
This approach deliberately restricts the freedom of the developer of applied solutions, forcing him to choose the required type of object from a reasonably limited palette of built-in types to implement his tasks. In return, the developer gets rich functionality implemented by the platform and really fast development. The advantages of this approach are obvious - accounting systems on 1C are easy and fast to create. There are also disadvantages - if you need to implement something for which there are no built-in types in the platform (for example, working with SFTP), then you need to either wait for a new version of the platform in which this functionality will be implemented, or write your own implementation in a “normal” language and call it from 1C through the technology of external components.
A few facts about the built-in 1C programming language:
- English (if…then) and Russian (if…then) syntax is supported.
- The language is Turing complete.
- It is a dynamically typed language. A variable is associated with a type at the time it is assigned a value, not at the time the variable is declared. When declaring a variable, you cannot specify its type.
It is possible so: var and; a = 1;
It is impossible so: var a as Int; a = 1; - To read data from the DBMS, 1C has its own query language, similar to SQL. Actually, it is translated into SQL when executing 1C programs.
How it all works
How are 1C solutions delivered to end users? And how do they work for these very end users?In order to answer this question more fully, we must remember one characteristic feature 1C.
A project in 1C is called a configuration. A configuration is a complete self-contained program, such as accounting or ERP; it includes all the objects and code needed for the full functioning of a business application. The peculiarity of 1C is that the configuration is stored in the database, in the same one that contains the data of the application itself (postings, data of directories and documents, etc.), i.e. the program is stored along with the data. A database with a configuration (and application data) in 1C terminology is called an infobase (abbreviated as an infobase).
The configuration can be uploaded to a file; in the form of a file, it usually comes from the developer to end users; on the client system, this file is imported into the infobase. After that, the solution is ready to go.
Solution architecture 1C
Where is the software installed:
- DBMS server - one or more DBMS supported by 1C (MS SQL, Oracle, IBM DB2, PostgreSQL). If several 1C applications are installed on the 1C server, applications can use different DBMS; for example, accounting is MS SQL, and ERP is Oracle.
- Server - one or more servers of a scalable failover cluster. Should be set here software"Server 1C" (a set of libraries and executable files). Fault tolerance and scalability of the cluster, as well as load balancing between the servers of the cluster are provided by means of 1C software. A single cluster can include servers running Windows and Linux, and a backup cluster can be provided in the system.
- Client: OS Windows or Linux, thin client (1cv8c.exe/1cv8) or thick client 1C (1Cv8.exe for Windows, 1cv8 for Linux) must be installed.
- The thin client is able to execute a limited set of functionality of the built-in 1C language. Operates on a limited set of built-in language types, intended only for displaying and modifying data in memory. All work with the database, object data, query execution is performed on the server side. The thin client only receives ready-made data prepared for display.
- A thick client can perform almost all the functionality provided by the built-in 1C language itself, resorting to the server only when it is necessary to write or read data from the database. Limitations: it requires a significant amount of hardware resources and can "communicate" with a cluster of 1C servers only via a local network. Considered obsolete, supported for backwards compatibility.
- Web server - IIS or Apache. From 1C - a set of extensions for web servers is installed.
- Web client - any of the four supported browsers: Internet Explorer, Chrome, Firefox, Safari.
- Mobile client: iOS or Android and any 1C mobile application. The way the 1C mobile application communicates with the server depends on the specific application; most commonly used are Web or HTTP services.
Between themselves, the 1C components - the server, thin and thick clients and web extensions - communicate either using their own protocol (implemented over TCP), or via http.
What is special in 1C
What distinguishes 1C:Enterprise technology? Thanks to the innovative approach to development organization (more on that below), 1C:Enterprise makes it easy to do two things: create business solutions from scratch and customize existing solutions to meet the needs of end users.Development
It is easy to create solutions from scratch - thanks to the built-in objects that implement the basic functionality of accounting systems. It is the well-thought-out system of built-in objects (and not a language that is, in general, an ordinary scripting language) that makes 1C:Enterprise a powerful tool for creating business applications. The developer does not need to write a data access layer, basic UI, etc. - you can immediately focus on solving a business problem. To solve business problems, a lot has already been implemented in built-in objects (read - basic libraries) - for example, support for hierarchical directories, accounting machines for implementing accounting and commodity accounting, mechanisms for complex periodic calculations (for example, payroll) and much more.Out of the box, the developer receives built-in objects (directories, documents, registers, etc.) implemented by the platform; these are patterns from the world of accounting systems. In the applied solution (configuration), the developer implements these patterns, filling them with specific business logic.
An applied solution in 1C:Enterprise is not literally written in a programming language. The two cornerstones of the development ideology are development from metadata (Metadata-driven development) and building an application based on a model (Model-driven development).
A business application is based on metadata, which is a declarative description of the application itself. The applied solution is not described in terms of relational tables, object programming language classes, etc., as in most systems. A solution in 1C:Enterprise is described by metadata in the form of a set of application objects selected from a certain set of prototype patterns (directories, documents, charts of accounts, ...).
Metadata form a hierarchy of objects from which all components of the application system are formed and which determine all aspects of its behavior. When running a business application, the platform interprets the metadata, providing all the necessary functionality.
Metadata describes data structures, composition of types, relationships between objects, features of their behavior and visual representation, access rights differentiation system, user interface, etc. Metadata contains information not only about what is stored in the database, but also about why this or that information is stored, what is its role in the system and how information arrays are interconnected. The use of a programming language is limited mainly to solving those problems that really require an algorithmic description (calculation of taxes, checking the correctness of entered data, etc.). We can briefly formulate the basic principle of development at 1C:Enterprise as follows: "Let's program only where it is really necessary, and let the platform do all the routine work."
1C:Enterprise was initially oriented towards building an applied solution based on a specific model. The model is understood as the whole ideology of building an applied solution. These are ways to build data structures, types of relationships between data, principles for manipulating them, forms for describing business logic, ways of linking data with interface objects, separating functionality by system levels, and much more.
All business applications follow the accepted model, and this ensures uniformity and predictability of their behavior. A developer who wants to reflect the specifics of a particular subject area in an applied solution has a well-defined set of ways to solve this problem using the tools embedded in the platform. On the one hand, this approach limits (meaningfully!) the freedom of the developer, but on the other hand, it protects him from many errors and allows you to quickly get a workable solution that can be further developed and supported both by himself and, if necessary, by others. specialist.
The presence of a single model has a positive effect on the ease of mastering the system. All development is carried out within the framework of one end-to-end system of concepts, in a single space of data types. The description in the metadata of certain objects (entities) immediately determines both the corresponding types of the built-in programming language and the database structures necessary for their storage. All subsequent manipulations of these objects, both in memory and in the database, are performed in a uniform way, without requiring overcoming barriers between various notations used when working with DBMS and universal programming languages.
A ready-made application (configuration) supplied in open source codes (for example, accounting or ERP), for a client-side programmer, is almost a DSL (Domain Specific Language, domain-specific language). The programmer can use ready-made configuration objects (counterparty directory, chart of accounts, payroll) to modify the system behavior to suit the needs of the customer.
Customization and support
Briefly about the business logic of the applied solution, we can say the following: it is being changed. It is changed by employees of the client's IT departments, adapting the solution to the business processes of the enterprise. And it is changed by the solution provider, adding new functionality, supporting changes in legislation and periodically releasing updates.The procedure for installing an update where the business logic has been changed "in the field" to suit the needs of the client is often a non-trivial operation, sometimes fraught with errors. By and large, this is a merger of the source codes of a new application from the vendor with a modified (compared to the previous version from the vendor) client application. On the one hand, you need to get the new functionality that came with the update; on the other hand, do not lose your achievements.
This task is familiar to anyone who has had to work in a team on the same application and merge (merge) their changes to the source code with the changes of other team members. Even if all developers are on the same team and adhere to the same set of rules for developing and coding code, the task of merging sources can sometimes be a difficult task. Well, in the case of ERP systems, it is complicated by the fact that the developers of the supplier and the client work in different organizations and they do not always have the opportunity to communicate in case of difficulty understanding the code.
Keep in mind that if the changes made by the client are too large, the application vendor may consider that they will not provide further support for the solution at the client.
The above is one of the biggest challenges in the life cycle of almost any open source business system. The success of the application in the market largely depends on how successfully the software manufacturer solves this problem. In the case of 1C, the merging of two configurations (provider and user) during the update is not just a merger of the source codes of two applications, it is, first of all, a merger of application models, which must follow certain rules.
To solve this problem, 1C has developed a support mechanism (part of the 1C: Enterprise platform) that allows the solution provider to determine which configuration objects (directories, documents, etc.) the client can change and which cannot, i.e. To. changing them will disrupt the system or make it impossible for further centralized support by the supplier.
In turn, the client, using this mechanism, can determine the rules for supporting objects of its configuration - for example, it can refuse to support a particular object by the supplier if it takes responsibility for further modification of this object or if this object is not needed in its work. Or, on the contrary, you can prohibit editing the object of "your" configuration (even if the supplier allows it) in order to insure against accidental changes.
Ideally, it would be desirable that user changes exist, as it were, "aside" from the standard configuration of the provider and are included in the work only at the moment of direct code execution. In this case, the process of installing updates from the vendor will become an automatic process that does not require human intervention. 1C offers two approaches that cover a significant percentage of customization scenarios.
The first approach is the use of external processing and external reports. These mechanisms allow you to add additional functionality "on top" of the system without changing the configuration source code. In fact, these are scripts with a graphical interface designed to run on a specific application solution. These mechanisms gave rise to their counterpart "App Store", an online store where independent programmers post, and end users purchase the necessary add-ons for various programs.
The second approach, which has appeared relatively recently, is extensions. The strategy offered by the extensions is that you do not need to change the default configuration. All changes are made in the so-called extension, which, in fact, is also a configuration (but a user one, separate from the provider's configuration). At the same time, the installation of the update from the vendor will be automatic - from the point of view of the support mechanism, the standard configuration has not changed. And during the operation of the final configuration (which is a combination of a typical configuration and an extension), those objects that are added (or modified) in the extension will be involved.
What else?
What else is interesting / important in the 1C technological line? The list includes the most significant mechanisms, each of which can be covered in a separate article (or several):
- Cloud solution 1cFresh is a “cloud out of the box”, a horizontally scalable environment for working with 1C application solutions (and partner companies) in a service model (SaaS). The product contains all the functions necessary for SaaS operation - registration and user management, the ability to quickly publish new application solutions, create backup copies of user data, etc. The 1C company itself uses the 1cFresh product to provide its products for rent (http://1cfresh.com), and also sells the 1cFresh solution as a boxed product, allowing partners and customers to deploy their own clouds for application solutions based on 1C: Enterprise technologies.
- 1C mobile platform (mentioned above), which allows you to create applications for mobile operating systems (iOS, Android) from one source code using the same methodology and development environment (Configurator) as for "regular" 1C applications.
- Powerful and flexible reporting system. Reports are an extremely important mechanism in any business system; many ERPs use external report generators from other vendors because creating a good report generator is not an easy task with special specifics. In 1C, reports are developed in the same environment (Configurator) as the application itself; The reporting mechanism is based on the data composition system (DCS), a mechanism for declarative description of reports. One of the important features of reports in 1C is that the end user can change the report created by the developer "for himself", using the same report design capabilities as the developer.
- Data exchange mechanism that allows you to create geographically distributed information systems that exchange data offline, without a permanent connection. Data exchange is possible both between 1C: Enterprise applications and between 1C: Enterprise applications and third-party systems.
- And many more interesting things
1C:Enterprise - technologies and tools
Instead of a conclusion
I hope that readers who are not familiar with 1C have a more or less clear picture - what 1C is, how it works and what opportunities it provides to developers. Many interesting topics remain outside the scope of the review; about them next time.A platform-oriented approach to application architecture was chosen by 1C back in the mid-1990s. This peculiar combination of a powerful platform and a reasonably limited application language has shown itself well - more than 1000 officially certified 1C solutions have been created on 1C technologies for various business areas, from small business automation to enterprise management systems with thousands of concurrent users. Add tags