Get from temporary storage 1c 8.3. Saving data from a file to temporary storage
Almost any information can be stored in the value store, for example,
... pictures (photos):
// in this place it displays everything ... Form Elements.PictureField1.Picture = Storage.Get (); TekImage.Write ();
... spreadsheet document:
TabDoc = New TabularDocument; TabDoc.Display (Form Elements.TableDocumentField1); Storage = New Storage of Values (TabDoc); Write ();
End of Procedure
Procedure Restore From Storage Press (Item)
TabDoc = Storage.Get (); If TabDoc<>Undefined Then Form Elements.TableDocumentField1.Offer (TabDoc); EndIf;
End of Procedure
... arbitrary files (binary data):
The eight supports compression of data placed in storage:
... external processing and reporting:
Compression Degree = New Data Compression (9); // 9 maximum PropsStorageType = NewValueStore (New BinaryData ("c: \ reports \ report.epf", Compression Degree));
End of Procedure
Procedure StartProcessingFrom Storage (Props StorageType)
TempFileName = TempFileDir () + "report.epf"; BinaryData = PropsTypeStorage.Get (); BinaryData.Write (TemporaryFileName); ExternalProcessing = ExternalProcessing.Create (TemporaryFileName); ExternalProcessing.GetForm (). Open ();
End of Procedure
Working with storage
If it was BinaryData, then it can be restored from the value storage using the Get method and written to a file using the Write () method.
BinaryData = Storage.Get ();
BinaryData = Storage;
EndIf; BinaryData.Write (FileName);
If it was, for example, a Word document (doc file, or another file of a registered type), then it can be opened like this:
To clear a field of type Value storage, you need to assign it Undefined:
Working with files and pictures in the built-in language 1C: Enterprise 8
Appointment
The managed application implements new mechanism working with files. It provides file exchange between information base and a client application. The peculiarity of this mechanism is that it is focused on use in a thin client and a Web client and is designed taking into account the restrictions on working with files imposed by web browsers.
The mechanism is a set of methods that can be used to put data stored locally at the user in the temporary storage of the infobase, transfer this information from the temporary storage to the database, and retrieve it back to the user's computer. The most common application tasks solved by this mechanism are the storage of accompanying information, for example, images of goods, documents related to contracts, etc.
Method scope
Temporary storage
Temporary storage is a specialized area of an infobase where binary data can be stored. The main purpose is the temporary storage of information during client-server interaction until it is transferred to the database.
The need for temporary storage arises due to the fact that in the model of the web browser it is required to transfer the file selected by the user directly to the server without the possibility of storing it on the client. When transferring a file, it is placed in temporary storage and only then can be used when writing an object to the database.
The most typical application problem solved by temporary storage is providing access to files or pictures before the object is written into the infobase, for example, in the form of an element.
A file or binary data placed in storage is identified by a unique address, which can later be used in write, read, or delete operations. This address is given by the methods for writing the file to the temporary storage. A separate method in built-in language allows you to determine whether the passed address is an address that points to data in temporary storage.
Information base
The mechanism allows you to access binary data stored in attributes of the ValueStore type.
As in the case of temporary storage, information can be accessed through a special address. You can get it through a special method by passing a reference to an object or an information register record key and an attribute name. In the case of a tabular section, it is additionally required to transfer the index of the row of the tabular section.
The methods of working with files are limited when working with infobase details. For them, unlike temporary storage, only reading information is available, but not writing or deleting it.
Description of methods for working with files
Saving data to temporary storage
The most typical scenario for using this mechanism involves the initial placement of user data in temporary storage. There are two methods for this: PlaceFile () and PlaceFileToTemporaryStorage ().
The first method, PlaceFile (), places a file from the local file system into temporary storage. The method can take the target address in the store. If it is not defined or is an empty string, then it will be created new file and the method will return its address through the corresponding parameter.
If the parameter that determines the interactive mode of operation is True, the method will display a standard file selection dialog box, in which you can select a file to be placed in the repository. In this case, the method will also return the address of the selected file.
As a result, the method returns False if the user interactively refused to perform the operation in the file selection dialog. The method is only available on the client.
The second method, PutFileToTemporaryStorage (), is similar to the previous one, except that it is available on the server, and the data for writing to temporary storage is not represented as a path to file system, and in the form variable type BinaryData. Likewise, if no target address is specified, a new file is created in the repository. Its address is returned as a result of the function.
Retrieving a file from temporary storage
When writing an object to an infobase, you may need to extract data from a temporary storage and place it, for example, in a props. There is a corresponding server method for this - GetFileFrom TemporaryStorage (). This method retrieves data from temporary storage and returns it as a result. To do this, you must specify the address in the temporary storage. This address is returned by the above methods PlaceFile () and PlaceFileTemporaryStorage () if they succeed.
Removing a file from temporary storage
After the data is saved in the props, the file in the temporary storage can be deleted. To do this, there is the DeleteFileFromTemporaryStorage () method, which removes the file from the temporary storage. The method takes in the parameter the address of the file in the temporary storage. Available on the server.
Checking the address for belonging to the temporary storage
The file address can point to both a temporary storage and an infobase variable. To check its type, there is the ThisTemporaryStorageAddress () method.
It verifies that the passed address is an address pointing to the store. Returns True if the address points to temporary storage. The method is available on the server.
Getting a props address
After the data has been placed in the props in the infobase, you may need to access them using file methods.
But before getting data, for example from a props, you need to get the address of this props. To do this, there is a method GetFileAddressVinformationBase ().
Its purpose is to return the file address in the infobase according to the original parameters. To do this, you need to pass the object key (it can be either a reference to an object or a key for an information register record) and the name of the attribute. If you need to get the address of the file stored in the attribute of the tabular section, before the attribute name in the parameter specifying the name of the attribute, you must add the name of the tabular section and the period ".". The method is available on both the client and the server.
Retrieving a file from an infobase
The GetFile () method retrieves a file from the infobase and saves it to the user's local file system. The first parameter defines the file address in the props or in the temporary file storage. The second parameter specifies the target location of the resulting file. In non-interactive mode, you must specify the path. In interactive mode, the parameter is optional.
By default, the method is executed interactively, that is, the last parameter is True. This means that a dialog box is displayed in which you can specify an action with the resulting file: run it or save it to a user-specified location. If the interactive mode is active and the Target path to file on disk parameter is not specified, then the file open operation is not available. Returns a boolean value. False means that the user has chosen to cancel the operation in the online save file dialog box.
An example of using file methods
Variable SelectedName; Variable Address of Temporary Storage; If PutFile (TemporaryStorage Address, SelectedName, True) Then Object.FileName = SelectedName; PlaceObjectFile (TemporaryStorageAddress); EndIf;
End of Procedure
// Copying a file from the temporary storage to the // requisite of the directory, recording an object, deleting a file from the temporary // storage & OnServer Procedure PlaceObjectFile (TemporaryStorage Address)
DirectoryElement = FormInValue ("Object"); BinaryData = GetFileFrom TemporaryStorage (TemporaryStorage Address); DirectoryElement.FileData = NewValueStore (BinaryData); FileDiskPath = New File (DirectoryElement.FileName); DirectoryElement.FileName = FilePathNaDisk.Name; DirectoryElement.Write (); Modification = False; DeleteFileFrom Temporary Storage (Temporary Storage Address); ValueVFormAttribute (DirectoryElement, "Object");
End of Procedure
// Read the file from the props and save it // to local disk Online & OnClient Procedure ReadFile ANDSaveOnDisk ()
Address = GetAddressFileInInformationBase (Object.Link, "FileData"); GetFile (Address, Object.FileName, True);
End of Procedure
Support for addresses in the picture field
The Image field control supports displaying an image specified by the file address in temporary storage or in a database.
To do this, in the Data property of the form element, you must specify a string type attribute. The value of this variable will be interpreted as the address of the picture.
Example
PlaceFile (ImageAddress, True)
Image.Data = ImageAddress
Restrictions when working with the Web client
The operation of the described mechanism when using the Web client has some limitations. These restrictions are related to the specifics of the browser security model. For example, the client cannot save a file to the local file system on its own, that is, only the interactive version of the client methods PlaceFile () and GetFile () is available. An exception is thrown when trying to use non-interactive mode. Dialog boxes displayed online are browser-specific.
Features when working with the Values Store on the Client
Problem:
When a Document has an attribute of the ValueStore type in the tabular section, it slows down the opening of the document form if this attribute contains large data.
Supposed reason:
Perhaps, when the form is opened, the client does not receive a link to the data stored in the Values Store, but the data itself.
Solution
- In the properties of the table attribute of the form, there is a flag "Always use". If set, then the content of the field is always passed between the server and the client - for example, when opening a form. This flag must be disabled, but you must take this into account in the code, since by default the value of this field will not be on the client. An example can be viewed in 1C: Archive.
Better yet, use temporary storage to transfer files between client and server.
Print (Ctrl + P)
This section describes the most common options for using the mechanism for working with temporary storage and files.
Saving data from a file to temporary storage
Placing a single file
The PlaceFile () method places a file from the local file system into temporary storage. The method can take an address in the temporary storage where you want to save the file. If the address is not defined or is an empty string, then it will be created new address and the method will return it via a special parameter.
Note. The amount of data transferred between the client and the server per call to the PlaceFile () method
If the parameter that determines the interactive mode of operation is True, the method will display a standard file selection dialog box, in which you can select a file to be placed in the repository. In this case, the method will also return the address of the selected file.
As a result, the method returns False if the user interactively refused to perform the operation in the file selection dialog.
Placing a set of files
Method PlaceFiles () places several files in temporary storage in one call. There are several different ways using this method:
● create a list of added files in advance, for example, when you have previously selected the files to be placed in the infobase;
● pass the file search mask to the method, for example, when it is required to place all files of a certain type in the infobase, for example, all pictures;
● pass a previously prepared object to the method FileSelect Dialogue in file open mode.
When finished, the method can return a list of actually added files.
// FileList is a form attribute of the ValuesList type,
// containing a list of files to add
ArrayFiles = New Array;
For Each Item List From File List Loop
ArrayFiles.Add (NewDescription of the TransmittedFile (ListElement,));
End of Cycle;
PlacedFiles= New Array;
Result = PlaceFiles (ArrayFiles, PlacedFiles, False, UniqueID);
Note 1. To use the method PlaceFiles () in the web client, a file extension is required.
Note 2. The amount of data transferred between client and server per method call PlaceFiles (), should not exceed 4 Gb (in serialized form).
Putting data into temporary storage
The method is similar to the PutFile () method, except that the data to be written to temporary storage
are not represented as a path in the file system, but as a value. Likewise, if no existing address is specified in the temporary store, a new address is created. The address is returned as a result of the function. As well as for files, the posted data necessarily belongs to some form and is automatically deleted after its deletion.
Note. The amount of data transferred between client and server per method call PlaceTemporaryStorage (), should not exceed 4 Gb (in serialized form).
Attention! When placed in temporary storage, the value is not actually serialized. A link to the value is placed, which is stored in the cache for 20 minutes. After this period, the value is serialized, written to disk (in the session data store), and flushed from the cache.
Retrieving data from temporary storage
When writing an object to an infobase, you may need to retrieve data from a temporary storage and place it, for example, in the infobase object attribute. There is a special method for this - GetFromTemporaryStorage (). This method retrieves data from temporary storage and returns it as the execution result. To receive data, you must specify the address in the temporary
storage. Methods for putting data into temporary storage return this address if they succeed (see previous sections).
Attention! When retrieving a value from a temporary storage on the server, you should take into account that it is obtained by reference. In fact, this link points to the value that is stored in the cache. Within 20 minutes, from the moment it was placed in the storage or from the moment of the last access, the value will be stored in the cache, and then written to disk and deleted from the cache. On the next call, the value is loaded from disk and put back into the cache.
After deserializing and restoring the value from the temporary store, the links are not restored. The value in the cache is restored from disk. But after serialization / deserialization, it is impossible to restore references to other objects within the value.
Deleting data from temporary storage
After the data is saved in the attribute of the infobase object, the data in the temporary storage can be deleted. There is a method for this
RemoveFrom TemporaryStorage (), which does the deletion. The method accepts an address in the temporary storage as a parameter.
Checking the address for belonging to the temporary storage
The address can indicate both a temporary storage and a variable in the infobase. To check its type, there is a method
This is the TemporaryStorageAddress (). It verifies that the passed address is an address pointing to the store. Returns True if the address points to temporary storage.
Getting a props address
After the data has been placed in the attribute of the infobase object, you may need to access it using file methods.
But before getting data, for example from a props, you need to get the address of this props. For this there is a method GetNavigationLink ().
It can return the address of the value in the infobase according to the original parameters. To do this, you need to pass the key of the object (this can be
both the object reference and the information register record key) and the props name. If you need to get the address of the value stored in the props
of the tabular section, then the name of the tabular section and the dot "." must be added to the attribute name in the parameter specifying the attribute name. For instance: Products.Image
Retrieving a file from an infobase
Receiving one file
The GetFile () method retrieves a file from the infobase and saves it to the user's local file system. The first parameter defines the file address in the infobase object attribute or in the temporary file storage. Saving will not occur if the user on whose behalf the operation is performed does not have the View right to the infobase object attribute. The second parameter determines where the resulting file is saved. In non-interactive mode, you must specify the path. In interactive mode, the parameter is
optional.
By default, the method is executed interactively. This means that a dialog box will be generated in which you can specify an action with the resulting file: launch it or save it to a user-specified location in the file system. If the interactive mode is selected and the File name parameter is not specified, then the file open operation is not available. The method returns a Boolean value. False means that the user has chosen to cancel the operation in the online save file dialog box.
Retrieving a set of files
The GetFiles () method allows you to retrieve and save several files stored in the infobase in the user's local file system. The list of uploaded files is passed as a parameter.
// FileList - a list of values containing links to elements
// the directory where the uploaded files are located
// The list of values is represented by the name of the uploaded file
ArrayFiles = New Array;
For Each Item List From File List Loop
File = New File (String (ListItem.Value));
ReceivedFile = New Description of the TransferredFile;
Received File.Name = ListElement.View;
Received File.Storage= P getNavigationLink (ListElement.Value, “Data”);
ArrayFiles.Add (ReceivedFile);
End of Cycle;
Received Files= New Array;
Result = GetFiles (ArrayFiles, ReceivedFiles, UploadFile Path, False);
If NOT Result Then
Message = New Message to User;
Message.Text = "Error receiving files!";
Message.Inform ();
EndIf;
When finished, the method can return a list of actually uploaded files with the full name of each saved file.
NOTE. To use the GetFiles () method in the web client, a file extension is required. If the Object Name property Description of the Transmitted File contains the absolute path to the file, the file will be saved to this path, excluding the parameter File Location.
The FileLocation parameter can be either a path in the local file system, or a FileSelectDialog object in the mode of choosing a directory or saving files. If the parameter value File Location object specified DialogueSelect Files in mode
save files, then:
● the dialog will be called for each file to be transferred, except for those files for which the Object Name property Description of TransferredFile contains an absolute path;
● the value of the Object Name property Description of the TransmittedFile will be used as the initial file name in the dialog;
● if refusal to save is selected for any file, then the Object Name property Description of the TransferredFile will contain an empty string;
● the GetFiles () method will return True if at least one file is received successfully;
● it should be borne in mind that the actual receipt of files is performed after the user answers the questions about specifying the name and path
all received files;
● if the user on whose behalf the GetFiles () method is executed does not have the View right to at least one attribute of the infobase object from which the files are being retrieved, the entire operation will fail.
Example:
TransferredFiles = New Array;
Description = New Description of the Transmitted File("Description", File-Address);
Files being transferred.(Description );
File Selection = New FileSelectDialogue (FileSelectionDialogueMode.Saving);
File Select.Header= "Save archive";
File Select.Extension= "Zip";
File Select. Filter= “Archive (*. Zip) | * .zip | All files | *. *”;
FileSelect.FilterIndex = 0;
GetFiles (TransferredFiles, FileSelect, False);
If the interactive mode of choosing the directory for saving files is selected, the web client will additionally request permission to save files specified with absolute paths. In case of non-interactive saving (the path to the directory is specified in the corresponding parameter), the request will be executed for the entire list of saved files.
An example of using file methods
// Get a file interactively from disk
// and putting it in temporary storage.
& OnClient
Procedure Select FileSDisk and Write ()
Variable SelectedName;
Change Address of the Temporary Storage;
NewObject = Object.Ref.Empty ();
If PlaceFile (TemporaryStorage Address, “”, SelectedName, True) Then
Object.FileName = SelectedName;
PlaceObjectFile (TemporaryStorageAddress);
EndIf;
End of Procedure
// Copy file from temporary storage to props
// directory, writing an object, deleting a file from a temporary
// repositories.
&On server
Procedure PlaceObjectFile (TemporaryStorageAddress)
DirectoryElement = FormInValue (“Object”);
BinaryData = GetFrom TemporaryStorage (TemporaryStorage Address);
Directory Element.File Data= New StoreValues (BinaryData, New Data Compression ());
File = New File (Directory Item.FileName);
DirectoryElement.FileName = File.Name;
DirectoryElement.Write ();
Modification = False;
DeleteFrom TemporaryStorage (TemporaryStorage Address);
ValueVFormAttribute (DirectoryElement, “Object”);
End of Procedure
// Read the file from the props and save it
// on the local disk in interactive mode.
& OnClient
Procedure ReadFileSaveToDisk ()
Address = GetNavigationLink (Object.Link, ”FileData”);
GetFile (Address, Object.FileName, True);
End of Procedure
Permission to perform a group of file operations
Some operations in the web client may require permission for multiple file operations.
For example, you need to get a document from an infobase and then open the saved document using the associated application.
To perform this operation, you will need to answer the question about saving the document and the question about the need to start. If there are more operations, the user will also have more questions.
To reduce the number of questions, you can use the method. When using this method
the user is shown a list of all operations that are planned to be performed and is prompted to allow the group of operations to be performed. If the user has allowed execution, then the requested operations will be performed without additional prompts to the user. If permission is not granted, operations will be performed in normal mode: one request for one operation.
NOTE. To use the method RequestUserPermission () in the web client, you need to connect the extension for working with files.
Let's consider an example of using the method:
If ConnectExtensionWork With Files () Then
Ref = GetNavigationLink (Object.Link, “FileData”);
// Formation of the description of the transferred files (in this case, there is only one file)
Transferred files= New Array;
Description = NewDescription of the TransmittedFile (Object.FileName, Link);
TransferredFiles.Add (Description);
// Prepare an object to receive information about the received files
Files Transferred= New Array;
// Define other parameters of the methods
CatalogSave= “C: \ temp”;
Interactive = False;
UploadedFileName = SaveDir + “\” + Object.FileName;
// Prepare a description of methods for obtaining permissions
Methods = New Array;
Methods.Add (“GetFiles”);
Methods.Add (TransferredFiles);
Methods.Add (TransferredFiles);
Methods.Add (Saving Directory);
Methods.Add (Interactive);
Methods.Add (New Array);
Methods.Add (“Run Application”);
Methods.Add (UploadedFileName);
If not RequestUserPermission (Methods) Then
Warning (“User denied permission.”);
Return;
EndIf;
ReceiveFiles (TransferredFiles, TransferredFiles, SavingDirectory, Interactively);
RunApplication (TransferFileName);
Otherwise
Warning ("Execution is not supported. The file extension is not installed.");
EndIf;
Several features of the application of the method should be noted. RequestUserPermission ().
1. Permission is requested only for following methods:
● RetrieveFiles () / StartFetchFiles (),
● PlaceFiles () / StartPlaceFiles (),
● FindFiles () / StartSearchFiles (),
● CopyFile () / StartCopyFile (),
● MoveFile () / StartMoveFile (),
● DeleteFiles () / StartDeleteFiles (),
● CreateDirectory () / StartCreateDirectory (),
● Launch Application () / Start Launch Application ().
2. Permission is requested for a specific set of method parameters. If, during the actual execution of the method for working with files, the parameter values differ from those for which permission has been obtained, this permission will not be valid and the user will receive a separate request to confirm the operation.
3. If you need to perform two (or more) identical operations with files (even with the same set of parameters), you should specify the appropriate number of elements in the array of method parameters RequestUserPermission ()... For example, if you need to retrieve the same file from an infobase twice and place it in a fixed location in the file system, you should request permission
for two operations.
4. If permission is requested for an operation during which an interactive operation is performed (for example, the GetFiles () function is passed an object FileSelect Dialogue), then such an operation is excluded from the request.
The permissions obtained are retained either until the allowed call is made or until the execution of the embedded language ends.
NOTE... In thick and thin clients RequestUserPermission () the method always returns True, with no user interaction.
Working with temporary storage in a background job
In the mechanism for working with temporary storage, it is possible to transfer data from a background job to the session that initiated the background job.
For such a transfer, an empty value should be placed in temporary storage in the parent session (using the method PlaceTemporaryStorage ()) by specifying any identifier of the temporary storage being created (the Address parameter). Then transfer the received address to the background job through the parameters of the background job. Further, if in background job use this address as the parameter value Method address Place inValueStorage (), then the result will be copied to the session from which the background job was started.
Data placed in temporary storage in a background job will not be available from the parent session until the background job completes.
Support for addresses in the picture field
Form element View field The picture field supports the display of the picture specified by the value address (which can be a picture or binary data) in temporary storage or in a database.
To do this, in the Data property of the form element, you must specify a string type attribute. The value of this variable will be interpreted as the address of the picture.
// Example 1
// Binding the image field to the image address in the temporary
// storage. AddressPictures - string-type form attribute
PlaceFile (ImageAddress, OriginalName, SelectedName, True, UniqueIdentifier);
// Example 2
// Getting the address of the picture from the object's attribute
// infobase
ImageFile = Object.PictureFile;
If Not Picture File.Empty () Then
ImageAddress = GetNavigationLink (ImageFile, “FileData”);
Otherwise
Image Address = “”;
End if;
Access to standard catalogs
When using the system, some space is required in the file system, where you can store various file data, which, on the one hand, are temporary, and on the other, must be stored for a sufficiently long time. These files include drafts for document management systems, external components that run on the client computer, etc.
A special directory is intended for storing such files, which is tied to a specific user of a specific infobase.
The same user working with two infobases will have access to two different directories for storing user data. The location of this directory is determined using the method UserData WorkDirectory (). If the directory is absent, then it is created the first time it is accessed. If the catalog cannot be created, the system raises an exception.
NOTE. The UserDataWorkDirectory () method is not available on the server side.
V operating system there is a special directory dedicated to permanent storage of user data. It could be some
reports, printed forms documents, etc. This directory contains data that can later be sent to external
consumers. To access this directory, use the DocumentCatalog () method. The physical location of the directory depends on the operating room
systems where the application is executed and is listed in the syntax assistant.
Configuration storage in 1C 8.2 and 8.3 Is a tool for group development of solutions, built into the 1C: Enterprise 8 platform. The repository allows multi-user development of solutions with an unlimited number of users. With its help, you can see the complete history of configuration development and each step of the developers in detail.
Let's consider the settings and work with the configuration repository in more detail.
A repository is essentially a database where configuration changes are stored. Each of the developers works with his own infobase connected to the repository. The working base can also be connected to the storage. Best of all, the general scheme is shown in this picture:
This database also stores information about who captured this or that object. Capturing an object is a label set by the developer. The established capture avoids collisions in group development. While the object is captured, no one can edit it.
You can capture an entire object (recursively), or separately an object or forms.
After the developer has performed some actions on the object, he is obliged to place the improvements in the repository. And thereby remove the mark that the object is captured.
How to create a 1C storage
It is quite simple to create a storage, for this you need to select the "Create storage" item in the "Configuration - Configuration storage" menu. In the menu that appears, it is enough to specify the path to the future storage location and the login / password of the administrator user:
When creating, make sure to make a backup account with administrative rights - very often it helps out.
How to connect to 1C storage
To connect to the configuration repository, select the "Connect to repository" item in the "Configuration - Configuration repository" menu in the menu. In the window that appears, you must specify the path to the storage and the username / password, click "Connect":
Get 267 1C video tutorials for free:
At the moment of connection, your configuration will be replaced with the configuration from the repository, be careful.
1C configuration storage administration
To administer 1C storage, select the following item in the configuration menu - "Configuration - Configuration storage - Administration":
- On the "Users" tab, you can add or remove new users, as well as define the scope of rights for each of them.
- On the "Connections" tab, you can view all users who have connected to the storage, and if necessary, disconnect them.
- On the "Cancel Capture" tab, you can remove the capture of any user to a specific object, if, of course, you have the rights to do so.
How to view the history of 1C storage
To view the history, go to the "Configuration - Configuration storage" menu, select the "Storage history" item:
In the history of 1C storage, you can see when, by whom and what was changed.
Development with 1C 8.3 repository
Working with the repository can be conditionally divided into basic actions:
- configurations from the 1C configuration storage;
- update the statuses of the 1C storage;
- capture in storage;
- storage room.
Let's dwell on each action in more detail:
Update statuses of 1C storage
Receives the latest statuses of objects (captured or not).
Called: "Configuration - Configuration storage - Update statuses".
Updating the configuration from the 1C configuration storage
The action will retrieve all changed configuration objects that were placed in the repository. Execution of this command also updates the statuses of objects.
Called: "Configuration - Configuration repository - Update configuration from repository".
Capturing 1C configuration storage
With this command, you can block the change of this object for other developers: while the object is captured by you, no user can change it until you put the object back.
Capture can be done by right-clicking context menu the metadata object:
In the window that opens, you can set some settings:
- Execute recursively- allows you to capture all subordinate objects - forms, etc.
- Allow to receive captured- allows other users to receive intermediate versions of the object
Storage room 1C
After changing the object, it must be placed back into the storage, this is done in the same way as the capture, only the "Put into storage" item is selected:
When posting, be sure to fill in the "comment" field, this is very important for group development. Six months later, you will not even remember why you performed certain actions. Just like a capture, a room has its own specific settings:
- Execute recursively- allows you to place all subordinate objects - forms, etc.
- Leave captured- allows you to place an "intermediate" version of the object, while leaving the capture by the user
How to convert images to PNG format?
Download graphics driver with opengl 2 support
Galvanic isolation of analog signal