Working with Terrasoft Web services from external applications. Web services We accept a file by web service 1c

ChoiceList=FormItems.AirportChoice.ChoiceList; ChoiceList.Clear(); AirportList=ServiceAeroflot.AirportList().GetList("list "); TotalAirports=ListAirports.Number(); For ii=0 by TotalAirports-1 Loop Airport=ListAirports.Get(s); ChoiceList.Add(Airport.code, ""+Airport.city+" : "+Airport.name); EndCycle;
Here we need a small comment on the designAirportList=ServiceAeroflot.AirportList().GetList("list");
The thing is that the values ​​returned by the methods of web services are represented in the platform by objects of the ObjectXDTO type. Since the topic of XDTO technology is beyond the scope of this article, I will only say that for transformation this object into a list (which it is), I called its GetList() method. The rest of the code is fairly self-explanatory, including the field names of the Airport struct, which I found on the web service description page.
Now you can run the configuration and make sure that the list of the select field is populated with the names of the airports:

"Day of departure, day of arrival..."

Procedure Fill in Tableau(Arrival=True) Table Tableau.Columns.Clear(); TableScoreboard.Columns.Add("FlightCode", "FlightCode"); TableScoreboard.Columns.Add(" CodeAirline", "Airline"); TableScoreboard.Columns.Add("FlightNumber", "Number"); TableScoreboard.Columns.Add(" AirportTransit", "airport transit"); TableScoreboard.Columns.Add("Airport", "Airport"+?(Arrival,"departure","arrival")); TableScoreboard.Columns.Add(" TimeSchedule", "Scheduled"); TableScoreboard.Columns.Add(" TimePlanned", "Planned"); TableScoreboard.Columns.Add(" TimeActual", "Actual"); TableScoreboard.Columns.Add("Calculated Time", "Calculated"); TableScoreboard.Columns.Add("Landing Time", ?(Arrival,"Landing","Takeoff")); TableScoreboard.Columns. Add("CombinedFlight", "Combined flight"); TableScoreboard.Columns.Add("Status", "Status"); If Not Arrival Then TableScoreboard.Columns.Add("Registration", "Registration"); TableScoreboard.Columns .Add("Landing", "Landing"); EndIf;FormElements.TableScoreboard.CreateColumns();FormElements.TableScoreboard.Columns.FlightCode.Visibility=False; If Not Arrival ThenFormElements.TableScoreboard.Columns.CalculatedTime.Visibility=False; EndIf; If Arrival Then Data=ServiceAeroflot.Arrival(SelectAirport, DateFlight).GetList("list "); Else Data=ServiceAeroflot.Departure(SelectAirport, DateFlight).GetList("list "); EndIf; TotalRecords=Data.Number( ); For ii=0 by TotalRecords-1 Loop Record=Data.Get(ies); NewRow=TableTable.Add(); NewRow.AirlineCode=Record.company; NewString.FlightNumber=Record.flight_no; NewString.AirportTransit=Record.airport_inter; NewRow.Airport=Record.airport; NewString.TimeSchedule=Record.sched; NewLine.TimePlanned=Record.plan; NewString.TimeActual=Record.fact; NewLine.CalculatedTime=Record.calc; NewString.DropDownTime=Record.real; NewRow.UnionFlight=Record.union_flight_no; NewRow.Status=Record.status; If Not Arrival Then NewString.Registration=Record.is_check; NewRow.Landing=Record.is_board; EndIf; EndCycle; EndProcedure

In order to check how it all works, I added an "Update" button with the corresponding image to the form's command bar, and wrote the following in its handler:

Procedure CommandPanel1 Refresh(Button) Fill inScoreboard(FormElements.PanelScoreboard.CurrentPage=FormElements.PanelScoreboard.Pages.Arrival); EndProcedure
Save, run, select, click, get:

Afterword

Print (Ctrl+P)

The Web services mechanism in 1C:Enterprise is a means of supporting Service-Oriented Architecture (SOA).
A service-oriented architecture is an application architecture in which all functions are defined as independent services with callable interfaces. Accessing these services in a certain sequence allows you to implement a particular business process.
Service-Oriented Architecture offers a new approach to building distributed information systems in which software resources are treated as services provided over a network. This approach allows you to quickly consolidate distributed components (services) into a single solution to support certain business processes.
The Web services mechanism makes it possible to use 1C:Enterprise as a set of services in complex distributed and heterogeneous systems, and also allows it to be integrated with other industrial systems using a service-oriented architecture.
The 1C:Enterprise system configuration can export its functionality via Web services. Web service definitions are defined in the configuration tree and made available to arbitrary information systems by publishing them on a web server.
In addition, 1C:Enterprise can access third-party Web services both through static links defined in the configuration tree and through dynamic links created using the 1C:Enterprise language. Rice. 1. Web Services

At the heart of the service architecture of the 1C:Enterprise 8 system is the service manager. The service manager performs the following functions:
● managing a pool of connections to infobases;
● support for WSDL description of the service;
● implementation of the SOAP protocol, message serialization, calling the corresponding service.
The service manager runs in the service host process, which performs the function of receiving/transmitting messages from/to the service manager. The service host can be an IIS or Apache web server.
The service manager contains a pool of connections through which interaction with the databases of the 1C:Enterprise system takes place.
The Web services mechanism implemented in 1C:Enterprise supports the following standards:
● SOAP 1.1,
● SOAP 1.2,
● WSDL 1.1,
● WS-I Basic Profile 1.1,
● HTTP 1.1,
● TLS 1.x (TLS 1.1 and 1.2 are supported if no client certificate needs to be passed to the server), including cryptographic algorithms,
corresponding to GOST R 34.10-2001, R 34.10-94, R 34.11-94 and 28147-89;
● MTOM;
● Authentication: Basic, NTLM/Negotiate.

To access the Web service, you must use the address, which is formed as follows:

http://host/base/ws/WebServiceName

Http://host/base/ws/WebServiceAddress.

Let's take a closer look at the components of the address:

http://host/base is a common URL used to access, for example, an infobase using a web client. If delimiters are present, specifying delimiter values ​​using the Z parameter is not supported command line launching the client application.

ws indicates that a Web service is being accessed (as opposed to hs, which defines access to an HTTP service, see here).

WebServiceName - The name of the Web service. Set in a property of the Web service object.

WebService Address - describes an alternative name for accessing the Web service. Set in the Publish File Name property of the Web service object. Can be changed when publishing the Web service.

Calls by the WebServiceName name and the WebServiceAddress address of a Web service are equivalent.

Exposing Functionality Through Web Services

To make the functionality of the 1C:Enterprise system available to external consumers of Web services, you need to do the following:
● create the required number of Web services in the configuration,
● publish Web services using a dedicated configurator tool.
The description of the procedure for publishing Web services and the description of using Reverse Proxy to access 1C:Enterprise is written in Chapter 7 “Administrator's Guide” on the ITS disk.
Creating a Web service is:
● adding the Web service configuration object to the metadata tree,
● describing the operations that the created Web service can perform,
● describing the parameters of Web service operations.
The Web service configuration object contains a module that creates procedures in the built-in language that are executed when certain Web service operations are called. Web service operation parameter types are described using XDTO types and can be either XDTO values ​​or XDTO objects.
The call to the Web service goes like this:
● a suitable connection is selected from the connection pool with information base; in the absence of a required connection, a connection is created;
● a new session is created and an event is raised for the created session SettingSessionParameters(in session module);
● the requested Web service method is called, and the handler is invoked SettingSessionParameters()(in the session module) each time an uninitialized session parameter is accessed.
ADVICE. It is not recommended to perform resource-intensive operations in an event handler SettingSessionParameters.
Event SettingSessionParameters The session module is called on the server in privileged mode. The called service module is executed on
server in normal mode.
The session module is used to initialize session parameters and execute a certain set of commands when calling any 1C:Enterprise Web service.

Sample Web Service Implementation

For example, you need to create a Web service of the 1C:Enterprise system, which should return the composition of its tabular section according to the passed invoice number. A similar example using HTTP services will be discussed in another article.
To describe the return value, let's create an XDTO package DataExpense Invoice with namespace http://www.MyCompany.ru/shipment, containing three types of XDTO objects:
● Nomenclature – for transferring data of the Nomenclature lookup element. This type of XDTO object will contain the following properties:
● Name – string type from the namespace
● Full name– string type from namespace http://www.w3.org/2001/XMLSchema;
● BarCode - string type from namespace http://www.w3.org/2001/XMLSchema;
● PurchasingPrice – type int from the namespace http://www.w3.org/2001/XMLSchema.
● StringInvoiceInvoice– to transfer the data of one line of the invoice. This type of XDTO object will contain the following properties:
● Nomenclature – type Nomenclature from the namespace ; is a reference to an XDTO object,
which we defined above;
● Quantity - type int from the http://www.w3.org/2001/XMLSchema namespace;
● Price – type int from the http://www.w3.org/2001/XMLSchema namespace;
● Sum is an int type from the http://www.w3.org/2001/XMLSchema namespace.
● Sales Invoice– to transfer data of all lines of the invoice. This type of XDTO object will contain a single property:
● Composition - type StringInvoiceInvoice from namespace http://www.MyCompany.ru/shipment. Represents a reference to an XDTO object,
which we defined above. In order for this property to contain an unlimited set of values, you must set it
property Upper bound to -1.
After the necessary XDTO types have been created, a new Web service must be added to the configuration DataExpense Invoice with the following property values:

● Namespace URI - http://www.MyCompany.ru/shipment;
● XDTO Packages - DataExpense Invoice;
● Publication File Name– shipment.1cws .
The generated Web service should have a Get operation with the following property values:
● return type – Sales Invoice from namespace http://www.MyCompany.ru/shipment;
● Possible empty value- installed;
● Procedure name - Get .
For the Get operation, define the DocumentNumber parameter with the following property values:
● Value type - type string from the namespace http://www.w3.org/2001/XMLSchema;
● Transfer Direction - Input.
After that, you should open the module of the created Web service and place the Get() function in this module, which will be executed when this Web service is called.

Working with third party web services

1C:Enterprise can use web services provided by other providers in several ways:
● using static links created in the configuration tree;
● using dynamic links created by means of the built-in language;
● a combination of the previous methods.
The advantage of using static links is more speed, because the description of the provider's web service is obtained once, when the link is created. In the future, when accessing this web service, the existing description of the web service is used.
When using dynamic links, the description of the supplier's web service will be obtained by 1C:Enterprise each time the web service is called, which will naturally slow down the work with this web service. However, the advantage of this approach is the ability to obtain an up-to-date description of the provider's web service. When using static links, to get the actual description of the web service, you should re-import the WSDL description using the configurator and save the changed configuration.
When using applied solutions, a situation may arise when the same web service is provided at different addresses (URL), but has exactly the same description (WSDL). In this case, there is a need to load the description of the web service into the configuration (create an object in the tree of configuration objects), but at the time of use specify the specific address where the web service is located. The combined method allows you to work in this way. As an example, consider the following situation: there is a replicated web service that performs
some function. An applied solution written in 1C:Enterprise uses the services of this service, while the address of the service can be different (the service is replicated), and the description is fixed. Then, a description of the web service can be loaded into the application solution, and in the settings of the application solution, provide for entering the address of a specific instance of the service, which (address) will be used during operation.
Another way is also available: a dynamic link is used, but the web service location address is not obtained from the description file (WSDL), but is directly specified when the object is created.
When trying to load a Web service description in the configurator (creating a static link) or using a dynamic link (using a WSDefinition object), the system checks the loaded Web service description (WSDL). If there is an error in the Web service description (from the "point of view" of the 1C:Enterprise system), then the description will not be loaded and an exception will be generated. The text of the exception will contain a detailed diagnosis of the reasons for the failure to download. WSDL errors are listed in the order in which they were encountered. Each WSDL error contains an entry detailing the following:

<Тип элемента с ошибкой>.<Имя>
[<Тип элемента с ошибкой>.<Имя>[…]]
<Описание ошибки>
<Тип элемента с ошибкой>
<Имя>
In this description:
● Error element type - WSDL element type. Most often corresponds to the tag name in the xml file describing the Web service.
● Error Description - Description of the specific error.
● Name - The name of the WSDL object in which the error occurred.

An example of using a static WS link

As an example of using third-party web services, consider accessing the Web service that was previously created in the example above.

First of all, you need to add a new WS-reference configuration object named InvoiceData to the configuration tree that references the published service. To do this, import the WSDL description of the published service and specify the URL as http://www.MyCompany.ru/shipment/ws/Shipment.1cws?wsdl. The description of the import of the WSDL description is written in another article.
After that, for example, in the receipt module, you can create the procedure below. It populates the tabular section of the document with the supplier's invoice data received using the supplier's web service.

If the address of the real location of the service differs from the address that was used when loading the web service description into the configuration,
then the new address must be explicitly specified when creating the WSProxy object:

An example of using a dynamic WS link

Using a dynamic link differs from using a static link only in the way the WS proxy is created and there is no need to create a WS link in the configuration tree.
Compared to the example presented in the previous section, unlike creating a proxy based on a static link, when using a dynamic link, the WS proxy is created using the constructor as follows:

// Create a WS proxy based on the WS definition
Definition = New WSDefinitions (“http://www.MyCompany.ru/shipment/ws/Shipment.1cws?wsdl”);
Proxy = New WSProxy (Definition , “http://www.MyCompany.ru/shipment”, “Invoice Data”, “Invoice Data Soap”);
Whereas creating a WS proxy based on a static link looks like this:

// Create a WS proxy based on the link
Proxy = WSReferences.InvoiceData. Create WSProxy (“http://www.MyCompany.ru/shipment”, “Invoice Data”, “Invoice Data”);
If the address of the actual location of the service differs from the address specified in the WSDL file used to create the web service definition, the new address must be explicitly specified when creating the WSProxy object based on the web service definition:

Editing Web Service Properties

On the Basic tab, enter the name, synonym, and comment of the object.
On the Operations tab, subordinate objects Operations are created, which, in turn, can have subordinate objects Parameters necessary for working with objects of this type. Description of subordinate objects is performed in the properties palette.

Properties "Operations"

In addition to the general properties of configuration objects, a Web service operation contains the following properties:

● Return Type - The type of value returned by the Web service operation. Can be an XDTO value type or an object type
XDTO.
● Can be null - Indicates whether the return value can be null.
● In Transaction - Indicates whether the Web service module code will be executed in a transaction or not. If the property is set, then when the Web service is called, a transaction will automatically be started, and when the Web service ends, the transaction will either be committed or the transaction will be rolled back (depending on the results of execution). If the property is not set, when starting the execution of the Web service module
the transaction will not start.
● Method Name - The name of the exported procedure of the Web service module that will be executed when this property is called.
The Subsystems tab indicates which subsystems the objects of this type belong to.
The following properties are defined on the Other tab:
● Namespace URI - Contains the namespace URI of the Web service. Each Web service can be uniquely identified in its own way.
name and the URI of the namespace it belongs to. The service namespace must not be the same as known namespaces that are already in use or reserved by other organizations. It is recommended that the service namespace include a fragment that is unique to the organization that develops the Web service. For example, for an organization named Promresurs, it makes sense to start all namespaces with a prefix, such as http://promresurs.com. Then the namespace URI of the Web service will look like http://promresurs.com/public/services/OurService.
● XDTO packages - a list of XDTO packages whose types can be used as operation return types and Web service operation parameter types.
● Publish File Name - The name of the Web service description file that is located on the Web server.
The Module button opens the Web service module editor.

"Parameter" properties
In addition to the general properties of configuration objects, the Web service operation parameter contains the following properties:
● Value Type - The value type of the Web service operation parameter. May be an XDTO value type or an XDTO object type.
● Can be empty - indicates whether the value of the operation parameter can take an undefined value.
● Transfer Direction - Specifies the direction of data transfer using this parameter. Possible values:
● Input - means that the parameter is used to pass data to the Web service;
● Output - means that the parameter is used to receive data from the Web service;
● Input-Output - means that the parameter can be used both for transmitting data and for receiving data from the Web service.

The topic title is really a question, because I myself do not know what it is and for the first time I will try to work with it within the framework of this article. The only thing I can guarantee is that the code below will work, however, my phrases will only be assumptions and guesses about how I myself understand all this. So let's go...

Introduction

1. SOAP. Before calling a remote procedure, you need to describe this call in an XML file of the SOAP format. SOAP is just one of the many XML markups used in web services. Everything that we want to send somewhere via HTTP is first turned into an XML SOAP description, then put into an HTTP packet and sent to another computer on the network via TCP / IP.
2. WSDL. There is a web service, i.e. a program whose methods can be called remotely. But the standard requires that a description be attached to this program, which says that “yes, you were not mistaken - this is really a web service and you can call such and such methods from it.” This description is represented by another XML file that has a different format, namely WSDL. Those. WSDL is just an XML file describing a web service and nothing else.

General Approach

1. Describe the interface of our web service
2. Implement this interface
3. Start our web service
4. Write a client and remotely call the desired web service method

Server

Client

Conclusion

In this article, I will describe the principles of working with Terrasoft web services from external applications. Using these mechanisms, you can implement various integration tasks with any external system.

There are two ways to work with Web services from third-party applications, it all depends on the purpose of use and the specific programming language:
1. Working through Terrasoft COM-objects
2. Working with Web services directly

Working through COM objects

The first option is the least time consuming and more convenient, but it requires the Terrasoft libraries to be registered on the client machine (to use COM objects). In this case, all work with Web services will be performed by Terrasoft COM objects, providing access to data and objects through the object model of the Terrasoft platform: IDataset, ISelectQuery, etc.

To connect programmatically, you need to execute the following code (example in Jscript, but this can be implemented in any language that works with COM objects):

// Instantiate Connector and Configuration COM objects
WSConnector = new ActiveXObject( "TSDskObjectLibrary.DskConnector") ; // For versions 3.4.0+, the object is created by ActiveXObject("TSObjectLibrary.Connector")
var WSConfiguration = new ActiveXObject( "TSObjectLibrary.Configuration") ;
WSConfiguration.DBExecutorTypeCode = "WebServices" ;

// Caching the created connection
Connector.Attributes("WSConnector" ) = WSConnector;

// Setting the connection string and the name of the configuration configured on the server
WSConfiguration.SetConnectionString(
""URL=http://192.168.227.128/TSWebServicesServerLibrary.dll/soap/IServer"" +
","ConfigurationName=Dev332"" ) ;

// Open configuration
var IsConnected = WSConnector.OpenConfiguration(
wsconfiguration,
1 , // Authentication type: 0 - Windows Authentication, 1 - Server
"ddd" , // Username
"" ); // Password

After a successful connection, we can access any objects, receive data, etc. For example, obtaining data about counterparties:

// Getting the ds_Account service from the connector to web services
var AccountDataset = WSConnector.Services .GetSingleItemByUSI ("ds_Account" ) ;

// Preparing the dataset: closing and clearing the filters
AccountDataset.Close();
EnableDatasetFilters(AccountDataset, false ) ;

// Applying a filter by the ID of the current record
ApplyDatasetFilter(AccountDataset, "ID" , dlData.Dataset ("ID" ) , true ) ;

// Open dataset
AccountDataset.Open();

// Read data
if (AccountDataset.IsEOF ) (
var Value = "(no data)" ; !}
edtWSName.Value = Value;
edtWSOfficialName.Value = Value;
edtWSCode.Value = Value;
) else (
edtWSName.Value = AccountDataset.ValAsStr("Name" ) ;
edtWSOfficialName.Value = AccountDataset.ValAsStr("OfficialAccountName" ) ;
edtWSCode.Value = AccountDataset.ValAsStr("Code" ) ;
}

// Closing the dataset
AccountDataset.Close();

Attached is a complete example of working with Web services in Jscript using COM objects.

Working with Web Services Directly

This type of work is more difficult because all requests to Web services must be sent independently, and you must also process the response from the server yourself. This does not use Terrasoft COM objects, so there is no need to install and register Terrasoft libraries on each client computer from which web services will be requested.

Requests to Web services can be sent based on their interface (WSDL) - descriptions of all methods with parameters.

To simplify the development of programs for working with Web services, some IDEs, such as Visual Studio, provide a WSDL (Add WebService Reference) import, while the IDE itself generates wrapper classes for working with Web services. By calling the methods of such a class, you will simply call the corresponding methods of the web service.

The simplification is that to call a Web service method, you need to send a full XML request, and with the help of wrapper classes, you simply call the corresponding method with parameters.

Example in C# :

// Create a web service client
ws. IServer sc = new ws. ServerClient(); // ws.IServer is a wrapper class for working with Terrasoft Web services
ws. OpenConfigurationRequest rqOpenConfiguration = new ws. OpenConfigurationRequest(); // Requests to open configuration
ws. OpenConfigurationResponse rsOpenConfiguration = new ws. OpenConfigurationResponse();

// Open configuration
rqOpenConfiguration. ACompressionLevel = 0 ; //Without compression (zip)
rqOpenConfiguration. AConfigurationName = Configuration;
rqOpenConfiguration. ADBExecutorTypeCode = "MSSQL" ;
rqOpenConfiguration. AUserName = UserName;
rqOpenConfiguration. AUserPassword = Password;
rsOpenConfiguration = sc. OpenConfiguration(rqOpenConfiguration) ;

At the same time, data transfer, splitting large data into packets, parsing the server response, etc. need to be implemented by yourself.

Attached is a complete example of working with Web services in C#.

Special thanks to Alexander Kravchuk for providing examples.

Fortunately, there are no restrictions on working with web services.

Adding a Web Service to the Metadata

Open the configuration tree, branch Are common, Further Web services, add a new web service (let's call it my_ws) and fill in the properties as shown in the figure.

It is necessary to make a few clarifications about the properties of web services

• XDTO Packages— this field specifies the list of XDTO packages whose types can be used in the value returned as a result of the web service operations.
• Namespace URI is a string that specifies the namespace URI for this web service. Any web service can be uniquely identified by the combination of its name and namespace. It must be clearly understood that this property has nothing to do with either the physical address of the web server, or the site of the organization, etc. It's just a virtual address. Therefore, it is necessary to assign a distinct name that can tell, for example, about the area where the web service is located and used. In particular, there may be an abbreviation of the typical configuration to which the web service belongs.

Web service operations

To ensure the functioning of a web service, it is necessary to create operations for it that will perform certain actions, and, if necessary, return the necessary data.

As an example, let's create an operation for our web service that will return the classic phrase "Hello world!". Let's call her hello:

Let's create a function in the web service module Hello World(), the reference to which we will insert into the corresponding property of the operation.

But this operation has one drawback. It cannot transfer raw data. For these purposes, web service operations use their subordinate objects − Options.

Let's add one more operation - HelloUsr, and create a parameter for it Name.

This operation will return a greeting to the user by calling the following function:

Publishing a Web Service

Now we are all set to publish the web service. To do this, you need to log into the configurator with administrator rights. Click on the label 1C right click and select the appropriate menu item:

In the menu choose Administration —> Publishing to a web server

In the window that opens, enter the name of the publication, check the item Publish Web Services and also mark the web service we created:

WS links

To work with web services, such a 1C object is used as WS link. It is a WSDL description of a web service obtained by importing from the source on which the web service is located. That is, first of all, we need to know the address where we can get the WSDL description of the web service. In relation to our example, in accordance with the settings that we made in the process of creating and publishing a web service, this address will look like this

http://localhost/professia1c/ws/my_ws.1cws?wsdl

Consider what parts this address consists of.

• http://localhost/- This address indicates the physical location of the web server. Since I have it on the local machine, then localhost, but in practice it is either the IP address of the server or its name
• profession1c is the name of the publication. We entered it into the field Name in the dialog box when publishing the web service
• ws- a sign that we are accessing a web service
• my_ws.1cws- the name of the publication file that we specified in the properties when creating the web service
• ?wsdl- a parameter that indicates that we need to get a WSDL description

After publishing a web service, in order to verify that it was published successfully, you can enter the address of its WSDL description in the browser's address bar. In this case, we should receive an XML file in the browser window with something like this:

1. Using a dynamic ws link.
2. Creating a static ws link.

Let's take a look at each of these methods.

Dynamic WS Links

As you might guess, the result of this procedure will be the text in the message box "Hi, Vasya!"

Static WS Links

Instead of programmatically creating an object WSDefinitions we can create a WS-reference metadata object directly in the configuration tree. During the creation process, a window will be displayed asking you to specify the WSDL address of the definition to import it:

After that, we can refer directly to this WS link in the code. And the procedure for accessing the web service will take the following form: